static void initialize_disabled_joysticks_list(HWND hwnd)
{
static const WCHAR disabled_str[] = {'d','i','s','a','b','l','e','d','\0'};
HKEY hkey, appkey;
DWORD values = 0;
HRESULT hr;
DWORD i;
SendDlgItemMessageW(hwnd, IDC_DISABLEDLIST, LB_RESETCONTENT, 0, 0);
/* Search for disabled joysticks */
get_app_key(&hkey, &appkey);
RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &values, NULL, NULL, NULL, NULL);
for (i=0; i < values; i++)
{
DWORD name_len = MAX_PATH, data_len = MAX_PATH;
WCHAR buf_name[MAX_PATH + 9], buf_data[MAX_PATH];
hr = RegEnumValueW(hkey, i, buf_name, &name_len, NULL, NULL, (BYTE*) buf_data, &data_len);
if (SUCCEEDED(hr) && !lstrcmpW(disabled_str, buf_data))
SendDlgItemMessageW(hwnd, IDC_DISABLEDLIST, LB_ADDSTRING, 0, (LPARAM) buf_name);
}
if (hkey) RegCloseKey(hkey);
if (appkey) RegCloseKey(appkey);
}
/***************************************************************************
* get_load_order (internal)
*
* Return the loadorder of a module.
* The system directory and '.dll' extension is stripped from the path.
*/
enum loadorder get_load_order( const WCHAR *app_name, const WCHAR *path )
{
enum loadorder ret = LO_INVALID;
HANDLE std_key, app_key = 0;
WCHAR *module, *basename;
UNICODE_STRING path_str;
int len;
if (!init_done) init_load_order();
std_key = get_standard_key();
if (app_name) app_key = get_app_key( app_name );
TRACE("looking for %s\n", debugstr_w(path));
/* Strip path information if the module resides in the system directory
*/
RtlInitUnicodeString( &path_str, path );
if (RtlPrefixUnicodeString( &system_dir, &path_str, TRUE ))
{
const WCHAR *p = path + system_dir.Length / sizeof(WCHAR);
while (*p == '\\' || *p == '/') p++;
if (!strchrW( p, '\\' ) && !strchrW( p, '/' )) path = p;
}
if (!(len = strlenW(path))) return ret;
if (!(module = RtlAllocateHeap( GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR) ))) return ret;
strcpyW( module+1, path ); /* reserve module[0] for the wildcard char */
basename = (WCHAR *)get_basename( module+1 );
if (len >= 4) remove_dll_ext( module + 1 + len - 4 );
/* first explicit module name */
if ((ret = get_load_order_value( std_key, app_key, module+1 )) != LO_INVALID)
goto done;
/* then module basename preceded by '*' */
basename[-1] = '*';
if ((ret = get_load_order_value( std_key, app_key, basename-1 )) != LO_INVALID)
goto done;
/* then module basename without '*' (only if explicit path) */
if (basename != module+1 && ((ret = get_load_order_value( std_key, app_key, basename )) != LO_INVALID))
goto done;
/* if loading the main exe with an explicit path, try native first */
if (!app_name && basename != module+1)
{
ret = LO_NATIVE_BUILTIN;
TRACE( "got main exe default %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) );
goto done;
}
/* and last the hard-coded default */
ret = LO_DEFAULT;
TRACE( "got hardcoded %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) );
done:
RtlFreeHeap( GetProcessHeap(), 0, module );
return ret;
}
static SysMouseImpl *alloc_device(REFGUID rguid, IDirectInputImpl *dinput)
{
SysMouseImpl* newDevice;
LPDIDATAFORMAT df = NULL;
unsigned i;
char buffer[20];
HKEY hkey, appkey;
newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysMouseImpl));
if (!newDevice) return NULL;
newDevice->base.IDirectInputDevice8A_iface.lpVtbl = &SysMouseAvt;
newDevice->base.IDirectInputDevice8W_iface.lpVtbl = &SysMouseWvt;
newDevice->base.ref = 1;
newDevice->base.dwCoopLevel = DISCL_NONEXCLUSIVE | DISCL_BACKGROUND;
newDevice->base.guid = *rguid;
InitializeCriticalSection(&newDevice->base.crit);
newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SysMouseImpl*->base.crit");
newDevice->base.dinput = dinput;
newDevice->base.event_proc = dinput_mouse_hook;
get_app_key(&hkey, &appkey);
if (!get_config_key(hkey, appkey, "MouseWarpOverride", buffer, sizeof(buffer)))
{
if (!strcasecmp(buffer, "disable"))
newDevice->warp_override = WARP_DISABLE;
else if (!strcasecmp(buffer, "force"))
newDevice->warp_override = WARP_FORCE_ON;
}
if (appkey) RegCloseKey(appkey);
if (hkey) RegCloseKey(hkey);
/* Create copy of default data format */
if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIMouse2.dwSize))) goto failed;
memcpy(df, &c_dfDIMouse2, c_dfDIMouse2.dwSize);
if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed;
memcpy(df->rgodf, c_dfDIMouse2.rgodf, df->dwNumObjs * df->dwObjSize);
/* Because we don't do any detection yet just modify instance and type */
for (i = 0; i < df->dwNumObjs; i++)
if (DIDFT_GETTYPE(df->rgodf[i].dwType) & DIDFT_AXIS)
df->rgodf[i].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_RELAXIS;
else
df->rgodf[i].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
newDevice->base.data_format.wine_df = df;
IDirectInput_AddRef(&newDevice->base.dinput->IDirectInput7A_iface);
EnterCriticalSection(&dinput->crit);
list_add_tail(&dinput->devices_list, &newDevice->base.entry);
LeaveCriticalSection(&dinput->crit);
return newDevice;
failed:
if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
HeapFree(GetProcessHeap(), 0, df);
HeapFree(GetProcessHeap(), 0, newDevice);
return NULL;
}
/******************************************************************************
* enable_joystick [internal]
* Writes to the DirectInput registry key that enables/disables a joystick
* from being enumerated.
*/
static void enable_joystick(WCHAR *joy_name, BOOL enable)
{
static const WCHAR disabled_str[] = {'d','i','s','a','b','l','e','d','\0'};
HKEY hkey, appkey;
get_app_key(&hkey, &appkey);
if (!enable)
set_config_key(hkey, appkey, joy_name, disabled_str, lstrlenW(disabled_str));
else
set_config_key(hkey, appkey, joy_name, NULL, 0);
if (hkey) RegCloseKey(hkey);
if (appkey) RegCloseKey(appkey);
}
static void inbox_received_handler(DictionaryIterator *iter, void *context) {
Tuple *reply_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyReply));
if(reply_tuple) {
Tuple *desc_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyDescription));
strncpy(s_info->description, desc_tuple->value->cstring, OWM_WEATHER_BUFFER_SIZE);
Tuple *desc_short_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyDescriptionShort));
strncpy(s_info->description_short, desc_short_tuple->value->cstring, OWM_WEATHER_BUFFER_SIZE);
Tuple *temp_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyTempK));
s_info->temp_k = temp_tuple->value->int32;
s_info->temp_c = s_info->temp_k - 273;
s_info->temp_f = ((s_info->temp_c * 9) / 5 /* *1.8 or 9/5 */) + 32;
s_info->timestamp = time(NULL);
Tuple *pressure_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyPressure));
s_info->pressure = pressure_tuple->value->int32;
Tuple *wind_speed_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyWindSpeed));
s_info->wind_speed = wind_speed_tuple->value->int32;
Tuple *wind_direction_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyWindDirection));
s_info->wind_direction = wind_direction_tuple->value->int32;
s_status = OWMWeatherStatusAvailable;
app_message_deregister_callbacks();
s_callback(s_info, s_status);
}
Tuple *err_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyBadKey));
if(err_tuple) {
s_status = OWMWeatherStatusBadKey;
s_callback(s_info, s_status);
}
err_tuple = dict_find(iter, get_app_key(OWMWeatherAppMessageKeyLocationUnavailable));
if(err_tuple) {
s_status = OWMWeatherStatusLocationUnavailable;
s_callback(s_info, s_status);
}
}
static bool fetch() {
DictionaryIterator *out;
AppMessageResult result = app_message_outbox_begin(&out);
if(result != APP_MSG_OK) {
fail_and_callback();
return false;
}
dict_write_cstring(out, get_app_key(OWMWeatherAppMessageKeyRequest), s_api_key);
result = app_message_outbox_send();
if(result != APP_MSG_OK) {
fail_and_callback();
return false;
}
s_status = OWMWeatherStatusPending;
s_callback(s_info, s_status);
return true;
}
HRESULT setup_dinput_options(JoystickGenericImpl *This, const int *default_axis_map)
{
char buffer[MAX_PATH+16];
HKEY hkey, appkey;
int tokens = 0;
int axis = 0;
int pov = 0;
get_app_key(&hkey, &appkey);
/* get options */
if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, sizeof(buffer)))
{
This->deadzone = atoi(buffer);
TRACE("setting default deadzone to: \"%s\" %d\n", buffer, This->deadzone);
}
This->axis_map = HeapAlloc(GetProcessHeap(), 0, This->device_axis_count * sizeof(int));
if (!This->axis_map) return DIERR_OUTOFMEMORY;
if (!get_config_key(hkey, appkey, This->name, buffer, sizeof(buffer)))
{
static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
"Slider1", "Slider2",
"POV1", "POV2", "POV3", "POV4"};
const char *delim = ",";
char * ptr;
TRACE("\"%s\" = \"%s\"\n", This->name, buffer);
if ((ptr = strtok(buffer, delim)) != NULL)
{
do
{
int i;
for (i = 0; i < sizeof(axis_names) / sizeof(axis_names[0]); i++)
{
if (!strcmp(ptr, axis_names[i]))
{
if (!strncmp(ptr, "POV", 3))
{
if (pov >= 4)
{
WARN("Only 4 POVs supported - ignoring extra\n");
i = -1;
}
else
{
/* Pov takes two axes */
This->axis_map[tokens++] = i;
pov++;
}
}
else
{
if (axis >= 8)
{
FIXME("Only 8 Axes supported - ignoring extra\n");
i = -1;
}
else
axis++;
}
break;
}
}
if (i == sizeof(axis_names) / sizeof(axis_names[0]))
{
ERR("invalid joystick axis type: \"%s\"\n", ptr);
i = -1;
}
This->axis_map[tokens] = i;
tokens++;
} while ((ptr = strtok(NULL, delim)) != NULL);
if (tokens != This->device_axis_count)
{
ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n",
This->device_axis_count, axis, pov, tokens);
while (tokens < This->device_axis_count)
{
This->axis_map[tokens] = -1;
tokens++;
}
}
}
}
else
{
int i;
if (default_axis_map)
{
/* Use default mapping from the driver */
for (i = 0; i < This->device_axis_count; i++)
{
This->axis_map[i] = default_axis_map[i];
tokens = default_axis_map[i];
if (tokens < 0)
continue;
if (tokens < 8)
axis++;
else if (tokens < 15)
{
i++;
pov++;
This->axis_map[i] = default_axis_map[i];
}
}
}
else
{
/* No config - set default mapping. */
for (i = 0; i < This->device_axis_count; i++)
{
if (i < 8)
This->axis_map[i] = axis++;
else if (i < 15)
{
This->axis_map[i++] = 8 + pov;
This->axis_map[i ] = 8 + pov++;
}
else
This->axis_map[i] = -1;
}
}
}
This->devcaps.dwAxes = axis;
This->devcaps.dwPOVs = pov;
if (appkey) RegCloseKey(appkey);
if (hkey) RegCloseKey(hkey);
return DI_OK;
}
static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, unsigned short index)
{
JoystickImpl* newDevice;
LPDIDATAFORMAT df = NULL;
int i, idx = 0;
char buffer[MAX_PATH+16];
HKEY hkey, appkey;
LONG def_deadzone = 0;
newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl));
if (!newDevice) return NULL;
newDevice->base.lpVtbl = jvt;
newDevice->base.ref = 1;
newDevice->base.guid = *rguid;
newDevice->base.dinput = dinput;
newDevice->joyfd = -1;
newDevice->joydev = &joydevs[index];
#ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
newDevice->ff_state = FF_STATUS_STOPPED;
#endif
InitializeCriticalSection(&newDevice->base.crit);
newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
/* get options */
get_app_key(&hkey, &appkey);
if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH))
{
def_deadzone = atoi(buffer);
TRACE("setting default deadzone to: %d\n", def_deadzone);
}
if (appkey) RegCloseKey(appkey);
if (hkey) RegCloseKey(hkey);
/* Create copy of default data format */
if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto failed;
memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed;
/* Supported Axis & POVs should map 1-to-1 */
for (i = 0; i < WINE_JOYSTICK_MAX_AXES; i++)
{
if (!test_bit(newDevice->joydev->absbits, i)) {
newDevice->axes[i] = -1;
continue;
}
memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize);
newDevice->axes[i] = idx;
newDevice->props[idx].lDevMin = newDevice->joydev->axes[i].minimum;
newDevice->props[idx].lDevMax = newDevice->joydev->axes[i].maximum;
newDevice->props[idx].lMin = 0;
newDevice->props[idx].lMax = 0xffff;
newDevice->props[idx].lSaturation = 0;
newDevice->props[idx].lDeadZone = def_deadzone;
df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numAxes++) | DIDFT_ABSAXIS;
}
for (i = 0; i < WINE_JOYSTICK_MAX_POVS; i++)
{
if (!test_bit(newDevice->joydev->absbits, ABS_HAT0X + i * 2) ||
!test_bit(newDevice->joydev->absbits, ABS_HAT0Y + i * 2)) {
newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = -1;
continue;
}
memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + WINE_JOYSTICK_MAX_AXES], df->dwObjSize);
newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = i;
df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numPOVs++) | DIDFT_POV;
}
/* Buttons can be anywhere, so check all */
for (i = 0; i < KEY_MAX && newDevice->numButtons < WINE_JOYSTICK_MAX_BUTTONS; i++)
{
if (!test_bit(newDevice->joydev->keybits, i)) continue;
memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[newDevice->numButtons + WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS], df->dwObjSize);
newDevice->buttons[i] = 0x80 | newDevice->numButtons;
df->rgodf[idx ].pguid = &GUID_Button;
df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numButtons++) | DIDFT_PSHBUTTON;
}
df->dwNumObjs = idx;
fake_current_js_state(newDevice);
newDevice->base.data_format.wine_df = df;
IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
return newDevice;
failed:
if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
HeapFree(GetProcessHeap(), 0, df);
HeapFree(GetProcessHeap(), 0, newDevice);
return NULL;
}
static HRESULT setup_dinput_options(JoystickImpl * device)
{
char buffer[MAX_PATH+16];
HKEY hkey, appkey;
int tokens = 0;
int axis = 0;
int pov = 0;
buffer[MAX_PATH]='\0';
get_app_key(&hkey, &appkey);
/* get options */
if (!get_config_key( hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH )) {
device->deadzone = atoi(buffer);
TRACE("setting default deadzone to: \"%s\" %d\n", buffer, device->deadzone);
}
device->axis_map = HeapAlloc(GetProcessHeap(), 0, device->axes * sizeof(int));
if (!device->axis_map) return DIERR_OUTOFMEMORY;
if (!get_config_key( hkey, appkey, device->name, buffer, MAX_PATH )) {
static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
"Slider1", "Slider2",
"POV1", "POV2", "POV3", "POV4"};
const char *delim = ",";
char * ptr;
TRACE("\"%s\" = \"%s\"\n", device->name, buffer);
if ((ptr = strtok(buffer, delim)) != NULL) {
do {
int i;
for (i = 0; i < sizeof(axis_names) / sizeof(axis_names[0]); i++)
if (!strcmp(ptr, axis_names[i]))
{
if (!strncmp(ptr, "POV", 3))
{
if (pov >= 4)
{
WARN("Only 4 POVs supported - ignoring extra\n");
i = -1;
}
else
{
/* Pov takes two axes */
device->axis_map[tokens++] = i;
pov++;
}
}
else
{
if (axis >= 8)
{
FIXME("Only 8 Axes supported - ignoring extra\n");
i = -1;
}
else
axis++;
}
break;
}
if (i == sizeof(axis_names) / sizeof(axis_names[0]))
{
ERR("invalid joystick axis type: \"%s\"\n", ptr);
i = -1;
}
device->axis_map[tokens] = i;
tokens++;
} while ((ptr = strtok(NULL, delim)) != NULL);
if (tokens != device->axes) {
ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n", device->axes, axis, pov,tokens);
while (tokens < device->axes) {
device->axis_map[tokens] = -1;
tokens++;
}
}
}
}
else
{
for (tokens = 0; tokens < device->axes; tokens++)
{
if (tokens < 8)
device->axis_map[tokens] = axis++;
else if (tokens < 16)
{
device->axis_map[tokens++] = 8 + pov;
device->axis_map[tokens ] = 8 + pov++;
}
else
device->axis_map[tokens] = -1;
}
}
device->devcaps.dwAxes = axis;
device->devcaps.dwPOVs = pov;
if (appkey)
RegCloseKey( appkey );
if (hkey)
RegCloseKey( hkey );
return DI_OK;
}
