static void dinput_joypad_destroy(void)
{
unsigned i;
settings_t *settings = config_get_ptr();
for (i = 0; i < MAX_USERS; i++)
{
if (g_pads[i].joypad)
{
IDirectInputDevice8_Unacquire(g_pads[i].joypad);
IDirectInputDevice8_Release(g_pads[i].joypad);
}
free(g_pads[i].joy_name);
g_pads[i].joy_name = NULL;
free(g_pads[i].joy_friendly_name);
g_pads[i].joy_friendly_name = NULL;
*settings->input.device_names[i] = '\0';
}
g_joypad_cnt = 0;
memset(g_pads, 0, sizeof(g_pads));
/* Can be blocked by global Dinput context. */
dinput_destroy_context();
}
void I_KillDevice(LPDIRECTINPUTDEVICE8 *dev)
{
if(*dev)
IDirectInputDevice8_Unacquire(*dev);
I_SAFE_RELEASE(*dev);
}
/*
* Closes the haptic device.
*/
void
SDL_SYS_HapticClose(SDL_Haptic * haptic)
{
if (haptic->hwdata) {
/* Free effects. */
SDL_free(haptic->effects);
haptic->effects = NULL;
haptic->neffects = 0;
/* Clean up */
if (haptic->hwdata->bXInputHaptic) {
haptic->hwdata->stopThread = 1;
SDL_WaitThread(haptic->hwdata->thread, NULL);
SDL_DestroyMutex(haptic->hwdata->mutex);
} else {
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
/* Only release if isn't grabbed by a joystick. */
if (haptic->hwdata->is_joystick == 0) {
IDirectInputDevice8_Release(haptic->hwdata->device);
}
}
/* Free */
SDL_free(haptic->hwdata);
haptic->hwdata = NULL;
}
}
void
SDL_DINPUT_HapticClose(SDL_Haptic * haptic)
{
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
/* Only release if isn't grabbed by a joystick. */
if (haptic->hwdata->is_joystick == 0) {
IDirectInputDevice8_Release(haptic->hwdata->device);
}
}
static void dinput_grab_mouse(void *data, bool state)
{
struct dinput_input *di = (struct dinput_input*)data;
IDirectInputDevice8_Unacquire(di->mouse);
IDirectInputDevice8_SetCooperativeLevel(di->mouse,
(HWND)driver.video_window,
state ?
(DISCL_EXCLUSIVE | DISCL_FOREGROUND) :
(DISCL_NONEXCLUSIVE | DISCL_FOREGROUND));
IDirectInputDevice8_Acquire(di->mouse);
}
int
SDL_DINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
{
HRESULT ret;
DWORD flags;
DIEFFECT temp;
/* Get the effect. */
SDL_memset(&temp, 0, sizeof(DIEFFECT));
if (SDL_SYS_ToDIEFFECT(haptic, &temp, data) < 0) {
goto err_update;
}
/* Set the flags. Might be worthwhile to diff temp with loaded effect and
* only change those parameters. */
flags = DIEP_DIRECTION |
DIEP_DURATION |
DIEP_ENVELOPE |
DIEP_STARTDELAY |
DIEP_TRIGGERBUTTON |
DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS;
/* Create the actual effect. */
ret =
IDirectInputEffect_SetParameters(effect->hweffect->ref, &temp, flags);
if (ret == DIERR_NOTEXCLUSIVEACQUIRED) {
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
ret = IDirectInputDevice8_SetCooperativeLevel(haptic->hwdata->device, SDL_HelperWindow, DISCL_EXCLUSIVE | DISCL_BACKGROUND);
if (SUCCEEDED(ret)) {
ret = DIERR_NOTACQUIRED;
}
}
if (ret == DIERR_INPUTLOST || ret == DIERR_NOTACQUIRED) {
ret = IDirectInputDevice8_Acquire(haptic->hwdata->device);
if (SUCCEEDED(ret)) {
ret = IDirectInputEffect_SetParameters(effect->hweffect->ref, &temp, flags);
}
}
if (FAILED(ret)) {
DI_SetError("Unable to update effect", ret);
goto err_update;
}
/* Copy it over. */
SDL_SYS_HapticFreeDIEFFECT(&effect->hweffect->effect, data->type);
SDL_memcpy(&effect->hweffect->effect, &temp, sizeof(DIEFFECT));
return 0;
err_update:
SDL_SYS_HapticFreeDIEFFECT(&temp, data->type);
return -1;
}
/* _al_win_joystick_dinput_unacquire: [window thread]
* Unacquires the joystick devices.
*/
void _al_win_joystick_dinput_unacquire(void *unused)
{
int i;
(void)unused;
if (joystick_dinput && win_disp) {
for (i=0; i < MAX_JOYSTICKS; i++) {
if (joydx_joystick[i].device) {
ALLEGRO_DEBUG("Unacquiring joystick device at slot %d\n", i);
IDirectInputDevice8_Unacquire(joydx_joystick[i].device);
}
}
}
}
static void dinput_joypad_destroy(void)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
if (g_pads[i].joypad)
{
IDirectInputDevice8_Unacquire(g_pads[i].joypad);
IDirectInputDevice8_Release(g_pads[i].joypad);
}
}
g_joypad_cnt = 0;
memset(g_pads, 0, sizeof(g_pads));
// Can be blocked by global Dinput context.
dinput_destroy_context();
}
void PERDXDeInit(void)
{
u32 i;
for (i = 0; i < numdevices; i++)
{
if (lpDIDevice[i])
{
IDirectInputDevice8_Unacquire(lpDIDevice[i]);
IDirectInputDevice8_Release(lpDIDevice[i]);
lpDIDevice[i] = NULL;
}
}
if (lpDI8)
{
IDirectInput8_Release(lpDI8);
lpDI8 = NULL;
}
}
void PERDXDeInit(void)
{
u32 i;
for (i = 0; i < num_devices; i++)
{
if (dev_list[i].lpDIDevice)
{
IDirectInputDevice8_Unacquire(dev_list[i].lpDIDevice);
IDirectInputDevice8_Release(dev_list[i].lpDIDevice);
dev_list[i].lpDIDevice = NULL;
}
}
if (lpDI8)
{
IDirectInput8_Release(lpDI8);
lpDI8 = NULL;
}
PERCORE_INITIALIZED = 0;
}
/***********************************************************************
* destroy_joysticks [internal]
*/
static void destroy_joysticks(struct JoystickData *data)
{
int i, j;
for (i = 0; i < data->num_joysticks; i++)
{
if (data->joysticks[i].forcefeedback && data->joysticks[i].num_effects > 0)
{
for (j = 0; j < data->joysticks[i].num_effects; j++)
IDirectInputEffect_Release(data->joysticks[i].effects[j].effect);
HeapFree(GetProcessHeap(), 0, data->joysticks[i].effects);
}
IDirectInputDevice8_Unacquire(data->joysticks[i].device);
IDirectInputDevice8_Release(data->joysticks[i].device);
}
HeapFree(GetProcessHeap(), 0, data->joysticks);
}
static void dinput_joypad_destroy(void)
{
unsigned i;
for (i = 0; i < MAX_USERS; i++)
{
if (g_pads[i].joypad)
{
if (g_pads[i].rumble_iface[0])
{
IDirectInputEffect_Stop(g_pads[i].rumble_iface[0]);
IDirectInputEffect_Release(g_pads[i].rumble_iface[0]);
}
if (g_pads[i].rumble_iface[1])
{
IDirectInputEffect_Stop(g_pads[i].rumble_iface[1]);
IDirectInputEffect_Release(g_pads[i].rumble_iface[1]);
}
IDirectInputDevice8_Unacquire(g_pads[i].joypad);
IDirectInputDevice8_Release(g_pads[i].joypad);
}
free(g_pads[i].joy_name);
g_pads[i].joy_name = NULL;
free(g_pads[i].joy_friendly_name);
g_pads[i].joy_friendly_name = NULL;
input_config_clear_device_name(i);
}
g_joypad_cnt = 0;
memset(g_pads, 0, sizeof(g_pads));
/* Can be blocked by global Dinput context. */
dinput_destroy_context();
}
void
SDL_DINPUT_JoystickClose(SDL_Joystick * joystick)
{
IDirectInputDevice8_Unacquire(joystick->hwdata->InputDevice);
IDirectInputDevice8_Release(joystick->hwdata->InputDevice);
}
int
SDL_DINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickdevice)
{
HRESULT result;
LPDIRECTINPUTDEVICE8 device;
DIPROPDWORD dipdw;
joystick->hwdata->buffered = SDL_TRUE;
joystick->hwdata->Capabilities.dwSize = sizeof(DIDEVCAPS);
SDL_zero(dipdw);
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
result =
IDirectInput8_CreateDevice(dinput,
&(joystickdevice->dxdevice.guidInstance), &device, NULL);
if (FAILED(result)) {
return SetDIerror("IDirectInput::CreateDevice", result);
}
/* Now get the IDirectInputDevice8 interface, instead. */
result = IDirectInputDevice8_QueryInterface(device,
&IID_IDirectInputDevice8,
(LPVOID *)& joystick->
hwdata->InputDevice);
/* We are done with this object. Use the stored one from now on. */
IDirectInputDevice8_Release(device);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::QueryInterface", result);
}
/* Acquire shared access. Exclusive access is required for forces,
* though. */
result =
IDirectInputDevice8_SetCooperativeLevel(joystick->hwdata->
InputDevice, SDL_HelperWindow,
DISCL_EXCLUSIVE |
DISCL_BACKGROUND);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetCooperativeLevel", result);
}
/* Use the extended data structure: DIJOYSTATE2. */
result =
IDirectInputDevice8_SetDataFormat(joystick->hwdata->InputDevice,
&SDL_c_dfDIJoystick2);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetDataFormat", result);
}
/* Get device capabilities */
result =
IDirectInputDevice8_GetCapabilities(joystick->hwdata->InputDevice,
&joystick->hwdata->Capabilities);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::GetCapabilities", result);
}
/* Force capable? */
if (joystick->hwdata->Capabilities.dwFlags & DIDC_FORCEFEEDBACK) {
result = IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::Acquire", result);
}
/* reset all actuators. */
result =
IDirectInputDevice8_SendForceFeedbackCommand(joystick->hwdata->
InputDevice,
DISFFC_RESET);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SendForceFeedbackCommand", result);
}
*/
result = IDirectInputDevice8_Unacquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::Unacquire", result);
}
/* Turn on auto-centering for a ForceFeedback device (until told
* otherwise). */
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DIPROPAUTOCENTER_ON;
result =
IDirectInputDevice8_SetProperty(joystick->hwdata->InputDevice,
DIPROP_AUTOCENTER, &dipdw.diph);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetProperty", result);
}
*/
}
/* What buttons and axes does it have? */
IDirectInputDevice8_EnumObjects(joystick->hwdata->InputDevice,
EnumDevObjectsCallback, joystick,
DIDFT_BUTTON | DIDFT_AXIS | DIDFT_POV);
/* Reorder the input objects. Some devices do not report the X axis as
* the first axis, for example. */
SortDevObjects(joystick);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = INPUT_QSIZE;
/* Set the buffer size */
result =
IDirectInputDevice8_SetProperty(joystick->hwdata->InputDevice,
DIPROP_BUFFERSIZE, &dipdw.diph);
if (result == DI_POLLEDDEVICE) {
/* This device doesn't support buffering, so we're forced
* to use less reliable polling. */
joystick->hwdata->buffered = SDL_FALSE;
} else if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetProperty", result);
}
return 0;
}
/*
* Opens the haptic device from the file descriptor.
*
* Steps:
* - Set cooperative level.
* - Set data format.
* - Acquire exclusiveness.
* - Reset actuators.
* - Get supported features.
*/
static int
SDL_SYS_HapticOpenFromDevice8(SDL_Haptic * haptic,
LPDIRECTINPUTDEVICE8 device8, SDL_bool is_joystick)
{
HRESULT ret;
DIPROPDWORD dipdw;
/* Allocate the hwdata */
haptic->hwdata = (struct haptic_hwdata *)SDL_malloc(sizeof(*haptic->hwdata));
if (haptic->hwdata == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
/* We'll use the device8 from now on. */
haptic->hwdata->device = device8;
haptic->hwdata->is_joystick = is_joystick;
/* Grab it exclusively to use force feedback stuff. */
ret = IDirectInputDevice8_SetCooperativeLevel(haptic->hwdata->device,
SDL_HelperWindow,
DISCL_EXCLUSIVE |
DISCL_BACKGROUND);
if (FAILED(ret)) {
DI_SetError("Setting cooperative level to exclusive", ret);
goto acquire_err;
}
/* Set data format. */
ret = IDirectInputDevice8_SetDataFormat(haptic->hwdata->device,
&c_dfDIJoystick2);
if (FAILED(ret)) {
DI_SetError("Setting data format", ret);
goto acquire_err;
}
/* Get number of axes. */
ret = IDirectInputDevice8_EnumObjects(haptic->hwdata->device,
DI_DeviceObjectCallback,
haptic, DIDFT_AXIS);
if (FAILED(ret)) {
DI_SetError("Getting device axes", ret);
goto acquire_err;
}
/* Acquire the device. */
ret = IDirectInputDevice8_Acquire(haptic->hwdata->device);
if (FAILED(ret)) {
DI_SetError("Acquiring DirectInput device", ret);
goto acquire_err;
}
/* Reset all actuators - just in case. */
ret = IDirectInputDevice8_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_RESET);
if (FAILED(ret)) {
DI_SetError("Resetting device", ret);
goto acquire_err;
}
/* Enabling actuators. */
ret = IDirectInputDevice8_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_SETACTUATORSON);
if (FAILED(ret)) {
DI_SetError("Enabling actuators", ret);
goto acquire_err;
}
/* Get supported effects. */
ret = IDirectInputDevice8_EnumEffects(haptic->hwdata->device,
DI_EffectCallback, haptic,
DIEFT_ALL);
if (FAILED(ret)) {
DI_SetError("Enumerating supported effects", ret);
goto acquire_err;
}
if (haptic->supported == 0) { /* Error since device supports nothing. */
SDL_SetError("Haptic: Internal error on finding supported effects.");
goto acquire_err;
}
/* Check autogain and autocenter. */
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 10000;
ret = IDirectInputDevice8_SetProperty(haptic->hwdata->device,
DIPROP_FFGAIN, &dipdw.diph);
if (!FAILED(ret)) { /* Gain is supported. */
haptic->supported |= SDL_HAPTIC_GAIN;
}
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DIPROPAUTOCENTER_OFF;
ret = IDirectInputDevice8_SetProperty(haptic->hwdata->device,
DIPROP_AUTOCENTER, &dipdw.diph);
if (!FAILED(ret)) { /* Autocenter is supported. */
haptic->supported |= SDL_HAPTIC_AUTOCENTER;
}
/* Status is always supported. */
haptic->supported |= SDL_HAPTIC_STATUS | SDL_HAPTIC_PAUSE;
/* Check maximum effects. */
haptic->neffects = 128; /* This is not actually supported as thus under windows,
there is no way to tell the number of EFFECTS that a
device can hold, so we'll just use a "random" number
instead and put warnings in SDL_haptic.h */
haptic->nplaying = 128; /* Even more impossible to get this then neffects. */
/* Prepare effects memory. */
haptic->effects = (struct haptic_effect *)
SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
if (haptic->effects == NULL) {
SDL_OutOfMemory();
goto acquire_err;
}
/* Clear the memory */
SDL_memset(haptic->effects, 0,
sizeof(struct haptic_effect) * haptic->neffects);
return 0;
/* Error handling */
acquire_err:
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
return -1;
}
JNIEXPORT jint JNICALL Java_net_java_games_input_IDirectInputDevice_nUnacquire(JNIEnv *env, jclass unused, jlong address) {
LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(INT_PTR)address;
HRESULT res = IDirectInputDevice8_Unacquire(lpDevice);
return res;
}
int PERDXFetchNextPress(HWND hWnd, u32 guidnum, char *buttonname)
{
LPDIRECTINPUT8 lpDI8temp = NULL;
LPDIRECTINPUTDEVICE8 lpDIDevicetemp;
DIDEVCAPS didc;
int buttonid=-1;
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8temp, NULL)))
return -1;
if (FAILED(IDirectInput8_CreateDevice(lpDI8temp, &GUIDDevice[guidnum], &lpDIDevicetemp,
NULL)))
{
IDirectInput8_Release(lpDI8temp);
return -1;
}
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevicetemp, &didc)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIKeyboard)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIJoystick)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIMouse2)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
if (DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_BUTTONCONFIG), hWnd, (DLGPROC)ButtonConfigDlgProc, (LPARAM)lpDIDevicetemp) == TRUE)
{
// Figure out what kind of code to generate
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
memset(buttonname, 0, MAX_PATH);
buttonid = nextpress.dwOfs;
// This fixes some strange inconsistencies
if (buttonid == DIK_PAUSE)
buttonid = DIK_NUMLOCK;
else if (buttonid == DIK_NUMLOCK)
buttonid = DIK_PAUSE;
if (buttonid & 0x80)
buttonid += 0x80;
GetKeyNameTextA(buttonid << 16, buttonname, MAX_PATH);
buttonid = nextpress.dwOfs;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (nextpress.dwOfs == DIJOFS_X)
{
if (nextpress.dwData <= 0x8000)
{
sprintf(buttonname, "Axis Left");
buttonid = 0x00;
}
else
{
sprintf(buttonname, "Axis Right");
buttonid = 0x01;
}
}
else if (nextpress.dwOfs == DIJOFS_Y)
{
if (nextpress.dwData <= 0x8000)
{
sprintf(buttonname, "Axis Up");
buttonid = 0x02;
}
else
{
sprintf(buttonname, "Axis Down");
buttonid = 0x03;
}
}
else if (nextpress.dwOfs == DIJOFS_POV(0))
{
if (nextpress.dwData < 9000)
{
sprintf(buttonname, "POV Up");
buttonid = 0x04;
}
else if (nextpress.dwData < 18000)
{
sprintf(buttonname, "POV Right");
buttonid = 0x05;
}
else if (nextpress.dwData < 27000)
{
sprintf(buttonname, "POV Down");
buttonid = 0x06;
}
else
{
sprintf(buttonname, "POV Left");
buttonid = 0x07;
}
}
else if (nextpress.dwOfs >= DIJOFS_BUTTON(0) && nextpress.dwOfs <= DIJOFS_BUTTON(127))
{
sprintf(buttonname, "Button %d", (int)(nextpress.dwOfs - 0x2F));
buttonid = nextpress.dwOfs;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
buttonid = nextpress.dwOfs-DIMOFS_BUTTON0;
sprintf(buttonname, "Button %d", buttonid+1);
}
}
IDirectInputDevice8_Unacquire(lpDIDevicetemp);
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return buttonid;
}
void PERDXLoadDevices(char *inifilename)
{
char tempstr[MAX_PATH];
char string1[20];
char string2[20];
GUID guid;
DIDEVCAPS didc;
u32 i;
int j, i2;
int buttonid;
DIPROPDWORD dipdw;
int id;
DWORD coopflags=DISCL_FOREGROUND | DISCL_NONEXCLUSIVE;
BOOL loaddefault=TRUE;
int numpads;
HRESULT hr;
if (!PERCore)
return;
PerPortReset();
memset(pad, 0, sizeof(pad));
// Check Connection Type
if (GetPrivateProfileStringA("Input", "Port1Type", "", tempstr, MAX_PATH, inifilename) == 0)
{
// Check if it's using the old ini settings for peripherals
if (GetPrivateProfileStringA("Peripheral1", "GUID", "", tempstr, MAX_PATH, inifilename) != 0)
{
// Convert to the newer type of settings
for (i = 0; i < 2; i++)
{
sprintf(string1, "Port%dType", (int)i+1);
WritePrivateProfileStringA("Input", string1, "1", inifilename);
sprintf(string1, "Peripheral%d", (int)i+1);
sprintf(string2, "Peripheral%dA", (int)i+1);
if (GetPrivateProfileStringA(string1, "GUID", "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, "GUID", tempstr, inifilename);
if (GetPrivateProfileStringA(string1, "EmulateType", "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, "EmulateType", tempstr, inifilename);
for (i2 = 0; i2 < 13; i2++)
{
if (GetPrivateProfileStringA(string1, PerPadNames[i2], "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, PerPadNames[i2], tempstr, inifilename);
}
}
// Remove old ini entries
for (i = 0; i < 12; i++)
{
sprintf(string1, "Peripheral%d", (int)i+1);
WritePrivateProfileStringA(string1, NULL, NULL, inifilename);
}
loaddefault = FALSE;
}
}
else
loaddefault = FALSE;
if (loaddefault)
{
LoadDefaultPort1A();
return;
}
// Load new type settings
for (i = 0; i < 2; i++)
{
sprintf(string1, "Port%dType", (int)i+1);
if (GetPrivateProfileStringA("Input", string1, "", tempstr, MAX_PATH, inifilename) != 0)
{
porttype[i] = atoi(tempstr);
switch(porttype[i])
{
case 1:
numpads = 1;
break;
case 2:
numpads = 6;
break;
default:
numpads = 0;
break;
}
// Load new type settings
for (j = 0; j < numpads; j++)
{
int padindex=(6*i)+j;
padconf_struct *curdevice=&paddevice[padindex];
sprintf(string1, "Peripheral%d%C", (int)i+1, 'A' + j);
// Let's first fetch the guid of the device
if (GetPrivateProfileStringA(string1, "GUID", "", tempstr, MAX_PATH, inifilename) == 0)
continue;
if (GetPrivateProfileStringA(string1, "EmulateType", "0", string2, MAX_PATH, inifilename))
{
curdevice->emulatetype = atoi(string2);
if (curdevice->emulatetype == 0)
continue;
}
if (curdevice->lpDIDevice)
{
// Free the default keyboard, etc.
IDirectInputDevice8_Unacquire(curdevice->lpDIDevice);
IDirectInputDevice8_Release(curdevice->lpDIDevice);
}
StringToGUID(tempstr, &guid);
// Ok, now that we've got the GUID of the device, let's set it up
if (FAILED(IDirectInput8_CreateDevice(lpDI8, &guid, &lpDIDevice[padindex],
NULL) ))
{
curdevice->lpDIDevice = NULL;
curdevice->emulatetype = 0;
continue;
}
curdevice->lpDIDevice = lpDIDevice[padindex];
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevice[padindex], &didc) ))
continue;
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIKeyboard) ))
continue;
curdevice->type = TYPE_KEYBOARD;
coopflags |= DISCL_NOWINKEY;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIJoystick2) ))
continue;
curdevice->type = TYPE_JOYSTICK;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIMouse2) ))
continue;
curdevice->type = TYPE_MOUSE;
coopflags = DISCL_FOREGROUND | DISCL_EXCLUSIVE;
}
hr = IDirectInputDevice8_SetCooperativeLevel(lpDIDevice[i], DXGetWindow(), coopflags);
if (FAILED(hr))
continue;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 8; // should be enough
// Setup Buffered input
if (FAILED(IDirectInputDevice8_SetProperty(lpDIDevice[padindex], DIPROP_BUFFERSIZE, &dipdw.diph)))
continue;
IDirectInputDevice8_Acquire(lpDIDevice[padindex]);
switch(curdevice->emulatetype)
{
case 1: // Standard Pad
id = PERPAD;
break;
case 2: // Analog Pad
case 3: // Stunner
case 5: // Keyboard
id = 0;
break;
case 4: // Mouse
id = PERMOUSE;
break;
default: break;
}
// Make sure we're added to the smpc list
if (i == 0)
pad[padindex] = PerAddPeripheral(&PORTDATA1, id);
else
pad[padindex] = PerAddPeripheral(&PORTDATA2, id);
// Now that we're all setup, let's fetch the controls from the ini
if (curdevice->emulatetype != 3 &&
curdevice->emulatetype != 4)
{
for (i2 = 0; i2 < 13; i2++)
{
buttonid = GetPrivateProfileIntA(string1, PerPadNames[i2], 0, inifilename);
PerSetKey(buttonid, i2, pad[padindex]);
}
}
else if (curdevice->emulatetype == 4)
{
for (i2 = 0; i2 < 4; i2++)
{
buttonid = GetPrivateProfileIntA(string1, mouse_names[i2], 0, inifilename);
PerSetKey(buttonid, PERMOUSE_LEFT+i2, pad[padindex]);
}
}
}
}
}
}
