dlls/dinput/ansi.c

   1 /*
   2  * Direct Input ANSI interface wrappers
   3  *
   4  * Copyright 2021 Rémi Bernon for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winreg.h"
  27 #include "winuser.h"
  28 #include "winerror.h"
  29 #include "dinput.h"
  30
  31 #include "device_private.h"
  32 #include "dinput_private.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  37
  38 static struct dinput_device *impl_from_IDirectInputDevice8A( IDirectInputDevice8A *iface )
  39 {
  40     return CONTAINING_RECORD( iface, struct dinput_device, IDirectInputDevice8A_iface );
  41 }
  42
  43 static IDirectInputDevice8W *IDirectInputDevice8W_from_impl( struct dinput_device *impl )
  44 {
  45     return &impl->IDirectInputDevice8W_iface;
  46 }
  47
  48 static inline IDirectInputDevice8A *IDirectInputDevice8A_from_IDirectInputDevice8W( IDirectInputDevice8W *iface )
  49 {
  50     if (!iface) return NULL;
  51     return &CONTAINING_RECORD( iface, struct dinput_device, IDirectInputDevice8W_iface )->IDirectInputDevice8A_iface;
  52 }
  53
  54 static inline IDirectInputDeviceA *IDirectInputDeviceA_from_IDirectInputDeviceW( IDirectInputDeviceW *iface )
  55 {
  56     return (IDirectInputDeviceA *)IDirectInputDevice8A_from_IDirectInputDevice8W( (IDirectInputDevice8W *)iface );
  57 }
  58
  59 static struct dinput *impl_from_IDirectInput7A( IDirectInput7A *iface )
  60 {
  61     return CONTAINING_RECORD( iface, struct dinput, IDirectInput7A_iface );
  62 }
  63
  64 static IDirectInput7W *IDirectInput7W_from_impl( struct dinput *impl )
  65 {
  66     return &impl->IDirectInput7W_iface;
  67 }
  68
  69 static struct dinput *impl_from_IDirectInput8A( IDirectInput8A *iface )
  70 {
  71     return CONTAINING_RECORD( iface, struct dinput, IDirectInput8A_iface );
  72 }
  73
  74 static IDirectInput8W *IDirectInput8W_from_impl( struct dinput *impl )
  75 {
  76     return &impl->IDirectInput8W_iface;
  77 }
  78
  79 static void dideviceobjectinstance_wtoa( const DIDEVICEOBJECTINSTANCEW *in, DIDEVICEOBJECTINSTANCEA *out )
  80 {
  81     out->guidType = in->guidType;
  82     out->dwOfs = in->dwOfs;
  83     out->dwType = in->dwType;
  84     out->dwFlags = in->dwFlags;
  85     WideCharToMultiByte( CP_ACP, 0, in->tszName, -1, out->tszName, sizeof(out->tszName), NULL, NULL );
  86
  87     if (out->dwSize <= FIELD_OFFSET( DIDEVICEOBJECTINSTANCEA, dwFFMaxForce )) return;
  88
  89     out->dwFFMaxForce = in->dwFFMaxForce;
  90     out->dwFFForceResolution = in->dwFFForceResolution;
  91     out->wCollectionNumber = in->wCollectionNumber;
  92     out->wDesignatorIndex = in->wDesignatorIndex;
  93     out->wUsagePage = in->wUsagePage;
  94     out->wUsage = in->wUsage;
  95     out->dwDimension = in->dwDimension;
  96     out->wExponent = in->wExponent;
  97     out->wReportId = in->wReportId;
  98 }
  99
 100 static void dideviceinstance_wtoa( const DIDEVICEINSTANCEW *in, DIDEVICEINSTANCEA *out )
 101 {
 102     out->guidInstance = in->guidInstance;
 103     out->guidProduct = in->guidProduct;
 104     out->dwDevType = in->dwDevType;
 105     WideCharToMultiByte( CP_ACP, 0, in->tszInstanceName, -1, out->tszInstanceName,
 106                          sizeof(out->tszInstanceName), NULL, NULL );
 107     WideCharToMultiByte( CP_ACP, 0, in->tszProductName, -1, out->tszProductName,
 108                          sizeof(out->tszProductName), NULL, NULL );
 109
 110     if (out->dwSize <= FIELD_OFFSET( DIDEVICEINSTANCEA, guidFFDriver )) return;
 111
 112     out->guidFFDriver = in->guidFFDriver;
 113     out->wUsagePage = in->wUsagePage;
 114     out->wUsage = in->wUsage;
 115 }
 116
 117 static void dieffectinfo_wtoa( const DIEFFECTINFOW *in, DIEFFECTINFOA *out )
 118 {
 119     out->guid = in->guid;
 120     out->dwEffType = in->dwEffType;
 121     out->dwStaticParams = in->dwStaticParams;
 122     out->dwDynamicParams = in->dwDynamicParams;
 123     WideCharToMultiByte( CP_ACP, 0, in->tszName, -1, out->tszName, sizeof(out->tszName), NULL, NULL );
 124 }
 125
 126 static HRESULT string_atow( const char *in, WCHAR **out )
 127 {
 128     int len;
 129
 130     *out = NULL;
 131     if (!in) return DI_OK;
 132
 133     len = MultiByteToWideChar( CP_ACP, 0, in, -1, NULL, 0 );
 134     if (!(*out = malloc( len * sizeof(WCHAR) ))) return DIERR_OUTOFMEMORY;
 135
 136     MultiByteToWideChar( CP_ACP, 0, in, -1, *out, len );
 137     return DI_OK;
 138 }
 139
 140 static void diactionformat_wtoa( const DIACTIONFORMATW *in, DIACTIONFORMATA *out )
 141 {
 142     DWORD i;
 143
 144     out->dwDataSize = in->dwDataSize;
 145     out->dwNumActions = in->dwNumActions;
 146
 147     for (i = 0; i < in->dwNumActions; ++i)
 148     {
 149         out->rgoAction[i].uAppData = in->rgoAction[i].uAppData;
 150         out->rgoAction[i].dwSemantic = in->rgoAction[i].dwSemantic;
 151         out->rgoAction[i].dwFlags = in->rgoAction[i].dwFlags;
 152         out->rgoAction[i].guidInstance = in->rgoAction[i].guidInstance;
 153         out->rgoAction[i].dwObjID = in->rgoAction[i].dwObjID;
 154         out->rgoAction[i].dwHow = in->rgoAction[i].dwHow;
 155     }
 156
 157     out->guidActionMap = in->guidActionMap;
 158     out->dwGenre = in->dwGenre;
 159     out->dwBufferSize = in->dwBufferSize;
 160     out->lAxisMin = in->lAxisMin;
 161     out->lAxisMax = in->lAxisMax;
 162     out->hInstString = in->hInstString;
 163     out->ftTimeStamp = in->ftTimeStamp;
 164     out->dwCRC = in->dwCRC;
 165
 166     WideCharToMultiByte( CP_ACP, 0, in->tszActionMap, -1, out->tszActionMap,
 167                          sizeof(out->tszActionMap), NULL, NULL );
 168 }
 169
 170 static HRESULT diactionformat_atow( const DIACTIONFORMATA *in, DIACTIONFORMATW *out, BOOL convert_names )
 171 {
 172     HRESULT hr = DI_OK;
 173     DWORD i;
 174
 175     out->dwDataSize = in->dwDataSize;
 176     out->dwNumActions = in->dwNumActions;
 177
 178     for (i = 0; i < out->dwNumActions && SUCCEEDED(hr); ++i)
 179     {
 180         out->rgoAction[i].uAppData = in->rgoAction[i].uAppData;
 181         out->rgoAction[i].dwSemantic = in->rgoAction[i].dwSemantic;
 182         out->rgoAction[i].dwFlags = in->rgoAction[i].dwFlags;
 183         out->rgoAction[i].guidInstance = in->rgoAction[i].guidInstance;
 184         out->rgoAction[i].dwObjID = in->rgoAction[i].dwObjID;
 185         out->rgoAction[i].dwHow = in->rgoAction[i].dwHow;
 186         if (!convert_names) out->rgoAction[i].lptszActionName = 0;
 187         else if (in->hInstString) out->rgoAction[i].uResIdString = in->rgoAction[i].uResIdString;
 188         else hr = string_atow( in->rgoAction[i].lptszActionName, (WCHAR **)&out->rgoAction[i].lptszActionName );
 189     }
 190
 191     for (; i < out->dwNumActions; ++i) out->rgoAction[i].lptszActionName = 0;
 192
 193     out->guidActionMap = in->guidActionMap;
 194     out->dwGenre = in->dwGenre;
 195     out->dwBufferSize = in->dwBufferSize;
 196     out->lAxisMin = in->lAxisMin;
 197     out->lAxisMax = in->lAxisMax;
 198     out->hInstString = in->hInstString;
 199     out->ftTimeStamp = in->ftTimeStamp;
 200     out->dwCRC = in->dwCRC;
 201
 202     MultiByteToWideChar( CP_ACP, 0, in->tszActionMap, -1, out->tszActionMap,
 203                          sizeof(out->tszActionMap) / sizeof(WCHAR) );
 204
 205     return hr;
 206 }
 207
 208 static void dideviceimageinfo_wtoa( const DIDEVICEIMAGEINFOW *in, DIDEVICEIMAGEINFOA *out )
 209 {
 210     WideCharToMultiByte( CP_ACP, 0, in->tszImagePath, -1, out->tszImagePath,
 211                          sizeof(out->tszImagePath), NULL, NULL );
 212
 213     out->dwFlags = in->dwFlags;
 214     out->dwViewID = in->dwViewID;
 215     out->rcOverlay = in->rcOverlay;
 216     out->dwObjID = in->dwObjID;
 217     out->dwcValidPts = in->dwcValidPts;
 218     out->rgptCalloutLine[0] = in->rgptCalloutLine[0];
 219     out->rgptCalloutLine[1] = in->rgptCalloutLine[1];
 220     out->rgptCalloutLine[2] = in->rgptCalloutLine[2];
 221     out->rgptCalloutLine[3] = in->rgptCalloutLine[3];
 222     out->rgptCalloutLine[4] = in->rgptCalloutLine[4];
 223     out->rcCalloutRect = in->rcCalloutRect;
 224     out->dwTextAlign = in->dwTextAlign;
 225 }
 226
 227 static void dideviceimageinfoheader_wtoa( const DIDEVICEIMAGEINFOHEADERW *in, DIDEVICEIMAGEINFOHEADERA *out )
 228 {
 229     DWORD i;
 230
 231     out->dwcViews = in->dwcViews;
 232     out->dwcButtons = in->dwcButtons;
 233     out->dwcAxes = in->dwcAxes;
 234     out->dwcPOVs = in->dwcPOVs;
 235     out->dwBufferUsed = 0;
 236
 237     for (i = 0; i < in->dwBufferUsed / sizeof(DIDEVICEIMAGEINFOW); ++i)
 238     {
 239         dideviceimageinfo_wtoa( &in->lprgImageInfoArray[i], &out->lprgImageInfoArray[i] );
 240         out->dwBufferUsed += sizeof(DIDEVICEIMAGEINFOA);
 241     }
 242 }
 243
 244 static HRESULT diconfiguredevicesparams_atow( const DICONFIGUREDEVICESPARAMSA *in, DICONFIGUREDEVICESPARAMSW *out )
 245 {
 246     const char *name_a = in->lptszUserNames;
 247     DWORD len_w, len_a;
 248
 249     if (!in->lptszUserNames) out->lptszUserNames = NULL;
 250     else
 251     {
 252         while (name_a[0] && name_a[1]) ++name_a;
 253         len_a = name_a - in->lptszUserNames + 1;
 254         len_w = MultiByteToWideChar( CP_ACP, 0, in->lptszUserNames, len_a, NULL, 0 );
 255
 256         out->lptszUserNames = calloc( len_w, sizeof(WCHAR) );
 257         if (!out->lptszUserNames) return DIERR_OUTOFMEMORY;
 258
 259         MultiByteToWideChar( CP_ACP, 0, in->lptszUserNames, len_a, out->lptszUserNames, len_w );
 260     }
 261
 262     out->dwcUsers = in->dwcUsers;
 263     out->dwcFormats = in->dwcFormats;
 264     out->hwnd = in->hwnd;
 265     out->dics = in->dics;
 266     out->lpUnkDDSTarget = in->lpUnkDDSTarget;
 267
 268     return DI_OK;
 269 }
 270
 271 static HRESULT WINAPI dinput_device_a_QueryInterface( IDirectInputDevice8A *iface_a, REFIID iid, void **out )
 272 {
 273     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 274     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 275     TRACE( "impl %p, iid %s, out %p.\n", impl, debugstr_guid( iid ), out );
 276     return IDirectInputDevice8_QueryInterface( iface_w, iid, out );
 277 }
 278
 279 static ULONG WINAPI dinput_device_a_AddRef( IDirectInputDevice8A *iface_a )
 280 {
 281     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 282     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 283     TRACE( "impl %p.\n", impl );
 284     return IDirectInputDevice8_AddRef( iface_w );
 285 }
 286
 287 static ULONG WINAPI dinput_device_a_Release( IDirectInputDevice8A *iface_a )
 288 {
 289     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 290     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 291     TRACE( "impl %p.\n", impl );
 292     return IDirectInputDevice8_Release( iface_w );
 293 }
 294
 295 static HRESULT WINAPI dinput_device_a_GetCapabilities( IDirectInputDevice8A *iface_a, DIDEVCAPS *caps )
 296 {
 297     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 298     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 299     TRACE( "impl %p, caps %p.\n", impl, caps );
 300     return IDirectInputDevice8_GetCapabilities( iface_w, caps );
 301 }
 302
 303 struct enum_objects_wtoa_params
 304 {
 305     LPDIENUMDEVICEOBJECTSCALLBACKA callback;
 306     void *ref;
 307 };
 308
 309 static BOOL CALLBACK enum_objects_wtoa_callback( const DIDEVICEOBJECTINSTANCEW *instance_w, void *ref )
 310 {
 311     struct enum_objects_wtoa_params *params = ref;
 312     DIDEVICEOBJECTINSTANCEA instance_a = {sizeof(instance_a)};
 313
 314     dideviceobjectinstance_wtoa( instance_w, &instance_a );
 315     return params->callback( &instance_a, params->ref );
 316 }
 317
 318 static HRESULT WINAPI dinput_device_a_EnumObjects( IDirectInputDevice8A *iface_a, LPDIENUMDEVICEOBJECTSCALLBACKA callback,
 319                                                    void *ref, DWORD flags )
 320 {
 321     struct enum_objects_wtoa_params params = {callback, ref};
 322     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 323     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 324
 325     TRACE( "impl %p, callback %p, ref %p, flags %#lx.\n", impl, callback, ref, flags );
 326
 327     if (!callback) return DIERR_INVALIDPARAM;
 328
 329     return IDirectInputDevice8_EnumObjects( iface_w, enum_objects_wtoa_callback, &params, flags );
 330 }
 331
 332 static HRESULT WINAPI dinput_device_a_GetProperty( IDirectInputDevice8A *iface_a, REFGUID guid, DIPROPHEADER *header )
 333 {
 334     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 335     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 336     TRACE( "impl %p, guid %s, header %p.\n", impl, debugstr_guid( guid ), header );
 337     return IDirectInputDevice8_GetProperty( iface_w, guid, header );
 338 }
 339
 340 static HRESULT WINAPI dinput_device_a_SetProperty( IDirectInputDevice8A *iface_a, REFGUID guid, const DIPROPHEADER *header )
 341 {
 342     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 343     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 344     TRACE( "impl %p, guid %s, header %p.\n", impl, debugstr_guid( guid ), header );
 345     return IDirectInputDevice8_SetProperty( iface_w, guid, header );
 346 }
 347
 348 static HRESULT WINAPI dinput_device_a_Acquire( IDirectInputDevice8A *iface_a )
 349 {
 350     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 351     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 352     TRACE( "impl %p.\n", impl );
 353     return IDirectInputDevice8_Acquire( iface_w );
 354 }
 355
 356 static HRESULT WINAPI dinput_device_a_Unacquire( IDirectInputDevice8A *iface_a )
 357 {
 358     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 359     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 360     TRACE( "impl %p.\n", impl );
 361     return IDirectInputDevice8_Unacquire( iface_w );
 362 }
 363
 364 static HRESULT WINAPI dinput_device_a_GetDeviceState( IDirectInputDevice8A *iface_a, DWORD count, void *data )
 365 {
 366     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 367     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 368     TRACE( "impl %p, count %#lx, data %p.\n", impl, count, data );
 369     return IDirectInputDevice8_GetDeviceState( iface_w, count, data );
 370 }
 371
 372 static HRESULT WINAPI dinput_device_a_GetDeviceData( IDirectInputDevice8A *iface_a, DWORD data_size, DIDEVICEOBJECTDATA *data,
 373                                                      DWORD *entries, DWORD flags )
 374 {
 375     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 376     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 377     TRACE( "impl %p, data_size %#lx, data %p, entries %p, flags %#lx.\n", impl, data_size, data, entries, flags );
 378     return IDirectInputDevice8_GetDeviceData( iface_w, data_size, data, entries, flags );
 379 }
 380
 381 static HRESULT WINAPI dinput_device_a_SetDataFormat( IDirectInputDevice8A *iface_a, const DIDATAFORMAT *format )
 382 {
 383     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 384     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 385     TRACE( "impl %p, format %p.\n", impl, format );
 386     return IDirectInputDevice8_SetDataFormat( iface_w, format );
 387 }
 388
 389 static HRESULT WINAPI dinput_device_a_SetEventNotification( IDirectInputDevice8A *iface_a, HANDLE event )
 390 {
 391     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 392     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 393     TRACE( "impl %p, event %p.\n", impl, event );
 394     return IDirectInputDevice8_SetEventNotification( iface_w, event );
 395 }
 396
 397 static HRESULT WINAPI dinput_device_a_SetCooperativeLevel( IDirectInputDevice8A *iface_a, HWND window, DWORD flags )
 398 {
 399     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 400     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 401     TRACE( "impl %p, window %p, flags %#lx.\n", impl, window, flags );
 402     return IDirectInputDevice8_SetCooperativeLevel( iface_w, window, flags );
 403 }
 404
 405 static HRESULT WINAPI dinput_device_a_GetObjectInfo( IDirectInputDevice8A *iface_a, DIDEVICEOBJECTINSTANCEA *instance_a,
 406                                                      DWORD obj, DWORD how )
 407 {
 408     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 409     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 410     DIDEVICEOBJECTINSTANCEW instance_w = {sizeof(instance_w)};
 411     HRESULT hr;
 412
 413     TRACE( "impl %p, instance_a %p, obj %#lx, how %#lx.\n", impl, instance_a, obj, how );
 414
 415     if (!instance_a) return E_POINTER;
 416     if (instance_a->dwSize != sizeof(DIDEVICEOBJECTINSTANCEA) &&
 417         instance_a->dwSize != sizeof(DIDEVICEOBJECTINSTANCE_DX3A))
 418         return DIERR_INVALIDPARAM;
 419
 420     hr = IDirectInputDevice8_GetObjectInfo( iface_w, &instance_w, obj, how );
 421     dideviceobjectinstance_wtoa( &instance_w, instance_a );
 422
 423     return hr;
 424 }
 425
 426 static HRESULT WINAPI dinput_device_a_GetDeviceInfo( IDirectInputDevice8A *iface_a, DIDEVICEINSTANCEA *instance_a )
 427 {
 428     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 429     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 430     DIDEVICEINSTANCEW instance_w = {sizeof(instance_w)};
 431     HRESULT hr;
 432
 433     TRACE( "impl %p, instance_a %p.\n", impl, instance_a );
 434
 435     if (!instance_a) return E_POINTER;
 436     if (instance_a->dwSize != sizeof(DIDEVICEINSTANCEA) && instance_a->dwSize != sizeof(DIDEVICEINSTANCE_DX3A))
 437         return DIERR_INVALIDPARAM;
 438
 439     hr = IDirectInputDevice8_GetDeviceInfo( iface_w, &instance_w );
 440     dideviceinstance_wtoa( &instance_w, instance_a );
 441
 442     return hr;
 443 }
 444
 445 static HRESULT WINAPI dinput_device_a_RunControlPanel( IDirectInputDevice8A *iface_a, HWND owner, DWORD flags )
 446 {
 447     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 448     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 449     TRACE( "impl %p, owner %p, flags %#lx.\n", impl, owner, flags );
 450     return IDirectInputDevice8_RunControlPanel( iface_w, owner, flags );
 451 }
 452
 453 static HRESULT WINAPI dinput_device_a_Initialize( IDirectInputDevice8A *iface_a, HINSTANCE instance, DWORD version, REFGUID guid )
 454 {
 455     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 456     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 457     TRACE( "impl %p, instance %p, version %#lx, guid %s.\n", impl, instance, version, debugstr_guid( guid ) );
 458     return IDirectInputDevice8_Initialize( iface_w, instance, version, guid );
 459 }
 460
 461 static HRESULT WINAPI dinput_device_a_CreateEffect( IDirectInputDevice8A *iface_a, REFGUID guid, const DIEFFECT *effect,
 462                                                     IDirectInputEffect **out, IUnknown *outer )
 463 {
 464     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 465     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 466     TRACE( "impl %p, guid %s, effect %p, out %p, outer %p.\n", impl, debugstr_guid( guid ), effect, out, outer );
 467     return IDirectInputDevice8_CreateEffect( iface_w, guid, effect, out, outer );
 468 }
 469
 470 struct enum_effects_wtoa_params
 471 {
 472     LPDIENUMEFFECTSCALLBACKA callback;
 473     void *ref;
 474 };
 475
 476 static BOOL CALLBACK enum_effects_wtoa_callback( const DIEFFECTINFOW *info_w, void *ref )
 477 {
 478     struct enum_effects_wtoa_params *params = ref;
 479     DIEFFECTINFOA info_a = {sizeof(info_a)};
 480
 481     dieffectinfo_wtoa( info_w, &info_a );
 482     return params->callback( &info_a, params->ref );
 483 }
 484
 485 static HRESULT WINAPI dinput_device_a_EnumEffects( IDirectInputDevice8A *iface_a, LPDIENUMEFFECTSCALLBACKA callback,
 486                                                    void *ref, DWORD type )
 487 {
 488     struct enum_effects_wtoa_params params = {callback, ref};
 489     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 490     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 491
 492     TRACE( "impl %p, callback %p, ref %p, type %#lx.\n", impl, callback, ref, type );
 493
 494     if (!callback) return DIERR_INVALIDPARAM;
 495
 496     return IDirectInputDevice8_EnumEffects( iface_w, enum_effects_wtoa_callback, &params, type );
 497 }
 498
 499 static HRESULT WINAPI dinput_device_a_GetEffectInfo( IDirectInputDevice8A *iface_a, DIEFFECTINFOA *info_a, REFGUID guid )
 500 {
 501     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 502     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 503     DIEFFECTINFOW info_w = {sizeof(info_w)};
 504     HRESULT hr;
 505
 506     TRACE( "impl %p, info_a %p, guid %s.\n", impl, info_a, debugstr_guid( guid ) );
 507
 508     if (!info_a) return E_POINTER;
 509     if (info_a->dwSize != sizeof(DIEFFECTINFOA)) return DIERR_INVALIDPARAM;
 510
 511     hr = IDirectInputDevice8_GetEffectInfo( iface_w, &info_w, guid );
 512     dieffectinfo_wtoa( &info_w, info_a );
 513
 514     return hr;
 515 }
 516
 517 static HRESULT WINAPI dinput_device_a_GetForceFeedbackState( IDirectInputDevice8A *iface_a, DWORD *state )
 518 {
 519     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 520     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 521     TRACE( "impl %p, state %p.\n", impl, state );
 522     return IDirectInputDevice8_GetForceFeedbackState( iface_w, state );
 523 }
 524
 525 static HRESULT WINAPI dinput_device_a_SendForceFeedbackCommand( IDirectInputDevice8A *iface_a, DWORD flags )
 526 {
 527     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 528     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 529     TRACE( "impl %p, flags %#lx.\n", impl, flags );
 530     return IDirectInputDevice8_SendForceFeedbackCommand( iface_w, flags );
 531 }
 532
 533 static HRESULT WINAPI dinput_device_a_EnumCreatedEffectObjects( IDirectInputDevice8A *iface_a, LPDIENUMCREATEDEFFECTOBJECTSCALLBACK callback,
 534                                                                 void *ref, DWORD flags )
 535 {
 536     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 537     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 538     TRACE( "impl %p, callback %p, ref %p, flags %#lx.\n", impl, callback, ref, flags );
 539     return IDirectInputDevice8_EnumCreatedEffectObjects( iface_w, callback, ref, flags );
 540 }
 541
 542 static HRESULT WINAPI dinput_device_a_Escape( IDirectInputDevice8A *iface_a, DIEFFESCAPE *escape )
 543 {
 544     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 545     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 546     TRACE( "impl %p, escape %p.\n", impl, escape );
 547     return IDirectInputDevice8_Escape( iface_w, escape );
 548 }
 549
 550 static HRESULT WINAPI dinput_device_a_Poll( IDirectInputDevice8A *iface_a )
 551 {
 552     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 553     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 554     TRACE( "impl %p.\n", impl );
 555     return IDirectInputDevice8_Poll( iface_w );
 556 }
 557
 558 static HRESULT WINAPI dinput_device_a_SendDeviceData( IDirectInputDevice8A *iface_a, DWORD count, const DIDEVICEOBJECTDATA *data,
 559                                                       DWORD *inout, DWORD flags )
 560 {
 561     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 562     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 563     TRACE( "impl %p, count %#lx, data %p, inout %p, flags %#lx.\n", impl, count, data, inout, flags );
 564     return IDirectInputDevice8_SendDeviceData( iface_w, count, data, inout, flags );
 565 }
 566
 567 static HRESULT WINAPI dinput_device_a_EnumEffectsInFile( IDirectInputDevice8A *iface_a, const char *filename_a, LPDIENUMEFFECTSINFILECALLBACK callback,
 568                                                          void *ref, DWORD flags )
 569 {
 570     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 571     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 572     WCHAR buffer[MAX_PATH], *filename_w = buffer;
 573
 574     TRACE( "impl %p, filename_a %s, callback %p, ref %p, flags %#lx.\n", impl,
 575            debugstr_a(filename_a), callback, ref, flags );
 576
 577     if (!filename_a) filename_w = NULL;
 578     else MultiByteToWideChar( CP_ACP, 0, filename_a, -1, buffer, MAX_PATH );
 579
 580     return IDirectInputDevice8_EnumEffectsInFile( iface_w, filename_w, callback, ref, flags );
 581 }
 582
 583 static HRESULT WINAPI dinput_device_a_WriteEffectToFile( IDirectInputDevice8A *iface_a, const char *filename_a, DWORD entries,
 584                                                          DIFILEEFFECT *file_effect, DWORD flags )
 585 {
 586     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 587     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 588     WCHAR buffer[MAX_PATH], *filename_w = buffer;
 589
 590     TRACE( "impl %p, filename_a %s, entries %#lx, file_effect %p, flags %#lx.\n", impl,
 591            debugstr_a(filename_a), entries, file_effect, flags );
 592
 593     if (!filename_a) filename_w = NULL;
 594     else MultiByteToWideChar( CP_ACP, 0, filename_a, -1, buffer, MAX_PATH );
 595
 596     return IDirectInputDevice8_WriteEffectToFile( iface_w, filename_w, entries, file_effect, flags );
 597 }
 598
 599 static HRESULT WINAPI dinput_device_a_BuildActionMap( IDirectInputDevice8A *iface_a, DIACTIONFORMATA *format_a,
 600                                                       const char *username_a, DWORD flags )
 601 {
 602     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 603     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 604     DIACTIONFORMATW format_w = {sizeof(format_w), sizeof(DIACTIONW)};
 605     HRESULT hr;
 606     WCHAR *username_w;
 607
 608     TRACE( "impl %p, format_a %p, username_a %s, flags %#lx.\n", impl, format_a, debugstr_a(username_a), flags );
 609
 610     if (!format_a) return E_POINTER;
 611     if (format_a->dwSize != sizeof(DIACTIONFORMATA)) return DIERR_INVALIDPARAM;
 612     if (format_a->dwActionSize != sizeof(DIACTIONA)) return DIERR_INVALIDPARAM;
 613     if (FAILED(hr = string_atow( username_a, &username_w ))) return hr;
 614
 615     format_w.dwNumActions = format_a->dwNumActions;
 616     format_w.rgoAction = calloc( format_a->dwNumActions, sizeof(DIACTIONW) );
 617     if (!format_w.rgoAction) hr = DIERR_OUTOFMEMORY;
 618     else
 619     {
 620         diactionformat_atow( format_a, &format_w, FALSE );
 621         hr = IDirectInputDevice8_BuildActionMap( iface_w, &format_w, username_w, flags );
 622         diactionformat_wtoa( &format_w, format_a );
 623         free( format_w.rgoAction );
 624     }
 625
 626     free( username_w );
 627     return hr;
 628 }
 629
 630 static HRESULT WINAPI dinput_device_a_SetActionMap( IDirectInputDevice8A *iface_a, DIACTIONFORMATA *format_a,
 631                                                     const char *username_a, DWORD flags )
 632 {
 633     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 634     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 635     DIACTIONFORMATW format_w = {sizeof(format_w), sizeof(DIACTIONW)};
 636     HRESULT hr;
 637     WCHAR *username_w;
 638
 639     TRACE( "impl %p, format_a %p, username_a %s, flags %#lx.\n", impl, format_a, debugstr_a(username_a), flags );
 640
 641     if (!format_a) return E_POINTER;
 642     if (format_a->dwSize != sizeof(DIACTIONFORMATA)) return DIERR_INVALIDPARAM;
 643     if (format_a->dwActionSize != sizeof(DIACTIONA)) return DIERR_INVALIDPARAM;
 644     if (FAILED(hr = string_atow( username_a, &username_w ))) return hr;
 645
 646     format_w.dwNumActions = format_a->dwNumActions;
 647     format_w.rgoAction = calloc( format_a->dwNumActions, sizeof(DIACTIONW) );
 648     if (!format_w.rgoAction) hr = DIERR_OUTOFMEMORY;
 649     else
 650     {
 651         diactionformat_atow( format_a, &format_w, FALSE );
 652         hr = IDirectInputDevice8_SetActionMap( iface_w, &format_w, username_w, flags );
 653         diactionformat_wtoa( &format_w, format_a );
 654         free( format_w.rgoAction );
 655     }
 656
 657     free( username_w );
 658     return hr;
 659 }
 660
 661 static HRESULT WINAPI dinput_device_a_GetImageInfo( IDirectInputDevice8A *iface_a, DIDEVICEIMAGEINFOHEADERA *header_a )
 662 {
 663     struct dinput_device *impl = impl_from_IDirectInputDevice8A( iface_a );
 664     IDirectInputDevice8W *iface_w = IDirectInputDevice8W_from_impl( impl );
 665     DIDEVICEIMAGEINFOHEADERW header_w = {sizeof(header_w), sizeof(DIDEVICEIMAGEINFOW)};
 666     HRESULT hr;
 667
 668     TRACE( "impl %p, header_a %p.\n", impl, header_a );
 669
 670     if (!header_a) return E_POINTER;
 671     if (header_a->dwSize != sizeof(DIDEVICEIMAGEINFOHEADERA)) return DIERR_INVALIDPARAM;
 672     if (header_a->dwSizeImageInfo != sizeof(DIDEVICEIMAGEINFOA)) return DIERR_INVALIDPARAM;
 673
 674     header_w.dwBufferSize = (header_a->dwBufferSize / sizeof(DIDEVICEIMAGEINFOA)) * sizeof(DIDEVICEIMAGEINFOW);
 675     header_w.lprgImageInfoArray = calloc( header_w.dwBufferSize, 1 );
 676     if (!header_w.lprgImageInfoArray) return DIERR_OUTOFMEMORY;
 677
 678     hr = IDirectInputDevice8_GetImageInfo( iface_w, &header_w );
 679     dideviceimageinfoheader_wtoa( &header_w, header_a );
 680     free( header_w.lprgImageInfoArray );
 681     return hr;
 682 }
 683
 684 const IDirectInputDevice8AVtbl dinput_device_a_vtbl =
 685 {
 686     /*** IUnknown methods ***/
 687     dinput_device_a_QueryInterface,
 688     dinput_device_a_AddRef,
 689     dinput_device_a_Release,
 690     /*** IDirectInputDeviceA methods ***/
 691     dinput_device_a_GetCapabilities,
 692     dinput_device_a_EnumObjects,
 693     dinput_device_a_GetProperty,
 694     dinput_device_a_SetProperty,
 695     dinput_device_a_Acquire,
 696     dinput_device_a_Unacquire,
 697     dinput_device_a_GetDeviceState,
 698     dinput_device_a_GetDeviceData,
 699     dinput_device_a_SetDataFormat,
 700     dinput_device_a_SetEventNotification,
 701     dinput_device_a_SetCooperativeLevel,
 702     dinput_device_a_GetObjectInfo,
 703     dinput_device_a_GetDeviceInfo,
 704     dinput_device_a_RunControlPanel,
 705     dinput_device_a_Initialize,
 706     /*** IDirectInputDevice2A methods ***/
 707     dinput_device_a_CreateEffect,
 708     dinput_device_a_EnumEffects,
 709     dinput_device_a_GetEffectInfo,
 710     dinput_device_a_GetForceFeedbackState,
 711     dinput_device_a_SendForceFeedbackCommand,
 712     dinput_device_a_EnumCreatedEffectObjects,
 713     dinput_device_a_Escape,
 714     dinput_device_a_Poll,
 715     dinput_device_a_SendDeviceData,
 716     /*** IDirectInputDevice7A methods ***/
 717     dinput_device_a_EnumEffectsInFile,
 718     dinput_device_a_WriteEffectToFile,
 719     /*** IDirectInputDevice8A methods ***/
 720     dinput_device_a_BuildActionMap,
 721     dinput_device_a_SetActionMap,
 722     dinput_device_a_GetImageInfo,
 723 };
 724
 725 static HRESULT WINAPI dinput8_a_QueryInterface( IDirectInput8A *iface_a, REFIID iid, void **out )
 726 {
 727     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 728     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 729     TRACE( "impl %p, iid %s, out %p.\n", impl, debugstr_guid( iid ), out );
 730     return IDirectInput8_QueryInterface( iface_w, iid, out );
 731 }
 732
 733 static ULONG WINAPI dinput8_a_AddRef( IDirectInput8A *iface_a )
 734 {
 735     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 736     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 737     TRACE( "impl %p.\n", impl );
 738     return IDirectInput8_AddRef( iface_w );
 739 }
 740
 741 static ULONG WINAPI dinput8_a_Release( IDirectInput8A *iface_a )
 742 {
 743     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 744     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 745     TRACE( "impl %p.\n", impl );
 746     return IDirectInput8_Release( iface_w );
 747 }
 748
 749 static HRESULT WINAPI dinput8_a_CreateDevice( IDirectInput8A *iface_a, REFGUID guid, IDirectInputDevice8A **out, IUnknown *outer )
 750 {
 751     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 752     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 753     IDirectInputDevice8W *outw;
 754     HRESULT hr;
 755
 756     TRACE( "impl %p, guid %s, out %p, outer %p.\n", impl, debugstr_guid( guid ), out, outer );
 757
 758     if (!out) return E_POINTER;
 759
 760     hr = IDirectInput8_CreateDevice( iface_w, guid, &outw, outer );
 761     *out = IDirectInputDevice8A_from_IDirectInputDevice8W( outw );
 762     return hr;
 763 }
 764
 765 struct enum_devices_wtoa_params
 766 {
 767     LPDIENUMDEVICESCALLBACKA callback;
 768     void *ref;
 769 };
 770
 771 static BOOL CALLBACK enum_devices_wtoa_callback( const DIDEVICEINSTANCEW *instance_w, void *data )
 772 {
 773     struct enum_devices_wtoa_params *params = data;
 774     DIDEVICEINSTANCEA instance_a = {sizeof(instance_a)};
 775
 776     dideviceinstance_wtoa( instance_w, &instance_a );
 777     return params->callback( &instance_a, params->ref );
 778 }
 779
 780 static HRESULT WINAPI dinput8_a_EnumDevices( IDirectInput8A *iface_a, DWORD type, LPDIENUMDEVICESCALLBACKA callback,
 781                                             void *ref, DWORD flags )
 782 {
 783     struct enum_devices_wtoa_params params = {callback, ref};
 784     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 785     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 786
 787     TRACE( "impl %p, type %#lx, callback %p, ref %p, flags %#lx.\n", impl, type, callback, ref, flags );
 788
 789     if (!callback) return DIERR_INVALIDPARAM;
 790
 791     return IDirectInput8_EnumDevices( iface_w, type, enum_devices_wtoa_callback, &params, flags );
 792 }
 793
 794 static HRESULT WINAPI dinput8_a_GetDeviceStatus( IDirectInput8A *iface_a, REFGUID instance_guid )
 795 {
 796     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 797     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 798     TRACE( "impl %p, instance_guid %s.\n", impl, debugstr_guid( instance_guid ) );
 799     return IDirectInput8_GetDeviceStatus( iface_w, instance_guid );
 800 }
 801
 802 static HRESULT WINAPI dinput8_a_RunControlPanel( IDirectInput8A *iface_a, HWND owner, DWORD flags )
 803 {
 804     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 805     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 806     TRACE( "impl %p, owner %p, flags %#lx.\n", impl, owner, flags );
 807     return IDirectInput8_RunControlPanel( iface_w, owner, flags );
 808 }
 809
 810 static HRESULT WINAPI dinput8_a_Initialize( IDirectInput8A *iface_a, HINSTANCE instance, DWORD version )
 811 {
 812     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 813     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 814     TRACE( "impl %p, instance %p, version %#lx.\n", impl, instance, version );
 815     return IDirectInput8_Initialize( iface_w, instance, version );
 816 }
 817
 818 static HRESULT WINAPI dinput8_a_FindDevice( IDirectInput8A *iface_a, REFGUID guid, const char *name_a, GUID *instance_guid )
 819 {
 820     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 821     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 822     HRESULT hr;
 823     WCHAR *name_w;
 824
 825     TRACE( "impl %p, guid %s, name_a %s, instance_guid %s.\n", impl, debugstr_guid( guid ),
 826            debugstr_a(name_a), debugstr_guid( instance_guid ) );
 827
 828     if (FAILED(hr = string_atow( name_a, &name_w ))) return hr;
 829
 830     hr = IDirectInput8_FindDevice( iface_w, guid, name_w, instance_guid );
 831     free( name_w );
 832     return hr;
 833 }
 834
 835 struct enum_devices_by_semantics_wtoa_params
 836 {
 837     LPDIENUMDEVICESBYSEMANTICSCBA callback;
 838     void *ref;
 839 };
 840
 841 static BOOL CALLBACK enum_devices_by_semantics_wtoa_callback( const DIDEVICEINSTANCEW *instance_w, IDirectInputDevice8W *iface_w,
 842                                                               DWORD flags, DWORD remaining, void *data )
 843 {
 844     struct enum_devices_by_semantics_wtoa_params *params = data;
 845     IDirectInputDevice8A *iface_a = IDirectInputDevice8A_from_IDirectInputDevice8W( iface_w );
 846     DIDEVICEINSTANCEA instance_a = {sizeof(instance_a)};
 847
 848     dideviceinstance_wtoa( instance_w, &instance_a );
 849     return params->callback( &instance_a, iface_a, flags, remaining, params->ref );
 850 }
 851
 852 static HRESULT WINAPI dinput8_a_EnumDevicesBySemantics( IDirectInput8A *iface_a, const char *username_a, DIACTIONFORMATA *format_a,
 853                                                        LPDIENUMDEVICESBYSEMANTICSCBA callback, void *ref, DWORD flags )
 854 {
 855     struct enum_devices_by_semantics_wtoa_params params = {callback, ref};
 856     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 857     DIACTIONFORMATW format_w = {sizeof(format_w), sizeof(DIACTIONW)};
 858     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 859     HRESULT hr;
 860     WCHAR *username_w;
 861
 862     TRACE( "impl %p, username_a %s, format_a %p, callback %p, ref %p, flags %#lx.\n", impl,
 863            debugstr_a(username_a), format_a, callback, ref, flags );
 864
 865     if (!callback) return DIERR_INVALIDPARAM;
 866     if (FAILED(hr = string_atow( username_a, &username_w ))) return hr;
 867
 868     format_w.dwNumActions = format_a->dwNumActions;
 869     format_w.rgoAction = calloc( format_a->dwNumActions, sizeof(DIACTIONW) );
 870     if (!format_w.rgoAction) hr = DIERR_OUTOFMEMORY;
 871     else
 872     {
 873         diactionformat_atow( format_a, &format_w, FALSE );
 874         hr = IDirectInput8_EnumDevicesBySemantics( iface_w, username_w, &format_w, enum_devices_by_semantics_wtoa_callback,
 875                                                    &params, flags );
 876         free( format_w.rgoAction );
 877     }
 878
 879     free( username_w );
 880     return hr;
 881 }
 882
 883 static HRESULT WINAPI dinput8_a_ConfigureDevices( IDirectInput8A *iface_a, LPDICONFIGUREDEVICESCALLBACK callback,
 884                                                  DICONFIGUREDEVICESPARAMSA *params_a, DWORD flags, void *ref )
 885 {
 886     struct dinput *impl = impl_from_IDirectInput8A( iface_a );
 887     IDirectInput8W *iface_w = IDirectInput8W_from_impl( impl );
 888     DICONFIGUREDEVICESPARAMSW params_w = {sizeof(params_w)};
 889     DIACTIONFORMATA *format_a = params_a->lprgFormats;
 890     DIACTIONFORMATW format_w = {sizeof(format_w), sizeof(DIACTIONW)};
 891     HRESULT hr;
 892     DWORD i;
 893
 894     TRACE( "impl %p, callback %p, params_a %p, flags %#lx, ref %p.\n", impl, callback, params_a, flags, ref );
 895
 896     if (FAILED(hr = diconfiguredevicesparams_atow( params_a, &params_w ))) return hr;
 897
 898     format_w.dwNumActions = format_a->dwNumActions;
 899     format_w.rgoAction = calloc( format_a->dwNumActions, sizeof(DIACTIONW) );
 900     if (!format_w.rgoAction) hr = DIERR_OUTOFMEMORY;
 901     else
 902     {
 903         hr = diactionformat_atow( format_a, &format_w, TRUE );
 904         params_w.lprgFormats = &format_w;
 905
 906         if (SUCCEEDED(hr)) hr = IDirectInput8_ConfigureDevices( iface_w, callback, &params_w, flags, ref );
 907         if (SUCCEEDED(hr)) diactionformat_wtoa( &format_w, format_a );
 908
 909         if (!format_w.hInstString)
 910         {
 911             for (i = 0; i < format_w.dwNumActions; ++i)
 912                 free( (void *)format_w.rgoAction[i].lptszActionName );
 913         }
 914         free( format_w.rgoAction );
 915     }
 916
 917     free( params_w.lptszUserNames );
 918     return hr;
 919 }
 920
 921 const IDirectInput8AVtbl dinput8_a_vtbl =
 922 {
 923     /*** IUnknown methods ***/
 924     dinput8_a_QueryInterface,
 925     dinput8_a_AddRef,
 926     dinput8_a_Release,
 927     /*** IDirectInput8A methods ***/
 928     dinput8_a_CreateDevice,
 929     dinput8_a_EnumDevices,
 930     dinput8_a_GetDeviceStatus,
 931     dinput8_a_RunControlPanel,
 932     dinput8_a_Initialize,
 933     dinput8_a_FindDevice,
 934     dinput8_a_EnumDevicesBySemantics,
 935     dinput8_a_ConfigureDevices,
 936 };
 937
 938 static HRESULT WINAPI dinput7_a_QueryInterface( IDirectInput7A *iface_a, REFIID iid, void **out )
 939 {
 940     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 941     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 942     TRACE( "impl %p, iid %s, out %p.\n", impl, debugstr_guid( iid ), out );
 943     return IDirectInput7_QueryInterface( iface_w, iid, out );
 944 }
 945
 946 static ULONG WINAPI dinput7_a_AddRef( IDirectInput7A *iface_a )
 947 {
 948     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 949     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 950     TRACE( "impl %p.\n", impl );
 951     return IDirectInput7_AddRef( iface_w );
 952 }
 953
 954 static ULONG WINAPI dinput7_a_Release( IDirectInput7A *iface_a )
 955 {
 956     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 957     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 958     TRACE( "impl %p.\n", impl );
 959     return IDirectInput7_Release( iface_w );
 960 }
 961
 962 static HRESULT WINAPI dinput7_a_CreateDevice( IDirectInput7A *iface_a, REFGUID guid, IDirectInputDeviceA **out_a, IUnknown *outer )
 963 {
 964     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 965     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 966     IDirectInputDeviceW *out_w;
 967     HRESULT hr;
 968
 969     TRACE( "impl %p, guid %s, out_a %p, outer %p.\n", impl, debugstr_guid( guid ), out_a, outer );
 970
 971     if (!out_a) return E_POINTER;
 972
 973     hr = IDirectInput7_CreateDevice( iface_w, guid, &out_w, outer );
 974     *out_a = IDirectInputDeviceA_from_IDirectInputDeviceW( out_w );
 975     return hr;
 976 }
 977
 978 static HRESULT WINAPI dinput7_a_EnumDevices( IDirectInput7A *iface_a, DWORD type, LPDIENUMDEVICESCALLBACKA callback,
 979                                              void *ref, DWORD flags )
 980 {
 981     struct enum_devices_wtoa_params params = {callback, ref};
 982     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 983     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 984
 985     TRACE( "impl %p, type %#lx, callback %p, ref %p, flags %#lx.\n", impl, type, callback, ref, flags );
 986
 987     if (!callback) return DIERR_INVALIDPARAM;
 988
 989     return IDirectInput7_EnumDevices( iface_w, type, enum_devices_wtoa_callback, &params, flags );
 990 }
 991
 992 static HRESULT WINAPI dinput7_a_GetDeviceStatus( IDirectInput7A *iface_a, REFGUID instance_guid )
 993 {
 994     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
 995     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
 996     TRACE( "impl %p, instance_guid %s.\n", impl, debugstr_guid( instance_guid ) );
 997     return IDirectInput7_GetDeviceStatus( iface_w, instance_guid );
 998 }
 999
1000 static HRESULT WINAPI dinput7_a_RunControlPanel( IDirectInput7A *iface_a, HWND owner, DWORD flags )
1001 {
1002     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
1003     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
1004     TRACE( "impl %p, owner %p, flags %#lx.\n", impl, owner, flags );
1005     return IDirectInput7_RunControlPanel( iface_w, owner, flags );
1006 }
1007
1008 static HRESULT WINAPI dinput7_a_Initialize( IDirectInput7A *iface_a, HINSTANCE instance, DWORD version )
1009 {
1010     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
1011     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
1012     TRACE( "impl %p, instance %p, version %#lx.\n", impl, instance, version );
1013     return IDirectInput7_Initialize( iface_w, instance, version );
1014 }
1015
1016 static HRESULT WINAPI dinput7_a_FindDevice( IDirectInput7A *iface_a, REFGUID guid, const char *name_a, GUID *instance_guid )
1017 {
1018     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
1019     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
1020     HRESULT hr;
1021     WCHAR *name_w;
1022
1023     TRACE( "impl %p, guid %s, name_a %s, instance_guid %s.\n", impl, debugstr_guid( guid ),
1024            debugstr_a(name_a), debugstr_guid( instance_guid ) );
1025
1026     if (FAILED(hr = string_atow( name_a, &name_w ))) return hr;
1027
1028     hr = IDirectInput7_FindDevice( iface_w, guid, name_w, instance_guid );
1029     free( name_w );
1030     return hr;
1031 }
1032
1033 static HRESULT WINAPI dinput7_a_CreateDeviceEx( IDirectInput7A *iface_a, REFGUID guid, REFIID iid, void **out, IUnknown *outer )
1034 {
1035     struct dinput *impl = impl_from_IDirectInput7A( iface_a );
1036     IDirectInput7W *iface_w = IDirectInput7W_from_impl( impl );
1037     TRACE( "impl %p, guid %s, iid %s, out %p, outer %p.\n", impl, debugstr_guid( guid ),
1038            debugstr_guid( iid ), out, outer );
1039     return IDirectInput7_CreateDeviceEx( iface_w, guid, iid, out, outer );
1040 }
1041
1042 const IDirectInput7AVtbl dinput7_a_vtbl =
1043 {
1044     /*** IUnknown methods ***/
1045     dinput7_a_QueryInterface,
1046     dinput7_a_AddRef,
1047     dinput7_a_Release,
1048     /*** IDirectInputA methods ***/
1049     dinput7_a_CreateDevice,
1050     dinput7_a_EnumDevices,
1051     dinput7_a_GetDeviceStatus,
1052     dinput7_a_RunControlPanel,
1053     dinput7_a_Initialize,
1054     /*** IDirectInput2A methods ***/
1055     dinput7_a_FindDevice,
1056     /*** IDirectInput7A methods ***/
1057     dinput7_a_CreateDeviceEx,
1058 };