/*-------------------------------------------------------------------------*/
HWND mswin_init_command_window () {
static int run_once = 0;
HWND ret;
/* register window class */
if( !run_once ) {
register_command_window_class();
run_once = 1;
}
/* create window */
ret = CreateWindow(
szNHCmdWindowClass, /* registered class name */
NULL, /* window name */
WS_CHILD | WS_CLIPSIBLINGS, /* window style */
0, /* horizontal position of window - set it later */
0, /* vertical position of window - set it later */
0, /* window width - set it later */
0, /* window height - set it later*/
GetNHApp()->hMainWnd, /* handle to parent or owner window */
NULL, /* menu handle or child identifier */
GetNHApp()->hApp, /* handle to application instance */
NULL ); /* window-creation data */
if( !ret ) {
panic("Cannot create command window");
}
return ret;
}
HWND
mswin_init_main_window()
{
static int run_once = 0;
HWND ret;
RECT rc;
/* register window class */
if (!run_once) {
LoadString(GetNHApp()->hApp, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
register_main_window_class();
run_once = 1;
}
/* create the main window */
SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0);
ret = CreateWindow(szMainWindowClass, /* registered class name */
szTitle, /* window name */
WS_CLIPCHILDREN, /* window style */
rc.left, /* horizontal position of window */
rc.top, /* vertical position of window */
rc.right - rc.left, /* window width */
rc.bottom - rc.top, /* window height */
NULL, /* handle to parent or owner window */
NULL, /* menu handle or child identifier */
GetNHApp()->hApp, /* handle to application instance */
NULL /* window-creation data */
);
if (!ret)
panic("Cannot create main window");
return ret;
}
/* on WM_CREATE */
void
onCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
PNHMapWindow data;
int i, j;
/* set window data */
data = (PNHMapWindow) malloc(sizeof(NHMapWindow));
if (!data)
panic("out of memory");
ZeroMemory(data, sizeof(NHMapWindow));
for (i = 0; i < COLNO; i++)
for (j = 0; j < ROWNO; j++) {
data->map[i][j] = -1;
}
data->bAsciiMode = FALSE;
data->xScrTile = GetNHApp()->mapTile_X;
data->yScrTile = GetNHApp()->mapTile_Y;
data->xLastMouseClick = data->yLastMouseClick = -1;
SetWindowLong(hWnd, GWL_USERDATA, (LONG) data);
}
HWND
mswin_init_map_window()
{
static int run_once = 0;
HWND ret;
DWORD styles;
if (!run_once) {
register_map_window_class();
run_once = 1;
}
styles = WS_CHILD | WS_CLIPSIBLINGS;
if (!GetNHApp()->bHideScrollBars)
styles |= WS_HSCROLL | WS_VSCROLL;
ret = CreateWindow(
szNHMapWindowClass, /* registered class name */
NULL, /* window name */
styles, /* window style */
0, /* horizontal position of window - set it later */
0, /* vertical position of window - set it later */
0, /* window width - set it later */
0, /* window height - set it later*/
GetNHApp()->hMainWnd, /* handle to parent or owner window */
NULL, /* menu handle or child identifier */
GetNHApp()->hApp, /* handle to application instance */
NULL); /* window-creation data */
if (!ret) {
panic("Cannot create map window");
}
return ret;
}
HWND mswin_init_status_window(void)
{
static int run_once = 0;
HWND ret;
NHStatusWindow* data;
if( !run_once ) {
register_status_window_class( );
run_once = 1;
}
ret = CreateWindow(
szStatusWindowClass,
NULL,
WS_CHILD | WS_DISABLED | WS_CLIPSIBLINGS,
0, /* x position */
0, /* y position */
0, /* x-size - we will set it later */
0, /* y-size - we will set it later */
GetNHApp()->hMainWnd,
NULL,
GetNHApp()->hApp,
NULL );
if( !ret ) panic("Cannot create status window");
EnableWindow(ret, FALSE);
data = (PNHStatusWindow)malloc(sizeof(NHStatusWindow));
if( !data ) panic("out of memory");
ZeroMemory(data, sizeof(NHStatusWindow));
SetWindowLongPtr(ret, GWLP_USERDATA, (LONG_PTR)data);
return ret;
}
/*-------------------------------------------------------------------------*/
void NHSPhoneSetKeypadDefault()
{
PNHCmdWindow data;
data = (PNHCmdWindow)GetWindowLong(GetNHApp()->hCmdWnd, GWL_USERDATA);
if( !data ) return;
if( nhcmdset_current!=nhcmdset_default ) nhcmdset_destroy( nhcmdset_current );
nhcmdset_current = nhcmdset_default;
SetCmdWindowLayout(
GetNHApp()->hCmdWnd,
data->layout_selected ? data->layout_selected : nhcmdset_get(nhcmdset_current, 0)
);
}
/*-------------------------------------------------------------------------*/
void NHSPhoneSetKeypadDirection()
{
PNHCmdWindow data;
data = (PNHCmdWindow)GetWindowLong(GetNHApp()->hCmdWnd, GWL_USERDATA);
if( !data ) return;
if( nhcmdset_current!=nhcmdset_default ) nhcmdset_destroy( nhcmdset_current );
nhcmdset_current = nhcmdset_default;
SetCmdWindowLayout(
GetNHApp()->hCmdWnd,
nhcmdset_get(nhcmdset_current, NH_LAYOUT_MOVEMENT)
);
}
/*-------------------------------------------------------------------------*/
void onCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
PNHCmdWindow data;
/* set window data */
data = (PNHCmdWindow)malloc(sizeof(NHCmdWindow));
if( !data ) panic("out of memory");
ZeroMemory(data, sizeof(NHCmdWindow));
SetWindowLong(hWnd, GWL_USERDATA, (LONG)data);
data->active_cell = -1;
/* load images bitmap */
data->images = LoadBitmap(GetNHApp()->hApp, MAKEINTRESOURCE(IDB_KEYPAD));
if( !data->images ) panic("cannot load keypad bitmap");
/* create default layouts */
data->layout_current = 0;
data->layout_save = 0;
data->cells = 0;
#if defined(WIN_CE_SMARTPHONE)
data->layout_selected = nhcmdset_get(nhcmdset_current, 0);
#endif
/* set default layout */
SetCmdWindowLayout(hWnd, nhcmdset_get(nhcmdset_current, 0));
}
HWND mswin_init_menu_window (int type) {
HWND ret;
ret = CreateDialog(
GetNHApp()->hApp,
MAKEINTRESOURCE(IDD_MENU),
GetNHApp()->hMainWnd,
MenuWndProc
);
if( !ret ) {
panic("Cannot create menu window");
}
SetMenuType(ret, type);
return ret;
}
/*-------------------------------------------------------------------------*/
void register_command_window_class()
{
WNDCLASS wcex;
PNHCmdLayout plt;
ZeroMemory( &wcex, sizeof(wcex));
/* window class */
wcex.style = CS_NOCLOSE;
wcex.lpfnWndProc = (WNDPROC)NHCommandWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = GetNHApp()->hApp;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = mswin_get_brush(NHW_KEYPAD, MSWIN_COLOR_BG);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szNHCmdWindowClass;
if( !RegisterClass(&wcex) ) {
panic("cannot register Map window class");
}
/* create default command set */
nhcmdset_current = nhcmdset_default = nhcmdset_create();
#ifdef WIN_CE_SMARTPHONE
plt = nhcmdlayout_create("General", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_general);
nhcmdset_add(nhcmdset_current, plt);
plt = nhcmdlayout_create("Movement", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_movement);
nhcmdset_add(nhcmdset_current, plt );
plt = nhcmdlayout_create("Attack", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_attack);
nhcmdset_add(nhcmdset_current, plt);
plt = nhcmdlayout_create("Item Handling", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_item_handling);
nhcmdset_add(nhcmdset_current, plt);
plt = nhcmdlayout_create("Game Controls", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_game);
nhcmdset_add(nhcmdset_current, plt);
plt = nhcmdlayout_create("Advanced Movement", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_adv_movement);
nhcmdset_add(nhcmdset_current, plt);
#else /* ! WIN_CE_SMARTPHONE */
plt = nhcmdlayout_create("lowercase", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_mod1);
nhcmdset_add(nhcmdset_current, plt);
plt = nhcmdlayout_create("uppercase", NH_CMDPAD_ROWS, NH_CMDPAD_COLS);
nhcmdlayout_init(plt, cells_layout_mod2);
nhcmdset_add(nhcmdset_current, plt);
#endif /* WIN_CE_SMARTPHONE */
}
/* on WM_HSCROLL */
void
onMSNH_HScroll(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
PNHMapWindow data;
SCROLLINFO si;
int xNewPos;
int xDelta;
/* get window data */
data = (PNHMapWindow) GetWindowLong(hWnd, GWL_USERDATA);
switch (LOWORD(wParam)) {
/* User clicked shaft left of the scroll box. */
case SB_PAGEUP:
xNewPos = data->xPos - data->xPageSize;
break;
/* User clicked shaft right of the scroll box. */
case SB_PAGEDOWN:
xNewPos = data->xPos + data->xPageSize;
break;
/* User clicked the left arrow. */
case SB_LINEUP:
xNewPos = data->xPos - 1;
break;
/* User clicked the right arrow. */
case SB_LINEDOWN:
xNewPos = data->xPos + 1;
break;
/* User dragged the scroll box. */
case SB_THUMBTRACK:
xNewPos = HIWORD(wParam);
break;
default:
xNewPos = data->xPos;
}
xNewPos = max(0, min(COLNO - data->xPageSize + 1, xNewPos));
if (xNewPos == data->xPos)
return;
xDelta = xNewPos - data->xPos;
data->xPos = xNewPos;
ScrollWindowEx(hWnd, -data->xScrTile * xDelta, 0, (CONST RECT *) NULL,
(CONST RECT *) NULL, (HRGN) NULL, (LPRECT) NULL,
SW_INVALIDATE | SW_ERASE);
if (!GetNHApp()->bHideScrollBars) {
si.cbSize = sizeof(si);
si.fMask = SIF_POS;
si.nPos = data->xPos;
SetScrollInfo(hWnd, SB_HORZ, &si, TRUE);
}
}
HWND
mswin_init_text_window()
{
HWND ret;
PNHTextWindow data;
RECT rt;
/* get window position */
if (GetNHApp()->bAutoLayout) {
SetRect(&rt, 0, 0, 0, 0);
} else {
mswin_get_window_placement(NHW_TEXT, &rt);
}
/* create text widnow object */
ret = CreateDialog(GetNHApp()->hApp, MAKEINTRESOURCE(IDD_NHTEXT),
GetNHApp()->hMainWnd, NHTextWndProc);
if (!ret)
panic("Cannot create text window");
/* move it in the predefined position */
if (!GetNHApp()->bAutoLayout) {
MoveWindow(ret, rt.left, rt.top, rt.right - rt.left,
rt.bottom - rt.top, TRUE);
}
/* Set window caption */
SetWindowText(ret, "Text");
if (!GetNHApp()->bWindowsLocked) {
DWORD style;
style = GetWindowLong(ret, GWL_STYLE);
style |= WS_CAPTION;
SetWindowLong(ret, GWL_STYLE, style);
SetWindowPos(ret, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
| SWP_NOZORDER
| SWP_FRAMECHANGED);
}
/* create and set window data */
data = (PNHTextWindow) malloc(sizeof(NHTextWindow));
if (!data)
panic("out of memory");
ZeroMemory(data, sizeof(NHTextWindow));
SetWindowLongPtr(ret, GWLP_USERDATA, (LONG_PTR) data);
return ret;
}
void
onMSNHCommand(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
switch (wParam) {
/* new window was just added */
case MSNH_MSG_ADDWND: {
PMSNHMsgAddWnd msg_param = (PMSNHMsgAddWnd) lParam;
HWND child = GetNHApp()->windowlist[msg_param->wid].win;
if (GetNHApp()->windowlist[msg_param->wid].type == NHW_MAP)
mswin_select_map_mode(iflags.wc_map_mode);
if (child)
mswin_layout_main_window(child);
} break;
}
}
void register_main_window_class()
{
WNDCLASS wcex;
ZeroMemory(&wcex, sizeof(wcex));
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)MainWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = GetNHApp()->hApp;
wcex.hIcon = LoadIcon(GetNHApp()->hApp, (LPCTSTR)IDI_NETHACKW);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = (TCHAR*)IDC_NETHACKW;
wcex.lpszClassName = szMainWindowClass;
RegisterClass(&wcex);
}
int
mswin_ext_cmd_window(int *selection)
{
int ret;
struct extcmd_data data;
/* init dialog data */
ZeroMemory(&data, sizeof(data));
*selection = -1;
data.selection = selection;
/* create modal dialog window */
ret = DialogBoxParam(GetNHApp()->hApp, MAKEINTRESOURCE(IDD_EXTCMD),
GetNHApp()->hMainWnd, ExtCmdDlgProc, (LPARAM) &data);
if (ret == -1)
panic("Cannot create extcmd window");
return ret;
}
HMENU
_get_main_menu(UINT menu_id)
{
HMENU hmenuMap;
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
TBBUTTONINFO tbbi;
#endif
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
tbbi.cbSize = sizeof(tbbi);
tbbi.dwMask = TBIF_LPARAM;
SendMessage(GetNHApp()->hMenuBar, TB_GETBUTTONINFO, menu_id,
(LPARAM) &tbbi);
hmenuMap = (HMENU) tbbi.lParam;
#else
hmenuMap = CommandBar_GetMenu(GetNHApp()->hMenuBar, 0);
#endif
return hmenuMap;
}
int
mswin_player_selection_window(int *selection)
{
int ret;
struct plsel_data data;
/* init dialog data */
ZeroMemory(&data, sizeof(data));
data.selection = selection;
/* create modal dialog */
ret = DialogBoxParam(
GetNHApp()->hApp, MAKEINTRESOURCE(IDD_PLAYER_SELECTOR),
GetNHApp()->hMainWnd, PlayerSelectorDlgProc, (LPARAM) &data);
if (ret == -1)
panic("Cannot create getlin window");
return ret;
}
HWND mswin_init_RIP_window () {
HWND ret;
PNHRIPWindow data;
ret = CreateDialog(
GetNHApp()->hApp,
MAKEINTRESOURCE(IDD_NHRIP),
GetNHApp()->hMainWnd,
NHRIPWndProc
);
if( !ret ) panic("Cannot create rip window");
data = (PNHRIPWindow)malloc(sizeof(NHRIPWindow));
if( !data ) panic("out of memory");
ZeroMemory(data, sizeof(NHRIPWindow));
SetWindowLong(ret, GWL_USERDATA, (LONG)data);
return ret;
}
int
mswin_getlin_window(const char *question, char *result, size_t result_size)
{
int ret;
struct getlin_data data;
/* initilize dialog data */
ZeroMemory(&data, sizeof(data));
data.question = question;
data.result = result;
data.result_size = result_size;
/* create modal dialog window */
ret = DialogBoxParam(GetNHApp()->hApp, MAKEINTRESOURCE(IDD_GETLIN),
GetNHApp()->hMainWnd, GetlinDlgProc, (LPARAM) &data);
if (ret == -1)
panic("Cannot create getlin window");
return ret;
}
HWND mswin_init_text_window () {
HWND ret;
PNHTextWindow data;
ret = CreateDialog(
GetNHApp()->hApp,
MAKEINTRESOURCE(IDD_NHTEXT),
GetNHApp()->hMainWnd,
TextWndProc
);
if( !ret ) panic("Cannot create text window");
data = (PNHTextWindow)malloc(sizeof(NHTextWindow));
if( !data ) panic("out of memory");
ZeroMemory(data, sizeof(NHTextWindow));
data->window_text = mswin_init_text_buffer(
program_state.gameover? FALSE : GetNHApp()->bWrapText
);
SetWindowLong(ret, GWL_USERDATA, (LONG)data);
return ret;
}
// Mesage handler for about box.
LRESULT CALLBACK
About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
char buf[BUFSZ];
TCHAR wbuf[NHSTR_BUFSIZE];
RECT main_rt, dlg_rt;
SIZE dlg_sz;
switch (message) {
case WM_INITDIALOG:
getversionstring(buf);
SetDlgItemText(hDlg, IDC_ABOUT_VERSION,
NH_A2W(buf, wbuf, NHSTR_BUFSIZE));
SetDlgItemText(hDlg, IDC_ABOUT_COPYRIGHT,
NH_A2W(COPYRIGHT_BANNER_A "\n" COPYRIGHT_BANNER_B
"\n" COPYRIGHT_BANNER_C
"\n" COPYRIGHT_BANNER_D,
wbuf, NHSTR_BUFSIZE));
/* center dialog in the main window */
GetWindowRect(GetNHApp()->hMainWnd, &main_rt);
GetWindowRect(hDlg, &dlg_rt);
dlg_sz.cx = dlg_rt.right - dlg_rt.left;
dlg_sz.cy = dlg_rt.bottom - dlg_rt.top;
dlg_rt.left = (main_rt.left + main_rt.right - dlg_sz.cx) / 2;
dlg_rt.right = dlg_rt.left + dlg_sz.cx;
dlg_rt.top = (main_rt.top + main_rt.bottom - dlg_sz.cy) / 2;
dlg_rt.bottom = dlg_rt.top + dlg_sz.cy;
MoveWindow(hDlg, (main_rt.left + main_rt.right - dlg_sz.cx) / 2,
(main_rt.top + main_rt.bottom - dlg_sz.cy) / 2, dlg_sz.cx,
dlg_sz.cy, TRUE);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
break;
}
return FALSE;
}
void
register_status_window_class()
{
WNDCLASS wcex;
ZeroMemory(&wcex, sizeof(wcex));
wcex.style = CS_NOCLOSE;
wcex.lpfnWndProc = (WNDPROC) StatusWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = GetNHApp()->hApp;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = mswin_get_brush(NHW_STATUS, MSWIN_COLOR_BG);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szStatusWindowClass;
RegisterClass(&wcex);
}
void register_status_window_class(void)
{
WNDCLASS wcex;
ZeroMemory( &wcex, sizeof(wcex));
wcex.style = CS_NOCLOSE;
wcex.lpfnWndProc = (WNDPROC)StatusWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = GetNHApp()->hApp;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = status_bg_brush
? status_bg_brush : SYSCLR_TO_BRUSH(DEFAULT_COLOR_BG_STATUS);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szStatusWindowClass;
RegisterClass(&wcex);
}
void CheckInputDialog(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
#if defined(WIN_CE_POCKETPC)
PNHMenuWindow data;
data = (PNHMenuWindow)GetWindowLong(hWnd, GWL_USERDATA);
if( !( data &&
data->type==MENU_TYPE_MENU &&
(data->how==PICK_ONE || data->how==PICK_ANY) ) ) return;
switch(message) {
case WM_SETFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_UP);
return;
case WM_DESTROY:
case WM_KILLFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_DOWN);
return;
case WM_NOTIFY:
{
LPNMHDR lpnmhdr = (LPNMHDR)lParam;
switch(lpnmhdr->code) {
case NM_SETFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_UP);
break;
case NM_KILLFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_DOWN);
break;
}
} return;
case WM_COMMAND:
switch(HIWORD(wParam)) {
case BN_SETFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_UP);
break;
case BN_KILLFOCUS:
if( GetNHApp()->bUseSIP ) SHSipPreference(hWnd, SIP_DOWN);
break;
}
return;
} /* end switch */
#endif
}
/* register window class for map window */
void register_map_window_class()
{
WNDCLASS wcex;
ZeroMemory( &wcex, sizeof(wcex));
/* window class */
wcex.style = CS_NOCLOSE | CS_DBLCLKS;
wcex.lpfnWndProc = (WNDPROC)MapWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = GetNHApp()->hApp;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = CreateSolidBrush(RGB(0, 0, 0)); /* set backgroup here */
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szNHMapWindowClass;
if( !RegisterClass(&wcex) ) {
panic("cannot register Map window class");
}
}
/* Set map display mode */
void
mswin_select_map_mode(int mode)
{
HMENU hmenuMap;
PNHMainWindow data;
winid map_id;
map_id = WIN_MAP;
data = (PNHMainWindow) GetWindowLong(GetNHApp()->hMainWnd, GWL_USERDATA);
#if defined(WIN_CE_SMARTPHONE)
/* Smartphone manu has only 2 items */
hmenuMap = _get_main_menu(ID_VIEW);
#else
hmenuMap = _get_main_menu(ID_MAP);
#endif
/* override for Rogue level */
if (Is_rogue_level(&u.uz) && !IS_MAP_ASCII(mode))
return;
/* set map mode menu mark */
if (IS_MAP_ASCII(mode)) {
CheckMenuRadioItem(hmenuMap, IDM_MAP_TILES, IDM_MAP_FIT_TO_SCREEN,
mapmode2menuid(IS_MAP_FIT_TO_SCREEN(mode)
? data->mapAcsiiModeSave
: mode),
MF_BYCOMMAND);
} else {
CheckMenuRadioItem(hmenuMap, IDM_MAP_TILES, IDM_MAP_FIT_TO_SCREEN,
mapmode2menuid(MAP_MODE_TILES), MF_BYCOMMAND);
}
#if defined(WIN_CE_SMARTPHONE)
/* update "Fit To Screen" item text */
{
TCHAR wbuf[BUFSZ];
TBBUTTONINFO tbbi;
ZeroMemory(wbuf, sizeof(wbuf));
if (!LoadString(GetNHApp()->hApp,
(IS_MAP_FIT_TO_SCREEN(mode) ? IDS_CAP_NORMALMAP
: IDS_CAP_ENTIREMAP),
wbuf, BUFSZ)) {
panic("cannot load main menu strings");
}
ZeroMemory(&tbbi, sizeof(tbbi));
tbbi.cbSize = sizeof(tbbi);
tbbi.dwMask = TBIF_TEXT;
tbbi.pszText = wbuf;
if (!SendMessage(GetNHApp()->hMenuBar, TB_SETBUTTONINFO,
IDM_MAP_FIT_TO_SCREEN, (LPARAM) &tbbi)) {
error("Cannot update IDM_MAP_FIT_TO_SCREEN menu item.");
}
}
#else
/* set fit-to-screen mode mark */
CheckMenuItem(hmenuMap, IDM_MAP_FIT_TO_SCREEN,
MF_BYCOMMAND | (IS_MAP_FIT_TO_SCREEN(mode) ? MF_CHECKED
: MF_UNCHECKED));
#endif
if (IS_MAP_ASCII(iflags.wc_map_mode)
&& !IS_MAP_FIT_TO_SCREEN(iflags.wc_map_mode)) {
data->mapAcsiiModeSave = iflags.wc_map_mode;
}
iflags.wc_map_mode = mode;
/*
** first, check if WIN_MAP has been inialized.
** If not - attempt to retrieve it by type, then check it again
*/
if (WIN_MAP != WIN_ERR)
mswin_map_mode(mswin_hwnd_from_winid(WIN_MAP), mode);
}
LRESULT
onWMCommand(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PNHMainWindow data;
data = (PNHMainWindow) GetWindowLong(hWnd, GWL_USERDATA);
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// process the menu selections:
switch (wmId) {
case IDM_ABOUT:
DialogBox(GetNHApp()->hApp, (LPCTSTR) IDD_ABOUTBOX, hWnd,
(DLGPROC) About);
break;
case IDM_EXIT:
done2();
break;
case IDM_SAVE:
dosave();
break;
case IDM_MAP_TILES:
case IDM_MAP_ASCII4X6:
case IDM_MAP_ASCII6X8:
case IDM_MAP_ASCII8X8:
case IDM_MAP_ASCII16X8:
case IDM_MAP_ASCII7X12:
case IDM_MAP_ASCII8X12:
case IDM_MAP_ASCII12X16:
case IDM_MAP_ASCII16X12:
case IDM_MAP_ASCII10X18:
mswin_select_map_mode(menuid2mapmode(wmId));
break;
case IDM_MAP_FIT_TO_SCREEN:
if (IS_MAP_FIT_TO_SCREEN(iflags.wc_map_mode)) {
mswin_select_map_mode(IS_MAP_ASCII(iflags.wc_map_mode)
? data->mapAcsiiModeSave
: MAP_MODE_TILES);
} else {
mswin_select_map_mode(IS_MAP_ASCII(iflags.wc_map_mode)
? MAP_MODE_ASCII_FIT_TO_SCREEN
: MAP_MODE_TILES_FIT_TO_SCREEN);
}
break;
case IDM_VIEW_KEYPAD:
GetNHApp()->bCmdPad = !GetNHApp()->bCmdPad;
CheckMenuItem(
_get_main_menu(ID_VIEW), IDM_VIEW_KEYPAD,
MF_BYCOMMAND | (GetNHApp()->bCmdPad ? MF_CHECKED : MF_UNCHECKED));
mswin_layout_main_window(GetNHApp()->hCmdWnd);
break;
case IDM_VIEW_OPTIONS:
doset();
break;
case IDM_DIRECT_COMMAND: /* SmartPhone: display dialog to type in arbitary
command text */
mswin_direct_command();
break;
case IDM_HELP_LONG:
display_file(HELP, TRUE);
break;
case IDM_HELP_COMMANDS:
display_file(SHELP, TRUE);
break;
case IDM_HELP_HISTORY:
(void) dohistory();
break;
case IDM_HELP_INFO_CHAR:
(void) dowhatis();
break;
case IDM_HELP_INFO_KEY:
(void) dowhatdoes();
break;
case IDM_HELP_OPTIONS:
option_help();
break;
case IDM_HELP_OPTIONS_LONG:
display_file(OPTIONFILE, TRUE);
break;
case IDM_HELP_EXTCMD:
(void) doextlist();
break;
case IDM_HELP_LICENSE:
display_file(LICENSE, TRUE);
break;
case IDM_HELP_MENU:
dohelp();
break;
default:
return 1;
}
return 0;
}
/* adjust windows to fit main window layout
---------------------------
| Status |
+-------------------------+
| |
| |
| MAP |
| |
| |
+-------------------------+
| Command pad |
+-------------------------+
| Messages |
---------------------------
*/
void
mswin_layout_main_window(HWND changed_child)
{
winid i;
RECT client_rt, wnd_rect;
POINT status_org;
SIZE status_size;
POINT msg_org;
SIZE msg_size;
POINT map_org;
SIZE map_size;
POINT cmd_org;
SIZE cmd_size;
HWND wnd_status, wnd_msg;
PNHMainWindow data;
#if defined(WIN_CE_POCKETPC)
SIPINFO sip;
RECT menu_bar;
RECT visible_rt;
POINT pt;
#endif
GetClientRect(GetNHApp()->hMainWnd, &client_rt);
#if defined(WIN_CE_POCKETPC)
ZeroMemory(&sip, sizeof(sip));
sip.cbSize = sizeof(sip);
SHSipInfo(SPI_GETSIPINFO, 0, &sip, 0);
if (GetNHApp()->bFullScreen)
sip.rcVisibleDesktop.top = 0;
/* adjust client rectangle size */
GetWindowRect(GetNHApp()->hMenuBar, &menu_bar);
client_rt.bottom -= menu_bar.bottom - menu_bar.top;
/* calcuate visible rect in client coordinates */
pt.x = sip.rcVisibleDesktop.left;
pt.y = sip.rcVisibleDesktop.top;
ScreenToClient(GetNHApp()->hMainWnd, &pt);
SetRect(&wnd_rect, pt.x, pt.y,
pt.x + sip.rcVisibleDesktop.right - sip.rcVisibleDesktop.left,
pt.y + sip.rcVisibleDesktop.bottom - sip.rcVisibleDesktop.top);
IntersectRect(&visible_rt, &client_rt, &wnd_rect);
#else
#if !defined(WIN_CE_SMARTPHONE)
client_rt.top += CommandBar_Height(GetNHApp()->hMenuBar);
#else
/* Smartphone only */
if (GetNHApp()->bFullScreen) {
RECT menu_bar;
GetWindowRect(GetNHApp()->hMenuBar, &menu_bar);
client_rt.bottom -= menu_bar.bottom - menu_bar.top;
}
#endif
#endif
/* get window data */
data = (PNHMainWindow) GetWindowLong(GetNHApp()->hMainWnd, GWL_USERDATA);
/* get sizes of child windows */
wnd_status = mswin_hwnd_from_winid(WIN_STATUS);
if (IsWindow(wnd_status)) {
mswin_status_window_size(wnd_status, &status_size);
} else {
status_size.cx = status_size.cy = 0;
}
wnd_msg = mswin_hwnd_from_winid(WIN_MESSAGE);
if (IsWindow(wnd_msg)) {
mswin_message_window_size(wnd_msg, &msg_size);
} else {
msg_size.cx = msg_size.cy = 0;
}
cmd_size.cx = cmd_size.cy = 0;
if (GetNHApp()->bCmdPad && IsWindow(GetNHApp()->hCmdWnd)) {
mswin_command_window_size(GetNHApp()->hCmdWnd, &cmd_size);
}
/* set window positions */
/* calculate the application windows size */
#if defined(WIN_CE_POCKETPC)
SetRect(&wnd_rect, visible_rt.left, visible_rt.top, visible_rt.right,
visible_rt.bottom);
if (sip.fdwFlags & SIPF_ON)
cmd_size.cx = cmd_size.cy = 0; /* hide keypad window */
#else
SetRect(&wnd_rect, client_rt.left, client_rt.top, client_rt.right,
client_rt.bottom);
#endif
#if !defined(WIN_CE_SMARTPHONE)
/* other ports have it at the bottom of the screen */
cmd_size.cx = (wnd_rect.right - wnd_rect.left);
cmd_org.x = wnd_rect.left;
cmd_org.y = wnd_rect.bottom - cmd_size.cy;
wnd_rect.bottom -= cmd_size.cy;
#endif
/* status window */
switch (iflags.wc_align_status) {
case ALIGN_LEFT:
status_size.cx = (wnd_rect.right - wnd_rect.left) / 4;
status_size.cy =
(wnd_rect.bottom - wnd_rect.top); // that won't look good
status_org.x = wnd_rect.left;
status_org.y = wnd_rect.top;
wnd_rect.left += status_size.cx;
break;
case ALIGN_RIGHT:
status_size.cx = (wnd_rect.right - wnd_rect.left) / 4;
status_size.cy =
(wnd_rect.bottom - wnd_rect.top); // that won't look good
status_org.x = wnd_rect.right - status_size.cx;
status_org.y = wnd_rect.top;
wnd_rect.right -= status_size.cx;
break;
case ALIGN_TOP:
status_size.cx = (wnd_rect.right - wnd_rect.left);
status_org.x = wnd_rect.left;
status_org.y = wnd_rect.top;
wnd_rect.top += status_size.cy;
break;
case ALIGN_BOTTOM:
default:
status_size.cx = (wnd_rect.right - wnd_rect.left);
status_org.x = wnd_rect.left;
status_org.y = wnd_rect.bottom - status_size.cy;
wnd_rect.bottom -= status_size.cy;
break;
}
/* message window */
switch (iflags.wc_align_message) {
case ALIGN_LEFT:
#if defined(WIN_CE_SMARTPHONE)
/* smartphone has a keypad window on the right (bottom) side of the
* message window */
msg_size.cx = cmd_size.cx = max(msg_size.cx, cmd_size.cx);
msg_size.cy = (wnd_rect.bottom - wnd_rect.top) - cmd_size.cy;
msg_org.x = cmd_org.x = wnd_rect.left;
msg_org.y = wnd_rect.top;
cmd_org.y = msg_org.y + msg_size.cy;
#else
msg_size.cx = (wnd_rect.right - wnd_rect.left) / 4;
msg_size.cy = (wnd_rect.bottom - wnd_rect.top);
msg_org.x = wnd_rect.left;
msg_org.y = wnd_rect.top;
#endif
wnd_rect.left += msg_size.cx;
break;
case ALIGN_RIGHT:
#if defined(WIN_CE_SMARTPHONE)
/* smartphone has a keypad window on the right (bottom) side of the
* message window */
msg_size.cx = cmd_size.cx = max(msg_size.cx, cmd_size.cx);
msg_size.cy = (wnd_rect.bottom - wnd_rect.top) - cmd_size.cy;
msg_org.x = cmd_org.x = wnd_rect.right - msg_size.cx;
msg_org.y = wnd_rect.top;
cmd_org.y = msg_org.y + msg_size.cy;
#else
msg_size.cx = (wnd_rect.right - wnd_rect.left) / 4;
msg_size.cy = (wnd_rect.bottom - wnd_rect.top);
msg_org.x = wnd_rect.right - msg_size.cx;
msg_org.y = wnd_rect.top;
#endif
wnd_rect.right -= msg_size.cx;
break;
case ALIGN_TOP:
#if defined(WIN_CE_SMARTPHONE)
/* smartphone has a keypad window on the right side of the message
* window */
msg_size.cy = cmd_size.cy = max(msg_size.cy, cmd_size.cy);
msg_size.cx = (wnd_rect.right - wnd_rect.left) - cmd_size.cx;
msg_org.x = wnd_rect.left;
cmd_org.x = msg_org.x + msg_size.cx;
msg_org.y = cmd_org.y = wnd_rect.bottom - msg_size.cy;
#else
msg_size.cx = (wnd_rect.right - wnd_rect.left);
msg_org.x = wnd_rect.left;
msg_org.y = wnd_rect.top;
#endif
wnd_rect.top += msg_size.cy;
break;
case ALIGN_BOTTOM:
default:
#if defined(WIN_CE_SMARTPHONE)
/* smartphone has a keypad window on the right side of the message
* window */
msg_size.cy = cmd_size.cy = max(msg_size.cy, cmd_size.cy);
msg_size.cx = (wnd_rect.right - wnd_rect.left) - cmd_size.cx;
msg_org.x = wnd_rect.left;
cmd_org.x = msg_org.x + msg_size.cx;
msg_org.y = cmd_org.y = wnd_rect.bottom - msg_size.cy;
#else
msg_size.cx = (wnd_rect.right - wnd_rect.left);
msg_org.x = wnd_rect.left;
msg_org.y = wnd_rect.bottom - msg_size.cy;
#endif
wnd_rect.bottom -= msg_size.cy;
break;
}
map_org.x = wnd_rect.left;
map_org.y = wnd_rect.top;
map_size.cx = wnd_rect.right - wnd_rect.left;
map_size.cy = wnd_rect.bottom - wnd_rect.top;
/* go through the windows list and adjust sizes */
for (i = 0; i < MAXWINDOWS; i++) {
if (GetNHApp()->windowlist[i].win
&& !GetNHApp()->windowlist[i].dead) {
switch (GetNHApp()->windowlist[i].type) {
case NHW_MESSAGE:
MoveWindow(GetNHApp()->windowlist[i].win, msg_org.x,
msg_org.y, msg_size.cx, msg_size.cy, TRUE);
break;
case NHW_MAP:
MoveWindow(GetNHApp()->windowlist[i].win, map_org.x,
map_org.y, map_size.cx, map_size.cy, TRUE);
break;
case NHW_STATUS:
MoveWindow(GetNHApp()->windowlist[i].win, status_org.x,
status_org.y, status_size.cx, status_size.cy,
TRUE);
break;
case NHW_TEXT:
case NHW_MENU:
case NHW_RIP: {
POINT menu_org;
SIZE menu_size;
menu_org.x = client_rt.left;
menu_org.y = client_rt.top;
#if defined(WIN_CE_POCKETPC)
menu_size.cx = min(sip.rcVisibleDesktop.right
- sip.rcVisibleDesktop.left,
client_rt.right - client_rt.left);
menu_size.cy = min(sip.rcVisibleDesktop.bottom
- sip.rcVisibleDesktop.top,
client_rt.bottom - client_rt.top);
#else
menu_size.cx = client_rt.right - client_rt.left;
menu_size.cy = client_rt.bottom - client_rt.top;
#endif
#if defined(WIN_CE_SMARTPHONE)
/* leave room for the command window */
if (GetNHApp()->windowlist[i].type == NHW_MENU) {
menu_size.cy -= cmd_size.cy;
}
/* dialogs are popup windows unde SmartPhone so we need
to convert to screen coordinates */
ClientToScreen(GetNHApp()->hMainWnd, &menu_org);
#endif
MoveWindow(GetNHApp()->windowlist[i].win, menu_org.x,
menu_org.y, menu_size.cx, menu_size.cy, TRUE);
} break;
}
ShowWindow(GetNHApp()->windowlist[i].win, SW_SHOW);
InvalidateRect(GetNHApp()->windowlist[i].win, NULL, TRUE);
}
}
if (IsWindow(GetNHApp()->hCmdWnd)) {
/* show command window only if it exists and
the game is ready (plname is set) */
if (GetNHApp()->bCmdPad && cmd_size.cx > 0 && cmd_size.cy > 0
&& *plname) {
MoveWindow(GetNHApp()->hCmdWnd, cmd_org.x, cmd_org.y, cmd_size.cx,
cmd_size.cy, TRUE);
ShowWindow(GetNHApp()->hCmdWnd, SW_SHOW);
} else {
ShowWindow(GetNHApp()->hCmdWnd, SW_HIDE);
}
}
}
/*
// FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
// PURPOSE: Processes messages for the main window.
*/
LRESULT CALLBACK
MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PNHMainWindow data;
switch (message) {
/*-----------------------------------------------------------------------*/
case WM_CREATE: {
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
SHMENUBARINFO menubar;
#endif
/* set window data */
data = (PNHMainWindow) malloc(sizeof(NHMainWindow));
if (!data)
panic("out of memory");
ZeroMemory(data, sizeof(NHMainWindow));
data->mapAcsiiModeSave = MAP_MODE_ASCII12x16;
SetWindowLong(hWnd, GWL_USERDATA, (LONG) data);
GetNHApp()->hMainWnd = hWnd;
/* create menu bar */
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
ZeroMemory(&menubar, sizeof(menubar));
menubar.cbSize = sizeof(menubar);
menubar.hwndParent = hWnd;
menubar.dwFlags = 0;
menubar.nToolBarId = IDC_WINHACK;
menubar.hInstRes = GetNHApp()->hApp;
#if defined(WIN_CE_POCKETPC)
menubar.nBmpId = IDB_MENUBAR;
menubar.cBmpImages = 2;
#else
menubar.nBmpId = 0;
menubar.cBmpImages = 0;
#endif
if (!SHCreateMenuBar(&menubar))
panic("cannot create menu");
GetNHApp()->hMenuBar = menubar.hwndMB;
#else
GetNHApp()->hMenuBar = CommandBar_Create(GetNHApp()->hApp, hWnd, 1);
if (!GetNHApp()->hMenuBar)
panic("cannot create menu");
CommandBar_InsertMenubar(GetNHApp()->hMenuBar, GetNHApp()->hApp,
IDC_WINHACK, 0);
#endif
CheckMenuItem(
_get_main_menu(ID_VIEW), IDM_VIEW_KEYPAD,
MF_BYCOMMAND | (GetNHApp()->bCmdPad ? MF_CHECKED : MF_UNCHECKED));
} break;
/*-----------------------------------------------------------------------*/
case WM_MSNH_COMMAND:
onMSNHCommand(hWnd, wParam, lParam);
break;
/*-----------------------------------------------------------------------*/
case WM_KEYDOWN:
data = (PNHMainWindow) GetWindowLong(hWnd, GWL_USERDATA);
/* translate arrow keys into nethack commands */
switch (wParam) {
case VK_LEFT:
if (STATEON(VK_CONTROL)) {
/* scroll map window one line left */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_HSCROLL,
MAKEWPARAM(SB_LINEUP, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_W));
}
return 0;
case VK_RIGHT:
if (STATEON(VK_CONTROL)) {
/* scroll map window one line right */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_HSCROLL,
MAKEWPARAM(SB_LINEDOWN, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_E));
}
return 0;
case VK_UP:
if (STATEON(VK_CONTROL)) {
/* scroll map window one line up */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_LINEUP, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_N));
}
return 0;
case VK_DOWN:
if (STATEON(VK_CONTROL)) {
/* scroll map window one line down */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_LINEDOWN, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_S));
}
return 0;
case VK_HOME:
if (STATEON(VK_CONTROL)) {
/* scroll map window to upper left corner */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_THUMBTRACK, 0), (LPARAM) NULL);
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_HSCROLL,
MAKEWPARAM(SB_THUMBTRACK, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_NW));
}
return 0;
case VK_END:
if (STATEON(VK_CONTROL)) {
/* scroll map window to lower right corner */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_THUMBTRACK, ROWNO), (LPARAM) NULL);
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_HSCROLL,
MAKEWPARAM(SB_THUMBTRACK, COLNO), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_SW));
}
return 0;
case VK_PRIOR:
if (STATEON(VK_CONTROL)) {
/* scroll map window one page up */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_PAGEUP, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_NE));
}
return 0;
case VK_NEXT:
if (STATEON(VK_CONTROL)) {
/* scroll map window one page down */
SendMessage(mswin_hwnd_from_winid(WIN_MAP), WM_VSCROLL,
MAKEWPARAM(SB_PAGEDOWN, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD(KEYTABLE(KEY_SE));
}
return 0;
case VK_DECIMAL:
case VK_DELETE:
NHEVENT_KBD(KEYTABLE(KEY_WAITLOOK));
return 0;
case VK_INSERT:
NHEVENT_KBD(KEYTABLE(KEY_INV));
return 0;
case VK_SUBTRACT:
NHEVENT_KBD(KEYTABLE(KEY_MINUS));
return 0;
case VK_ADD:
NHEVENT_KBD(KEYTABLE(KEY_PLUS));
return 0;
case VK_CLEAR: /* This is the '5' key */
NHEVENT_KBD(KEYTABLE(KEY_GOINTERESTING));
return 0;
case VK_F4:
if (IS_MAP_FIT_TO_SCREEN(iflags.wc_map_mode)) {
mswin_select_map_mode(IS_MAP_ASCII(iflags.wc_map_mode)
? data->mapAcsiiModeSave
: MAP_MODE_TILES);
} else {
mswin_select_map_mode(IS_MAP_ASCII(iflags.wc_map_mode)
? MAP_MODE_ASCII_FIT_TO_SCREEN
: MAP_MODE_TILES_FIT_TO_SCREEN);
}
return 0;
case VK_F5:
if (IS_MAP_ASCII(iflags.wc_map_mode)) {
if (IS_MAP_FIT_TO_SCREEN(iflags.wc_map_mode)) {
mswin_select_map_mode(MAP_MODE_TILES_FIT_TO_SCREEN);
} else {
mswin_select_map_mode(MAP_MODE_TILES);
}
} else {
if (IS_MAP_FIT_TO_SCREEN(iflags.wc_map_mode)) {
mswin_select_map_mode(MAP_MODE_ASCII_FIT_TO_SCREEN);
} else {
mswin_select_map_mode(data->mapAcsiiModeSave);
}
}
return 0;
case VK_RETURN: {
int x, y;
if (WIN_MAP != WIN_ERR) {
mswin_map_get_cursor(mswin_hwnd_from_winid(WIN_MAP), &x, &y);
} else {
x = u.ux;
y = u.uy;
}
NHEVENT_MS(CLICK_1, x, y);
}
return 0;
}
#if defined(WIN_CE_SMARTPHONE)
if (GetNHApp()->bCmdPad
&& NHSPhoneTranslateKbdMessage(wParam, lParam, TRUE))
return 0;
#endif
return 1; /* end of WM_KEYDOWN */
/*-----------------------------------------------------------------------*/
#if defined(WIN_CE_SMARTPHONE)
case WM_KEYUP:
if (GetNHApp()->bCmdPad
&& NHSPhoneTranslateKbdMessage(wParam, lParam, FALSE))
return 0;
return 1; /* end of WM_KEYUP */
#endif
/*-----------------------------------------------------------------------*/
case WM_CHAR:
#if defined(WIN_CE_SMARTPHONE)
/* if smartphone cmdpad is up then translation happens - disable
WM_CHAR processing
to avoid double input */
if (GetNHApp()->bCmdPad) {
return 1;
}
#endif
if (wParam == '\n' || wParam == '\r' || wParam == C('M'))
return 0; /* we already processed VK_RETURN */
/* all characters go to nethack except Ctrl-P that scrolls message
* window up */
if (wParam == C('P') || wParam == C('p')) {
SendMessage(mswin_hwnd_from_winid(WIN_MESSAGE), WM_VSCROLL,
MAKEWPARAM(SB_LINEUP, 0), (LPARAM) NULL);
} else {
NHEVENT_KBD((lParam & 1 << 29) ? M(tolower(wParam)) : wParam);
}
return 0;
/*-----------------------------------------------------------------------*/
case WM_COMMAND:
/* process commands - menu commands mostly */
if (IsWindow(GetNHApp()->hPopupWnd)) {
return SendMessage(GetNHApp()->hPopupWnd, message, wParam,
lParam);
} else if (onWMCommand(hWnd, wParam, lParam))
return DefWindowProc(hWnd, message, wParam, lParam);
else
return 0;
/*-----------------------------------------------------------------------*/
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_INACTIVE) {
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
if (GetNHApp()->bFullScreen)
SHFullScreen(GetNHApp()->hMainWnd,
SHFS_HIDETASKBAR | SHFS_HIDESTARTICON);
else
SHFullScreen(GetNHApp()->hMainWnd,
SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON);
#endif
mswin_layout_main_window(NULL);
}
break;
case WM_SETTINGCHANGE:
#if defined(WIN_CE_POCKETPC) || defined(WIN_CE_SMARTPHONE)
if (GetNHApp()->bFullScreen)
SHFullScreen(GetNHApp()->hMainWnd,
SHFS_HIDETASKBAR | SHFS_HIDESTARTICON);
else
SHFullScreen(GetNHApp()->hMainWnd,
SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON);
#endif
mswin_layout_main_window(NULL);
break;
case WM_SIZE:
mswin_layout_main_window(NULL);
break;
/*-----------------------------------------------------------------------*/
case WM_SETFOCUS:
/* if there is a menu window out there -
transfer input focus to it */
if (IsWindow(GetNHApp()->hPopupWnd)) {
SetFocus(GetNHApp()->hPopupWnd);
}
break;
/*-----------------------------------------------------------------------*/
case WM_CLOSE: {
/* exit gracefully */
#ifdef SAFERHANGUP
/* destroy popup window - it has its own loop and we need to
return control to NetHack core at this point */
if (IsWindow(GetNHApp()->hPopupWnd))
SendMessage(GetNHApp()->hPopupWnd, WM_COMMAND, IDCANCEL, 0);
/* tell NetHack core that "hangup" is requested */
hangup(1);
#else
dosave0();
terminate(EXIT_SUCCESS);
#endif
}
return 0;
/*-----------------------------------------------------------------------*/
case WM_DESTROY: {
/* apparently we never get here
TODO: work on exit routines - need to send
WM_QUIT somehow */
/* clean up */
free((PNHMainWindow) GetWindowLong(hWnd, GWL_USERDATA));
SetWindowLong(hWnd, GWL_USERDATA, (LONG) 0);
terminate(EXIT_SUCCESS);
} break;
/*-----------------------------------------------------------------------*/
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void
mswin_display_splash_window(BOOL show_ver)
{
MSG msg;
int left, top;
RECT splashrt;
RECT clientrt;
RECT controlrt;
HWND hWnd;
int buttop;
int strsize = 0;
int bufsize = BUFSZ;
char *buf = malloc(bufsize);
if (buf == NULL)
panic("out of memory");
buf[0] = '\0';
hWnd = CreateDialog(GetNHApp()->hApp, MAKEINTRESOURCE(IDD_SPLASH),
GetNHApp()->hMainWnd, NHSplashWndProc);
if (!hWnd)
panic("Cannot create Splash window");
mswin_init_splashfonts(hWnd);
GetNHApp()->hPopupWnd = hWnd;
/* Get control size */
GetWindowRect(GetDlgItem(hWnd, IDOK), &controlrt);
controlrt.right -= controlrt.left;
controlrt.bottom -= controlrt.top;
/* Get current client area */
GetClientRect(hWnd, &clientrt);
/* Get window size */
GetWindowRect(hWnd, &splashrt);
splashrt.right -= splashrt.left;
splashrt.bottom -= splashrt.top;
/* Get difference between requested client area and current value */
splashrt.right += SPLASH_WIDTH + SPLASH_OFFSET_X * 2 - clientrt.right;
splashrt.bottom += SPLASH_HEIGHT + controlrt.bottom + SPLASH_OFFSET_Y * 3
- clientrt.bottom;
/* Place the window centered */
/* On the screen, not on the parent window */
left = (GetSystemMetrics(SM_CXSCREEN) - splashrt.right) / 2;
top = (GetSystemMetrics(SM_CYSCREEN) - splashrt.bottom) / 2;
MoveWindow(hWnd, left, top, splashrt.right, splashrt.bottom, TRUE);
/* Place the OK control */
GetClientRect(hWnd, &clientrt);
MoveWindow(GetDlgItem(hWnd, IDOK),
(clientrt.right - clientrt.left - controlrt.right) / 2,
clientrt.bottom - controlrt.bottom - SPLASH_OFFSET_Y,
controlrt.right, controlrt.bottom, TRUE);
buttop = clientrt.bottom - controlrt.bottom - SPLASH_OFFSET_Y;
/* Place the text control */
GetWindowRect(GetDlgItem(hWnd, IDC_EXTRAINFO), &controlrt);
controlrt.right -= controlrt.left;
controlrt.bottom -= controlrt.top;
GetClientRect(hWnd, &clientrt);
MoveWindow(GetDlgItem(hWnd, IDC_EXTRAINFO),
clientrt.left + SPLASH_OFFSET_X,
buttop - controlrt.bottom - SPLASH_OFFSET_Y,
clientrt.right - 2 * SPLASH_OFFSET_X, controlrt.bottom, TRUE);
/* Fill the text control */
Sprintf(buf, "%s\r\n%s\r\n%s\r\n%s\r\n\r\n", COPYRIGHT_BANNER_A,
COPYRIGHT_BANNER_B, COPYRIGHT_BANNER_C, COPYRIGHT_BANNER_D);
strsize = strlen(buf);
if (show_ver) {
/* Show complete version information */
dlb *f;
char verbuf[BUFSZ];
int verstrsize = 0;
getversionstring(verbuf);
verstrsize = strlen(verbuf);
if (verstrsize + strlen("\r\n\r\n") + 1 < BUFSZ - 1)
strcat(verbuf, "\r\n\r\n");
verstrsize = strlen(verbuf);
if (strsize + verstrsize + 1 > bufsize) {
bufsize += BUFSZ;
buf = realloc(buf, bufsize);
if (buf == NULL)
panic("out of memory");
}
strcat(buf, verbuf);
strsize = strlen(buf);
/* Add compile options */
f = dlb_fopen(OPTIONS_USED, RDTMODE);
if (f) {
char line[LLEN + 1];
while (dlb_fgets(line, LLEN, f)) {
size_t len;
len = strlen(line);
if (len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\r';
line[len] = '\n';
line[len + 1] = '\0';
len++;
}
if (strsize + (int) len + 1 > bufsize) {
bufsize += BUFSZ;
buf = realloc(buf, bufsize);
if (buf == NULL)
panic("out of memory");
}
strcat(buf, line);
strsize += len;
}
(void) dlb_fclose(f);
}
} else {
/* Show news, if any */
if (iflags.news) {
FILE *nf;
iflags.news = 0; /* prevent newgame() from re-displaying news */
nf = fopen(NEWS, "r");
if (nf != NULL) {
char line[LLEN + 1];
while (fgets(line, LLEN, nf)) {
size_t len;
len = strlen(line);
if (len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\r';
line[len] = '\n';
line[len + 1] = '\0';
len++;
}
if (strsize + (int) len + 1 > bufsize) {
bufsize += BUFSZ;
buf = realloc(buf, bufsize);
if (buf == NULL)
panic("out of memory");
}
strcat(buf, line);
strsize += len;
}
(void) fclose(nf);
} else {
strcat(buf, "No news.");
}
}
}
SetWindowText(GetDlgItem(hWnd, IDC_EXTRAINFO), buf);
free(buf);
ShowWindow(hWnd, SW_SHOW);
while (IsWindow(hWnd) && GetMessage(&msg, NULL, 0, 0) != 0) {
if (!IsDialogMessage(hWnd, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
GetNHApp()->hPopupWnd = NULL;
mswin_destroy_splashfonts();
}
