src/msw/ctl3d/wat386/ctl3d32.c

/*
 * File:	ctl3d32.c
 * Purpose:	32bit interface to CTL3D functions for Watcom C/C++
 * Author:	Patrick Halke
 * Created:	1995
 * Updated:
 * Copyright:	(c) 1995
 */

#include <malloc.h>

#include <windows.h>

#include "ctl3d.h"

#if defined(__WINDOWS_386__)

#ifdef __cplusplus
extern "C" {
#endif

#undef FAR
#define FAR

#define INDIR_INT INDIR_WORD
#define INDIR_UINT INDIR_WORD
#define INDIR_WPARAM INDIR_UINT
#define INDIR_LPARAM INDIR_DWORD
#define INDIR_LONG INDIR_DWORD
#define INDIR_ULONG INDIR_DWORD

#ifdef STRICT
#define INDIR_HANDLE INDIR_PTR
#define INDIR_HWND INDIR_PTR
#define INDIR_HDC INDIR_PTR
#else
#define INDIR_HANDLE INDIR_UINT
#define INDIR_HWND INDIR_UINT
#define INDIR_HDC INDIR_UINT
#endif

typedef struct tagCTL3DFUNCTIONS {
    HINSTANCE	dll;
    /* Function Handles */
    HINDIR	_Ctl3dSubclassDlg;
    HINDIR	_Ctl3dSubclassDlgEx;
    HINDIR	_Ctl3dGetVer;
    HINDIR	_Ctl3dEnabled;
    HINDIR	_Ctl3dCtlColor;
    HINDIR	_Ctl3dCtlColorEx;
    HINDIR	_Ctl3dColorChange;
    HINDIR	_Ctl3dSubclassCtl;
    HINDIR	_Ctl3dDlgFramePaint;
    HINDIR	_Ctl3dAutoSubclass;
    HINDIR	_Ctl3dRegister;
    HINDIR	_Ctl3dUnregister;
    HINDIR	_Ctl3dWinIniChange;
} CTL3DFUNCTIONS;

static CTL3DFUNCTIONS	Ctl3dFunc = { 0 };

static BOOL load_functions( CTL3DFUNCTIONS* functions )
{
    FARPROC		proc;
    HINSTANCE		dll;

    dll = LoadLibrary( "CTL3D.DLL" );
    if( dll < HINSTANCE_ERROR ) {
	return( FALSE );
    }

    /* Function thunks */

    proc = GetProcAddress(dll, "Ctl3dSubclassDlg");
    functions->_Ctl3dSubclassDlg = GetIndirectFunctionHandle( proc,
	INDIR_HWND,
	INDIR_WORD,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dSubclassDlgEx" );
    functions->_Ctl3dSubclassDlgEx = GetIndirectFunctionHandle( proc,
	INDIR_HWND,
	INDIR_DWORD,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dGetVer" );
    functions->_Ctl3dGetVer = GetIndirectFunctionHandle( proc,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dEnabled" );
    functions->_Ctl3dEnabled = GetIndirectFunctionHandle( proc,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dCtlColor" );
    functions->_Ctl3dCtlColor = GetIndirectFunctionHandle( proc,
	INDIR_HDC,
	INDIR_LONG,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dCtlColorEx" );
    functions->_Ctl3dCtlColorEx = GetIndirectFunctionHandle( proc,
	INDIR_UINT,
	INDIR_WPARAM,
	INDIR_LPARAM,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dColorChange" );
    functions->_Ctl3dColorChange = GetIndirectFunctionHandle( proc,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dSubclassCtl" );
    functions->_Ctl3dSubclassCtl = GetIndirectFunctionHandle( proc,
	INDIR_HWND,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dDlgFramePaint" );
    functions->_Ctl3dDlgFramePaint = GetIndirectFunctionHandle( proc,
	INDIR_HWND,
	INDIR_UINT,
	INDIR_WPARAM,
	INDIR_LPARAM,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dAutoSubclass" );
    functions->_Ctl3dAutoSubclass = GetIndirectFunctionHandle( proc,
	INDIR_HANDLE,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dRegister" );
    functions->_Ctl3dRegister = GetIndirectFunctionHandle( proc,
	INDIR_HANDLE,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dUnregister" );
    functions->_Ctl3dUnregister = GetIndirectFunctionHandle( proc,
	INDIR_HANDLE,
	INDIR_ENDLIST );

    proc = GetProcAddress( dll, "Ctl3dWinIniChange" );
    functions->_Ctl3dWinIniChange = GetIndirectFunctionHandle( proc,
	INDIR_ENDLIST );

    functions->dll = dll;
    return( TRUE );
}

static void unload_functions( CTL3DFUNCTIONS * functions )
{
    FreeLibrary( functions->dll );
    functions->dll = 0;
}

/* Function Definitions */

BOOL WINAPI Ctl3dSubclassDlg(HWND hwnd, WORD w)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassDlg,
				      hwnd, w);
}

BOOL WINAPI Ctl3dSubclassDlgEx(HWND hwnd, DWORD dw)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassDlgEx,
				      hwnd, dw);
}

WORD WINAPI Ctl3dGetVer(void)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
      return FALSE;

  return (WORD)InvokeIndirectFunction(Ctl3dFunc._Ctl3dGetVer);
}

BOOL WINAPI Ctl3dEnabled(void)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
      return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dEnabled);
}

HBRUSH WINAPI Ctl3dCtlColor(HDC hdc, LONG l)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (HBRUSH)InvokeIndirectFunction(Ctl3dFunc._Ctl3dCtlColor,
				        hdc, l);
}

HBRUSH WINAPI Ctl3dCtlColorEx(UINT ui, WPARAM wp, LPARAM lp)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (HBRUSH)InvokeIndirectFunction(Ctl3dFunc._Ctl3dCtlColorEx,
				        ui, wp, lp);
}

BOOL WINAPI Ctl3dColorChange(void)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dColorChange);
}

BOOL WINAPI Ctl3dSubclassCtl(HWND hwnd)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassCtl,
				      hwnd);
}

LONG WINAPI Ctl3dDlgFramePaint(HWND hwnd, UINT ui, WPARAM wp, LPARAM lp)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (LONG)InvokeIndirectFunction(Ctl3dFunc._Ctl3dDlgFramePaint,
				      hwnd, ui, wp, lp);
}

BOOL WINAPI Ctl3dAutoSubclass(HANDLE hnd)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dAutoSubclass,
				      hnd);
}

BOOL WINAPI Ctl3dRegister(HANDLE hnd)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dRegister,
				      hnd);
}

BOOL WINAPI Ctl3dUnregister(HANDLE hnd)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
    return FALSE;

  return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dUnregister,
				      hnd);
}

VOID WINAPI Ctl3dWinIniChange(void)
{
  if (!Ctl3dFunc.dll)
    if (!load_functions(&Ctl3dFunc))
      return;

  InvokeIndirectFunction(Ctl3dFunc._Ctl3dWinIniChange);
}

#ifdef __cplusplus
}
#endif

#endif	// __WINDOWS_386__
Commit	Line	Data
	1	/*
	2	* File: ctl3d32.c
	3	* Purpose: 32bit interface to CTL3D functions for Watcom C/C++
	4	* Author: Patrick Halke
	5	* Created: 1995
	6	* Updated:
	7	* Copyright: (c) 1995
	8	*/
	9
	10	#include <malloc.h>
	11
	12	#include <windows.h>
	13
	14	#include "ctl3d.h"
	15
	16	#if defined(__WINDOWS_386__)
	17
	18	#ifdef __cplusplus
	19	extern "C" {
	20	#endif
	21
	22	#undef FAR
	23	#define FAR
	24
	25	#define INDIR_INT INDIR_WORD
	26	#define INDIR_UINT INDIR_WORD
	27	#define INDIR_WPARAM INDIR_UINT
	28	#define INDIR_LPARAM INDIR_DWORD
	29	#define INDIR_LONG INDIR_DWORD
	30	#define INDIR_ULONG INDIR_DWORD
	31
	32	#ifdef STRICT
	33	#define INDIR_HANDLE INDIR_PTR
	34	#define INDIR_HWND INDIR_PTR
	35	#define INDIR_HDC INDIR_PTR
	36	#else
	37	#define INDIR_HANDLE INDIR_UINT
	38	#define INDIR_HWND INDIR_UINT
	39	#define INDIR_HDC INDIR_UINT
	40	#endif
	41
	42	typedef struct tagCTL3DFUNCTIONS {
	43	HINSTANCE dll;
	44	/* Function Handles */
	45	HINDIR _Ctl3dSubclassDlg;
	46	HINDIR _Ctl3dSubclassDlgEx;
	47	HINDIR _Ctl3dGetVer;
	48	HINDIR _Ctl3dEnabled;
	49	HINDIR _Ctl3dCtlColor;
	50	HINDIR _Ctl3dCtlColorEx;
	51	HINDIR _Ctl3dColorChange;
	52	HINDIR _Ctl3dSubclassCtl;
	53	HINDIR _Ctl3dDlgFramePaint;
	54	HINDIR _Ctl3dAutoSubclass;
	55	HINDIR _Ctl3dRegister;
	56	HINDIR _Ctl3dUnregister;
	57	HINDIR _Ctl3dWinIniChange;
	58	} CTL3DFUNCTIONS;
	59
	60	static CTL3DFUNCTIONS Ctl3dFunc = { 0 };
	61
	62	static BOOL load_functions( CTL3DFUNCTIONS* functions )
	63	{
	64	FARPROC proc;
	65	HINSTANCE dll;
	66
	67	dll = LoadLibrary( "CTL3D.DLL" );
	68	if( dll < HINSTANCE_ERROR ) {
	69	return( FALSE );
	70	}
	71
	72	/* Function thunks */
	73
	74	proc = GetProcAddress(dll, "Ctl3dSubclassDlg");
	75	functions->_Ctl3dSubclassDlg = GetIndirectFunctionHandle( proc,
	76	INDIR_HWND,
	77	INDIR_WORD,
	78	INDIR_ENDLIST );
	79
	80	proc = GetProcAddress( dll, "Ctl3dSubclassDlgEx" );
	81	functions->_Ctl3dSubclassDlgEx = GetIndirectFunctionHandle( proc,
	82	INDIR_HWND,
	83	INDIR_DWORD,
	84	INDIR_ENDLIST );
	85
	86	proc = GetProcAddress( dll, "Ctl3dGetVer" );
	87	functions->_Ctl3dGetVer = GetIndirectFunctionHandle( proc,
	88	INDIR_ENDLIST );
	89
	90	proc = GetProcAddress( dll, "Ctl3dEnabled" );
	91	functions->_Ctl3dEnabled = GetIndirectFunctionHandle( proc,
	92	INDIR_ENDLIST );
	93
	94	proc = GetProcAddress( dll, "Ctl3dCtlColor" );
	95	functions->_Ctl3dCtlColor = GetIndirectFunctionHandle( proc,
	96	INDIR_HDC,
	97	INDIR_LONG,
	98	INDIR_ENDLIST );
	99
	100	proc = GetProcAddress( dll, "Ctl3dCtlColorEx" );
	101	functions->_Ctl3dCtlColorEx = GetIndirectFunctionHandle( proc,
	102	INDIR_UINT,
	103	INDIR_WPARAM,
	104	INDIR_LPARAM,
	105	INDIR_ENDLIST );
	106
	107	proc = GetProcAddress( dll, "Ctl3dColorChange" );
	108	functions->_Ctl3dColorChange = GetIndirectFunctionHandle( proc,
	109	INDIR_ENDLIST );
	110
	111	proc = GetProcAddress( dll, "Ctl3dSubclassCtl" );
	112	functions->_Ctl3dSubclassCtl = GetIndirectFunctionHandle( proc,
	113	INDIR_HWND,
	114	INDIR_ENDLIST );
	115
	116	proc = GetProcAddress( dll, "Ctl3dDlgFramePaint" );
	117	functions->_Ctl3dDlgFramePaint = GetIndirectFunctionHandle( proc,
	118	INDIR_HWND,
	119	INDIR_UINT,
	120	INDIR_WPARAM,
	121	INDIR_LPARAM,
	122	INDIR_ENDLIST );
	123
	124	proc = GetProcAddress( dll, "Ctl3dAutoSubclass" );
	125	functions->_Ctl3dAutoSubclass = GetIndirectFunctionHandle( proc,
	126	INDIR_HANDLE,
	127	INDIR_ENDLIST );
	128
	129	proc = GetProcAddress( dll, "Ctl3dRegister" );
	130	functions->_Ctl3dRegister = GetIndirectFunctionHandle( proc,
	131	INDIR_HANDLE,
	132	INDIR_ENDLIST );
	133
	134	proc = GetProcAddress( dll, "Ctl3dUnregister" );
	135	functions->_Ctl3dUnregister = GetIndirectFunctionHandle( proc,
	136	INDIR_HANDLE,
	137	INDIR_ENDLIST );
	138
	139	proc = GetProcAddress( dll, "Ctl3dWinIniChange" );
	140	functions->_Ctl3dWinIniChange = GetIndirectFunctionHandle( proc,
	141	INDIR_ENDLIST );
	142
	143	functions->dll = dll;
	144	return( TRUE );
	145	}
	146
	147	static void unload_functions( CTL3DFUNCTIONS * functions )
	148	{
	149	FreeLibrary( functions->dll );
	150	functions->dll = 0;
	151	}
	152
	153	/* Function Definitions */
	154
	155	BOOL WINAPI Ctl3dSubclassDlg(HWND hwnd, WORD w)
	156	{
	157	if (!Ctl3dFunc.dll)
	158	if (!load_functions(&Ctl3dFunc))
	159	return FALSE;
	160
	161	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassDlg,
	162	hwnd, w);
	163	}
	164
	165	BOOL WINAPI Ctl3dSubclassDlgEx(HWND hwnd, DWORD dw)
	166	{
	167	if (!Ctl3dFunc.dll)
	168	if (!load_functions(&Ctl3dFunc))
	169	return FALSE;
	170
	171	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassDlgEx,
	172	hwnd, dw);
	173	}
	174
	175	WORD WINAPI Ctl3dGetVer(void)
	176	{
	177	if (!Ctl3dFunc.dll)
	178	if (!load_functions(&Ctl3dFunc))
	179	return FALSE;
	180
	181	return (WORD)InvokeIndirectFunction(Ctl3dFunc._Ctl3dGetVer);
	182	}
	183
	184	BOOL WINAPI Ctl3dEnabled(void)
	185	{
	186	if (!Ctl3dFunc.dll)
	187	if (!load_functions(&Ctl3dFunc))
	188	return FALSE;
	189
	190	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dEnabled);
	191	}
	192
	193	HBRUSH WINAPI Ctl3dCtlColor(HDC hdc, LONG l)
	194	{
	195	if (!Ctl3dFunc.dll)
	196	if (!load_functions(&Ctl3dFunc))
	197	return FALSE;
	198
	199	return (HBRUSH)InvokeIndirectFunction(Ctl3dFunc._Ctl3dCtlColor,
	200	hdc, l);
	201	}
	202
	203	HBRUSH WINAPI Ctl3dCtlColorEx(UINT ui, WPARAM wp, LPARAM lp)
	204	{
	205	if (!Ctl3dFunc.dll)
	206	if (!load_functions(&Ctl3dFunc))
	207	return FALSE;
	208
	209	return (HBRUSH)InvokeIndirectFunction(Ctl3dFunc._Ctl3dCtlColorEx,
	210	ui, wp, lp);
	211	}
	212
	213	BOOL WINAPI Ctl3dColorChange(void)
	214	{
	215	if (!Ctl3dFunc.dll)
	216	if (!load_functions(&Ctl3dFunc))
	217	return FALSE;
	218
	219	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dColorChange);
	220	}
	221
	222	BOOL WINAPI Ctl3dSubclassCtl(HWND hwnd)
	223	{
	224	if (!Ctl3dFunc.dll)
	225	if (!load_functions(&Ctl3dFunc))
	226	return FALSE;
	227
	228	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dSubclassCtl,
	229	hwnd);
	230	}
	231
	232	LONG WINAPI Ctl3dDlgFramePaint(HWND hwnd, UINT ui, WPARAM wp, LPARAM lp)
	233	{
	234	if (!Ctl3dFunc.dll)
	235	if (!load_functions(&Ctl3dFunc))
	236	return FALSE;
	237
	238	return (LONG)InvokeIndirectFunction(Ctl3dFunc._Ctl3dDlgFramePaint,
	239	hwnd, ui, wp, lp);
	240	}
	241
	242	BOOL WINAPI Ctl3dAutoSubclass(HANDLE hnd)
	243	{
	244	if (!Ctl3dFunc.dll)
	245	if (!load_functions(&Ctl3dFunc))
	246	return FALSE;
	247
	248	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dAutoSubclass,
	249	hnd);
	250	}
	251
	252	BOOL WINAPI Ctl3dRegister(HANDLE hnd)
	253	{
	254	if (!Ctl3dFunc.dll)
	255	if (!load_functions(&Ctl3dFunc))
	256	return FALSE;
	257
	258	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dRegister,
	259	hnd);
	260	}
	261
	262	BOOL WINAPI Ctl3dUnregister(HANDLE hnd)
	263	{
	264	if (!Ctl3dFunc.dll)
	265	if (!load_functions(&Ctl3dFunc))
	266	return FALSE;
	267
	268	return (BOOL)InvokeIndirectFunction(Ctl3dFunc._Ctl3dUnregister,
	269	hnd);
	270	}
	271
	272	VOID WINAPI Ctl3dWinIniChange(void)
	273	{
	274	if (!Ctl3dFunc.dll)
	275	if (!load_functions(&Ctl3dFunc))
	276	return;
	277
	278	InvokeIndirectFunction(Ctl3dFunc._Ctl3dWinIniChange);
	279	}
	280
	281	#ifdef __cplusplus
	282	}
	283	#endif
	284
	285	#endif // __WINDOWS_386__