jetomit/avp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed several unused files.

Browse source
This commit is contained in:
Steven Fuller 2001-08-07 03:16:27 +00:00 • committed by Patryk Obara
parent 455f56573e
commit 78cdb29e7a
12 changed files with 1 additions and 2835 deletions
Download patch file Download diff file Expand all files Collapse all files

1
notes.txt
View file

@ -13,5 +13,6 @@ Env_List can be removed
SCREENDESCRIPTORBLOCK.SDB_DiagonalWidth is unused
========
movement.txt and genparam.txt code is unused
the english.txt file could be removed also
========
there is some unused junk in comp_shp.c

14
src/avp/macro.h
View file

@ -1,14 +0,0 @@
/*
Project specific inline macro support,
currently platform specific by
default
*/
#define GNU_ABS(x) (((x) < 0) ? -(x) : (x))
#define GNU_SIGN(x) (((x) < 0) ? -1 : +1)

115
src/avp/mp_launch.c
View file

@ -1,115 +0,0 @@
// Launches mplayer.com into a specific URL with LaunchMplayer()
// By Rich Rice --rich@mpath.com
// Modified by Edmond Meinfelder (edmond@mpath.com) for use with AvP
#include <windows.h>
#include <stdio.h>
#include <sys/stat.h>
#ifdef _MSC_VER
#define stat _stat
#endif
// Execute executes whatever the text in cmdline is.
// If an executable is successfully launched as a
// result, TRUE is returned. False is returned if
// nothing happens.
static int
Execute(char *cmdline)
{
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInfo;
memset (&StartupInfo, 0, sizeof StartupInfo);
StartupInfo.cb = sizeof (StartupInfo);
StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
StartupInfo.wShowWindow = SW_SHOWNORMAL;
if (CreateProcess(NULL, cmdline, NULL, NULL, FALSE,
CREATE_DEFAULT_ERROR_MODE, NULL, NULL,
&StartupInfo, &ProcessInfo) == 0)
return FALSE;
return TRUE;
}
// Mplayer stores it installed location in the Windows Registry
// under HKEY_LOCAL_MACHINE\Software\Mplayer\Main\Root Directory
// This function returns the location stored in that string value.
// Upon failure, FALSE is returned and, upon success, TRUE is
// returned.
// The location of the Mplayer's install path is returned in
// the parameter mplayer_directory.
static int
GetMplayerDirectory(char *mplayer_directory)
{
HKEY hkey;
HKEY key = HKEY_LOCAL_MACHINE;
char subkey[]="software\\mpath\\mplayer\\main";
char valuename[]="root directory";
char buffer[MAX_PATH];
DWORD dwType, dwSize;
if (RegOpenKeyEx(key, subkey, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
{
dwSize = MAX_PATH;
if (RegQueryValueEx(hkey, valuename, 0, &dwType, (LPBYTE) buffer,
&dwSize) == ERROR_SUCCESS)
{
sprintf(mplayer_directory, "%s", buffer);
return TRUE;
}
RegCloseKey(hkey);
}
return FALSE;
}
// If the named file exists, this function
// returns TRUE, otherwise FALSE is returned.
static int
FileExists(char *file)
{
struct stat buf;
int result;
// Get data associated with 'file'
result = stat( file, &buf );
// Check if we have a file
if( result == 0 )
{
return TRUE;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
// This is the only public function, it launches Mplayer's user interface.
// This function returns FALSE upon failure and TRUE on success.
int
LaunchMplayer()
{
char mplayer_url[]="http://www.mplayer.com/mic/avp.html";
char cmdline[MAX_PATH], mplaunch_exe[MAX_PATH], mplayer_directory[MAX_PATH];
if (GetMplayerDirectory(mplayer_directory))
{
sprintf(mplaunch_exe, "%s\\programs\\mplaunch.exe", mplayer_directory);
if (FileExists(mplaunch_exe))
{
sprintf(cmdline, "%s AvP.mpi", mplaunch_exe);
return Execute(cmdline);
}
}
sprintf(cmdline, "rundll32.exe url.dll,FileProtocolHandler %s", mplayer_url);
return Execute(cmdline);
}

2
src/avp/win95/d3d_hud.cpp
View file

@ -17,8 +17,6 @@ extern "C" {
#include "stratdef.h"
#include "gamedef.h"
#include "bh_types.h"
#include "d3dmacs.h"
//#include "string.h"
#include "hudgfx.h"
#include "huddefs.h"

118
src/avp/win95/dbdefs.h
View file

@ -1,118 +0,0 @@
// enums for the number of information screens we have
// data description
typedef enum maps{
I_No_Map,
I_Map_Gen1, I_Map_Gen2, I_Map_Gen3, I_Map_Gen4,
I_Map_Cmc1, I_Map_Cmc2, I_Map_Cmc3, I_Map_Cmc4, I_Map_Cmc5, I_Map_Cmc6,
I_Map_Rnd1, I_Map_Rnd2, I_Map_Rnd3, I_Map_Rnd4,
I_Map_Mps1, I_Map_Mps2, I_Map_Mps3, I_Map_Mps4,
I_Map_Sp1, I_Map_Sp2, I_Map_Sp3,
I_Map_Surface, I_Map_Medlab,
I_Num_Maps
}DATABASE_MAP;
typedef enum
{
I_Floor_0 = 0,
I_Floor_1,
I_Floor_2,
I_Floor_3,
I_Floor_4,
I_Floor_5,
I_Max_Num_Floors,
}FLOOR_NUM;
typedef enum
{
I_No_Weapon,
I_Weapon_Pulse,
I_Num_Weapons
}DATABASE_WEAPON;
typedef enum
{
I_No_Message,
I_Message_1,
I_Num_Messages,
}DATABASE_MESSAGE;
typedef struct dbasedesc
{
int floor;
DATABASE_MAP map_enum;
DATABASE_WEAPON weap_enum;
DATABASE_MESSAGE message_enum;
short pixel_x;
short pixel_y;
}DBASEDESC;
// enums to control flow of the database screens
// data base states - each one is associated with a
// enum to describes the option from the satae
typedef enum
{
DB_STATE_SELECT,
DB_STATE_MAP,
DB_STATE_MESSAGE,
DB_STATE_WEAPON,
DB_STATE_LOAD,
DB_STATE_SAVE,
DB_STATE_END,
NUM_DB_STATES,
}DB_MENU_STATE;
typedef enum database_options
{
DB_MAP_OPTION,
DB_MESSAGE_OPTION,
DB_WEAPON_OPTION,
DB_LOAD_OPTION,
DB_SAVE_OPTION,
DB_LOGOFF_OPTION,
DB_QUIT_OPTION,
DB_NUM_OPTIONS
}DB_MENU_OPTIONS;
typedef enum map_screen_options
{
DB_MAP_EXIT_OPTION,
DB_MAP_LOGOFF_OPTION,
DB_NUM_MAP_OPTIONS,
}DB_MAP_OPTIONS;
typedef enum
{
DB_WEAPON_EXIT_OPTION,
DB_WEAPON_LOGOFF_OPTION,
DB_NUM_WEAPON_OPTIONS,
}DB_WEAPON_OPTIONS;
typedef enum
{
DB_MESSAGE_PLAY_OPTION,
DB_MESSAGE_STOP_OPTION,
DB_MESSAGE_EXIT_OPTION,
DB_MESSAGE_LOGOFF_OPTION,
DB_NUM_MESSAGE_OPTIONS,
}DB_MESSAGE_OPTIONS;
extern void DatabaseMenus(DATABASE_BLOCK*);
extern void PlatformSpecificEnteringDatabase();
extern void PlatformSpecificExitingDatabase();

57
src/avp/win95/mousecentreing.cpp
View file

@ -1,57 +0,0 @@
#include <windows.h>
#include <process.h>
#include <math.h>
extern "C"
{
extern BOOL bActive;
extern int WinLeftX, WinRightX, WinTopY, WinBotY;
}
static volatile int EndMouseThread=0;
//thread continually moves the mouse cursor to the centre of the window
//so you don't accidently click outside it.
void MouseThread(void* )
{
while(!EndMouseThread)
{
Sleep(10);
if(!bActive) continue;
SetCursorPos((WinLeftX+WinRightX)>>1,(WinTopY+WinBotY)>>1);
}
EndMouseThread=0;
}
extern "C"
{
void InitCentreMouseThread()
{
_beginthread(MouseThread,10000,0);
}
void FinishCentreMouseThread()
{
EndMouseThread=1;
}
};

147
src/win95/d3dmacs.h
View file

@ -1,147 +0,0 @@
/*
* Copyright (C) 1995, 1996 Microsoft Corporation. All Rights Reserved.
*
* File: d3dmacs.h
*
* Useful macros for generating execute buffers. Consult the D3D sample
* code for examples of their usage.
*
* Use OP_NOP to QWORD align triangle and line instructions.
*/
#ifndef __D3DMACS_H__
#define __D3DMACS_H__
#undef RELEASE
#ifndef __cplusplus
#define MAKE_MATRIX(lpDev, handle, data) \
if (lpDev->lpVtbl->CreateMatrix(lpDev, &handle) != D3D_OK) \
return FALSE; \
if (lpDev->lpVtbl->SetMatrix(lpDev, handle, &data) != D3D_OK) \
return FALSE
#define RELEASE(x) if (x != NULL) {x->lpVtbl->Release(x); x = NULL;}
#endif
#ifdef __cplusplus
#define MAKE_MATRIX(lpDev, handle, data) \
if (lpDev->CreateMatrix(&handle) != D3D_OK) \
return FALSE; \
if (lpDev->SetMatrix(handle, &data) != D3D_OK) \
return FALSE
#define RELEASE(x) if (x != NULL) {x->Release(); x = NULL;}
#endif
#define PUTD3DINSTRUCTION(op, sz, cnt, ptr) \
((LPD3DINSTRUCTION) ptr)->bOpcode = op; \
((LPD3DINSTRUCTION) ptr)->bSize = sz; \
((LPD3DINSTRUCTION) ptr)->wCount = cnt; \
ptr = (void *)(((LPD3DINSTRUCTION) ptr) + 1)
#define VERTEX_DATA(loc, cnt, ptr) \
if ((ptr) != (loc)) memcpy((ptr), (loc), sizeof(D3DVERTEX) * (cnt)); \
ptr = (void *)(((LPD3DVERTEX) (ptr)) + (cnt))
// OP_MATRIX_MULTIPLY size: 4 (sizeof D3DINSTRUCTION)
#define OP_MATRIX_MULTIPLY(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_MATRIXMULTIPLY, sizeof(D3DMATRIXMULTIPLY), cnt, ptr)
// MATRIX_MULTIPLY_DATA size: 12 (sizeof MATRIXMULTIPLY)
#define MATRIX_MULTIPLY_DATA(src1, src2, dest, ptr) \
((LPD3DMATRIXMULTIPLY) ptr)->hSrcMatrix1 = src1; \
((LPD3DMATRIXMULTIPLY) ptr)->hSrcMatrix2 = src2; \
((LPD3DMATRIXMULTIPLY) ptr)->hDestMatrix = dest; \
ptr = (void *)(((LPD3DMATRIXMULTIPLY) ptr) + 1)
// OP_STATE_LIGHT size: 4 (sizeof D3DINSTRUCTION)
#define OP_STATE_LIGHT(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_STATELIGHT, sizeof(D3DSTATE), cnt, ptr)
// OP_STATE_TRANSFORM size: 4 (sizeof D3DINSTRUCTION)
#define OP_STATE_TRANSFORM(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_STATETRANSFORM, sizeof(D3DSTATE), cnt, ptr)
// OP_STATE_RENDER size: 4 (sizeof D3DINSTRUCTION)
#define OP_STATE_RENDER(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_STATERENDER, sizeof(D3DSTATE), cnt, ptr)
// STATE_DATA size: 8 (sizeof D3DSTATE)
#define STATE_DATA(type, arg, ptr) \
((LPD3DSTATE) ptr)->drstRenderStateType = (D3DRENDERSTATETYPE)type; \
((LPD3DSTATE) ptr)->dwArg[0] = arg; \
ptr = (void *)(((LPD3DSTATE) ptr) + 1)
// OP_PROCESS_VERTICES size: 4 (sizeof D3DINSTRUCTION)
#define OP_PROCESS_VERTICES(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_PROCESSVERTICES, sizeof(D3DPROCESSVERTICES), cnt, ptr)
// PROCESSVERTICES_DATA size: 16 (sizeof D3DPROCESSVERTICES)
#define PROCESSVERTICES_DATA(flgs, strt, cnt, ptr) \
((LPD3DPROCESSVERTICES) ptr)->dwFlags = flgs; \
((LPD3DPROCESSVERTICES) ptr)->wStart = strt; \
((LPD3DPROCESSVERTICES) ptr)->wDest = strt; \
((LPD3DPROCESSVERTICES) ptr)->dwCount = cnt; \
((LPD3DPROCESSVERTICES) ptr)->dwReserved = 0; \
ptr = (void *)(((LPD3DPROCESSVERTICES) ptr) + 1)
// OP_TRIANGLE_LIST size: 4 (sizeof D3DINSTRUCTION)
#define OP_TRIANGLE_LIST(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_TRIANGLE, sizeof(D3DTRIANGLE), cnt, ptr)
#define TRIANGLE_LIST_DATA(loc, count, ptr) \
if ((ptr) != (loc)) memcpy((ptr), (loc), sizeof(D3DTRIANGLE) * (count)); \
ptr = (void *)(((LPD3DTRIANGLE) (ptr)) + (count))
// OP_LINE_LIST size: 4 (sizeof D3DINSTRUCTION)
#define OP_LINE_LIST(cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_LINE, sizeof(D3DLINE), cnt, ptr)
#define LINE_LIST_DATA(loc, count, ptr) \
if ((ptr) != (loc)) memcpy((ptr), (loc), sizeof(D3DLINE) * (count)); \
ptr = (void *)(((LPD3DLINE) (ptr)) + (count))
// OP_POINT_LIST size: 8 (sizeof D3DINSTRUCTION + sizeof D3DPOINT)
#define OP_POINT_LIST(first, cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_POINT, sizeof(D3DPOINT), 1, ptr); \
((LPD3DPOINT)(ptr))->wCount = cnt; \
((LPD3DPOINT)(ptr))->wFirst = first; \
ptr = (void*)(((LPD3DPOINT)(ptr)) + 1)
// OP_SPAN_LIST size: 8 (sizeof D3DINSTRUCTION + sizeof D3DSPAN)
#define OP_SPAN_LIST(first, cnt, ptr) \
PUTD3DINSTRUCTION(D3DOP_SPAN, sizeof(D3DSPAN), 1, ptr); \
((LPD3DSPAN)(ptr))->wCount = cnt; \
((LPD3DSPAN)(ptr))->wFirst = first; \
ptr = (void*)(((LPD3DSPAN)(ptr)) + 1)
// OP_BRANCH_FORWARD size: 18 (sizeof D3DINSTRUCTION + sizeof D3DBRANCH)
#define OP_BRANCH_FORWARD(tmask, tvalue, tnegate, toffset, ptr) \
PUTD3DINSTRUCTION(D3DOP_BRANCHFORWARD, sizeof(D3DBRANCH), 1, ptr); \
((LPD3DBRANCH) ptr)->dwMask = tmask; \
((LPD3DBRANCH) ptr)->dwValue = tvalue; \
((LPD3DBRANCH) ptr)->bNegate = tnegate; \
((LPD3DBRANCH) ptr)->dwOffset = toffset; \
ptr = (void *)(((LPD3DBRANCH) (ptr)) + 1)
// OP_SET_STATUS size: 20 (sizeof D3DINSTRUCTION + sizeof D3DSTATUS)
#define OP_SET_STATUS(flags, status, _x1, _y1, _x2, _y2, ptr) \
PUTD3DINSTRUCTION(D3DOP_SETSTATUS, sizeof(D3DSTATUS), 1, ptr); \
((LPD3DSTATUS)(ptr))->dwFlags = flags; \
((LPD3DSTATUS)(ptr))->dwStatus = status; \
((LPD3DSTATUS)(ptr))->drExtent.x1 = _x1; \
((LPD3DSTATUS)(ptr))->drExtent.y1 = _y1; \
((LPD3DSTATUS)(ptr))->drExtent.x2 = _x2; \
((LPD3DSTATUS)(ptr))->drExtent.y2 = _y2; \
ptr = (void *)(((LPD3DSTATUS) (ptr)) + 1)
// OP_NOP size: 4
#define OP_NOP(ptr) \
PUTD3DINSTRUCTION(D3DOP_TRIANGLE, sizeof(D3DTRIANGLE), 0, ptr)
#define OP_EXIT(ptr) \
PUTD3DINSTRUCTION(D3DOP_EXIT, 0, 0, ptr)
#define QWORD_ALIGNED(ptr) \
!(0x00000007L & (ULONG)(ptr))
#endif // __D3DMACS_H__

64
src/win95/pentime.h
View file

@ -1,64 +0,0 @@
/* pentime.h */
extern unsigned long int rdtsc_lo(void);
extern unsigned long int rdtsc_hi(void);
extern unsigned long int rdtsc_mid(void);
#define ProfileStart() \
{ \
int time = rdtsc_lo();
#define ProfileStop(x) \
textprint("%s %d\n",x,rdtsc_lo()-time); \
}
#pragma aux rdtsc_lo = \
"db 0fh, 31h" \
value [eax] \
modify [edx];
#pragma aux rdtsc_hi = \
"db 0fh, 31h" \
value [edx] \
modify [eax];
#pragma aux rdtsc_mid = \
"db 0fh, 31h" \
"shr eax, 10h" \
"shl edx, 10h" \
"add eax, edx" \
value [eax] \
modify [edx];
/* Test to see if we have a Pentium or not. Note that this test is reliable
* enough for a tools project (where we can put in an overide switch) but not
* for a released product.
*/
extern unsigned char Pentium(void);
#pragma aux Pentium = \
"pushfd" \
"pop eax" \
"or eax, 00200000h" \
"push eax" \
"popfd" \
"pushfd" \
"pop eax" \
"mov ecx, eax" \
"and eax, 00200000h" \
"cmp eax, 0" \
"je not_Pentium" \
"mov eax, ecx" \
"and eax, 0ffdfffffh" \
"push eax" \
"popfd" \
"pushfd" \
"pop eax" \
"and eax, 00200000h" \
"cmp eax, 0" \
"jne not_Pentium" \
"is_Pentium: mov al, 1" \
"jmp finish" \
"not_Pentium: mov al, 0" \
"finish: nop" \
value [al] \
modify [eax ecx]

2096
src/win95/scandraw.asm
View file

File diff suppressed because it is too large Load diff

33
src/win95/vramtime.c
View file

@ -1,33 +0,0 @@
#include <windows.h>
#include "vramtime.h"
static DWORD transition_times_matrix[][VWS_MAXSTATES] =
{
/* from DDRELEASE */
{ 0, 20, 0, 100, 100 },
/* from D3DTEXRELEASE */
{ 20, 0, 100, 100, 100 },
/* from DDCREATE */
{ 0, 100, 0, 20, 100 },
/* from D3DTEXCREATE */
{ 20, 100, 20, 20, 100 },
/* from UNKNOWN */
{ 100, 100, 100, 100, 100 }
};
void WaitForVRamReady(VRAM_WAIT_STATE vws)
{
static DWORD old_time = 0;
static VRAM_WAIT_STATE old_vws = VWS_UNKNOWN;
DWORD new_time;
if (0==old_time) old_time = timeGetTime();
do new_time = timeGetTime(); while (new_time - old_time < transition_times_matrix[old_vws][vws]);
old_time = new_time;
old_vws = vws;
}

25
src/win95/vramtime.h
View file

@ -1,25 +0,0 @@
#ifndef _included_vramtime_h_
#define _included_vramtime_h_
#ifdef __cplusplus
extern "C" {
#endif
typedef enum VramWaitState
{
VWS_DDRELEASE,
VWS_D3DTEXRELEASE,
VWS_DDCREATE,
VWS_D3DTEXCREATE,
VWS_UNKNOWN,
VWS_MAXSTATES
} VRAM_WAIT_STATE;
void WaitForVRamReady(VRAM_WAIT_STATE);
#ifdef __cplusplus
}
#endif
#endif /* ! _included_vramtime_h_ */

164
src/win95/zmouse.h
View file

@ -1,164 +0,0 @@
/****************************************************************************
* *
* ZMOUSE.H -- Include file for IntelliMouse(tm) 1.0 *
* *
* NOTE: Zmouse.h contains #defines required when providing IntelliMouse *
* wheel support for Windows95 and NT3.51. Wheel is supported *
* natively in WinNT4.0, please refer to the NT4.0 SDK for more info *
* on providing support for IntelliMouse in NT4.0. *
* *
* Copyright (c) 1983-1996, Microsoft Corp. All rights reserved. *
* *
\***************************************************************************/
/**************************************************************************
Client Appplication (API) Defines for Wheel rolling
***************************************************************************/
// Apps need to call RegisterWindowMessage using the #define below to
// get the message number that is sent to the foreground window
// when a wheel roll occurs
#ifdef UNICODE
#define MSH_MOUSEWHEEL L"MSWHEEL_ROLLMSG"
#else
#define MSH_MOUSEWHEEL "MSWHEEL_ROLLMSG"
#endif
// wParam = wheel rotation expressed in multiples of WHEEL_DELTA
// lParam is the mouse coordinates
#define WHEEL_DELTA 120 // Default value for rolling one notch
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL (WM_MOUSELAST+1) // message that will be supported
// by the OS
#endif
/**************************************************************************
Client Appplication (API) Defines for
* determining if wheel support active
* determining # of Scroll Lines
***************************************************************************/
// Class name for MSWHEEL.EXE's invisible window
// use FindWindow to get hwnd to MSWHEEL
#ifdef UNICODE
#define MOUSEZ_CLASSNAME L"MouseZ" // wheel window class
#define MOUSEZ_TITLE L"Magellan MSWHEEL" // wheel window title
#else
#define MOUSEZ_CLASSNAME "MouseZ" // wheel window class
#define MOUSEZ_TITLE "Magellan MSWHEEL" // wheel window title
#endif
#define MSH_WHEELMODULE_CLASS (MOUSEZ_CLASSNAME)
#define MSH_WHEELMODULE_TITLE (MOUSEZ_TITLE)
// Apps need to call RegisterWindowMessage using the #defines
// below to get the message numbers for:
// 1) the message that can be sent to the MSWHEEL window to
// query if wheel support is active (MSH_WHEELSUPPORT)>
// 2) the message to query for the number of scroll lines
// (MSH_SCROLL_LINES)
//
// To send a message to MSWheel window, use FindWindow with the #defines
// for CLASS and TITLE above. If FindWindow fails to find the MSWHEEL
// window or the return from SendMessage is false, then Wheel support
// is not currently available.
#ifdef UNICODE
#define MSH_WHEELSUPPORT L"MSH_WHEELSUPPORT_MSG" // name of msg to send
// to query for wheel support
#else
#define MSH_WHEELSUPPORT "MSH_WHEELSUPPORT_MSG" // name of msg to send
// to query for wheel support
#endif
// MSH_WHEELSUPPORT
// wParam - not used
// lParam - not used
// returns BOOL - TRUE if wheel support is active, FALSE otherwise
#ifdef UNICODE
#define MSH_SCROLL_LINES L"MSH_SCROLL_LINES_MSG"
#else
#define MSH_SCROLL_LINES "MSH_SCROLL_LINES_MSG"
#endif
// MSH_SCROLL_LINES
// wParam - not used
// lParam - not used
// returns int - number of lines to scroll on a wheel roll
#ifndef WHEEL_PAGESCROLL
#define WHEEL_PAGESCROLL (UINT_MAX) // signifies to scroll a page, also
// defined in winuser.h in the
// NT4.0 SDK
#endif
#ifndef SPI_SETWHEELSCROLLLINES
#define SPI_SETWHEELSCROLLLINES 105 // Also defined in winuser.h in the
// NT4.0 SDK, please see the NT4.0 SDK
// documentation for NT4.0 implementation
// specifics.
// For Win95 and WinNT3.51,
// Mswheel broadcasts the message
// WM_SETTINGCHANGE (equivalent to
// WM_WININICHANGE) when the scroll
// lines has changed. Applications
// will recieve the WM_SETTINGCHANGE
// message with the wParam set to
// SPI_SETWHEELSCROLLLINES. When
// this message is recieved the application
// should query Mswheel for the new
// setting.
#endif
/*********************************************************************
* INLINE FUNCTION: HwndMsWheel
* Purpose : Get a reference to MSWheel Window, the registered messages,
* wheel support active setting, and number of scrollLines
* Params : PUINT puiMsh_MsgMouseWheel - address of UINT to contain returned registered wheel message
* PUINT puiMsh_Msg3DSupport - address of UINT to contain wheel support registered message
* PUINT puiMsh_MsgScrollLines - address of UINT to contain Scroll lines registered message
* PBOOL pf3DSupport - address of BOOL to contain returned flag for wheel support active
* PINT piScrollLines - address of int to contain returned scroll lines
* Returns : HWND handle to the MsWheel window
* Note : The return value for pf3DSupport and piScrollLines is dependant
* on the POINT32 module. If POINT32 module is not running then
* the values returned for these parameters will be
* FALSE and 3, respectively.
*********************************************************************/
__inline HWND HwndMSWheel(
PUINT puiMsh_MsgMouseWheel,
PUINT puiMsh_Msg3DSupport,
PUINT puiMsh_MsgScrollLines,
PBOOL pf3DSupport,
PINT piScrollLines
)
{
HWND hdlMsWheel;
hdlMsWheel = FindWindow(MSH_WHEELMODULE_CLASS, MSH_WHEELMODULE_TITLE);
*puiMsh_MsgMouseWheel = RegisterWindowMessage(MSH_MOUSEWHEEL);
*puiMsh_Msg3DSupport = RegisterWindowMessage(MSH_WHEELSUPPORT);
*puiMsh_MsgScrollLines = RegisterWindowMessage(MSH_SCROLL_LINES);
if (*puiMsh_Msg3DSupport)
*pf3DSupport = (BOOL)SendMessage(hdlMsWheel, *puiMsh_Msg3DSupport, 0, 0);
else
*pf3DSupport = FALSE; // default to FALSE
if (*puiMsh_MsgScrollLines)
*piScrollLines = (int)SendMessage(hdlMsWheel, *puiMsh_MsgScrollLines, 0, 0);
else
*piScrollLines = 3; // default
return(hdlMsWheel);
}