#include "AppHdr.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef USE_X11 //Sys dep
#include <X11/Xlib.h>
#include <X11/X.h>
#include <X11/Xutil.h>
#include <X11/Xlocale.h>
#include <X11/keysym.h>
#include <X11/keysymdef.h>
#include <X11/Xmd.h>
#endif
#include "cio.h"
#include "enum.h"
#include "externs.h"
#include "guic.h"
#include "libutil.h"
/*
 * Tile related stuff
 */
#ifdef USE_TILE
#include "tiles.h"
static Display *display=NULL;
static int screen;
static int x11_keypress(XKeyEvent *xev);
static void x11_check_exposure(XEvent *xev);
extern WinClass *win_main;
void GetNextEvent(int *etype, int *key, bool *shift, bool *ctrl,
{
    XEvent xev;
    {
        XNextEvent(display, &xev);
        {
            int button = xev.xbutton.button;
            *shift = (xev.xkey.state & ShiftMask)   ? true : false;
            *ctrl  = (xev.xkey.state & ControlMask) ? true : false;
            *x1 = xev.xbutton.x;
            *y1 = xev.xbutton.y;
            *key = button;
        }
        {
            *x1 = xev.xbutton.x;
            *y1 = xev.xbutton.y;
        }
        {
            int button = xev.xbutton.button;
            *x1 = xev.xbutton.x;
            *y1 = xev.xbutton.y;
            *key = button;
            break;
}
char *my_getenv(const char *envname, const char *def)
{
    const char *result = getenv(envname);
    return (char *)result;
}
int my_getenv_int(const char *envname, int def)
{
    const char *rstr = getenv(envname);
    return atoi(rstr);
}
extern WinClass *win_main;
extern TextRegionClass *region_tip;
void update_tip_text(const char *tip)
{
        return;
    {
        {
            // try to remove inscriptions
            {
                *ins = 0;
            }
            else
            {
                // try to remove state, e.g. "(worn)"
                {
                    *state = 0;
                }
                else
                {
                    // if nothing else...
                }
            }
        }
    }
}
void TileDrawDungeonAux()
{
}
#endif  /* USE_TILE */
/* X11 */
    int sx, sy, ex, ey;
    sx = xev->xexpose.x;
    sy = xev->xexpose.y;
    win_main->redraw(sx,sy,ex,ey);
}
/* X11 */
// This routine is taken from Angband main-x11.c
int x11_keypress(XKeyEvent *xev)
{
#define IsSpecialKey(keysym) \
  ((unsigned)(keysym) >= 0xFF00)
    {
    };
    int dir, base;
    int n;
    bool mc, ms, ma;
    unsigned int ks1;
    XKeyEvent *ev = (XKeyEvent*)(xev);
    KeySym ks;
    char buf[256];
    n = XLookupString(ev, buf, 125, &ks, NULL);
    buf[n] = '\0';
    if (IsModifierKey(ks)) return 0;
    /* Extract "modifier flags" */
    mc = (ev->state & ControlMask) ? true : false;
    /* Normal keys */
    if (n &&  !IsSpecialKey(ks))
    {
        buf[n] = 0;
    }
    /* Hack -- convert into an unsigned int */
    ks1 = (uint)(ks);
    /* Handle a few standard keys (bypass modifiers) XXX XXX XXX */
    base = dir = 0;
    switch (ks1)
    //Handle keypad first
    if (dir != 0)
    {
    }
    if (base != 0)
    {
    }
    //Hack Special key
    {
    }
    return 0;
}
void libgui_init_sys()
{
    GuicInit(&display, &screen);
}
void libgui_shutdown_sys()
{
    GuicDeinit();
}
void update_screen()
{
    XFlush(display);
}
int kbhit()
{
    XEvent xev;
    {
        XPutBackEvent(display, &xev);
        return 1;
    }
    return 0;
}
void delay( unsigned long time )
{
    usleep( time * 1000 );
}
/* Convert value to string */
int itoa(int value, char *strptr, int radix)
{
    unsigned int bitmask = 32768;
    int ctr = 0;
    int startflag = 0;
    if (radix == 10)
    {
        sprintf(strptr, "%i", value);
    }
    {
        while (bitmask)
        {
            if (value & bitmask)
            {
                startflag = 1;
                sprintf(strptr + ctr, "1");
            }
            {
            }
            bitmask = bitmask >> 1;
            if (startflag)
                ctr++;
        }
        if (!startflag)         /* Special case if value == 0 */
            sprintf((strptr + ctr++), "0");
        strptr[ctr] = (char) NULL;
    }
    return (0);                /* Me? Fail? Nah. */
}
// Convert string to lowercase.
char *strlwr(char *str)
{
    unsigned int i;
    for (i = 0; i < strlen(str); i++)
        str[i] = tolower(str[i]);
    return (str);
}
int stricmp( const char *str1, const char *str2 )
{
    return (strcmp(str1, str2));
}
                sprintf(strptr + ctr, "0");
            else if (startflag)
    else if (radix == 2)             /* int to "binary string" */
    if (XCheckMaskEvent(display, KeyPressMask | ButtonPressMask, &xev))
        base = 512 + ks1 - 0xff00;
        if (ms) base |= 1024;
        if (mc) base |= 2048;
        if (ma) base |= 4096;
        return base;
    if (ks1 >=
0xff00)
       if (ms) base |= 1024;
       if (mc) base |= 2048;
       if (ma) base |= 4096;
       return base;
        if (ms) result += CK_SHIFT_UP - CK_UP;
        if (mc) result += CK_CTRL_UP  - CK_UP;
        return result;
        int result = ck_table[dir-1];
        // Keypad
        case XK_KP_1:
        case XK_KP_End:
            dir = 1;
            break;
        case XK_KP_2:
        case XK_KP_Down:
            dir = 2;
            break;
        case XK_KP_3:
        case XK_KP_Page_Down:
            dir = 3;
            break;
        case XK_KP_6:
        case XK_KP_Right:
            dir = 6;
            break;
        case XK_KP_9:
        case XK_KP_Page_Up:
            dir = 9;
            break;
        case XK_KP_8:
        case XK_KP_Up:
            dir = 8;
            break;
        case XK_KP_7:
        case XK_KP_Home:
            dir = 7;
            break;
        case XK_KP_4:
        case XK_KP_Left:
            dir = 4;
            break;
        case XK_KP_5:
            dir = 5;
            break;
    }
        // for menus
        case XK_Down:
           return CK_DOWN;
        case XK_Up:
           return CK_UP;
        case XK_Left:
           return CK_LEFT;
        case XK_Right:
           return CK_RIGHT;
    {
        case XK_Escape:
            base = 0x1b;
            break;
        case XK_Return:
            base = '\r';
            break;
        case XK_Tab:
            base = '\t';
            break;
        case XK_Delete:
        case XK_BackSpace:
            base = '\010';
            break;
        /* Alt + ? */
        return 2048|buf[0];
        if (!ma)
            return buf[0];
        // Hack Ctrl + [0-9] etc.
        if (mc && ((ks >= '0' && ks <= '9') || buf[0] >= ' '))
            return 1024 | ks;
    ms = (ev->state & ShiftMask)   ? true : false;
    ma = (ev->state & Mod1Mask)    ? true : false;
        CK_END,  CK_DOWN,   CK_PGDN,
        CK_LEFT, CK_INSERT, CK_RIGHT,
        CK_HOME, CK_UP,     CK_PGUP
    const unsigned int ck_table[9] =
    if (xev->xany.window != win_main->win)
        return;
    ey = xev->xexpose.y + (xev->xexpose.height) - 1;
    ex = xev->xexpose.x + (xev->xexpose.width)  - 1;
void x11_check_exposure(XEvent *xev)
{
        if (is_main_screen)
        {
            region_tip->addstr(this_tip);
            region_tip->make_active();
        }
        else
        {
            ASSERT(i == 0);
            textattr(WHITE);
            cprintf("%s", this_tip);
            clear_to_end_of_line();
        }
            cgotoxy(1, get_number_of_lines() + 1);
            region_tip->cgotoxy(1, 1 + i);
                    this_tip[width-1] = '.';
                    this_tip[width-2] = '.';
                    this_tip[width]   = 0;
                char *state = strchr(this_tip, '(');
                if (state && state[-1] == ' ')
                    state--;
                if (state && (state - this_tip <= (int)width))
            char *ins = strchr(this_tip, '{');
            if (ins && ins[-1] == ' ')
                ins--;
            if (ins && (ins - this_tip <= (int)width))
        char *this_tip = next_tip;
        // find end of line
        char *pc = strchr(next_tip, '\n');
        if (pc)
        {
            *pc = 0;
            next_tip = pc + 1;
        }
        else
            next_tip = 0;
        if (strlen(this_tip) > width)
    char *next_tip = new_tip;
    for (unsigned int i = 0; next_tip && i < height; i++)
    if (is_main_screen)
        region_tip->clear();
    const bool is_main_screen = (win_main->active_layer == 0);
    const unsigned int height = is_main_screen ? region_tip->my : 1;
    const unsigned int width  = is_main_screen ? region_tip->mx
                                               : region_crt->mx;
    strncpy(new_tip, tip, tip_size);
    strncpy(old_tip, new_tip, tip_size);
    if (strncmp(old_tip, tip, tip_size) == 0)
    const unsigned int tip_size = 512;
    static char old_tip[tip_size];
    char new_tip[tip_size];
extern TextRegionClass *region_crt;
    if (!rstr)
        return def;
    if (!result)
        result = def;
        }
    }
            if (button == 3)
                button = 2;
            else if (button == 2)
                button = 3;
            *etype = EV_UNBUTTON;
        else if (xev.type == ButtonRelease)
            break;
        }
        else if (xev.type == LeaveNotify)
        {
            *etype = EV_MOVE;
            *x1 = -100;
            *y1 = -100;
            break;
            *etype = EV_MOVE;
        else if (xev.type == MotionNotify || xev.type == EnterNotify)
            break;
            if (button == 3)
                button = 2;
            else if (button == 2)
                button = 3;
            *etype = EV_KEYIN;
            *key = x11_keypress(&(xev.xkey));
            break;
        }
        else if (xev.type == Expose)
        {
            x11_check_exposure(&xev);
        }
        else if (xev.type == ConfigureNotify)
        {
            win_main->ox = xev.xconfigure.x;
            win_main->oy = xev.xconfigure.y;
            break;
        }
        else if (xev.type == ButtonPress)
        {
            *etype = EV_BUTTON;
        if (xev.type == KeyPress)
    while (true)
                  int *x1, int *y1, int *x2, int *y2)
/*
 *  File:       guic-win.cc
 *  Created by: ennewalker on Sat Jan 5 01:33:53 2008 UTC
 *
 *  Modified for Crawl Reference by $Author: j-p-e-g $ on $Date: 2008-03-07 $
 */

#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>
#include <commctrl.h>
// GDT_NONE in commctrl.h conflicts with enum.h
#ifdef GDT_NONE
#undef GDT_NONE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include "AppHdr.h"
#include "cio.h"
#include "externs.h"
#include "guic.h"
#include "itemprop.h"
#include "state.h"
#include "tiles.h"
extern int old_main(int argc, char *argv[]);
extern WinClass *win_main;
extern TileRegionClass *region_tile;
extern img_type TileImg;
extern BYTE pix_transparent;
typedef struct ev_data
{
    int type;
    int key;
    int x1, y1;
    bool sh, ct;
}ev_data;
#define EV_MAX 1024
struct ev_data ev_cue[EV_MAX];
static int ev_head = 0;
static int ev_tail = 0;
void ev_push(struct ev_data *e);
static bool skip_key = false;
// Tip text
static TOOLINFO tiTip;
static HWND hTool;
static HWND pWin;
#ifdef USE_TILE
#define PAL_STD    0  //standard palette
#define PAL_BER    1  //berserk palette
#define PAL_SHA    2  //shadow palette
static int palette = PAL_STD;
LPBYTE lpPalettes[3] ;
#endif
#define DF_TOOLTIP_WIDTH  300
ATOM   MyRegisterClass( HINSTANCE hInstance );
BOOL   InitInstance( HINSTANCE, int );
LRESULT CALLBACK    WndProc( HWND, UINT, WPARAM, LPARAM );
bool libgui_init_sys();
void libgui_shutdown_sys();
void update_tip_text(const char *tip);
void GetNextEvent(int *etype, int *key, bool *shift, bool *ctrl,
void TileInitWin();
void delay(unsigned long ms);
int kbhit();
/***************************/
void TileInitWin()
{
    int i;
    TileImg->pDib->bmiColors[pix_transparent].rgbRed   = 0;
    TileImg->pDib->bmiColors[pix_transparent].rgbGreen = 0;
    TileImg->pDib->bmiColors[pix_transparent].rgbBlue  = 0;
    RegionClass::set_std_palette(&TileImg->pDib->bmiColors[0]);
    lpPalettes[0] = (LPBYTE) (&TileImg->pDib->bmiColors[0]);
    for (i = 0; i < 256; i++)
    {
        chcol = (TileImg->pDib->bmiColors[i].rgbRed  * 30
        ptr[2] = (BYTE)chcol;
        ptr[0] = (BYTE)( (chcol +1)/6 );
        ptr[1] = (BYTE)( (chcol +1)/6 );
        ptr[2] = ptr[0] = ptr[1] = (BYTE)chcol;
    }
}
void update_tip_text(const char *tip)
{
#define MAXTIP 512
    static char oldtip[MAXTIP+1];
    strncpy(oldtip, tip, MAXTIP);
    tiTip.lpszText = (char *)tip;
    SendMessage(hTool, TTM_UPDATETIPTEXT, 0, (LPARAM)&tiTip);
}
bool libgui_init_sys( )
{
}
void libgui_shutdown_sys()
{
    DestroyWindow( pWin );
}
void GetNextEvent(int *etype, int *key, bool *sh, bool *ct,
{
    MSG msg;
    {
        TranslateMessage( &msg );
        DispatchMessage( &msg );
    }
    struct ev_data *e = &ev_cue[ev_head];
    ev_head++;
        ev_head = 0;
    *etype = e->type;
    *key = e->key;
    *sh =  e->sh;
    *ct =  e->ct;
    *x1 =  e->x1;
    *y1 =  e->y1;
}
void ev_push(struct ev_data *e)
{
    ev_cue[ev_tail] = *e;
    ev_tail++;
        ev_tail = 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
{
    MSG msg;
    MyRegisterClass( hInstance );
    GuicInit(hInstance, nCmdShow);
    return msg.wParam;
}
ATOM MyRegisterClass( HINSTANCE hInstance )
{
    WNDCLASSEX wcex;
    wcex.cbSize        = sizeof(WNDCLASSEX);
    wcex.style         = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc   = (WNDPROC)WndProc;
    wcex.cbClsExtra    = 0;
    wcex.cbWndExtra    = 0;
    wcex.hInstance     = hInstance;
    wcex.hIcon         = LoadIcon(hInstance, TEXT("CRAWL_ICON"));
    wcex.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName  = "CRAWL";
    wcex.lpszClassName = "CrawlList";
    wcex.hIconSm       = NULL;//LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
    return RegisterClassEx( &wcex );
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;
    struct ev_data ev;
    static int clix = 0;
    static int cliy = 0;
    // For keypad
    {
    };
    switch( message )
    {
        case WM_CREATE:
        {
            pWin = hWnd;
            InitCommonControls();
            hTool = CreateWindowEx( 0 , TOOLTIPS_CLASS ,
                    NULL , TTS_ALWAYSTIP ,
                    CW_USEDEFAULT , CW_USEDEFAULT ,
                    CW_USEDEFAULT , CW_USEDEFAULT ,
                    hWnd , NULL , ((LPCREATESTRUCT)(lParam))->hInstance ,
                    NULL
            );
            tiTip.hwnd = hWnd;
            tiTip.lpszText = (char *)
            SendMessage(hTool, TTM_ADDTOOL , 0 , (LPARAM)&tiTip);
            return 0;
        }
        case WM_RBUTTONDOWN:
        case WM_LBUTTONDOWN:
        case WM_MBUTTONDOWN:
        {
            ev.x1 = LOWORD(lParam);
            ev.y1 = HIWORD(lParam);
            ev.key = 1;
            if (message == WM_RBUTTONDOWN) ev.key = 2;
            if (message == WM_MBUTTONDOWN) ev.key = 3;
            return 0;
        }
        case WM_RBUTTONUP:
            ev.x1 = LOWORD(lParam);
            ev.y1 = HIWORD(lParam);
            ev.key = 1;
            if (message == WM_RBUTTONUP) ev.key = 2;
            if (message == WM_MBUTTONUP) ev.key = 3;
            return 0;
        case WM_MOUSEWHEEL:
        {
            return 0;
        }
        case WM_MOUSEMOVE:
        {
            ev.x1 = LOWORD(lParam);
            ev.y1 = HIWORD(lParam);
            return 0;
        }
        case WM_KEYDOWN:
        {
            int result = 0;
            {
                switch(ch)
                {
                    case VK_LEFT:  dir = 4; break;
                    case VK_RIGHT: dir = 6; break;
                    case VK_UP:    dir = 8; break;
                    case VK_DOWN:  dir = 2; break;
                    case VK_HOME:  dir = 7; break;
                    case VK_PRIOR: dir = 9; break;
                    case VK_NEXT:  dir = 3; break;
                    case VK_END:   dir = 1; break;
                    case VK_CLEAR: dir = 5; break;
                }
            if (dir != 0)
            {
                if (fc)
                if (fs)
                ev.key = ch;
                return 0;
        }
        case WM_CHAR:
        {
            ev.key = (int)wParam;
            return 0;
        }
        case WM_PAINT:
        {
            hdc = BeginPaint(hWnd, &ps);
            win_main->redraw();
            EndPaint(hWnd, &ps);
            return 0;
        }
        case WM_COMMAND:
        {
            wmId    = LOWORD(wParam);
            wmEvent = HIWORD(wParam);
            switch( wmId )
            {
                default:
                    return DefWindowProc( hWnd, message, wParam, lParam );
            }
            return 0;
        }
        case WM_CLOSE:
            {
                if (crawl_state.need_save)
                    save_game(true);
            }
            break;
        case WM_DESTROY:
        {
            PostQuitMessage( 0 );
            exit(0);
            break;
        }
        default:
            return DefWindowProc( hWnd, message, wParam, lParam );
    }
    return 0;
}
#ifdef USE_TILE
    dib_pack *pBuf = region_tile->backbuf;
    if (new_palette != palette)
    {
        SetDIBColorTable(pBuf->hDC, 0, 256, (RGBQUAD *)lpPalettes[palette]);
    }
}
#endif
bool windows_change_font(char *font_name, int *font_size, bool dos)
{
    CHOOSEFONT cf;
    memset(&cf, 0, sizeof(cf));
    cf.lStructSize = sizeof(cf);
    cf.iPointSize = *font_size;
    cf.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY | CF_NOVERTFONTS
    LOGFONT lf;
    strcpy(lf.lfFaceName, font_name);
    cf.lpLogFont = &lf;
    if (ChooseFont(&cf))
    {
        *font_size = (cf.iPointSize / 10);
        strcpy(font_name, lf.lfFaceName);
    }
}
void windows_get_winpos(int *x, int *y)
{
    WINDOWPLACEMENT wndpl;
    // set length
    wndpl.length = sizeof( WINDOWPLACEMENT );
    {
        *x = wndpl.rcNormalPosition.top;
        *y = wndpl.rcNormalPosition.left;
    }
}
void delay(unsigned long ms)
{
   Sleep((DWORD)ms);
}
int kbhit()
{
    MSG msg;
    if (PeekMessage(&msg, NULL, WM_CHAR, WM_CHAR, PM_NOREMOVE)
        return 1;
    else
        return 0;
}
void update_screen()
{
}
    }
        || PeekMessage(&msg, NULL, WM_KEYDOWN, WM_KEYDOWN, PM_NOREMOVE))
    {
    if (GetWindowPlacement( win_main->hWnd, &wndpl ) != 0)
    return (false);
        return (true);
    lf.lfHeight         = 16;
    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;
    lf.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
    lf.lfCharSet        = (dos)? OEM_CHARSET:ANSI_CHARSET;
               | CF_INITTOLOGFONTSTRUCT | CF_LIMITSIZE | CF_FORCEFONTEXIST;
    cf.nSizeMin  = 8;
    cf.nSizeMax  = 24;
        palette = new_palette;
    int new_palette = PAL_STD; // standard
    if (you.duration[DUR_BERSERKER])
        new_palette = PAL_BER;
    // XXX: is this supposed to override Berserk?
    if (you.special_wield == SPWLD_SHADOW)
        new_palette = PAL_SHA;
void TileDrawDungeonAux()
{
                libgui_shutdown();
            if (mouse_get_mode() == MOUSE_MODE_COMMAND
                || !crawl_state.need_save )
                // XXX: Isn't that always the case?
        case WM_MOVE:
        {
            clix = LOWORD(lParam);
            cliy = HIWORD(lParam);
            return 0;
        }
            ev.type = EV_KEYIN;
            ev_push(&ev);
            if (skip_key)
            {
                skip_key = false;
                return 0;
            }
            return 0;
            if (result)
            {
                if (fs) result |= 512;
                if (fc) result |= 1024;
                if (fa) result |= 2048;
                ev.key = result;
                ev.type = EV_KEYIN;
                ev_push(&ev);
            }
            }
            {
            }
                result = 300 + ch;
            else if (ch >= VK_PAUSE
                     && (ch < VK_CAPITAL || ch > VK_SPACE)
                     && ch != VK_PROCESSKEY
                     && ch != VK_NUMLOCK
                     && (ch < VK_LSHIFT || ch > VK_RMENU)
                     && (ch < 0x30 || ch > 0x39)
                     && (ch < 0x41 || ch > 0x5a)
                     && (ch < 0xa6 || ch > 0xe4))
                ev.type = EV_KEYIN;
                ev_push(&ev);
                if (fa)
                    ch |= 2048;
                    ch += CK_SHIFT_UP - CK_UP;
                    ch += CK_CTRL_UP - CK_UP;
                ch = ck_table[dir-1];
            }
            if (ch >= VK_NUMPAD1 && ch <= VK_NUMPAD9)
            {
                skip_key = true;
                dir = ch - VK_NUMPAD0;
            }
            else if (VK_PRIOR <= ch && ch <= VK_DOWN || ch == VK_CLEAR)
            int dir = 0;
            bool fs = ((GetKeyState(VK_SHIFT)  & 0x80) != 0)? true : false;
            bool fc = ((GetKeyState(VK_CONTROL)& 0x80) != 0)? true : false;
            bool fa = ((GetKeyState(VK_MENU)   & 0x80) != 0)? true : false;
            int ch = (int) wParam;
            ev_push(&ev);
            ev.type = EV_MOVE;
            int z   = (short)HIWORD(wParam);
            ev.x1   = LOWORD(lParam) - clix;
            ev.y1   = HIWORD(lParam) - cliy;
            ev.type = EV_BUTTON;
            ev.sh   = ((GetKeyState(VK_SHIFT)   & 0x80) != 0) ? true : false;
            ev.ct   = ((GetKeyState(VK_CONTROL) & 0x80) != 0) ? true : false;
            ev.key  = (z > 0) ? 4 : 5;
            ev_push(&ev);
        }
            ev_push(&ev);
        {
            ev.type = EV_UNBUTTON;
            ev_push(&ev);
            ev.sh = ((GetKeyState(VK_SHIFT)   & 0x80) != 0)? true : false;
            ev.ct = ((GetKeyState(VK_CONTROL) & 0x80) != 0)? true : false;
            ev.type = EV_BUTTON;
            // Allow line wrap
            SendMessage(hTool, TTM_SETMAXTIPWIDTH, 0, DF_TOOLTIP_WIDTH);
                "This text will tell you" EOL
                " what you are pointing";
            tiTip.cbSize = sizeof (TOOLINFO);
            tiTip.uFlags = TTF_SUBCLASS;
            GetClientRect(hWnd , &tiTip.rect);
            // Example taken from
            // http://black.sakura.ne.jp/~third/system/winapi/common10.html
        CK_END,  CK_DOWN,   CK_PGDN,
        CK_LEFT, CK_INSERT, CK_RIGHT,
        CK_HOME, CK_UP,     CK_PGUP
    const unsigned char ck_table[9] =
    // Redirect output to the console
    AttachConsole(ATTACH_PARENT_PROCESS);
    freopen("CONOUT$", "wb", stdout);
    freopen("CONOUT$", "wb", stderr);
    // I'll be damned if I have to parse lpCmdLine myself...
    int argc;
    LPWSTR *wargv = CommandLineToArgvW(GetCommandLineW(), &argc);
    char *ptr = args;
    for (int i = 0; i < argc; i++)
    {
        wsprintfA(ptr, "%S", wargv[i]);
        argv[i] = ptr;
        ptr += strlen(argv[i]) + 1;
    }
    ASSERT(ptr <= args + args_len);
    old_main(argc, argv);
    delete args;
    delete argv;
    FreeConsole();
    char **argv   = new char*[argc];
    int args_len  = wcslen(GetCommandLineW()) + argc;
    char *args    = new char[args_len];
                   LPSTR lpCmdLine, int nCmdShow )
    if (ev_tail == EV_MAX)
    if (ev_head == EV_MAX)
        if (ev_tail != ev_head)
            break;
    while ( GetMessage(&msg, NULL, 0, 0) )
                  int *x1, int *y1, int *x2, int *y2)
    GlobalFree(lpPalettes[1]);
    GlobalFree(lpPalettes[2]);
    return (true);
    if (strncmp(oldtip, tip, MAXTIP) == 0)
        return;
        ptr    = lpPalettes[2] + i * sizeof(RGBQUAD);
                + TileImg->pDib->bmiColors[i].rgbGreen * 59
                + TileImg->pDib->bmiColors[i].rgbBlue  * 11) / 100;
        LPBYTE ptr = lpPalettes[1] + i * sizeof(RGBQUAD);
    lpPalettes[1] = (LPBYTE)GlobalAlloc(GPTR, 256 * sizeof(RGBQUAD) );
    lpPalettes[2] = (LPBYTE)GlobalAlloc(GPTR, 256 * sizeof(RGBQUAD) );
    WORD chcol;
                  int *x1, int *y1, int *x2, int *y2);
#include "files.h"
#include "debug.h"
#include <fcntl.h>
/*
 *  File:       guic-win.cc
 *  Created by: ennewalker on Sat Jan 5 01:33:53 2008 UTC
 *
 *  Modified for Crawl Reference by $Author: j-p-e-g $ on $Date: 2008-03-07 $
 */
#define _WIN32_WINNT 0x0501

#ifdef USE_X11
#include <X11/Xlib.h>
#include <X11/X.h>
bool GuicInit(Display **d, int *s);
void GuicDeinit();
#elif defined(WIN32TILES)
#include <windows.h>
#include <commdlg.h>
bool GuicInit(HINSTANCE h, int nCmdShow);
void GuicDeinit();
#elif defined(SOME_OS)
#include <some-headers.h>
bool GuicInit(some args);
#endif
#include <vector>
/*
 * Internal Image types
 */
#ifdef USE_X11
/*********** X11 ********/
typedef XImage *img_type;
#define ImgWidth(img) (img->width)
#define ImgHeight(img) (img->height)
#elif defined(WIN32TILES)
/********** Windows *****/
// struct for DIB info
typedef struct dib_pack
{
} dib_pack;
typedef dib_pack *img_type;
#define ImgWidth(img) (img->Width)
#define ImgHeight(img) (img->Height)
#elif defined(SOME_OS)
typedef sometype *img_type;
#define ImgWidth(img) (img->x)
#define ImgHeight(img) (img->y)
#endif
// Image overlay/copy between internal images,
// implemented in winclass-*.cc 
void ImgCopy(img_type src,  int sx, int sy, int wx, int wy,
             img_type dest, int dx, int dy, int copy);
// hilight rim color #010101 to magenta
void ImgCopyH(img_type src,  int sx, int sy, int wx, int wy,
              img_type dest, int dx, int dy, int copy);
// maskout by char array mask
void ImgCopyMasked(img_type src,  int sx, int sy, int wx, int wy,
                   img_type dest, int dx, int dy, char *mask);
// maskout+hilight
void ImgCopyMaskedH(img_type src,  int sx, int sy, int wx, int wy,
                    img_type dest, int dx, int dy, char *mask);
// create internal buffer (not assosiated to any window)
img_type ImgCreateSimple(int wx, int wy);
// create it from file
img_type ImgLoadFile(const char *name);
// destroy
void ImgDestroy(img_type img);
// clear by transparent color
void ImgClear(img_type img);
// if it is pix_transparent #476c6c
bool ImgIsTransparentAt(img_type img, int x, int y);
void ImgSetTransparentPix(img_type img);
/*
 * Windows and internal regions (text, dungeon, map, etc)
 */
class WinClass
{
    public:
    int ox;  //Offset x in dots
    int oy;  //Offset y in dots
    int wx; //width in dots
    int wy; //height in dots
    std::vector<class RegionClass *> regions;
    std::vector<int> layers;
    int active_layer;
    // Pointer to the window
#ifdef USE_X11
    Window win;
#elif defined(WIN32TILES)
    HWND hWnd;
#elif defined(SOME_OS)
    somewindowtype win;
#endif
    WinClass();
    void SysInit();
    void SysDeinit();
    ~WinClass();
    // fillout with black: Sys dep
    void clear();
    // create: Sys dep
#ifdef USE_X11
    void create(char *name);
#elif defined(WIN32TILES)
    BOOL create(const char *name);
#elif defined(SOME_OS)
    void create(some args);
#endif
    void resize(int wx, int wy);
    void resize();
    void move(int ox, int oy);
    void move();
    // place Regions inside it
                     int pflag,
                     int margin_bottom = 0, int margin_right = 0);
                      int x, int y,
                      int margin_bottom = 0, int margin_right = 0);
    // fillout a rectangle
    void fillrect(int left, int right, int top, int bottom, int color);
    // redraw for exposure, etc
    void redraw(int x1, int y1, int x2, int y2);
    void redraw();
};
class RegionClass
{
    public:
    WinClass *win;
    int layer;
    // Geometry
    // <-----------------wx----------------------->
    // sx     ox                                ex
    // |margin| text/tile area            |margin|
    int ox;  //Offset x in dots
    int oy;  //Offset y in dots
    int dx;  //unit width
    int dy;  //unit height
    int mx;  //window width in dx
    int my;  //window height in dy
    int wx; //width in dots = dx*mx + margins
    int wy; //height in dots = dy*my + margins
    int sx; //Left edge pos
    int sy; //Top edge pos
    int ex; //right edge pos
    int ey; //bottom edge pos
    bool flag;// use or no
    int id; // for general purpose
    // pointer to internal backup image buffer
    // used for redraw and supplessing flicker
    img_type backbuf;
#ifdef WIN32TILES
    static void set_std_palette(RGBQUAD *pPal);
    static RGBQUAD std_palette[256];
    void init_backbuf(RGBQUAD *pPal = NULL, int ncol = 0);
    bool dos_char;
#else
    void init_backbuf();
#endif
    void resize_backbuf();
    // font-related 
    int fx; // font height and width (can differ from dx, dy)
    int fy;
#ifdef USE_X11
    int asc; //font ascent
  #ifdef JP
    XFontSet font; //fontset
  #else
    XFontStruct *font;
  #endif
    void init_font(const char *name);
#elif defined(WIN32TILES)
    HFONT font;
    void init_font(const char *name, int height);
    void change_font(const char *name, int height);
#elif defined(SOME_OS)
    sometype font;
    void init_font(some args);
#endif
    bool font_copied;
    void copy_font(RegionClass *r);
    // init/deinit
    RegionClass();
    virtual ~RegionClass();
    // system-dependent init/deinit
    void SysInit();
    void SysDeinit();
    // Sys indep
    bool is_active();
    void make_active();
    //Sys indep
    // convert mouse point into logical position
    virtual bool mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy);
    virtual bool convert_redraw_rect(int x1, int y1, int x2, int y2, 
                      int *rx1, int *ry1, int *rx2, int *ry2);
    virtual void redraw(int x1, int y1, int x2, int y2);
    virtual void redraw();
    void sys_flush();
    virtual void fillrect(int left, int right, int top, int bottom, int color);
    virtual void framerect(int left, int right, int top, int bottom, int color);
    virtual void clear();
};
class TextRegionClass :public RegionClass
{
    public:
    // init/deinit
    TextRegionClass(int x, int y , int cx, int cy);
    ~TextRegionClass();
    // os dependent init/deinit
    void SysInit(int x, int y, int cx, int cy);
    void SysDeinit();
    // where now printing? what color?
    static int print_x;
    static int print_y;
    static int text_col;
    // which region now printing?
    static class TextRegionClass *text_mode;
    // display cursor? where is the cursor now?
    static int cursor_flag;
    static class TextRegionClass *cursor_region;
    static int cursor_x;
    static int cursor_y;
    // class methods
    static int wherex();
    static int wherey();
    //static int get_number_of_lines(void);
    static void _setcursortype(int curstype);
    static void textbackground(int bg);
    static void textcolor(int col);
    // Object's method
    void clear_to_end_of_line(void);
    void clear_to_end_of_screen(void);
    void putch(unsigned char chr);
    void writeWChar(unsigned char *ch);
    unsigned char *cbuf; //text backup
    unsigned char *abuf; //textcolor backup
    int cx_ofs; //cursor x offset
    int cy_ofs; //cursor y offset
    void addstr(char *buffer);
    void addstr_aux(char *buffer, int len);
    void adjust_region(int *x1, int *x2, int y);
    void scroll();
    //bool mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy);
    //Sys dep
    void draw_string(int x, int y, unsigned char *buf, int len, int col);
    void draw_cursor(int x, int y, int width);
    void draw_cursor(int x, int y);
    void erase_cursor();
    void clear();
    void init_backbuf();
    void redraw(int x1, int y1, int x2, int y2);
    void resize(int x, int y);
};
class TileRegionClass :public RegionClass
{
    public:
    bool force_redraw;
    void DrawPanel(int left, int top, int width, int height);
    void fillrect(int left, int right, int top, int bottom, int color);
    void framerect(int left, int right, int top, int bottom, int color);
    bool mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy);
    virtual bool convert_redraw_rect(int x1, int y1, int x2, int y2, 
                      int *rx1, int *ry1, int *rx2, int *ry2);
    void redraw(int x1, int y1, int x2, int y2);
    void redraw();
    void clear();
    //Sys dep
    void resize(int x, int y, int dx, int dy);
#ifdef WIN32TILES
    void init_backbuf(RGBQUAD *pPal = NULL);
#else
    void init_backbuf();
#endif
    void resize_backbuf();
    TileRegionClass(int mx0, int my0, int dx0, int dy0);
    void SysInit(int mx0, int my0, int dx0, int dy0);
    void SysDeinit();
    ~TileRegionClass();
};
{
    int mx2;
    int my2;
    int x_margin;
    int y_margin;
    unsigned char *mbuf;
    bool force_redraw;
    bool mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy);
    void redraw(int x1, int y1, int x2, int y2);
    void redraw();
    void clear();
    //Sys dep
    void init_backbuf();
    void resize_backbuf();
    void resize(int mx0, int my0, int dx0, int dy0);
    void set_col(int col, int x, int y);
    int get_col(int x, int y);
    void SysInit(int x, int y, int o_x, int o_y);
    void SysDeinit();
};
#define PLACE_RIGHT 0
#define PLACE_BOTTOM 1
#define PLACE_FORCE 2
// Graphics Colors
#define PIX_BLACK 0
#define PIX_BLUE 1
#define PIX_GREEN 2
#define PIX_CYAN 3
#define PIX_RED 4
#define PIX_MAGENTA 5
#define PIX_BROWN 6
#define PIX_LIGHTGREY 7
#define PIX_DARKGREY 8
#define PIX_LIGHTBLUE 9
#define PIX_LIGHTGREEN 10
#define PIX_LIGHTCYAN 11
#define PIX_LIGHTRED 12
#define PIX_LIGHTMAGENTA 13
#define PIX_YELLOW 14
#define PIX_WHITE 15
#define MAX_TERM_COL 16
#define MAP_BLACK  0
#define MAP_DKGREY 1
#define MAP_MDGREY 2
#define MAP_LTGREY 3
#define MAP_WHITE  4
#define MAP_BLUE   5
#define MAP_LTBLUE 6
#define MAP_DKBLUE 7
#define MAP_GREEN    8
#define MAP_LTGREEN  9
#define MAP_DKGREEN 10
#define MAP_CYAN    11
#define MAP_LTCYAN  12
#define MAP_DKCYAN  13
#define MAP_RED     14
#define MAP_LTRED   15
#define MAP_DKRED   16
#define MAP_MAGENTA   17
#define MAP_LTMAGENTA 18
#define MAP_DKMAGENTA 19
#define MAP_YELLOW   20
#define MAP_LTYELLOW 21
#define MAP_DKYELLOW 22
#define MAP_BROWN    23
#define MAX_MAP_COL 24
extern const int term_colors[MAX_TERM_COL][3];
extern const int map_colors[MAX_MAP_COL][3];
protected:
    int old_mark_x;
    int old_mark_y;
    MapRegionClass(int x, int y, int o_x, int o_y, int marker_length);
    ~MapRegionClass();
    void draw_data(unsigned char *buf, bool show_mark, int mark_x, int mark_y);
    int marker_length;
public:
class MapRegionClass : public RegionClass
    static void cgotoxy(int x, int y);
    void removeRegion(class RegionClass *r);
                      int margin_top = 0, int margin_left = 0,
    void placeRegion(class RegionClass *r, int layer,
                     int margin_top = 0, int margin_left = 0,
    void placeRegion(class RegionClass *r, int layer,
                     class RegionClass *neighbor,
    LPBITMAPINFO       pDib     ;
    HBITMAP            hDib     ;
    HDC                hDC      ;
    LPBYTE             pDibBits ;
    LPBYTE             pDibZero ;
    int                Width    ;
    int                Height   ;
/*
 *  File:       guic-win.cc
 *  Created by: ennewalker on Sat Jan 5 01:33:53 2008 UTC
 *
 *  Modified for Crawl Reference by $Author: j-p-e-g $ on $Date: 2008-03-07 $
 */

 */
#include "guic.h"
#ifdef WIN32TILES
#else
#define dos_char false;
#endif
int TextRegionClass::print_x;
int TextRegionClass::print_y;
TextRegionClass *TextRegionClass::text_mode = NULL;
int TextRegionClass::text_col = 0;
TextRegionClass *TextRegionClass::cursor_region= NULL;
int TextRegionClass::cursor_flag = 0;
int TextRegionClass::cursor_x;
int TextRegionClass::cursor_y;
// more logical color naming
{
    {  0,   0,   0}, // BLACK
    {128, 128, 128}, // DKGREY
    {160, 160, 160}, // MDGREY
    {192, 192, 192}, // LTGREY
    {255, 255, 255}, // WHITE
    {  0,  64, 255}, // BLUE  (actually cyan-blue)
    {128, 128, 255}, // LTBLUE
    {  0,  32, 128}, // DKBLUE (maybe too dark)
    {  0, 255,   0}, // GREEN
    {128, 255, 128}, // LTGREEN
    {  0, 128,   0}, // DKGREEN
    {  0, 255, 255}, // CYAN
    { 64, 255, 255}, // LTCYAN (maybe too pale)
    {  0, 128, 128}, // DKCYAN
    {255,   0,   0}, // RED
    {255, 128, 128}, // LTRED (actually pink)
    {128,   0,   0}, // DKRED
    {192,   0, 255}, // MAGENTA (actually blue-magenta)
    {255, 128, 255}, // LTMAGENTA
    { 96,   0, 128}, // DKMAGENTA
    {255, 255,   0}, // YELLOW
    {255, 255,  64}, // LTYELLOW (maybe too pale)
    {128, 128,   0},  // DKYELLOW
    {165,  91,   0},  // BROWN
};
{
    {  0,   0,   0}, // BLACK
    {  0,  82, 255}, // BLUE
    {100, 185,  70}, // GREEN
    {  0, 180, 180}, // CYAN
    {255,  48,   0}, // RED
    {238,  92, 238}, // MAGENTA
    {165,  91,   0}, // BROWN
    {162, 162, 162}, // LIGHTGREY
    { 82,  82,  82}, // DARKGREY
    { 82, 102, 255}, // LIGHTBLUE
    { 82, 255,  82}, // LIGHTGREEN
    { 82, 255, 255}, // LIGHTCYAN
    {255,  82,  82}, // LIGHTRED
    {255,  82, 255}, // LIGHTMAGENTA
    {255, 255,  82}, // YELLOW
    {255, 255, 255}  // WHITE
};
WinClass::WinClass()
{
    // Minimum;
    wx = 10;
    wy = 10;
    ox = 0;
    oy = 0;
    SysInit();
}
WinClass::~WinClass()
{
    SysDeinit();
    regions.clear();
    layers.clear();
}
void WinClass::placeRegion(RegionClass *r, int layer0,
     int x, int y,
     int margin_top, int margin_left,
     int margin_bottom, int margin_right)
{
    if (r->win == NULL)
    {
        regions.push_back(r);
        layers.push_back(layer0);
    }
    r->win = this;
    r->layer = layer0;
    r->flag = true;
    r->sx = x;
    r->sy = y;
    r->ox = r->sx + margin_left;
    r->oy = r->sy + margin_top;
    r->wx = r->dx * r->mx + margin_left + margin_right;
    r->wy = r->dy * r->my + margin_top + margin_bottom;
    r->ex = r->sx + r->wx;
    r->ey = r->sy + r->wy;
    if (r->ex > wx) wx = r->ex;
    if (r->ey > wy) wy = r->ey;
}
void WinClass::placeRegion(RegionClass *r, int layer0,
     RegionClass *neighbor, int pflag,
     int margin_top, int margin_left,
     int margin_bottom, int margin_right)
{
    int x = 0;
    int y = 0;
    if (neighbor!=NULL)
    {
        sx0 = neighbor->sx;
        sy0 = neighbor->sy;
        ex0 = neighbor->ex;
        ey0 = neighbor->ey;
    }
    if (pflag == PLACE_RIGHT)
    {
        x = ex0;
        y = sy0;
    }
    else
    {
        x = sx0;
        y = ey0;
    }
    placeRegion(r, layer0, x, y, margin_top, margin_left,
     margin_bottom, margin_right);
}
void WinClass::redraw(int x1, int y1, int x2, int y2)
{
    std::vector <RegionClass *>::iterator r;
    int cx1, cx2, cy1, cy2;
    {
            (*r)->redraw(cx1, cy1, cx2, cy2);
    }
}
void WinClass::redraw()
{
    redraw(0, 0, wx-1, wy-1);
}
void WinClass::move(int ox0, int oy0)
{
    ox = ox0;
    oy = oy0;
    move(); // system dependent
}
void WinClass::resize(int wx0, int wy0)
{
    if (wx0>0) wx = wx0;
    if (wy0>0) wy = wy0;
    resize(); // system dependent
}
RegionClass::RegionClass()
{
    flag = false;
    win = NULL;
    backbuf = NULL;
    SysInit();
    ox = oy = 0;
    dx = dy = 1;
    font_copied = false;
    id = 0;
}
RegionClass::~RegionClass()
{
    SysDeinit();
}
void TextRegionClass::resize(int x, int y)
{
    int i;
    free(cbuf);
    free(abuf);
    cbuf = (unsigned char *)malloc(x*y);
    abuf = (unsigned char *)malloc(x*y);
    {
    }
    mx = x;
    my = y;
}
TextRegionClass::TextRegionClass(int x, int y, int cx, int cy)
{
    cbuf = NULL;
    abuf = NULL;
    resize(x, y);
    // Cursor Offset
    cx_ofs = cx;
    cy_ofs = cy;
    SysInit(x, y, cx, cy);
}
TextRegionClass::~TextRegionClass()
{
    SysDeinit();
    free(cbuf);
    free(abuf);
}
TileRegionClass::TileRegionClass(int mx0, int my0, int dx0, int dy0)
{
    // Unit size
    dx = dx0;
    dy = dy0;
    mx = mx0;
    my = my0;
    force_redraw = false;
    SysInit(mx0, my0, dx0, dy0);
}
TileRegionClass::~TileRegionClass()
{
    SysDeinit();
}
void TileRegionClass::resize(int mx0, int my0, int dx0, int dy0)
{
    if (mx0 != 0) mx = mx0;
    if (my0 != 0) my = my0;
    if (dx0 != 0) dx = dx0;
    if (dy0 != 0) dy = dy0;
}
{
    int i;
    mx2 = x;
    my2 = y;
    mx = mx2;
    my = my2;
    mbuf = (unsigned char *)malloc(mx2*my2);
    x_margin = o_x;
    y_margin = o_y;
    force_redraw = false;
    SysInit(x, y, o_x, o_y);
}
MapRegionClass::~MapRegionClass()
{
    SysDeinit();
    free(mbuf);
}
void MapRegionClass::resize(int mx0, int my0, int dx0, int dy0)
{
    if (mx0 != 0) mx2 = mx0;
    if (my0 != 0) my2 = my0;
    if (dx0 != 0) dx = dx0;
    if (dy0 != 0) dy = dy0;
    if (mx0 != 0 || my0 != 0)
    {
        int i;
        free(mbuf);
        mbuf = (unsigned char *)malloc(mx2*my2);
    }
}
/*------------------------------------------*/
bool RegionClass::is_active()
{
    if (win->active_layer == layer)
}
void RegionClass::make_active()
{
    win->active_layer = layer;
void RegionClass::redraw(int x1, int y1, int x2, int y2)
{
}
void RegionClass::redraw()
{
    redraw(0, 0, mx-1, my-1);
}
void MapRegionClass::redraw()
{
    redraw(0, 0, mx-1, my-1);
}
void TileRegionClass::redraw()
{
    redraw(0, 0, mx*dx-1, my*dy-1);
}
void MapRegionClass::set_col(int col, int x, int y)
{
    mbuf[x + y * mx2] = col;
}
int MapRegionClass::get_col(int x, int y)
{
    return mbuf[x + y * mx2];
}
/*------------------------------------------*/
                  int *rx1, int *ry1, int *rx2, int *ry2)
{
    int cx1 = x1-ox;
    int cy1 = y1-oy;
    int cx2 = x2-ox;
    int cy2 = y2-oy;
    cx1 /= dx;
    cy1 /= dy;
    cx2 /= dx;
    cy2 /= dy;
    *rx1 = cx1;
    *ry1 = cy1;
    *rx2 = cx2;
    *ry2 = cy2;
}
{
    int cx1 = x1-ox;
    int cy1 = y1-oy;
    int cx2 = x2-ox;
    int cy2 = y2-oy;
    int wwx = dx*mx;
    int wwy = dy*my;
    *rx1 = cx1;
    *ry1 = cy1;
    *rx2 = cx2;
    *ry2 = cy2;
}
bool RegionClass::mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy)
{
    int x = mouse_x - ox;
    int y = mouse_y - oy;
    x /= dx;
    y /= dy;
    *cx = x;
    *cy = y;
}
bool MapRegionClass::mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy)
{
    x /= dx;
    y /= dy;
    *cx = x;
    *cy = y;
}
bool TileRegionClass::mouse_pos(int mouse_x, int mouse_y, int *cx, int *cy)
{
    int x = mouse_x - ox;
    int y = mouse_y - oy;
    x /= dx;
    y /= dy;
    *cx = x;
    *cy = y;
}
void TextRegionClass::scroll()
{
    int idx;
        return;
    {
        cbuf[idx] = cbuf[idx + mx];
        abuf[idx] = abuf[idx + mx];
    }
    {
        cbuf[idx] = ' ';
        abuf[idx] = 0;
    }
    redraw(0, 0, mx-1, my-1);
}
void TextRegionClass::adjust_region(int *x1, int *x2, int y)
{
    *x2 = *x2 + 1;
}
void TextRegionClass::addstr(char *buffer)
{
    int i,j;
    char buf2[1024];
    int len = strlen(buffer);
    {
        char c = buffer[i];
        {
            newline = true;
                i++;
        }
        buf2[j] = c;
        j++;
        {
            if (j-1 != 0)
                addstr_aux(buf2, j - 1); // draw it
            if (newline)
            {
                print_x = cx_ofs;
                print_y++;
            }
        }
    }
}
void TextRegionClass::addstr_aux(char *buffer, int len)
{
    int i;
    int x = print_x - cx_ofs;
    int y = print_y - cy_ofs;
    int adrs = y * mx;
    int head = x;
    int tail = x + len - 1;
    adjust_region(&head, &tail, y);
    {
    }
    draw_string(head, y, &cbuf[adrs+head], tail-head, text_col);
    print_x += len;
}
void TextRegionClass::redraw(int x1, int y1, int x2, int y2)
{
    int x, y;
    {
        unsigned char *a = &abuf[y * mx];
        unsigned char *c = &cbuf[y * mx];
        int head = x1;
        int tail = x2;
        adjust_region(&head, &tail, y);
        int col = a[x];
        {
            int oldcol = col;
                col = -1;
            else
                col = a[x];
            if (oldcol != col)
            {
                draw_string(head, y, &c[head], x-head, oldcol);
                head = x;
            }
            x++;
        }
    }
        draw_cursor(cursor_x, cursor_y);
    sys_flush();
}
void TextRegionClass::clear_to_end_of_line()
{
    int i;
    int cx = print_x - cx_ofs;
    int cy = print_y - cy_ofs;
    int col = text_col;
    int adrs = cy * mx;
    }
    redraw(cx, cy, mx-1, cy);
}
void TextRegionClass::clear_to_end_of_screen()
{
    int i;
    int cy = print_y - cy_ofs;
    int col = text_col;
    }
    redraw(0, cy, mx-1, my-1);
}
void TextRegionClass::putch(unsigned char ch)
{
    addstr_aux((char *)&ch, 1);
}
void TextRegionClass::writeWChar(unsigned char *ch)
{
    addstr_aux((char *)ch, 2);
}
void TextRegionClass::textcolor(int color)
{
    text_col = color;
}
void TextRegionClass::textbackground(int col)
{
    textcolor(col*16 + (text_col & 0xf));
}
{
    print_x = x-1;
    print_y = y-1;
    if (cursor_region != NULL && cursor_flag)
    {
        cursor_region ->erase_cursor();
        cursor_region = NULL;
    }
    if (cursor_flag)
    {
        text_mode->draw_cursor(print_x, print_y);
        cursor_x = print_x;
        cursor_y = print_y;
        cursor_region = text_mode;
    }
}
int  TextRegionClass::wherex()
{
    return print_x + 1;
}
int  TextRegionClass::wherey()
{
    return print_y + 1;
}
void TextRegionClass::_setcursortype(int curstype)
{
    cursor_flag = curstype;
    if (cursor_region != NULL)
    if (curstype)
    {
        text_mode->draw_cursor(print_x, print_y);
        cursor_x = print_x;
        cursor_y = print_y;
        cursor_region = text_mode;
    }
}
        cursor_region->erase_cursor();
    ASSERT(x >= 1);
    ASSERT(y >= 1);
void TextRegionClass::cgotoxy(int x, int y)
    if (ch == 0)
        ch=32;
    for (i = cy*mx; i < mx*my; i++)
    {
        cbuf[i] = ' ';
        abuf[i] = col;
    if (!flag)
        return;
        cbuf[adrs+i] = ' ';
        abuf[adrs+i] = col;
    ASSERT(adrs + mx - 1 < mx * my);
    for (i = cx; i < mx; i++)
    {
        return;
    if (!flag)
    if (cursor_region == this && cursor_flag == 1)
            if (x == tail)
        while (x <= tail)
        x = head;
    for (y = y1; y <= y2; y++)
        return;
    if (!flag)
        cbuf[adrs+x+i] = buffer[i];
        abuf[adrs+x+i] = text_col;
    for (i = 0; i < len && x + i < mx; i++)
        return;
    if (!flag)
    if (cursor_flag)
        cgotoxy(print_x+1, print_y+1);
                    scroll();
                if (print_y - cy_ofs == my)
                j = 0;
        if (c == 0)
            if (buffer[i+1] == '\n' || buffer[i+1] == '\r')
            c = 0;
        bool newline = false;
        if (c == '\n' || c == '\r')
    for (i = 0; i < len + 1; i++)
    j = 0;
    if (!flag)
        return;
    if (print_y > 0)
        print_y -= 1;
    if (cursor_y > 0)
        cursor_y -= 1;
    for (idx = mx*(my-1); idx < mx*my; idx++)
    for (idx = 0; idx < mx*(my-1); idx++)
    if (!flag)
//
// Text related
//
    return (true);
    if (!is_active())
        return (false);
    if (x < 0 || y < 0)
        return (false);
    if (x >= dx * mx || y >= dy * my)
        return (false);
    return (true);
    if (x >= mx || y >= my)
        return (false);
    if (!is_active())
        return (false);
    int x = mouse_x - ox - x_margin;
    int y = mouse_y - oy - y_margin;
    if (x < 0 || y < 0)
        return (false);
    return (true);
    if (x >= mx || y >= my)
        return (false);
    if (!is_active())
        return (false);
    if ( x < 0 || y < 0 )
        return (false);
    return (true);
    if (cx2 >= wwx - 1)
        cx2 = wwx - 1;
    if (cy2 >= wwy - 1)
        cy2 = wwy - 1;
    if (cx1 < 0)
        cx1 = 0;
    if (cy1 < 0)
        cy1 = 0;
    if (cx2 < 0 || cy2 < 0 || cx1 >= wwx || cy1 >=wwy)
        return (false);
bool TileRegionClass::convert_redraw_rect(int x1, int y1, int x2, int y2,
                                          int *rx1, int *ry1,
                                          int *rx2, int *ry2)
    return (true);
    if (cx2 >= mx - 1)
        cx2 = mx - 1;
    if (cy2 >= my - 1)
        cy2 = my - 1;
    if (cx1 < 0)
        cx1 = 0;
    if (cy1 < 0)
        cy1 = 0;
    if (cx2 < 0 || cy2 < 0 || cx1 >= dx * mx || cy1 >= dy * my)
        return (false);
bool RegionClass::convert_redraw_rect(int x1, int y1, int x2, int y2,
}
    if (!flag)
        return;
        return (true);
    else
        return (false);
    if (!flag)
        return (false);
        for (i = 0; i < mx2*my2; i++)
            mbuf[i] = 0;
    marker_length = marker_len;
    old_mark_x = old_mark_y = 0;
    for (i = 0; i < mx2*my2; i++)
        mbuf[i] = 0;
MapRegionClass::MapRegionClass(int x, int y, int o_x, int o_y, int marker_len)
        cbuf[i] = ' ';
        abuf[i] = 0;
    for (i = 0; i < x*y; i++)
    if (backbuf != NULL)
        ImgDestroy(backbuf);
        if (!(*r)->is_active())
            continue;
        if ( (*r)->convert_redraw_rect(x1, y1, x2, y2, &cx1, &cy1, &cx2, &cy2) )
    for (r = regions.begin();r != regions.end();r++)
            return;
        }
    }
}
void WinClass::removeRegion(RegionClass *r)
{
    for (unsigned int i = 0; i < regions.size(); i++)
    {
        if (regions[i] == r)
        {
            for (unsigned int j = i + 1; j < regions.size(); j++)
            {
                regions[j-1] = regions[j];
                layers[j-1] = layers[j];
            }
            regions.pop_back();
            layers.pop_back();
    int sx0 = 0;
    int sy0 = 0;
    int ex0 = 0;
    int ey0 = 0;
const int term_colors[MAX_TERM_COL][3] =
const int map_colors[MAX_MAP_COL][3] =
#include "AppHdr.h"
#include "debug.h"
/*
 *  File:       guic-win.cc
 *  Summary:    1) Image manipulation routines
 *              2) WinClass and RegionClass system independent imprementaions
 *              see guic-*.cc for  system dependent implementations
 *  Created by: ennewalker on Sat Jan 5 01:33:53 2008 UTC
 *
 *  Modified for Crawl Reference by $Author: j-p-e-g $ on $Date: 2008-03-07 $