int FAR PASCAL Lib3( LPSTR data, WORD a, WORD b,
DWORD d1, WORD c, DWORD d2 )
{
char far *str;
char buf[128];
str = (char far *)MK_FP32( data );
sprintf( buf, "Lib3: string ==>%Fs<==", str );
MessageBox( NULL, buf, "DLL32", MB_OK | MB_TASKMODAL );
#ifdef __cplusplus
{
ostrstream sout( buf, sizeof( buf ) );
sout << hex << "Lib3: a=" << a <<
", b=" << b <<
", c=" << c << ends;
MessageBox( NULL, sout.str(), "DLL32", MB_OK | MB_TASKMODAL );
}
#else
sprintf( buf, "Lib3: a=%hd, b=%hd, c=%hd", a, b, c );
MessageBox( NULL, buf, "DLL32", MB_OK | MB_TASKMODAL );
#endif
#ifdef __cplusplus
{
ostrstream sout( buf, sizeof( buf ) );
sout << hex << "Lib3: d1=" << d1 <<
", d2=" << d2 << ends;
MessageBox( NULL, sout.str(), "DLL32", MB_OK | MB_TASKMODAL );
}
#else
sprintf( buf, "Lib3: d1=%lx, d2=%lx", d1, d2 );
MessageBox( NULL, buf, "DLL32", MB_OK | MB_TASKMODAL );
#endif
return( d1 + d2 );
}
WINEXPORT int CALLBACK EnumFamTypefaces( const LOGFONT FAR *lf, const TEXTMETRIC FAR *tm, DWORD FontType, LPARAM lparam )
#endif
{
#ifdef __WINDOWS_386__
char faceName[LF_FACESIZE];
const LOGFONT __far *lf = MK_FP32( (void *)_lf );
tm = tm;
#elif defined( __WINDOWS__ )
const LOGFONT FAR *lf = (const LOGFONT FAR *)elf;
// const TEXTMETRIC FAR *tm = (const TEXTMETRIC FAR *)ntm;
ntm = ntm;
#else
tm = tm;
#endif
lparam = lparam;
FontType = FontType;
#ifdef __WINDOWS_386__
/* On Win386, we need to pass a near 32-bit pointer with LB_ADDSTRING,
* but we get a far pointer from Windows. Hence the shenanigans with
* a temp buffer in the flat address space.
*/
_fstrcpy( faceName, lf->lfFaceName );
SendMessage( hwndTypeface, LB_ADDSTRING, 0, (LPARAM)faceName );
#else
SendMessage( hwndTypeface, LB_ADDSTRING, 0, (LPARAM)(lf->lfFaceName) );
#endif
return( TRUE );
}
WINEXPORT int CALLBACK SetupFontData( const LOGFONT FAR *lf, const TEXTMETRIC FAR *tm, DWORD FontType, LPARAM lparam )
#endif
{
#ifdef __WINDOWS_386__
const LOGFONT __far *lf = MK_FP32( (void *)_lf );
tm = tm;
#elif defined( __WINDOWS__ )
const LOGFONT FAR *lf = (const LOGFONT FAR *)elf;
// const TEXTMETRIC FAR *tm = (const TEXTMETRIC FAR *)ntm;
ntm = ntm;
#else
tm = tm;
#endif
FontType = FontType;
lparam = lparam;
/* start setting up CurLogfont based on the font data */
CurLogfont.lfCharSet = lf->lfCharSet;
CurLogfont.lfOutPrecision = lf->lfOutPrecision;
CurLogfont.lfClipPrecision = lf->lfClipPrecision;
CurLogfont.lfQuality = lf->lfQuality;
CurLogfont.lfPitchAndFamily = lf->lfPitchAndFamily;
/* only do this for the 1st font - we just want defaults */
return( FALSE );
}
static void ps2_mouse_callback(struct sigcontext *scp,
const struct RealModeCallStructure *rmreg,
int is_32, void *arg)
{
unsigned short *rm_ssp;
void *sp = SEL_ADR_CLNT(_ss, _esp, is_32);
struct pmaddr_s *PS2mouseCallBack = arg;
if (!ValidAndUsedSelector(PS2mouseCallBack->selector)) {
D_printf("MSDOS: ERROR: PS2 mouse callback to unused segment\n");
return;
}
D_printf("MSDOS: starting PS2 mouse callback\n");
rm_ssp = MK_FP32(RMREG(ss), RMREG(sp) + 4 + 8);
if (is_32) {
unsigned int *ssp = sp;
*--ssp = *--rm_ssp;
D_printf("data: 0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x\n", *ssp);
*--ssp = _cs;
*--ssp = _eip;
_esp -= 24;
} else {
unsigned short *ssp = sp;
*--ssp = *--rm_ssp;
D_printf("data: 0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x ", *ssp);
*--ssp = *--rm_ssp;
D_printf("0x%x\n", *ssp);
*--ssp = _cs;
*--ssp = _LWORD(eip);
_LWORD(esp) -= 12;
}
_cs = PS2mouseCallBack->selector;
_eip = PS2mouseCallBack->offset;
}
WINEXPORT int CALLBACK EnumFamInfo( const LOGFONT FAR *lf, const TEXTMETRIC FAR *tm, DWORD FontType, LPARAM lparam )
#endif
{
char sbuf[40];
int height;
long *isTrueType = (long *)lparam;
#ifdef __WINDOWS_386__
const LOGFONT __far *lf = MK_FP32( (void *)_lf );
tm = tm;
#elif defined( __WINDOWS__ )
const LOGFONT FAR *lf = (const LOGFONT FAR *)elf;
// const TEXTMETRIC FAR *tm = (const TEXTMETRIC FAR *)ntm;
ntm = ntm;
#else
tm = tm;
#endif
if( FontType == TRUETYPE_FONTTYPE ) {
/* truetype creates the style string for us
*/
/* PROBLEM: the style string may be weird (eg "Outline Italic").
If so, we are stuck as we cannot apparently specify this
to CreateFont. For now, we are simply IGNORING any/all
TrueType style strings are are just specifying the 4 basic ones
damNit.
*/
*isTrueType = 1;
} else {
/* add size to list
*/
height = abs( lf->lfHeight );
sprintf( sbuf, "%d", height );
if( SendMessage( hwndSize, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)sbuf ) == CB_ERR ) {
SendMessage( hwndSize, CB_INSERTSTRING, NSizes, (LPARAM)sbuf );
}
}
return( 1 );
}
WINEXPORT UINT_PTR CALLBACK OpenHook( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
unsigned len;
#ifdef __WINDOWS_386__
static OPENFILENAME __far *of;
#else
static OPENFILENAME *of;
#endif
wparam = wparam;
lparam = lparam;
hwnd = hwnd;
switch( msg ) {
case WM_INITDIALOG:
/* danger - not sure that lparam is guaranteed to be the of. struct */
#ifdef __WINDOWS_386__
of = (OPENFILENAME __far *)MK_FP32( (void *)lparam );
#else
of = (OPENFILENAME *)lparam;
#endif
// return( FALSE );
return( TRUE );
case WM_COMMAND:
switch( LOWORD( wparam ) ) {
case IDOK:
len = SendDlgItemMessage( hwnd, edt1, WM_GETTEXTLENGTH, 0, 0 );
if( len >= of->nMaxFile ) {
FileNameList = MemAlloc( len + 1 );
len = SendDlgItemMessage( hwnd, edt1, WM_GETTEXT, len + 1, (LPARAM)FileNameList );
}
}
break;
}
return( FALSE );
}
static bool guiToolBarProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 wparam, WPI_PARAM2 lparam )
{
gui_window *wnd;
toolbarinfo *tbar;
HMENU hmenu;
gui_ctl_id id;
wnd = GetToolWnd( hwnd );
if( wnd == NULL ) {
return( false );
}
tbar = wnd->tbinfo;
if( tbar == NULL ) {
return( false );
}
switch( msg ) {
case WM_CREATE :
hwnd = _wpi_getframe( hwnd );
hmenu = _wpi_getsystemmenu( hwnd );
if( hmenu != NULLHANDLE ) {
if( _wpi_appendmenu( hmenu, MF_SEPARATOR, 0, 0, NULLHANDLE, NULL ) ) {
_wpi_appendmenu( hmenu, MF_ENABLED|MF_SYSMENU, 0,
GUIHint[GUI_MENU_FIX_TOOLBAR].id, NULLHANDLE,
GUIHint[GUI_MENU_FIX_TOOLBAR].label );
}
}
break;
#ifdef __OS2_PM__
case WM_CHAR :
case WM_TRANSLATEACCEL :
#else
case WM_SYSKEYDOWN :
case WM_SYSKEYUP :
case WM_KEYUP :
case WM_KEYDOWN :
#endif
return( GUIProcesskey( hwnd, msg, wparam, lparam ) != 0 );
case WM_MENUSELECT :
GUIProcessMenuSelect( wnd, hwnd, msg, wparam, lparam );
return( true );
case WM_SYSCOMMAND :
id = _wpi_getid( wparam );
switch( id ) {
case GUI_FIX_TOOLBAR :
GUIChangeToolBar( wnd );
}
break;
#ifndef __OS2_PM__
case WM_NCLBUTTONDBLCLK :
#endif
case WM_RBUTTONDBLCLK :
case WM_LBUTTONDBLCLK :
/* flip the current state of the toolbar -
* if we are fixed then start to float or vice versa
*/
if( !HasToolAtPoint( tbar->hdl, wparam, lparam ) ) {
#ifdef __OS2_PM__
// Hack: For some reason we will get here with bogus coords,
// we need to ignore the event. Should really find out where
// the message is coming from.
if( (ULONG)wparam != 0x0FFFFFFF )
GUIChangeToolBar( wnd );
#else
GUIChangeToolBar( wnd );
#endif
return( true );
}
break;
case WM_MOVE:
case WM_SIZE:
// Whenever we are moved or sized as a floating toolbar, we remember our position
// so that we can restore it when dbl. clicked
if( tbar->info.style == TOOLBAR_FLOAT_STYLE ) {
hwnd = _wpi_getframe( hwnd );
_wpi_getwindowrect( hwnd, &tbar->floatrect );
}
break;
case WM_GETMINMAXINFO:
{
#ifdef __WINDOWS_386__
WPI_MINMAXINFO __far *minmax= (WPI_MINMAXINFO __far *)MK_FP32( (void *)lparam );
#else
WPI_MINMAXINFO *minmax = (WPI_MINMAXINFO *)lparam;
#endif
_wpi_setmintracksize( minmax,
( tbar->info.border_size.x + _wpi_getsystemmetrics( SM_CXFRAME ) ) * 2 + tbar->info.button_size.x,
( tbar->info.border_size.y + _wpi_getsystemmetrics( SM_CYFRAME ) ) * 2 + tbar->info.button_size.y + _wpi_getsystemmetrics( SM_CYCAPTION ) );
}
break;
case WM_CLOSE :
GUICloseToolBar( wnd );
return( true );
break;
}
return( false );
}
unsigned int mhp_debug(enum dosdebug_event code, unsigned int parm1, unsigned int parm2)
{
int rtncd = 0;
#if 0
return rtncd;
#endif
mhpdbgc.currcode = code;
mhp_bpclr();
switch (DBG_TYPE(mhpdbgc.currcode)) {
case DBG_INIT:
mhp_init();
break;
case DBG_BOOT:
mhp_boot();
break;
case DBG_INTx:
if (!mhpdbg.active)
break;
if (test_bit(DBG_ARG(mhpdbgc.currcode), mhpdbg.intxxtab)) {
if ((mhpdbgc.bpload==1) && (DBG_ARG(mhpdbgc.currcode) == 0x21) && (LWORD(eax) == 0x4b00) ) {
/* mhpdbgc.bpload_bp=((long)SREG(cs) << 4) +LWORD(eip); */
mhpdbgc.bpload_bp = SEGOFF2LINEAR(SREG(cs), LWORD(eip));
if (mhp_setbp(mhpdbgc.bpload_bp)) {
mhp_printf("bpload: intercepting EXEC\n", SREG(cs), REG(eip));
/*
mhp_cmd("r");
mhp_cmd("d ss:sp 30h");
*/
mhpdbgc.bpload++;
mhpdbgc.bpload_par=MK_FP32(BIOSSEG,(long)DBGload_parblock-(long)bios_f000);
MEMCPY_2UNIX(mhpdbgc.bpload_par, SEGOFF2LINEAR(SREG(es), LWORD(ebx)), 14);
MEMCPY_2UNIX(mhpdbgc.bpload_cmdline, PAR4b_addr(commandline_ptr), 128);
MEMCPY_2UNIX(mhpdbgc.bpload_cmd, SEGOFF2LINEAR(SREG(ds), LWORD(edx)), 128);
SREG(es)=BIOSSEG;
LWORD(ebx)=(void *)mhpdbgc.bpload_par - MK_FP32(BIOSSEG, 0);
LWORD(eax)=0x4b01; /* load, but don't execute */
}
else {
mhp_printf("bpload: ??? #1\n");
mhp_cmd("r");
mhpdbgc.bpload_bp=0;
mhpdbgc.bpload=0;
}
if (!--mhpdbgc.int21_count) {
volatile register int i=0x21; /* beware, set_bit-macro has wrong constraints */
clear_bit(i, mhpdbg.intxxtab);
if (test_bit(i, mhpdbgc.intxxalt)) {
clear_bit(i, mhpdbgc.intxxalt);
reset_revectored(i, &vm86s.int_revectored);
}
}
}
else {
if ((DBG_ARG(mhpdbgc.currcode) != 0x21) || !mhpdbgc.bpload ) {
mhpdbgc.stopped = 1;
if (parm1)
LWORD(eip) -= 2;
mhpdbgc.int_handled = 0;
mhp_poll();
if (mhpdbgc.int_handled)
rtncd = 1;
else if (parm1)
LWORD(eip) += 2;
}
}
}
break;
case DBG_INTxDPMI:
if (!mhpdbg.active) break;
mhpdbgc.stopped = 1;
#if WITH_DPMI
dpmi_mhp_intxxtab[DBG_ARG(mhpdbgc.currcode) & 0xff] &= ~2;
#endif
break;
case DBG_TRAP:
if (!mhpdbg.active)
break;
if (DBG_ARG(mhpdbgc.currcode) == 1) { /* single step */
switch (mhpdbgc.trapcmd) {
case 2: /* t command -- step until IP changes */
if (mhpdbgc.trapip == mhp_getcsip_value())
break;
/* no break */
case 1: /* ti command */
mhpdbgc.trapcmd = 0;
rtncd = 1;
mhpdbgc.stopped = 1;
break;
}
if (traceloop && mhp_bpchk(mhp_getcsip_value())) {
traceloop = 0;
loopbuf[0] = '\0';
}
}
if (DBG_ARG(mhpdbgc.currcode) == 3) { /* int3 (0xCC) */
int ok=0;
unsigned int csip=mhp_getcsip_value() - 1;
if (mhpdbgc.bpload_bp == csip ) {
/* mhp_cmd("r"); */
mhp_clearbp(mhpdbgc.bpload_bp);
mhp_modify_eip(-1);
if (mhpdbgc.bpload == 2) {
mhp_printf("bpload: INT3 caught\n");
SREG(cs)=BIOSSEG;
LWORD(eip)=(long)DBGload-(long)bios_f000;
mhpdbgc.trapcmd = 1;
mhpdbgc.bpload = 0;
}
}
else {
if ((ok=mhp_bpchk( csip))) {
mhp_modify_eip(-1);
}
else {
if ((ok=test_bit(3, mhpdbg.intxxtab))) {
/* software programmed INT3 */
mhp_modify_eip(-1);
mhp_cmd("r");
mhp_modify_eip(+1);
}
}
}
if (ok) {
mhpdbgc.trapcmd = 0;
rtncd = 1;
mhpdbgc.stopped = 1;
}
}
break;
case DBG_PRE_VM86:
mhp_pre_vm86();
break;
case DBG_POLL:
mhp_poll();
break;
case DBG_GPF:
if (!mhpdbg.active)
break;
mhpdbgc.stopped = 1;
mhp_poll();
break;
default:
break;
}
if (mhpdbg.active) mhp_bpset();
return rtncd;
}
exprintw(_fs,buf,(ERB_L4+ERB_LEFTM));
exprintw(_gs,buf,(ERB_L4+ERB_LEFTM)+13);
exprintw(_ss,buf,(ERB_L4+ERB_LEFTM)+26);
exprintl(_eflags,buf,(ERB_L4+ERB_LEFTM)+39);
if (pmode & 2) {
buf[(ERB_L4+ERB_LEFTM)+47] = 0;
}
else {
if (pmode & 1) {
if (Segments[_ss>>3].is_32)
stk = (unsigned short *)(GetSegmentBaseAddress(_ss)+_esp);
else
stk = (unsigned short *)(GetSegmentBaseAddress(_ss)+_LWORD(esp));
}
else
stk = MK_FP32(_ss,_LWORD(esp));
for (i=(ERB_L5+ERB_LEFTM); i<(ERB_L6-2); i+=5) {
exprintw(*stk++,buf,i);
}
}
return buf;
}
char *e_emu_disasm(unsigned char *org, int is32, unsigned int refseg)
{
static char buf[512];
static char frmtbuf[256];
int rc;
int i;
char *p, *p1;
int CALLBACK EnumFontsEnumFunc( const LOGFONT FAR *lf, const TEXTMETRIC FAR *tm, DWORD ftype, LPARAM data )
#endif
{
#ifdef __WINDOWS_386__
const LOGFONT __far *lf = MK_FP32( (void *)_lf );
tm = tm;
#elif defined( __WINDOWS__ )
const LOGFONT FAR *lf = (const LOGFONT FAR *)elf;
// const TEXTMETRIC FAR *tm = (const TEXTMETRIC FAR *)ntm;
ntm = ntm;
#else
tm = tm;
#endif
ftype = ftype;
data = data;
/*
* Something has happened in the font world and Windows font mapper since
* the original source was written, it checked only for Courier. All the
* font names below are verified as good monospaced fonts. Check for the
* best fonts first, so that the system picks the best if enumerated first.
* Changed the test to == 0, because it is easier to read and understand.
*/
#if defined( __NT__ )
if( FARstricmp( lf->lfFaceName, "andale mono" ) == 0 ||
FARstricmp( lf->lfFaceName, "lucida console" ) == 0 ||
FARstricmp( lf->lfFaceName, "vera sans mono" ) == 0 ||
FARstricmp( lf->lfFaceName, "courier new" ) == 0 ||
FARstricmp( lf->lfFaceName, "courier" ) == 0 ) {
#else
if( FARstricmp( lf->lfFaceName, "courier new" ) == 0 ||
FARstricmp( lf->lfFaceName, "courier" ) == 0 ) {
#endif
courierFont = CreateFont( 13, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, lf->lfCharSet,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
lf->lfPitchAndFamily, lf->lfFaceName );
return( 0 );
}
return( 1 );
} /* EnumFunc */
/*
* getCourierFont - find a mono font
*/
static void getCourierFont( HANDLE inst )
{
LOGFONT logfont;
FARPROC fp;
HDC hdc;
inst = inst; /* shut up the compiler for NT */
hdc = GetDC( HWND_DESKTOP );
fp = MakeFontEnumProcInstance( EnumFontsEnumFunc, inst );
#if defined( __WINDOWS__ ) && defined( _M_I86 )
EnumFonts( hdc, NULL, (OLDFONTENUMPROC)fp, 0 );
#else
EnumFonts( hdc, NULL, (FONTENUMPROC)fp, 0 );
#endif
FreeProcInstance( fp );
ReleaseDC( (HWND)NULL, hdc );
if( courierFont == NULL ) {
courierFont = GetStockObject( ANSI_FIXED_FONT );
GetObject( courierFont, sizeof( LOGFONT ), (LPSTR)&logfont );
courierFont = CreateFontIndirect( &logfont );
}
} /* getCourierFont */
/*
* DialogTemplate - build a dialog template
*/
TEMPLATE_HANDLE DialogTemplate( LONG dtStyle, int dtx, int dty, int dtcx,
int dtcy, char *menuname, char *classname,
char *captiontext, int pointsize,
char *typeface )
{
TEMPLATE_HANDLE data;
UINT blocklen,menulen, classlen, captionlen, typefacelen;
UINT _ISFAR *numbytes;
char _ISFAR *dlgtemp;
char _ISFAR *dlgtypeface;
_DLGTEMPLATE _ISFAR *dt;
FONTINFO _ISFAR *fi;
/*
* get size of block and allocate memory
*/
menulen = SLEN( menuname );
classlen = SLEN( classname );
captionlen = SLEN( captiontext );
blocklen = sizeof( UINT ) + sizeof( _DLGTEMPLATE ) + menulen + classlen +
captionlen;
if( dtStyle & DS_SETFONT ) {
typefacelen = SLEN( typeface );
blocklen += sizeof(short) + typefacelen;
} else {
typefacelen = 0;
}
ADJUST_BLOCKLEN( blocklen );
data = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, blocklen );
if( data == NULL ) return( NULL );
numbytes = (UINT _ISFAR *) MK_FP32( GlobalLock( data ) );
*numbytes = (UINT) blocklen;
/*
* set up template
*/
dt = (_DLGTEMPLATE _ISFAR *) (numbytes + 1);
dt->dtStyle = dtStyle;
dt->dtItemCount = 0;
dt->dtX = dtx;
dt->dtY = dty;
dt->dtCX = dtcx;
dt->dtCY = dtcy;
dlgtemp = (char _ISFAR *) (dt + 1);
/*
* add extra strings to block
*/
dlgtemp = copyString( dlgtemp, menuname, menulen );
dlgtemp = copyString( dlgtemp, classname, classlen );
dlgtemp = copyString( dlgtemp, captiontext, captionlen );
/*
* add font data (if needed)
*/
if (dtStyle & DS_SETFONT) {
#ifdef ALIGN_WORDS
fi = (FONTINFO _ISFAR *) ((u_int)dlgtemp + 4 - (u_int)dlgtemp % 4);
#else
fi = (FONTINFO _ISFAR *) dlgtemp;
#endif
fi->PointSize = pointsize;
dlgtypeface = (char _ISFAR *) (fi + 1);
copyString( dlgtypeface, typeface, typefacelen );
}
GlobalUnlock( data );
return( data );
} /* DialogTemplate */
int mscdex(void)
{
unsigned char *buf = MK_FP32(_ES, _BX);
unsigned long dev;
unsigned seg, strat, intr;
int error;
int i;
char devname[] = "MSCD0001";
if (numDrives == 0)
return 0;
switch (_AL) {
case 0x00: /* install check */
_BX = numDrives;
if (_BX > 0) {
int firstdrive = INT_MAX;
for (i = 0; i < 4; i++) {
if (cd_drives[i] != -1
&& cd_drives[i] < firstdrive)
firstdrive = cd_drives[i];
}
_CX = firstdrive;
}
break;
case 0x01: /* driver info */
for (i = 0; i < 4; i++) {
if (cd_drives[i] != -1) {
/* subunit: always 0 for cdrom.sys */
WRITE_BYTE(buf, 0x00);
devname[7] = i + '1';
WRITE_DWORD(buf + 1, is_dos_device(devname));
buf += 5;
}
};
break;
case 0x02: /* copyright file name */
case 0x03: /* abstract file name */
case 0x04: /* documentation file name */
{
char readbuf[CD_FRAMESIZE];
if (ReadVTOC(_CX, 0x00, readbuf) == 0) {
MEMCPY_2DOS(buf, readbuf + 702 + (_AL - 2) * 37,
37);
WRITE_BYTE(buf + 37, 0);
NOCARRY;
} else {
_AX = MSCDEX_ERROR_UNKNOWN_DRIVE;
CARRY;
}
break;
}
case 0x05: /* read vtoc */
NOCARRY;
error = ReadVTOC(_CX, _DX, buf);
if (error) {
_AL = error;
CARRY;
};
break;
case 0x08: /* read sectors */
NOCARRY;
error = ReadSectors(_CX, (_SI << 16) + _DI, _DX, buf);
if (error) {
_AL = error;
CARRY;
};
break;
case 0x09: /* write sectors - not supported */
_AL = MSCDEX_ERROR_DRIVE_NOT_READY;
CARRY;
break;
case 0x0B: /* CD-ROM drive check */
_AX = 0;
for (i = 0; i < 4; i++)
if (_CX == cd_drives[i]) {
_AX = 1;
break;
}
_BX = 0xadad;
break;
case 0x0C:
_BX = (MSCDEX_VERSION_HIGH << 8) + MSCDEX_VERSION_LOW;
break;
case 0x0D: /* get drives */
for (i = 0; i < 4; i++)
if (cd_drives[i] != -1)
WRITE_BYTE(buf++, cd_drives[i]);
break;
case 0x0F: /* Get directory entry */
CARRY;
_AX =
GetDirectoryEntry(_CL, _CH & 1, buf,
SEGOFF2LINEAR(_SI, _DI));
if (_AX == 0 || _AX == 1)
NOCARRY;
break;
case 0x10:
{
int driver = GetDriver(_CX);
if (driver >= 4)
break;
devname[7] = driver + '1';
dev = is_dos_device(devname);
seg = dev >> 16;
dev = SEGOFF2LINEAR(seg, dev & 0xffff);
strat = READ_WORD(dev + 6);
intr = READ_WORD(dev + 8);
fake_call_to(seg, intr);
fake_call_to(seg, strat);
break;
}
default:
C_printf("unknown mscdex\n");
return 0;
}
return 1;
}
/* vesa_reinit: a function to reinitialize in case the DOS VESA driver
changes at runtime (e.g. univbe). Also called at startup */
static void vesa_reinit(void)
{
unsigned char *vbe_buffer, *info_buffer, *s;
vesa_int10 = MK_FP16(ISEG(0x10), IOFF(0x10));
vbe_buffer = info_buffer = lowmem_heap_alloc(VBE_viSize+VBE_vmSize);
vesa_r.eax = 0x4f00;
vesa_r.es = FP_SEG32(vbe_buffer);
vesa_r.edi = 0;
VBE_viVBESig = 0x32454256; /* "VBE2" */
do_int10_callback(&vesa_r);
if ((vesa_r.eax & 0xffff) != 0x4f || VBE_viVBESig != 0x41534556 /* "VESA" */ ) {
v_printf("No VESA bios detected!\n");
if (config.gfxmemsize < 0) config.gfxmemsize = 256;
vesa_regs_size = 0;
vesa_linear_vbase = 0;
goto out;
}
/* check if the VESA BIOS has changed */
s = MK_FP32(FP_SEG16(VBE_viOEMID), FP_OFF16(VBE_viOEMID));
if (vesa_oemstring && VBE_viOEMID == vesa_oemid &&
strcmp(s, vesa_oemstring) == 0)
goto out;
vesa_oemid = VBE_viOEMID;
if (vesa_oemstring) free(vesa_oemstring);
vesa_oemstring = strdup(s);
if (config.gfxmemsize < 0) config.gfxmemsize = VBE_viMemory*64;
vesa_version = VBE_viVESAVersion;
vbe_buffer += VBE_viSize;
memset(&vesa_r, 0, sizeof(vesa_r));
vesa_granularity = 64;
vesa_read_write = 6;
vesa_linear_vbase = 0;
vesa_r.eax = 0x4f01;
vesa_r.ecx = vesa_version >= 0x200 ? 0x81ff : 0x101;
vesa_r.es = (size_t)vbe_buffer >> 4;
vesa_r.edi = (size_t)vbe_buffer & 0xf;
do_int10_callback(&vesa_r);
if ((vesa_r.eax & 0xffff) == 0x4f) {
vesa_granularity= VBE_vmWinGran;
vesa_read_write = VBE_vmWinAAttrib & 6;
if (vesa_version >= 0x200 && (VBE_vmModeAttrib & 0x80) && config.pci_video) {
vesa_linear_vbase = (size_t)get_hardware_ram(VBE_vmPhysBasePtr);
v_printf("VESA: physical base = %x, virtual base = %zx\n",
VBE_vmPhysBasePtr, vesa_linear_vbase);
}
} else {
v_printf("VESA: Can't get mode info\n");
}
/* if not reported then guess */
if (vesa_granularity == 0) vesa_granularity = 64;
vesa_regs_size = 0;
vesa_r.eax = 0x4f04;
vesa_r.edx = 0;
vesa_r.ecx = VESA_SAVE_BITMAP;
vesa_r.ebx = 0;
do_int10_callback(&vesa_r);
if ((vesa_r.eax & 0xffff) == 0x4f)
vesa_regs_size = vesa_r.ebx * 64;
out:
lowmem_heap_free(info_buffer);
v_printf("VESA: memory size = %lu, regs_size=%x\n",
config.gfxmemsize, vesa_regs_size);
}
long _EXPORT FAR PASCAL WndProc( HWND hwnd, UINT message, WPARAM wparam,
LPARAM lparam )
/*********************************************************************/
{
static HANDLE hdlginstance;
static BOOL got_watzee_bonus;
PAINTSTRUCT ps;
FARPROC dlg_proc;
HDC hdc;
POINT point;
short x;
short y;
short dy;
short i;
switch( message ) {
case WM_CREATE :
hdlginstance = ((CREATESTRUCT far *) MK_FP32((void*)lparam))->hInstance;
x = CharWidth * 22 + CharWidth / 2;
y = CharHeight * 3;
dy = CharHeight * 3;
dy += dy / 7;
/* create the check marks for the dice bitmaps, and the ROLL and
OK buttons */
for( i = 0; i < 5; i++, y += dy ) {
CreateWindow( "BUTTON", "", WS_CHILD|WS_VISIBLE|BS_CHECKBOX,
x, y, CharWidth, CharHeight, hwnd,
(HMENU)(IDW_DICE1+i),
hdlginstance,
NULL );
}
CreateWindow( "BUTTON", "ROLL", WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
x, CharHeight * 19, 9 * CharWidth / 2 ,
CharHeight * 2, hwnd, (HMENU)IDW_ROLL,
hdlginstance, NULL );
CreateWindow( "BUTTON", "OK", WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
x, 43 * CharHeight / 2, 9 * CharWidth / 2,
CharHeight * 2, hwnd, (HMENU)IDW_OK,
hdlginstance, NULL );
return( 0 );
case WMW_START_NEW_GAME :
dlg_proc = MakeProcInstance( (FARPROC)GetNumPlayersDialogProc, hdlginstance );
DialogBox( hdlginstance, "GetNumPlayers", hwnd, (DLGPROC)dlg_proc );
FreeProcInstance( dlg_proc );
dlg_proc = MakeProcInstance( (FARPROC)GetInitialsDialogProc, hdlginstance );
DialogBox( hdlginstance, "GetPlayersInitials", hwnd, (DLGPROC)dlg_proc );
FreeProcInstance( dlg_proc );
EnableWindow( GetDlgItem( hwnd, IDW_OK ), FALSE );
EnableWindow( GetDlgItem( hwnd, IDW_ROLL ), TRUE );
PlayingGameYet = TRUE;
InvalidateRect( hwnd, NULL, FALSE );
for( i = 0; i < NumberOfPlayers; i++ ) {
if( Player[i][IS_COMPUTER] ) break;
}
if( i < NumberOfPlayers && !GotTimer ) {
while( !SetTimer( hwnd, ID_TIMER, TIMER_INTERVAL, NULL ) ) {
if( MessageBox( hwnd, "Too many clocks or timers are active",
AppName, MB_ICONEXCLAMATION|MB_RETRYCANCEL ) == IDCANCEL ) {
DestroyWindow( hwnd );
return( 0 );
}
}
GotTimer = TRUE;
}
if( i == 0 ) {
PCTurn = TRUE;
EnableWindow( GetDlgItem( hwnd, IDW_ROLL ), FALSE );
}
hdc = GetDC( hwnd );
RollDice( hwnd, hdc );
GetDiceInfo();
ReleaseDC( hwnd, hdc );
// SetFocus( hwnd );
return( 0 );
case WM_COMMAND :
switch( LOWORD( wparam ) ) {
case IDM_NEWGAME :
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
}
if( MessageBox( hwnd, "Start New Game: Are you sure?", "WATZEE",
MB_YESNO | MB_ICONEXCLAMATION ) == IDYES ) {
InitializeGameData();
InvalidateRect( hwnd, NULL, TRUE );
SendMessage( hwnd, WMW_START_NEW_GAME, 0, 0 );
} else if( GotTimer ) {
SetTimer( hwnd, ID_TIMER, TIMER_INTERVAL, NULL );
}
break;
case IDM_OPTIONS :
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
}
dlg_proc = MakeProcInstance( (FARPROC)OptionsDialogProc, hdlginstance );
DialogBox( hdlginstance, "Options", hwnd, (DLGPROC)dlg_proc );
FreeProcInstance( dlg_proc );
if( GotTimer ) {
SetTimer( hwnd, ID_TIMER, TIMER_INTERVAL, NULL );
}
break;
case IDM_EXIT :
DestroyWindow( hwnd );
break;
case IDM_SCORING :
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
}
dlg_proc = MakeProcInstance( (FARPROC)HelpDialogProc, hdlginstance );
DialogBox( hdlginstance, "WatzeeHelp", hwnd, (DLGPROC)dlg_proc );
FreeProcInstance( dlg_proc );
if( GotTimer ) {
SetTimer( hwnd, ID_TIMER, TIMER_INTERVAL, NULL );
}
break;
case IDM_ABOUT :
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
}
dlg_proc = MakeProcInstance( (FARPROC)AboutDialogProc, hdlginstance );
DialogBox( hdlginstance, "AboutWatzee", hwnd, (DLGPROC)dlg_proc );
FreeProcInstance( dlg_proc );
if( GotTimer ) {
SetTimer( hwnd, ID_TIMER, TIMER_INTERVAL, NULL );
}
break;
case IDW_DICE1 :
case IDW_DICE2 :
case IDW_DICE3 :
case IDW_DICE4 :
case IDW_DICE5 :
if( !PCTurn && CurrentRoll < 2 ) {
SendMessage( hwnd, WMW_DIE_CHECK, wparam, 0 );
}
break;
case IDW_ROLL :
SendMessage( hwnd, WMW_ROLL, 0, 0 );
break;
case IDW_OK :
SendMessage( hwnd, WMW_OK, 0, 0 );
break;
}
return( 0 );
case WM_LBUTTONUP :
if( !PCTurn ) {
MAKE_POINT( point, lparam );
if( point.x > CharWidth * 24
&& point.y < CharHeight * 20 ) {
wparam = GetDieCheck( hwnd, point );
if( wparam && CurrentRoll < 2 ) {
SendMessage( hwnd, WMW_DIE_CHECK, wparam, 0 );
}
} else {
wparam = GetScoreCheck( point );
if( wparam && Player[CurrentPlayer][wparam] == UNDEFINED ) {
SendMessage( hwnd, WMW_SCORE_CHECK, wparam, 0 );
}
}
}
return( 0 );
case WMW_DIE_CHECK :
i = LOWORD( wparam ) - IDW_DICE1;
Dice[i].is_checked = !Dice[i].is_checked;
CheckDlgButton( hwnd, wparam, (BOOL)Dice[i].is_checked );
// SetFocus( hwnd );
return( 0 );
case WMW_SCORE_CHECK :
hdc = GetDC( hwnd );
if( wparam != LastScoreSelection ) {
DoScore( hdc, wparam );
EnableWindow( GetDlgItem( hwnd, IDW_OK ), TRUE );
}
ReleaseDC( hwnd, hdc );
// SetFocus( hwnd );
return( 0 );
case WMW_ROLL :
hdc = GetDC( hwnd );
if( DieCheckMeansRoll ) {
for( i = 0; i < 5; i++ ) {
if( Dice[i].is_checked ) break;
}
} else {
for( i = 0; i < 5; i++ ) {
if( !Dice[i].is_checked ) break;
}
}
if( i < 5 ) {
if( LastScoreSelection ) {
Player[CurrentPlayer][LastScoreSelection] = UNDEFINED;
WriteScore( hdc, CurrentPlayer, LastScoreSelection );
DoScoreTotals( hdc );
LastScoreSelection = 0;
}
got_watzee_bonus = FALSE;
CurrentRoll++;
RollDice( hwnd, hdc );
GetDiceInfo();
if( DiceInfo.got_watzee && Player[CurrentPlayer][WATZEE] == 50 ) {
got_watzee_bonus = TRUE;
}
if( CurrentRoll == 2 ) {
EnableWindow( GetDlgItem( hwnd, IDW_ROLL ), FALSE );
}
}
ReleaseDC( hwnd, hdc );
// SetFocus( hwnd );
return( 0 );
case WMW_OK :
hdc = GetDC( hwnd );
LastScoreSelection = 0;
if( got_watzee_bonus ) {
DoScore( hdc, WATZEE_BONUS );
LastScoreSelection = 0;
got_watzee_bonus = FALSE;
}
NextPlayer( hwnd, hdc );
ReleaseDC( hwnd, hdc );
// SetFocus( hwnd );
return( 0 );
case WMW_GAME_OVER :
hdc = GetDC( hwnd );
WriteScoreOptions( hdc );
ReleaseDC( hwnd, hdc );
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
GotTimer = FALSE;
}
if( MessageBox( hwnd, "Another Game ?", "WATZEE", MB_YESNO ) == IDYES ) {
InitializeGameData();
InvalidateRect( hwnd, NULL, TRUE );
SendMessage( hwnd, WMW_START_NEW_GAME, 0, 0 );
} else {
DestroyWindow( hwnd );
}
return( 0 );
case WM_TIMER :
if( PCTurn ) {
PCPlay( hwnd );
}
return( 0 );
case WM_PAINT :
hdc = BeginPaint( hwnd, &ps );
DrawDice( hwnd, hdc );
DrawScoreCard( hdc );
WriteScoreOptions( hdc );
if( PlayingGameYet ) {
WriteInitials( hdc );
HighliteName( hdc, CurrentPlayer );
WriteScores( hdc );
}
EndPaint( hwnd, &ps );
return( 0 );
case WM_DESTROY :
{
HBITMAP hbm;
if( GotTimer ) {
KillTimer( hwnd, ID_TIMER );
}
for( i = 0; i < 6; i++ ) {
hbm = (HBITMAP)GetWindowLong( hwnd, i * sizeof( DWORD ) );
DeleteObject( hbm );
}
PostQuitMessage( 0 );
return( 0 );
}
}
return( DefWindowProc( hwnd, message, wparam, lparam ) );
}
WPI_MRESULT CALLBACK GUIWindowProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 wparam,
WPI_PARAM2 lparam )
{
gui_window *wnd;
gui_window *root;
WORD param;
WPI_POINT currentpoint;
gui_coord point;
gui_coord size;
WPI_MRESULT ret;
WPI_MINMAXINFO _W386FAR *info;
WPI_RECT rect;
HWND parent;
CREATESTRUCT FAR *lpcs;
wmcreate_info _W386FAR *wmcreateinfo;
gui_create_info *createinfo;
bool use_defproc;
unsigned control_id;
HWND win;
#ifndef __OS2_PM__
gui_key_state key_state;
RECT rc;
#endif
root = NULL;
ret = 0L;
use_defproc = FALSE;
if( msg == WM_CREATE ) {
lpcs = ( CREATESTRUCT FAR * )MK_FP32( (void *)lparam );
wmcreateinfo = (wmcreate_info _W386FAR *)MK_FP32( _wpi_getcreateparms( lpcs ) );
if ( wmcreateinfo != NULL ) {
wnd = wmcreateinfo->wnd;
createinfo = wmcreateinfo->info;
if( wnd->hwnd == NULLHANDLE ) {
#ifdef __OS2_PM__
if( wnd->root_frame != NULLHANDLE && wnd->root == NULLHANDLE ) {
wnd->root = hwnd;
} else {
wnd->hwnd = hwnd;
}
#else
if( _wpi_getparent( hwnd ) == HWND_DESKTOP ) {
wnd->root = hwnd;
wnd->root_frame = hwnd;
} else {
wnd->hwnd = hwnd;
wnd->hwnd_frame = hwnd;
}
#endif
}
DoSetWindowLong( hwnd, wnd );
}
}
wnd = GUIGetWindow( hwnd );
if( wnd == NULL ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
}
if( GUIMDIProcessMessage( wnd, hwnd, msg, wparam, lparam, &ret ) ) {
return( ret );
}
if( wnd->root == hwnd ) {
/* message for root window */
switch( msg ) {
case WM_CREATE :
#ifdef __OS2_PM__
wnd->root_pinfo.normal_pres =
_wpi_createos2normpres( GUIMainHInst, hwnd );
#endif
_wpi_getclientrect( wnd->root_frame, &wnd->root_client );
if( CreateBackgroundWnd( wnd, createinfo ) ) {
return( 0 );
}
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
break;
case WM_DESTROY :
wnd->flags |= DOING_DESTROY;
GUICloseToolBar( wnd );
//ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
//wnd->root = NULL;
//wnd->root_frame = NULL;
return( 0L );
}
} else if( ( wnd->root != NULLHANDLE ) && ( hwnd == wnd->hwnd ) ) {
/* message for container window */
switch( msg ) {
case WM_SIZE :
if( !_wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
size.x = _wpi_getwmsizex( wparam, lparam );
size.y = _wpi_getwmsizey( wparam, lparam );
GUIDoResize( wnd, hwnd, &size );
}
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
case WM_MOVE :
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
case WM_VSCROLL :
case WM_HSCROLL :
case WM_CLOSE :
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
}
}
switch( msg ) {
case WM_CREATE :
#ifdef __OS2_PM__
wnd->hwnd_pinfo.normal_pres =
_wpi_createos2normpres( GUIMainHInst, hwnd );
#endif
NumWindows++; // even if -1 is returned, window will get WM_DESTROY
win = GUIGetParentFrameHWND( wnd );
if( ( wnd->root_frame != NULLHANDLE ) ||
( createinfo->style & GUI_POPUP ) ) {
if( !GUIAddToSystemMenu( wnd, win, 0, NULL,
createinfo->style ) ) {
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
} else {
if( !GUIAddToSystemMenu( wnd, win, createinfo->num_menus,
createinfo->menu, createinfo->style ) ) {
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
}
_wpi_getclientrect( hwnd, &wnd->hwnd_client );
GUISetRowCol( wnd, NULL );
if( ( hwnd == wnd->hwnd ) && ( wnd->root == NULLHANDLE ) ) {
GUIMDINewWindow( hwnd );
}
if( GUIEVENTWND( wnd, GUI_INIT_WINDOW, NULL ) ) {
wnd->flags |= SENT_INIT;
GUISetScroll( wnd ); /* initalize scroll ranges */
GUIBringToFront( wnd );
return( 0 );
} else {
/* app decided not to create window */
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
break;
#if defined(__NT__) || defined(WILLOWS)
case WM_CTLCOLORBTN :
case WM_CTLCOLORDLG :
//case WM_CTLCOLORLISTBOX :
case WM_CTLCOLORSTATIC :
//case WM_CTLCOLOREDIT :
ret = (WPI_MRESULT)GUICtl3dCtlColorEx( msg, wparam, lparam );
if( ret == (HBRUSH)NULL ) {
SetBkColor( (HDC)wparam, GetNearestColor( (HDC)wparam,
GUIGetBack( wnd, GUI_BACKGROUND ) ) );
ret = (WPI_MRESULT)wnd->bk_brush;
}
return( ret );
#elif !defined( __OS2_PM__ )
case WM_CTLCOLOR :
switch( HIWORD( lparam ) ) {
case CTLCOLOR_BTN :
case CTLCOLOR_DLG :
case CTLCOLOR_EDIT :
case CTLCOLOR_LISTBOX :
case CTLCOLOR_MSGBOX :
case CTLCOLOR_STATIC :
ret = (WPI_MRESULT)GUICtl3dCtlColorEx( msg, wparam, lparam );
if( ret == (HBRUSH)NULL ) {
SetBkColor( (HDC)wparam, GetNearestColor( (HDC)wparam,
GUIGetBack( wnd, GUI_BACKGROUND ) ) );
ret = (WPI_MRESULT)wnd->bk_brush;
}
break;
}
return( ret );
#endif
#ifndef __OS2_PM__
case WM_INITMENUPOPUP :
return( GUIProcessInitMenuPopup( wnd, hwnd, msg, wparam, lparam ) );
case WM_MENUSELECT :
return( GUIProcessMenuSelect( wnd, hwnd, msg, wparam, lparam ) );
#endif
case WM_GETMINMAXINFO :
info = (WPI_MINMAXINFO _W386FAR *)MK_FP32( (void *)lparam );
ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
if( wnd->root == NULLHANDLE ) {
parent = _wpi_getparent( hwnd );
_wpi_getclientrect( parent, &rect );
_wpi_setmaxposition( *info, 0, 0 );
_wpi_setmaxtracksize( info, _wpi_getwidthrect( rect ),
_wpi_getheightrect( rect ) );
}
return( ret );
case WM_ERASEBKGND:
#ifdef __OS2_PM__
//GUIInvalidatePaintHandles( wnd );
return( (WPI_MRESULT)TRUE );
#else
if( !_wpi_isiconic( hwnd ) ) {
GetClientRect( hwnd, &rc );
FillRect( (HDC)wparam, &rc, wnd->bk_brush );
}
use_defproc = TRUE;
break;
#endif
#if !defined(__OS2_PM__) && !defined(WILLOWS)
case WM_PAINTICON :
{
HICON old;
old = SET_HICON( wnd->hwnd, wnd->icon );
ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
SET_HICON( wnd->hwnd, old );
return( ret );
}
#endif
case WM_PAINT:
if( _wpi_isiconic( hwnd ) ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
GUIPaint( wnd, hwnd, FALSE );
}
break;
#ifndef __OS2_PM__
case WM_ACTIVATEAPP :
root = GUIGetRootWindow();
ActivateNC( root, wparam );
if( GUICurrWnd != NULL ) {
ActivateNC( GUICurrWnd, wparam );
}
use_defproc = (bool)wparam; // I'm cheating and using 'use_defproc'
// outside of its self-documented purpose
if( root ) GUIEVENTWND( root, GUI_ACTIVATEAPP, &use_defproc );
use_defproc = TRUE;
break;
#if 0
// this repaints the nc client area when the window loses focus to
// a window that is not a descendant of a GUI window
case WM_KILLFOCUS :
if( !GUIIsGUIChild( (HWND)wparam ) ) {
ActivateNC( wnd, FALSE );
}
break;
#endif
case WM_SETFOCUS :
if( !_wpi_ismsgsetfocus( msg, lparam ) ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
}
if( !EditControlHasFocus ) {
if( SetFocusToParent() ) {
return( 0L );
}
}
break;
#endif
case WM_VSCROLL :
case WM_HSCROLL :
GUIProcessScrollMsg( wnd, msg, wparam, lparam );
return( 0L );
#ifdef __NT__
case WM_MOUSEWHEEL :
{
// Try to handle mousewheel messages...
// Fake them into GUIProcessScrollMsg()
// as "normal" vertical scroll messages.
short gcWheelDelta; //wheel delta from roll
WORD wKey;
// The wnd I get is not the same as WM_VSCROLL : above gets...
// Note to self: Fix it...
// Seems like the main app window gets the message, rather than
// the MDI clients...
gcWheelDelta = HIWORD(wparam);
wKey = LOWORD(wparam);
// Scroll wheel upwards gives 120
// " " downward " -120
if( wnd != GUICurrWnd ) // Send to child window with focus
wnd = GUICurrWnd;
if( gcWheelDelta > 0 ) {
// positive - scroll up
if( wKey == MK_CONTROL || wKey == MK_SHIFT )
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_PAGEUP, 0L );
else
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_LINEUP, 0L );
} else {
// negative - scroll down
if( wKey == MK_CONTROL || wKey == MK_SHIFT )
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_PAGEDOWN, 0L );
else
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_LINEDOWN, 0L );
}
// Inform GUI system we are done with scrolling for now.
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_ENDSCROLL, 0 );
}
return( 0L );
#endif
case WM_MOVE :
use_defproc = TRUE;
if( wnd->flags & DOING_CLOSE ) {
break;
}
if( !GUIParentHasFlags( wnd, IS_MINIMIZED ) ) {
GUIEVENTWND( wnd, GUI_MOVE, NULL );
}
use_defproc = TRUE;
break;
case WM_SIZE:
use_defproc = TRUE;
if( wnd->flags & DOING_CLOSE ) {
break;
}
if( _wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
wnd->flags |= IS_MINIMIZED;
if( wnd->style & GUI_CHANGEABLE_FONT ) {
GUIEnableSysMenuItem( wnd, GUI_CHANGE_FONT, FALSE );
}
GUIEVENTWND( wnd, GUI_ICONIFIED, NULL );
if( GUIMDI ) {
GUIBringNewToFront( wnd );
}
} else {
wnd->flags &= ~IS_MINIMIZED;
size.x = _wpi_getwmsizex( wparam, lparam );
size.y = _wpi_getwmsizey( wparam, lparam );
GUIDoResize( wnd, hwnd, &size );
if( wnd->flags & IS_ROOT ) {
win = GUIGetParentFrameHWND( wnd );
if( !_wpi_isiconic( win ) ) {
GUIMaximizeZoomedChildren( wnd );
}
}
}
//Call back to tell about resizing so system tray can be used
WndSizeChange( hwnd, wparam, lparam );
break;
case WM_MOUSEMOVE:
currentpoint.x = GET_WM_MOUSEMOVE_POSX( wparam, lparam );
currentpoint.y = GET_WM_MOUSEMOVE_POSY( wparam, lparam );
point.x = currentpoint.x;
point.y = currentpoint.y;
GUIScreenToScaleR( &point );
if( ( currentpoint.x != prevpoint.x ) ||
( currentpoint.y != prevpoint.y ) ) {
prevpoint.x = currentpoint.x;
prevpoint.y = currentpoint.y;
SendPointEvent( wparam, lparam, wnd, GUI_MOUSEMOVE, TRUE );
}
break;
#ifndef __OS2_PM__
case WM_NCLBUTTONDOWN :
case WM_NCMBUTTONDOWN :
case WM_NCRBUTTONDOWN :
CheckDoFront( wnd );
use_defproc = TRUE;
break;
case WM_RBUTTONDOWN:
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDOWN, TRUE );
break;
#else
case WM_RBUTTONDOWN :
WPI_MAKEPOINT( wparam, lparam, currentpoint );
win = PM1632WinWindowFromPoint( hwnd, ¤tpoint, FALSE );
if( ( win != (HWND)NULL) && ( win != hwnd ) ) {
control_id = _wpi_getdlgctrlid( win );
if( control_id != 0 ) {
GUIEVENTWND( wnd, GUI_CONTROL_RCLICKED, &control_id );
}
} else {
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDOWN, TRUE );
}
break;
#endif
case WM_LBUTTONDOWN:
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONDOWN, TRUE );
use_defproc = TRUE;
break;
case WM_LBUTTONUP:
_wpi_releasecapture();
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONUP, TRUE );
use_defproc = TRUE;
break;
case WM_RBUTTONUP:
_wpi_releasecapture();
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONUP, TRUE );
break;
case WM_LBUTTONDBLCLK:
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONDBLCLK, TRUE );
break;
case WM_RBUTTONDBLCLK:
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDBLCLK, TRUE );
break;
case WM_SYSCOMMAND:
param = _wpi_getid( wparam );
switch( param ) {
case SC_NEXTWINDOW :
if( GUIMDI ) {
NextWndToFront( hwnd );
return( 0L );
}
default :
if( ( param & 0xf000 ) == ( SC_NEXTWINDOW & 0xf000 ) ) {
/* top value same for all SC_* values */
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
ProcessMenu( wnd, param );
}
break;
}
break;
#ifdef __OS2_PM__
case WM_CONTROL :
GUIProcessControlNotification( SHORT1FROMMP(wparam),
SHORT2FROMMP(wparam), wnd );
break;
#else
case WM_PARENTNOTIFY:
if( ( LOWORD(wparam) == WM_RBUTTONDOWN ) ||
( LOWORD(wparam) == WM_LBUTTONDOWN ) ||
( LOWORD(wparam) == WM_MBUTTONDOWN ) ) {
if( wnd->root == NULLHANDLE ) {
CheckDoFront( wnd );
}
}
if( LOWORD(wparam) == WM_RBUTTONDOWN ) {
WPI_MAKEPOINT( wparam, lparam, currentpoint );
MapWindowPoints( hwnd, (HWND)NULL, ¤tpoint, 1 );
win = _wpi_windowfrompoint( currentpoint );
control_id = _wpi_getdlgctrlid( win );
if( control_id != 0 ) {
if( _wpi_getparent(win) == hwnd ) {
GUIEVENTWND( wnd, GUI_CONTROL_RCLICKED, &control_id );
}
}
}
break;
case WM_ENDSESSION : {
gui_end_session es;
es.endsession = (bool)wparam;
es.logoff = (bool)( lparam == 0x80000000L );
GUIEVENTWND( wnd, GUI_ENDSESSION, &es );
return( 0L );
}
case WM_QUERYENDSESSION : {
gui_end_session es;
es.endsession = (bool)wparam;
es.logoff = (bool)( lparam == 0x80000000L ); // ENDSESSION_LOGOFF
if( !GUIEVENTWND( wnd, GUI_QUERYENDSESSION, &es ) ) {
return( TRUE );
}
return( 0L );
}
#endif
case WM_COMMAND:
if( _wpi_ismenucommand( wparam, lparam ) ||
IsToolBarCommand( wnd, wparam, lparam ) ) { /* from menu or toolbar */
ProcessMenu( wnd, _wpi_getid( wparam ) );
//SetFocusToParent();
} else {
GUIProcessControlMsg( wparam, lparam, wnd, NULL );
}
use_defproc = TRUE;
break;
#ifndef __OS2_PM__
case WM_VKEYTOITEM :
use_defproc = FALSE;
ret = -1;
GUIGetKeyState( &key_state.state );
if( ( GUIWindowsMapKey( wparam, lparam, &key_state.key ) ) ) {
ret = GUIEVENTWND( wnd, GUI_KEYTOITEM, &key_state );
}
break;
#endif
#ifdef __OS2_PM__
case WM_CHAR :
case WM_TRANSLATEACCEL :
#else
case WM_MENUCHAR :
case WM_SYSKEYDOWN :
case WM_SYSKEYUP :
case WM_KEYUP :
case WM_KEYDOWN :
#endif
return( GUIProcesskey( hwnd, msg, wparam, lparam ) );
case WM_CLOSE :
if( wnd->flags & DOING_CLOSE ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else if( wnd->style & GUI_CLOSEABLE ) {
if( GUIEVENTWND( wnd, GUI_CLOSE, NULL ) ) {
wnd->flags |= DOING_CLOSE;
if( wnd->flags & IS_ROOT ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
_wpi_destroywindow( wnd->hwnd_frame );
}
}
}
return( 0L );
// Message to deal with tray icons (Win 95 and NT 4.0 ).
case WM_TRAYCALLBACK :
TrayCallBack( hwnd, wparam, lparam );
return( 0L );
case WM_DESTROY :
wnd->flags |= DOING_DESTROY;
NumWindows--;
GUIEVENTWND( wnd, GUI_DESTROY, NULL );
//ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
GUIDestroyAllChildren( wnd );
if( wnd->flags & IS_ROOT ) {
GUIDestroyAllPopupsWithNoParent();
}
GUIFreeWindowMemory( wnd, FALSE, FALSE );
if( NumWindows == 0 ) {
_wpi_postquitmessage( 0 );
Posted = TRUE;
}
return( 0L );
default:
use_defproc = TRUE;
}
if( use_defproc ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
return( ret );
}
}
