np2/win9x/dialog/d_sound.cpp - diff

Return to d_sound.cpp CVS log

Up to [RetroPC.NET] / np2 / win9x / dialog

Diff for /np2/win9x/dialog/d_sound.cpp between versions 1.7 and 1.20

version 1.7, 2003/10/31 03:40:10	version 1.20, 2007/01/08 07:52:01
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"
#include <windowsx.h>
#include <commctrl.h>	#include <commctrl.h>
#include <prsht.h>	#include <prsht.h>
#include "strres.h"	#include "strres.h"
#include "resource.h"	#include "resource.h"
#include "np2.h"	#include "np2.h"
	#include "oemtext.h"
#include "dosio.h"	#include "dosio.h"
#include "joymng.h"	#include "joymng.h"
#include "sysmng.h"	#include "sysmng.h"
#include "menu.h"	#include "menu.h"
	#include "np2class.h"
#include "dialog.h"	#include "dialog.h"
#include "dialogs.h"	#include "dialogs.h"
#include "bit2res.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "sound.h"	#include "sound.h"
#include "fmboard.h"	#include "fmboard.h"
#include "s98.h"	#include "s98.h"
	#include "dipswbmp.h"


static const char *sndioport[4] = {"0088", "0188", "0288", "0388"};	static const TCHAR str_0088[] = _T("0088");
static const char *sndinterrupt[4] = {str_int0, str_int4, str_int5, str_int6};	static const TCHAR str_0188[] = _T("0188");
static const char *sndromaddr[5] = {"C8000", "CC000", "D0000", "D4000", "N/C"};	static const TCHAR str_0288[] = _T("0288");
static const char *sndid[8] = {"0x", "1x", "2x", "3x", "4x", "5x", "6x", "7x"};	static const TCHAR str_0388[] = _T("0388");
	static const TCHAR str_c8000[] = _T("C8000");
	static const TCHAR str_cc000[] = _T("CC000");
	static const TCHAR str_d0000[] = _T("D0000");
	static const TCHAR str_d4000[] = _T("D4000");
	static const TCHAR str_n0x[] = _T("0x");
	static const TCHAR str_n1x[] = _T("1x");
	static const TCHAR str_n2x[] = _T("2x");
	static const TCHAR str_n3x[] = _T("3x");
	static const TCHAR str_n4x[] = _T("4x");
	static const TCHAR str_n5x[] = _T("5x");
	static const TCHAR str_n6x[] = _T("6x");
	static const TCHAR str_n7x[] = _T("7x");
	static const TCHAR *sndioport[4] =
	{str_0088, str_0188, str_0288, str_0388};
	static const TCHAR *sndinterrupt[4] =
	{str_int0, str_int4, str_int5, str_int6};
	static const TCHAR *sndromaddr[5] =
	{str_c8000, str_cc000, str_d0000, str_d4000, str_nc};
	static const TCHAR *sndid[8] =
	{str_n0x, str_n1x, str_n2x, str_n3x,
	str_n4x, str_n5x, str_n6x, str_n7x};

static const char str_sndopt[] = "Sound board option";	static const TCHAR str_sndopt[] = _T("Sound board option");


typedef struct {	typedef struct {
UINT16 res;	UINT16 res;
UINT16 resstr;	UINT16 resstr;
BYTE *value;	UINT8 *value;
UINT16 min;	UINT16 min;
UINT16 max;	UINT16 max;
} SLIDERTBL;	} SLIDERTBL;

static void slidersetvaluestr(HWND hWnd, const SLIDERTBL *item, BYTE value) {	static void slidersetvaluestr(HWND hWnd, const SLIDERTBL *item, UINT8 value) {

char work[32];	TCHAR work[32];

wsprintf(work, str_d, value);	wsprintf(work, tchar_d, value);
SetDlgItemText(hWnd, item->resstr, work);	SetDlgItemText(hWnd, item->resstr, work);
}	}

static void slidersetvalue(HWND hWnd, const SLIDERTBL *item, BYTE value) {	static void slidersetvalue(HWND hWnd, const SLIDERTBL *item, UINT8 value) {

if (value > (BYTE)(item->max)) {	if (value > (UINT8)item->max) {
value = (BYTE)(item->max);	value = (UINT8)item->max;
}	}
else if (value < (BYTE)(item->min)) {	else if (value < (UINT8)item->min) {
value = (BYTE)(item->min);	value = (UINT8)item->min;
}	}
SendDlgItemMessage(hWnd, item->res, TBM_SETPOS, TRUE, value);	SendDlgItemMessage(hWnd, item->res, TBM_SETPOS, TRUE, value);
slidersetvaluestr(hWnd, item, value);	slidersetvaluestr(hWnd, item, value);
Line 64 static void sliderinit(HWND hWnd, const	Line 86 static void sliderinit(HWND hWnd, const

static void sliderresetpos(HWND hWnd, const SLIDERTBL *item) {	static void sliderresetpos(HWND hWnd, const SLIDERTBL *item) {

BYTE value;	UINT8 value;

value = (BYTE)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);	value = (UINT8)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);
if (value > (BYTE)(item->max)) {	if (value > (UINT8)item->max) {
value = (BYTE)(item->max);	value = (UINT8)item->max;
}	}
else if (value < (BYTE)(item->min)) {	else if (value < (UINT8)item->min) {
value = (BYTE)(item->min);	value = (UINT8)item->min;
}	}
slidersetvaluestr(hWnd, item, value);	slidersetvaluestr(hWnd, item, value);
}	}

static BYTE sliderrestore(HWND hWnd, const SLIDERTBL *item) {	static UINT8 sliderrestore(HWND hWnd, const SLIDERTBL *item) {

BYTE value;	UINT8 value;
BYTE ret;	UINT8 ret;

value = (BYTE)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);	value = (UINT8)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);
if (value > (BYTE)(item->max)) {	if (value > (UINT8)item->max) {
value = (BYTE)(item->max);	value = (UINT8)item->max;
}	}
else if (value < (BYTE)(item->min)) {	else if (value < (UINT8)item->min) {
value = (BYTE)(item->min);	value = (UINT8)item->min;
}	}
ret = (*(item->value)) - value;	ret = (*(item->value)) - value;
if (ret) {	if (ret) {
Line 118 static LRESULT CALLBACK SndmixDlgProc(HW	Line 140 static LRESULT CALLBACK SndmixDlgProc(HW
return(TRUE);	return(TRUE);

case WM_COMMAND:	case WM_COMMAND:
switch (LOWORD(wp)) {	switch(LOWORD(wp)) {
case IDC_SNDMIXDEF:	case IDC_SNDMIXDEF:
for (i=0; i<5; i++) {	for (i=0; i<5; i++) {
slidersetvalue(hWnd, &sndmixitem[i], 64);	slidersetvalue(hWnd, &sndmixitem[i], 64);
Line 160 static LRESULT CALLBACK SndmixDlgProc(HW	Line 182 static LRESULT CALLBACK SndmixDlgProc(HW
}	}


// -------------------------------------------------------- PC-9801-14	// ---- PC-9801-14

static const SLIDERTBL snd14item[] = {	static const SLIDERTBL snd14item[] = {
{IDC_VOL14L, IDC_VOL14LSTR, np2cfg.vol14+0, 0,15},	{IDC_VOL14L, IDC_VOL14LSTR, np2cfg.vol14+0, 0,15},
Line 213 static LRESULT CALLBACK Snd14optDlgProc(	Line 235 static LRESULT CALLBACK Snd14optDlgProc(

static const UINT snd26paranum[4] = {0, 3, 1, 2};	static const UINT snd26paranum[4] = {0, 3, 1, 2};

static void setsnd26iopara(HWND hWnd, BYTE value) {	static void setsnd26iopara(HWND hWnd, UINT8 value) {

SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((value >> 4) & 1), (LPARAM)0);	SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((value >> 4) & 1), (LPARAM)0);
}	}

static BYTE getsnd26io(HWND hWnd, WORD res) {	static UINT8 getsnd26io(HWND hWnd, UINT16 res) {

char work[8];	TCHAR work[8];

GetDlgItemText(hWnd, res, work, sizeof(work));	GetDlgItemText(hWnd, res, work, NELEMENTS(work));
return((BYTE)((work[1] == '1')?0x10:0x00));	return((UINT8)((work[1] == '1')?0x10:0x00));
}	}

static void setsnd26intpara(HWND hWnd, BYTE value) {	static void setsnd26intpara(HWND hWnd, UINT8 value) {

SendMessage(hWnd, CB_SETCURSEL,	SendMessage(hWnd, CB_SETCURSEL,
(WPARAM)snd26paranum[(value >> 6) & 3], (LPARAM)0);	(WPARAM)snd26paranum[(value >> 6) & 3], (LPARAM)0);
}	}

static BYTE getsnd26int(HWND hWnd, WORD res) {	static UINT8 getsnd26int(HWND hWnd, UINT16 res) {

char work[8];	TCHAR work[8];

GetDlgItemText(hWnd, res, work, sizeof(work));	GetDlgItemText(hWnd, res, work, NELEMENTS(work));
switch(work[3]) {	switch(work[3]) {
case '0':	case '0':
return(0x00);	return(0x00);
Line 250 static BYTE getsnd26int(HWND hWnd, WORD	Line 272 static BYTE getsnd26int(HWND hWnd, WORD
return(0xc0);	return(0xc0);
}	}

static void setsnd26rompara(HWND hWnd, BYTE value) {	static void setsnd26rompara(HWND hWnd, UINT8 value) {

int para;	int para;

Line 261 static void setsnd26rompara(HWND hWnd, B	Line 283 static void setsnd26rompara(HWND hWnd, B
SendMessage(hWnd, CB_SETCURSEL, (WPARAM)para, (LPARAM)0);	SendMessage(hWnd, CB_SETCURSEL, (WPARAM)para, (LPARAM)0);
}	}

static BYTE getsnd26rom(HWND hWnd, WORD res) {	static UINT8 getsnd26rom(HWND hWnd, UINT16 res) {

char work[8];	TCHAR work[8];
DWORD adrs;	UINT32 adrs;

GetDlgItemText(hWnd, res, work, sizeof(work));	GetDlgItemText(hWnd, res, work, NELEMENTS(work));
adrs = ((DWORD)milstr_solveHEX(work) - 0xc8000) >> 14;	adrs = ((UINT32)miltchar_solveHEX(work) - 0xc8000) >> 14;
if (adrs < 4) {	if (adrs < 4) {
return((BYTE)adrs);	return((UINT8)adrs);
}	}
return(4);	return(4);
}	}

void setsnd26iodip(BYTE *image, int px, int py, int align, BYTE v) {

if (v & 0x10) {
px++;
}
dlgs_setjumpery(image, px, py, align);
}

void setsnd26intdip(BYTE *image, int px, int py, int align, BYTE v) {

dlgs_setjumperx(image, px + ((v & 0x80)?0:1), py, align);
dlgs_setjumperx(image, px + ((v & 0x40)?0:1), py + 1, align);
}

void setsnd26romdip(BYTE *image, int px, int py, int align, BYTE v) {

v &= 7;
if (v >= 4) {
v = 4;
}
dlgs_setjumpery(image, px + v, py, align);
}

// ---- PC-9801-26	// ---- PC-9801-26

static BYTE snd26 = 0;	static UINT8 snd26 = 0;
static SUBCLASSPROC oldidc_snd26jmp = NULL;

static LRESULT CALLBACK Snd26jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {

PAINTSTRUCT ps;
HDC hdc;
HBITMAP hBitmap;
HDC hMemDC;
BYTE *image;
HANDLE hwork;
BITMAPINFO *work;
BYTE *imgbtm;
int align;

switch(msg) {
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&snd26dip)))
== NULL) {
break;
}
if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {
GlobalFree(hwork);
break;
}
bit2res_sethead(work, &snd26dip);
hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,
(void **)&image, NULL, 0);
bit2res_setdata(image, &snd26dip);
align = ((snd26dip.x + 7) / 2) & ~3;
imgbtm = image + align * (snd26dip.y - 1);
setsnd26iodip(imgbtm, 15, 1, align, snd26);
setsnd26intdip(imgbtm, 9, 1, align, snd26);
setsnd26romdip(imgbtm, 2, 1, align, snd26);
if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {
SelectObject(hMemDC, hBitmap);
StretchBlt(hdc, 0, 0, snd26dip.x, snd26dip.y, hMemDC,
0, 0, snd26dip.x, snd26dip.y, SRCCOPY);
DeleteDC(hMemDC);
}
DeleteObject(hBitmap);
EndPaint(hWnd, &ps);
GlobalUnlock(hwork);
GlobalFree(hwork);
break;
default:
return(CallWindowProc(oldidc_snd26jmp, hWnd, msg, wp, lp));
}
return(FALSE);
}

static void set26jmp(HWND hWnd, BYTE value, BYTE bit) {	static void set26jmp(HWND hWnd, UINT8 value, UINT8 bit) {

if ((snd26 ^ value) & bit) {	if ((snd26 ^ value) & bit) {
snd26 &= ~bit;	snd26 &= ~bit;
Line 360 static void set26jmp(HWND hWnd, BYTE val	Line 310 static void set26jmp(HWND hWnd, BYTE val
}	}
}	}

static void snd26cmddipsw(HWND hWnd) {	static void snd26cmdjmp(HWND hWnd) {

RECT rect1;	RECT rect1;
RECT rect2;	RECT rect2;
POINT p;	POINT p;
BYTE b, bit;	BOOL redraw;
	UINT8 b;
	UINT8 bit;

GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);	GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);
GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);	GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);
GetCursorPos(&p);	GetCursorPos(&p);
	redraw = FALSE;
p.x += rect2.left - rect1.left;	p.x += rect2.left - rect1.left;
p.y += rect2.top - rect1.top;	p.y += rect2.top - rect1.top;
p.x /= 9;	p.x /= 9;
Line 378 static void snd26cmddipsw(HWND hWnd) {	Line 331 static void snd26cmddipsw(HWND hWnd) {
return;	return;
}	}
if ((p.x >= 2) && (p.x < 7)) {	if ((p.x >= 2) && (p.x < 7)) {
b = (BYTE)(p.x - 2);	b = (UINT8)(p.x - 2);
if ((snd26 ^ b) & 7) {	if ((snd26 ^ b) & 7) {
snd26 &= ~0x07;	snd26 &= ~0x07;
snd26 \|= b;	snd26 \|= b;
setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), b);	setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);	redraw = TRUE;
}	}
}	}
else if ((p.x >= 9) && (p.x < 12)) {	else if ((p.x >= 9) && (p.x < 12)) {
Line 405 static void snd26cmddipsw(HWND hWnd) {	Line 358 static void snd26cmddipsw(HWND hWnd) {
if (snd26 != b) {	if (snd26 != b) {
snd26 = b;	snd26 = b;
setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), b);	setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);	redraw = TRUE;
}	}
}	}
else if ((p.x >= 15) && (p.x < 17)) {	else if ((p.x >= 15) && (p.x < 17)) {
b = (BYTE)((p.x - 15) << 4);	b = (UINT8)((p.x - 15) << 4);
if ((snd26 ^ b) & 0x10) {	if ((snd26 ^ b) & 0x10) {
snd26 &= ~0x10;	snd26 &= ~0x10;
snd26 \|= b;	snd26 \|= b;
setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);	setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);	redraw = TRUE;
}	}
}	}
	if (redraw) {
	InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
	}
}	}

static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,	static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,
WPARAM wp, LPARAM lp) {	WPARAM wp, LPARAM lp) {

	HWND sub;

switch(msg) {	switch(msg) {
case WM_INITDIALOG:	case WM_INITDIALOG:
snd26 = np2cfg.snd26opt;	snd26 = np2cfg.snd26opt;
Line 431 static LRESULT CALLBACK Snd26optDlgProc(	Line 389 static LRESULT CALLBACK Snd26optDlgProc(
setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), snd26);	setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), snd26);
SETLISTSTR(hWnd, IDC_SND26ROM, sndromaddr);	SETLISTSTR(hWnd, IDC_SND26ROM, sndromaddr);
setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);	setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);
oldidc_snd26jmp = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,	sub = GetDlgItem(hWnd, IDC_SND26JMP);
IDC_SND26JMP), GWL_WNDPROC);	SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
SetWindowLong(GetDlgItem(hWnd, IDC_SND26JMP), GWL_WNDPROC,	(GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
(LONG)Snd26jmp);
return(TRUE);	return(TRUE);

case WM_COMMAND:	case WM_COMMAND:
switch (LOWORD(wp)) {	switch(LOWORD(wp)) {
case IDC_SND26IO:	case IDC_SND26IO:
set26jmp(hWnd, getsnd26io(hWnd, IDC_SND26IO), 0x10);	set26jmp(hWnd, getsnd26io(hWnd, IDC_SND26IO), 0x10);
break;	break;
Line 460 static LRESULT CALLBACK Snd26optDlgProc(	Line 417 static LRESULT CALLBACK Snd26optDlgProc(
break;	break;

case IDC_SND26JMP:	case IDC_SND26JMP:
snd26cmddipsw(hWnd);	snd26cmdjmp(hWnd);
break;	break;
}	}
break;	break;
Line 474 static LRESULT CALLBACK Snd26optDlgProc(	Line 431 static LRESULT CALLBACK Snd26optDlgProc(
return(TRUE);	return(TRUE);
}	}
break;	break;

	case WM_DRAWITEM:
	if (LOWORD(wp) == IDC_SND26JMP) {
	dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
	dipswbmp_getsnd26(snd26));
	}
	return(FALSE);
}	}
return(FALSE);	return(FALSE);
}	}


// ---- PC-9801-86	// ---- PC-9801-86

static BYTE snd86 = 0;	static UINT8 snd86 = 0;
static SUBCLASSPROC oldidc_snd86dip = NULL;

static const UINT snd86paranum[4] = {0, 1, 3, 2};	static const UINT snd86paranum[4] = {0, 1, 3, 2};

static LRESULT CALLBACK snd86jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {

PAINTSTRUCT ps;
HDC hdc;
HBITMAP hBitmap;
HDC hMemDC;
BYTE *image;
HANDLE hwork;
BITMAPINFO *work;
BYTE *imgbtm;
int align;
int i;
int x, y, yl;

switch(msg) {	static void setsnd86iopara(HWND hWnd, UINT8 value) {
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&snd86dip)))
== NULL) {
break;
}
if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {
GlobalFree(hwork);
break;
}
bit2res_sethead(work, &snd86dip);
hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,
(void **)&image, NULL, 0);
bit2res_setdata(image, &snd86dip);
align = ((snd86dip.x + 7) / 2) & ~3;
imgbtm = image + align * (snd86dip.y - 1);
for (i=0; i<8; i++) {
x = i * 8 + 17;
y = ((snd86&(1<<i))?16:9);
for (yl=0; yl<7; yl++) {
dlgs_linex(imgbtm, x, y++, 6, align, 3);
}
}
if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {
SelectObject(hMemDC, hBitmap);
StretchBlt(hdc, 0, 0, snd86dip.x, snd86dip.y, hMemDC,
0, 0, snd86dip.x, snd86dip.y, SRCCOPY);
DeleteDC(hMemDC);
}
DeleteObject(hBitmap);
EndPaint(hWnd, &ps);
GlobalUnlock(hwork);
GlobalFree(hwork);
break;
default:
return(CallWindowProc(oldidc_snd86dip, hWnd, msg, wp, lp));
}
return(FALSE);
}


static void setsnd86iopara(HWND hWnd, BYTE value) {

SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((~value) & 1), (LPARAM)0);	SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((~value) & 1), (LPARAM)0);
}	}

static BYTE getsnd86io(HWND hWnd, WORD res) {	static UINT8 getsnd86io(HWND hWnd, UINT16 res) {

char work[8];	TCHAR work[8];

GetDlgItemText(hWnd, res, work, sizeof(work));	GetDlgItemText(hWnd, res, work, NELEMENTS(work));
return((BYTE)((work[1] == '1')?0x01:0x00));	return((UINT8)((work[1] == '1')?0x01:0x00));
}	}

static void setsnd86intpara(HWND hWnd, BYTE value) {	static void setsnd86intpara(HWND hWnd, UINT8 value) {

SendMessage(hWnd, CB_SETCURSEL,	SendMessage(hWnd, CB_SETCURSEL,
(WPARAM)snd86paranum[(value >> 2) & 3], (LPARAM)0);	(WPARAM)snd86paranum[(value >> 2) & 3], (LPARAM)0);
}	}

static BYTE getsnd86int(HWND hWnd) {	static UINT8 getsnd86int(HWND hWnd) {

char work[8];	TCHAR work[8];

Edit_GetText(hWnd, work, sizeof(work));	GetWindowText(hWnd, work, NELEMENTS(work));
switch(work[3]) {	switch(work[3]) {
case '0':	case '0':
return(0x00);	return(0x00);
Line 578 static BYTE getsnd86int(HWND hWnd) {	Line 487 static BYTE getsnd86int(HWND hWnd) {
return(0x0c);	return(0x0c);
}	}

static void setsnd86idpara(HWND hWnd, BYTE value) {	static void setsnd86idpara(HWND hWnd, UINT8 value) {

SendMessage(hWnd, CB_SETCURSEL, (WPARAM)(((~value) >> 5) & 7), (LPARAM)0);	SendMessage(hWnd, CB_SETCURSEL, (WPARAM)(((~value) >> 5) & 7), (LPARAM)0);
}	}

static BYTE getsnd86id(HWND hWnd) {	static UINT8 getsnd86id(HWND hWnd) {

char work[8];	TCHAR work[8];

Edit_GetText(hWnd, work, sizeof(work));	GetWindowText(hWnd, work, NELEMENTS(work));
return((~work[0] & 7) << 5);	return((~work[0] & 7) << 5);
}	}

static void set86jmp(HWND hWnd, BYTE value, BYTE bit) {	static void set86jmp(HWND hWnd, UINT8 value, UINT8 bit) {

if ((snd86 ^ value) & bit) {	if ((snd86 ^ value) & bit) {
snd86 &= ~bit;	snd86 &= ~bit;
Line 600 static void set86jmp(HWND hWnd, BYTE val	Line 509 static void set86jmp(HWND hWnd, BYTE val
}	}
}	}

static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,	static void snd86cmddipsw(HWND hWnd) {
WPARAM wp, LPARAM lp) {

RECT rect1;	RECT rect1;
RECT rect2;	RECT rect2;
POINT p;	POINT p;

	GetWindowRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect1);
	GetClientRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect2);
	GetCursorPos(&p);
	p.x += rect2.left - rect1.left;
	p.y += rect2.top - rect1.top;
	p.x /= 8;
	p.y /= 8;
	if ((p.x < 2) \|\| (p.x >= 10) \|\|
	(p.y < 1) \|\| (p.y >= 3)) {
	return;
	}
	p.x -= 2;
	snd86 ^= (1 << p.x);
	switch(p.x) {
	case 0:
	setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);
	break;

	case 1:
	SetDlgItemCheck(hWnd, IDC_SND86ROM, snd86 & 2);
	break;

	case 2:
	case 3:
	setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);
	break;

	case 4:
	SetDlgItemCheck(hWnd, IDC_SND86INT, snd86 & 0x10);
	break;

	case 5:
	case 6:
	case 7:
	setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);
	break;
	}
	InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);
	}

	static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,
	WPARAM wp, LPARAM lp) {

	HWND sub;

switch(msg) {	switch(msg) {
case WM_INITDIALOG:	case WM_INITDIALOG:
snd86 = np2cfg.snd86opt;	snd86 = np2cfg.snd86opt;
SETnLISTSTR(hWnd, IDC_SND86IO, sndioport+1, 2);	SETnLISTSTR(hWnd, IDC_SND86IO, sndioport+1, 2);
setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);	setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT), snd86 & 0x10);	SetDlgItemCheck(hWnd, IDC_SND86INT, snd86 & 0x10);
SETLISTSTR(hWnd, IDC_SND86INTA, sndinterrupt);	SETLISTSTR(hWnd, IDC_SND86INTA, sndinterrupt);
setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);	setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);
SETLISTSTR(hWnd, IDC_SND86ID, sndid);	SETLISTSTR(hWnd, IDC_SND86ID, sndid);
setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);	setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), snd86 & 2);	SetDlgItemCheck(hWnd, IDC_SND86ROM, snd86 & 2);
oldidc_snd86dip = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,
IDC_SND86DIP), GWL_WNDPROC);	sub = GetDlgItem(hWnd, IDC_SND86DIP);
SetWindowLong(GetDlgItem(hWnd, IDC_SND86DIP), GWL_WNDPROC,	SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
(LONG)snd86jmp);	(GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
return(TRUE);	return(TRUE);

case WM_COMMAND:	case WM_COMMAND:
switch (LOWORD(wp)) {	switch(LOWORD(wp)) {
case IDC_SND86IO:	case IDC_SND86IO:
set86jmp(hWnd, getsnd86io(hWnd, IDC_SND86IO), 0x01);	set86jmp(hWnd, getsnd86io(hWnd, IDC_SND86IO), 0x01);
break;	break;
case IDC_SND86INT:	case IDC_SND86INT:
set86jmp(hWnd,	set86jmp(hWnd,
((Button_GetCheck(GetDlgItem(hWnd, IDC_SND86INT)))	(GetDlgItemCheck(hWnd, IDC_SND86INT))?0x10:0x00,
?0x10:0x00), 0x10);	0x10);
break;	break;
case IDC_SND86INTA:	case IDC_SND86INTA:
set86jmp(hWnd,	set86jmp(hWnd,
Line 640 static LRESULT CALLBACK Snd86optDlgProc(	Line 593 static LRESULT CALLBACK Snd86optDlgProc(
break;	break;
case IDC_SND86ROM:	case IDC_SND86ROM:
set86jmp(hWnd,	set86jmp(hWnd,
((Button_GetCheck(GetDlgItem(hWnd, IDC_SND86ROM)))	(GetDlgItemCheck(hWnd, IDC_SND86ROM))?0x02:0x00,
?0x02:0x00), 0x02);	0x02);
break;	break;
case IDC_SND86ID:	case IDC_SND86ID:
set86jmp(hWnd,	set86jmp(hWnd,
getsnd86id(GetDlgItem(hWnd, IDC_SND86ID)), 0xe0);	getsnd86id(GetDlgItem(hWnd, IDC_SND86ID)), 0xe0);
break;	break;

case IDC_SND86DEF:	case IDC_SND86DEF:
snd86 = 0x7f;	snd86 = 0x7f;
setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);	setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT), TRUE);	SetDlgItemCheck(hWnd, IDC_SND86INT, TRUE);
setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);	setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);
setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);	setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), TRUE);	SetDlgItemCheck(hWnd, IDC_SND86ROM, TRUE);
InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);	InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);
break;	break;

case IDC_SND86DIP:	case IDC_SND86DIP:
GetWindowRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect1);	snd86cmddipsw(hWnd);
GetClientRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect2);
GetCursorPos(&p);
p.x += rect2.left - rect1.left;
p.y += rect2.top - rect1.top;
p.x /= 8;
p.y /= 8;
if ((p.x < 2) \|\| (p.x >= 10) \|\|
(p.y < 1) \|\| (p.y >= 3)) {
break;
}
p.x -= 2;
snd86 ^= (1 << p.x);
switch(p.x) {
case 0:
setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO),
snd86);
break;
case 1:
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM),
snd86 & 2);
break;
case 2:
case 3:
setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA),
snd86);
break;
case 4:
Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT),
snd86 & 0x10);
break;
case 5:
case 6:
case 7:
setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID),
snd86);
break;
}
InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP),
NULL, TRUE);
break;	break;
}	}
break;	break;
Line 710 static LRESULT CALLBACK Snd86optDlgProc(	Line 626 static LRESULT CALLBACK Snd86optDlgProc(
return(TRUE);	return(TRUE);
}	}
break;	break;

	case WM_DRAWITEM:
	if (LOWORD(wp) == IDC_SND86DIP) {
	dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
	dipswbmp_getsnd86(snd86));
	}
	return(FALSE);
}	}
return(FALSE);	return(FALSE);
}	}

// ------------------------------------------------------ Speak board

static BYTE spb = 0;	// ---- Speak board
static BYTE spbvrc = 0;
static SUBCLASSPROC oldidc_spbjmp = NULL;


static LRESULT CALLBACK spbjmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {

PAINTSTRUCT ps;
HDC hdc;
HBITMAP hBitmap;
HDC hMemDC;
BYTE *image;
HANDLE hwork;
BITMAPINFO *work;
BYTE *imgbtm;
int align;

switch(msg) {	static UINT8 spb = 0;
case WM_PAINT:	static UINT8 spbvrc = 0;
hdc = BeginPaint(hWnd, &ps);
if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&spbdip)))	static void setspbVRch(HWND hWnd) {
== NULL) {
	SetDlgItemCheck(hWnd, IDC_SPBVRL, spbvrc & 1);
	SetDlgItemCheck(hWnd, IDC_SPBVRR, spbvrc & 2);
	}

	static void spbcreate(HWND hWnd) {

	HWND sub;

	spb = np2cfg.spbopt;
	SETnLISTSTR(hWnd, IDC_SPBIO, sndioport, 2);
	setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);
	SETLISTSTR(hWnd, IDC_SPBINT, sndinterrupt);
	setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), spb);
	SETLISTSTR(hWnd, IDC_SPBROM, sndromaddr);
	setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), spb);
	spbvrc = np2cfg.spb_vrc; // ver0.30
	setspbVRch(hWnd);
	SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETRANGE, TRUE,
	MAKELONG(0, 24));
	SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETPOS, TRUE,
	np2cfg.spb_vrl);
	SetDlgItemCheck(hWnd, IDC_SPBREVERSE, np2cfg.spb_x);

	sub = GetDlgItem(hWnd, IDC_SPBJMP);
	SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
	(GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
	}

	static void spbcmdjmp(HWND hWnd) {

	RECT rect1;
	RECT rect2;
	POINT p;
	BOOL redraw;
	UINT8 b;
	UINT8 bit;

	GetWindowRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect1);
	GetClientRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect2);
	GetCursorPos(&p);
	redraw = FALSE;
	p.x += rect2.left - rect1.left;
	p.y += rect2.top - rect1.top;
	p.x /= 9;
	p.y /= 9;
	if ((p.y < 1) \|\| (p.y >= 3)) {
	return;
	}
	if ((p.x >= 2) && (p.x < 5)) {
	b = spb;
	bit = 0x40 << (2 - p.y);
	switch(p.x) {
	case 2:
	b \|= bit;
break;	break;
}
if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {	case 3:
GlobalFree(hwork);	b ^= bit;
break;	break;
}
bit2res_sethead(work, &spbdip);	case 4:
hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,	b &= ~bit;
(void **)&image, NULL, 0);	break;
bit2res_setdata(image, &spbdip);	}
align = ((spbdip.x + 7) / 2) & ~3;	if (spb != b) {
imgbtm = image + align * (spbdip.y - 1);	spb = b;
setsnd26intdip(imgbtm, 2, 1, align, spb);	setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), b);
setsnd26iodip(imgbtm, 10, 1, align, spb);	redraw = TRUE;
setsnd26romdip(imgbtm, 14, 1, align, spb);	}
if (spb & 0x20) {	}
dlgs_setjumpery(imgbtm, 7, 1, align);	else if (p.x == 7) {
}	spb ^= 0x20;
dlgs_setjumperx(imgbtm, ((spbvrc&2)?21:22), 1, align);	redraw = TRUE;
dlgs_setjumperx(imgbtm, ((spbvrc&1)?21:22), 2, align);	}
if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {	else if ((p.x >= 10) && (p.x < 12)) {
SelectObject(hMemDC, hBitmap);	b = (UINT8)((p.x - 10) << 4);
StretchBlt(hdc, 0, 0, spbdip.x, spbdip.y, hMemDC,	if ((spb ^ b) & 0x10) {
0, 0, spbdip.x, spbdip.y, SRCCOPY);	spb &= ~0x10;
DeleteDC(hMemDC);	spb \|= b;
}	setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), b);
DeleteObject(hBitmap);	redraw = TRUE;
EndPaint(hWnd, &ps);	}
GlobalUnlock(hwork);	}
GlobalFree(hwork);	else if ((p.x >= 14) && (p.x < 19)) {
break;	b = (UINT8)(p.x - 14);
default:	if ((spb ^ b) & 7) {
return(CallWindowProc(oldidc_spbjmp, hWnd, msg, wp, lp));	spb &= ~0x07;
	spb \|= b;
	setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), b);
	redraw = TRUE;
	}
	}
	else if ((p.x >= 21) && (p.x < 24)) {
	spbvrc ^= (UINT8)(3 - p.y);
	setspbVRch(hWnd);
	redraw = TRUE;
	}
	if (redraw) {
	InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);
}	}
return(FALSE);
}	}

static void setspbjmp(HWND hWnd, BYTE value, BYTE bit) {	static void setspbjmp(HWND hWnd, UINT8 value, UINT8 bit) {

if ((spb ^ value) & bit) {	if ((spb ^ value) & bit) {
spb &= ~bit;	spb &= ~bit;
Line 784 static void setspbjmp(HWND hWnd, BYTE va	Line 756 static void setspbjmp(HWND hWnd, BYTE va
}	}
}	}

static void setspbVRch(HWND hWnd) {	static UINT8 getspbVRch(HWND hWnd) {

Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRL), spbvrc & 1);
Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRR), spbvrc & 2);
}

static BYTE getspbVRch(HWND hWnd) {

BYTE ret = 0;	UINT8 ret;

if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRL))) {	ret = 0;
ret++;	if (GetDlgItemCheck(hWnd, IDC_SPBVRL)) {
	ret += 1;
}	}
if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRR))) {	if (GetDlgItemCheck(hWnd, IDC_SPBVRR)) {
ret += 2;	ret += 2;
}	}
return(ret);	return(ret);
}	}


static LRESULT CALLBACK SPBoptDlgProc(HWND hWnd, UINT msg,	static LRESULT CALLBACK SPBoptDlgProc(HWND hWnd, UINT msg,
WPARAM wp, LPARAM lp) {	WPARAM wp, LPARAM lp) {
BYTE b, bit;	UINT8 b;
RECT rect1;
RECT rect2;
POINT p;
UINT update;	UINT update;

switch(msg) {	switch(msg) {
case WM_INITDIALOG:	case WM_INITDIALOG:
spb = np2cfg.spbopt;	spbcreate(hWnd);
SETnLISTSTR(hWnd, IDC_SPBIO, sndioport, 2);
setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);
SETLISTSTR(hWnd, IDC_SPBINT, sndinterrupt);
setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), spb);
SETLISTSTR(hWnd, IDC_SPBROM, sndromaddr);
setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), spb);
spbvrc = np2cfg.spb_vrc; // ver0.30
setspbVRch(hWnd);
SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETRANGE, TRUE,
MAKELONG(0, 24));
SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETPOS, TRUE,
np2cfg.spb_vrl);
Button_SetCheck(GetDlgItem(hWnd, IDC_SPBREVERSE), np2cfg.spb_x);

oldidc_spbjmp = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,
IDC_SPBJMP), GWL_WNDPROC);
SetWindowLong(GetDlgItem(hWnd, IDC_SPBJMP), GWL_WNDPROC,
(LONG)spbjmp);
return(TRUE);	return(TRUE);

case WM_COMMAND:	case WM_COMMAND:
switch (LOWORD(wp)) {	switch(LOWORD(wp)) {
case IDC_SPBIO:	case IDC_SPBIO:
setspbjmp(hWnd, getsnd26io(hWnd, IDC_SPBIO), 0x10);	setspbjmp(hWnd, getsnd26io(hWnd, IDC_SPBIO), 0x10);
break;	break;

case IDC_SPBINT:	case IDC_SPBINT:
setspbjmp(hWnd, getsnd26int(hWnd, IDC_SPBINT), 0xc0);	setspbjmp(hWnd, getsnd26int(hWnd, IDC_SPBINT), 0xc0);
break;	break;

case IDC_SPBROM:	case IDC_SPBROM:
setspbjmp(hWnd, getsnd26rom(hWnd, IDC_SPBROM), 0x07);	setspbjmp(hWnd, getsnd26rom(hWnd, IDC_SPBROM), 0x07);
break;	break;

case IDC_SPBDEF:	case IDC_SPBDEF:
spb = 0xd1;	spb = 0xd1;
setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);	setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);
Line 855 static LRESULT CALLBACK SPBoptDlgProc(HW	Line 803 static LRESULT CALLBACK SPBoptDlgProc(HW
setspbVRch(hWnd);	setspbVRch(hWnd);
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);	InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);
break;	break;

case IDC_SPBVRL:	case IDC_SPBVRL:
case IDC_SPBVRR:	case IDC_SPBVRR:
b = getspbVRch(hWnd);	b = getspbVRch(hWnd);
Line 864 static LRESULT CALLBACK SPBoptDlgProc(HW	Line 813 static LRESULT CALLBACK SPBoptDlgProc(HW
NULL, TRUE);	NULL, TRUE);
}	}
break;	break;

case IDC_SPBJMP:	case IDC_SPBJMP:
GetWindowRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect1);	spbcmdjmp(hWnd);
GetClientRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect2);
GetCursorPos(&p);
p.x += rect2.left - rect1.left;
p.y += rect2.top - rect1.top;
p.x /= 9;
p.y /= 9;
if ((p.y < 1) \|\| (p.y >= 3)) {
break;
}
if ((p.x >= 2) && (p.x < 5)) {
b = spb;
bit = 0x40 << (2 - p.y);
switch(p.x) {
case 2:
b \|= bit;
break;
case 3:
b ^= bit;
break;
case 4:
b &= ~bit;
break;
}
if (spb != b) {
spb = b;
setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),
NULL, TRUE);
}
}
else if (p.x == 7) {
spb ^= 0x20;
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),
NULL, TRUE);
}
else if ((p.x >= 10) && (p.x < 12)) {
b = (BYTE)((p.x - 10) << 4);
if ((spb ^ b) & 0x10) {
spb &= ~0x10;
spb \|= b;
setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),
NULL, TRUE);
}
}
else if ((p.x >= 14) && (p.x < 19)) {
b = (BYTE)(p.x - 14);
if ((spb ^ b) & 7) {
spb &= ~0x07;
spb \|= b;
setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), b);
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),
NULL, TRUE);
}
}
else if ((p.x >= 21) && (p.x < 24)) {
spbvrc ^= (BYTE)(3 - p.y);
setspbVRch(hWnd);
InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),
NULL, TRUE);
}
break;	break;
}	}
break;	break;
Line 942 static LRESULT CALLBACK SPBoptDlgProc(HW	Line 831 static LRESULT CALLBACK SPBoptDlgProc(HW
np2cfg.spb_vrc = spbvrc;	np2cfg.spb_vrc = spbvrc;
update \|= SYS_UPDATECFG;	update \|= SYS_UPDATECFG;
}	}
b = (BYTE)SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL,	b = (UINT8)SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL,
TBM_GETPOS, 0, 0);	TBM_GETPOS, 0, 0);
if (np2cfg.spb_vrl != b) {	if (np2cfg.spb_vrl != b) {
np2cfg.spb_vrl = b;	np2cfg.spb_vrl = b;
update \|= SYS_UPDATECFG;	update \|= SYS_UPDATECFG;
}	}
opngen_setVR(np2cfg.spb_vrc, np2cfg.spb_vrl);	opngen_setVR(np2cfg.spb_vrc, np2cfg.spb_vrl);
b = (BYTE)(Button_GetCheck(GetDlgItem(hWnd, IDC_SPBREVERSE))? 1:0);	b = (UINT8)GetDlgItemCheck(hWnd, IDC_SPBREVERSE);
if (np2cfg.spb_x != b) {	if (np2cfg.spb_x != b) {
np2cfg.spb_x = b;	np2cfg.spb_x = b;
update \|= SYS_UPDATECFG;	update \|= SYS_UPDATECFG;
Line 958 static LRESULT CALLBACK SPBoptDlgProc(HW	Line 847 static LRESULT CALLBACK SPBoptDlgProc(HW
return(TRUE);	return(TRUE);
}	}
break;	break;

	case WM_DRAWITEM:
	if (LOWORD(wp) == IDC_SPBJMP) {
	dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
	dipswbmp_getsndspb(spb, spbvrc));
	}
	return(FALSE);
}	}
return(FALSE);	return(FALSE);
}	}
Line 968 static LRESULT CALLBACK SPBoptDlgProc(HW	Line 864 static LRESULT CALLBACK SPBoptDlgProc(HW
typedef struct {	typedef struct {
UINT16 res;	UINT16 res;
UINT16 bit;	UINT16 bit;
BYTE *ptr;	UINT8 *ptr;
} CHECKTBL;	} CHECKTBL;

static const CHECKTBL pad1opt[13] = {	static const CHECKTBL pad1opt[13] = {
Line 989 static const CHECKTBL pad1opt[13] = {	Line 885 static const CHECKTBL pad1opt[13] = {

static void checkbtnres_load(HWND hWnd, const CHECKTBL *item) {	static void checkbtnres_load(HWND hWnd, const CHECKTBL *item) {

Button_SetCheck(GetDlgItem(hWnd, item->res),	SetDlgItemCheck(hWnd, item->res, (*(item->ptr)) & (1 << (item->bit)));
(*(item->ptr)) & (1 << (item->bit)));
}	}

static BYTE checkbtnres_store(HWND hWnd, const CHECKTBL *item) {	static UINT8 checkbtnres_store(HWND hWnd, const CHECKTBL *item) {

BYTE value;	UINT8 value;
BYTE bit;	UINT8 bit;
BYTE ret;	UINT8 ret;

bit = 1 << (item->bit);	bit = 1 << (item->bit);
value = ((Button_GetCheck(GetDlgItem(hWnd, item->res)))?0xff:0) & bit;	value = GetDlgItemCheck(hWnd, item->res)?bit:0;
ret = ((*(item->ptr)) ^ value) & bit;	ret = ((*(item->ptr)) ^ value) & bit;
if (ret) {	if (ret) {
(*(item->ptr)) ^= bit;	(*(item->ptr)) ^= bit;
Line 1012 static LRESULT CALLBACK PAD1optDlgProc(H	Line 907 static LRESULT CALLBACK PAD1optDlgProc(H
WPARAM wp, LPARAM lp) {	WPARAM wp, LPARAM lp) {

int i;	int i;
BYTE renewal;	UINT8 renewal;

switch(msg) {	switch(msg) {
case WM_INITDIALOG:	case WM_INITDIALOG:
Line 1020 static LRESULT CALLBACK PAD1optDlgProc(H	Line 915 static LRESULT CALLBACK PAD1optDlgProc(H
checkbtnres_load(hWnd, pad1opt + i);	checkbtnres_load(hWnd, pad1opt + i);
}	}
if (np2oscfg.JOYPAD1 & 2) {	if (np2oscfg.JOYPAD1 & 2) {
Button_Enable(GetDlgItem(hWnd, IDC_JOYPAD1), FALSE);	EnableWindow(GetDlgItem(hWnd, IDC_JOYPAD1), FALSE);
}	}
return(TRUE);	return(TRUE);

Line 1031 static LRESULT CALLBACK PAD1optDlgProc(H	Line 926 static LRESULT CALLBACK PAD1optDlgProc(H
renewal \|= checkbtnres_store(hWnd, pad1opt + i);	renewal \|= checkbtnres_store(hWnd, pad1opt + i);
}	}
if (renewal) {	if (renewal) {
joy_init();	joymng_initialize();
sysmng_update(SYS_UPDATECFG);	sysmng_update(SYS_UPDATECFG);
}	}
return(TRUE);	return(TRUE);
Line 1049 void dialog_sndopt(HWND hWnd) {	Line 944 void dialog_sndopt(HWND hWnd) {
HINSTANCE hinst;	HINSTANCE hinst;
PROPSHEETPAGE psp;	PROPSHEETPAGE psp;
PROPSHEETHEADER psh;	PROPSHEETHEADER psh;
HPROPSHEETPAGE hpsp[6]; // ver0.29	HPROPSHEETPAGE hpsp[6];

hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);	hinst = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);

ZeroMemory(&psp, sizeof(psp));	ZeroMemory(&psp, sizeof(psp));
psp.dwSize = sizeof(PROPSHEETPAGE);	psp.dwSize = sizeof(PROPSHEETPAGE);
Line 1084 void dialog_sndopt(HWND hWnd) {	Line 979 void dialog_sndopt(HWND hWnd) {

ZeroMemory(&psh, sizeof(psh));	ZeroMemory(&psh, sizeof(psh));
psh.dwSize = sizeof(PROPSHEETHEADER);	psh.dwSize = sizeof(PROPSHEETHEADER);
psh.dwFlags = PSH_NOAPPLYNOW \| PSH_USEHICON;	psh.dwFlags = PSH_NOAPPLYNOW \| PSH_USEHICON \| PSH_USECALLBACK;
psh.hwndParent = hWnd;	psh.hwndParent = hWnd;
psh.hInstance = hinst;	psh.hInstance = hinst;
psh.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON2));	psh.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON2));
psh.nPages = 6;	psh.nPages = 6;
psh.phpage = hpsp;	psh.phpage = hpsp;
psh.pszCaption = str_sndopt;	psh.pszCaption = str_sndopt;
	psh.pfnCallback = np2class_propetysheet;
PropertySheet(&psh);	PropertySheet(&psh);
InvalidateRect(hWnd, NULL, TRUE);	InvalidateRect(hWnd, NULL, TRUE);
}	}
Line 1098 void dialog_sndopt(HWND hWnd) {	Line 994 void dialog_sndopt(HWND hWnd) {

// ----	// ----

static const char s98ui_file[] = "NP2_%04d.S98";	#if defined(SUPPORT_S98)
static const char s98ui_title[] = "Save as S98 log";	static const OEMCHAR s98ui_file[] = OEMTEXT("NP2_%04d.S98");
static const char s98ui_ext[] = "s98";	static const TCHAR s98ui_title[] = _T("Save as S98 log");
static const char s98ui_filter[] = "S98 log (.s98)\0.s98\0";	static const TCHAR s98ui_ext[] = _T("s98");
	static const TCHAR s98ui_filter[] = _T("S98 log (.s98)\0.s98\0");
static const FILESEL s98ui = {s98ui_title, s98ui_ext, s98ui_filter, 1};	static const FILESEL s98ui = {s98ui_title, s98ui_ext, s98ui_filter, 1};

void dialog_s98(HWND hWnd) {	void dialog_s98(HWND hWnd) {

BOOL check;	BOOL check;
char path[MAX_PATH];	OEMCHAR path[MAX_PATH];

S98_close();	S98_close();
check = FALSE;	check = FALSE;
file_cpyname(path, bmpfilefolder, sizeof(path));	file_cpyname(path, bmpfilefolder, NELEMENTS(path));
file_cutname(path);	file_cutname(path);
file_catname(path, s98ui_file, sizeof(path));	file_catname(path, s98ui_file, NELEMENTS(path));
if ((dlgs_selectwritenum(hWnd, &s98ui, path, sizeof(path))) &&	if ((dlgs_selectwritenum(hWnd, &s98ui, path, NELEMENTS(path))) &&
(S98_open(path) == SUCCESS)) {	(S98_open(path) == SUCCESS)) {
file_cpyname(bmpfilefolder, path, sizeof(bmpfilefolder));	file_cpyname(bmpfilefolder, path, NELEMENTS(bmpfilefolder));
sysmng_update(SYS_UPDATEOSCFG);	sysmng_update(SYS_UPDATEOSCFG);
check = TRUE;	check = TRUE;
}	}
xmenu_sets98logging(check);	xmenu_sets98logging(check);
}	}
	#endif


	// ----

	#if defined(SUPPORT_WAVEREC)
	static const OEMCHAR wrui_file[] = OEMTEXT("NP2_%04d.WAV");
	static const TCHAR wrui_title[] = _T("Save as Sound");
	static const TCHAR wrui_ext[] = _T("WAV");
	static const TCHAR wrui_filter[] = _T("Wave files (.wav)\0.wav\0");
	static const FILESEL wrui = {wrui_title, wrui_ext, wrui_filter, 1};

	void dialog_waverec(HWND hWnd) {

	UINT8 check;
	OEMCHAR path[MAX_PATH];

	check = FALSE;
	sound_recstop();
	file_cpyname(path, bmpfilefolder, NELEMENTS(path));
	file_cutname(path);
	file_catname(path, wrui_file, NELEMENTS(path));
	if ((dlgs_selectwritenum(hWnd, &wrui, path, NELEMENTS(path))) &&
	(sound_recstart(path) == SUCCESS)) {
	file_cpyname(bmpfilefolder, path, NELEMENTS(bmpfilefolder));
	sysmng_update(SYS_UPDATEOSCFG);
	check = TRUE;
	}
	xmenu_setwaverec(check);
	}
	#endif

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.7
changed lines
	Added in v.1.20