dlls/windows.gaming.input/controller.c

   1 /* WinRT Windows.Gaming.Input implementation
   2  *
   3  * Copyright 2021 Rémi Bernon for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "private.h"
  21 #include "provider.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(input);
  26
  27 static CRITICAL_SECTION controller_cs;
  28 static CRITICAL_SECTION_DEBUG controller_cs_debug =
  29 {
  30     0, 0, &controller_cs,
  31     { &controller_cs_debug.ProcessLocksList, &controller_cs_debug.ProcessLocksList },
  32       0, 0, { (DWORD_PTR)(__FILE__ ": controller_cs") }
  33 };
  34 static CRITICAL_SECTION controller_cs = { &controller_cs_debug, -1, 0, 0, 0, 0 };
  35
  36 static IVector_RawGameController *controllers;
  37 static struct list controller_added_handlers = LIST_INIT( controller_added_handlers );
  38 static struct list controller_removed_handlers = LIST_INIT( controller_removed_handlers );
  39
  40 static HRESULT init_controllers(void)
  41 {
  42     static const struct vector_iids iids =
  43     {
  44         .vector = &IID_IVector_RawGameController,
  45         .view = &IID_IVectorView_RawGameController,
  46         .iterable = &IID_IIterable_RawGameController,
  47         .iterator = &IID_IIterator_RawGameController,
  48     };
  49     HRESULT hr;
  50
  51     EnterCriticalSection( &controller_cs );
  52     if (controllers) hr = S_OK;
  53     else hr = vector_create( &iids, (void **)&controllers );
  54     LeaveCriticalSection( &controller_cs );
  55
  56     return hr;
  57 }
  58
  59 struct controller
  60 {
  61     IGameControllerImpl IGameControllerImpl_iface;
  62     IGameControllerInputSink IGameControllerInputSink_iface;
  63     IRawGameController IRawGameController_iface;
  64     IGameController *IGameController_outer;
  65     LONG ref;
  66
  67     IGameControllerProvider *provider;
  68     IWineGameControllerProvider *wine_provider;
  69 };
  70
  71 static inline struct controller *impl_from_IGameControllerImpl( IGameControllerImpl *iface )
  72 {
  73     return CONTAINING_RECORD( iface, struct controller, IGameControllerImpl_iface );
  74 }
  75
  76 static HRESULT WINAPI controller_QueryInterface( IGameControllerImpl *iface, REFIID iid, void **out )
  77 {
  78     struct controller *impl = impl_from_IGameControllerImpl( iface );
  79
  80     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  81
  82     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  83         IsEqualGUID( iid, &IID_IInspectable ) ||
  84         IsEqualGUID( iid, &IID_IGameControllerImpl ))
  85     {
  86         IInspectable_AddRef( (*out = &impl->IGameControllerImpl_iface) );
  87         return S_OK;
  88     }
  89
  90     if (IsEqualGUID( iid, &IID_IGameControllerInputSink ))
  91     {
  92         IInspectable_AddRef( (*out = &impl->IGameControllerInputSink_iface) );
  93         return S_OK;
  94     }
  95
  96     if (IsEqualGUID( iid, &IID_IRawGameController ))
  97     {
  98         IInspectable_AddRef( (*out = &impl->IRawGameController_iface) );
  99         return S_OK;
 100     }
 101
 102     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 103     *out = NULL;
 104     return E_NOINTERFACE;
 105 }
 106
 107 static ULONG WINAPI controller_AddRef( IGameControllerImpl *iface )
 108 {
 109     struct controller *impl = impl_from_IGameControllerImpl( iface );
 110     ULONG ref = InterlockedIncrement( &impl->ref );
 111     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 112     return ref;
 113 }
 114
 115 static ULONG WINAPI controller_Release( IGameControllerImpl *iface )
 116 {
 117     struct controller *impl = impl_from_IGameControllerImpl( iface );
 118     ULONG ref = InterlockedDecrement( &impl->ref );
 119
 120     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 121
 122     if (!ref)
 123     {
 124         if (impl->wine_provider)
 125             IWineGameControllerProvider_Release( impl->wine_provider );
 126         IGameControllerProvider_Release( impl->provider );
 127         free( impl );
 128     }
 129
 130     return ref;
 131 }
 132
 133 static HRESULT WINAPI controller_GetIids( IGameControllerImpl *iface, ULONG *iid_count, IID **iids )
 134 {
 135     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI controller_GetRuntimeClassName( IGameControllerImpl *iface, HSTRING *class_name )
 140 {
 141     return WindowsCreateString( RuntimeClass_Windows_Gaming_Input_RawGameController,
 142                                 ARRAY_SIZE(RuntimeClass_Windows_Gaming_Input_RawGameController),
 143                                 class_name );
 144 }
 145
 146 static HRESULT WINAPI controller_GetTrustLevel( IGameControllerImpl *iface, TrustLevel *trust_level )
 147 {
 148     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI controller_Initialize( IGameControllerImpl *iface, IGameController *outer,
 153                                              IGameControllerProvider *provider )
 154 {
 155     struct controller *impl = impl_from_IGameControllerImpl( iface );
 156     HRESULT hr;
 157
 158     TRACE( "iface %p, outer %p, provider %p.\n", iface, outer, provider );
 159
 160     impl->IGameController_outer = outer;
 161     IGameControllerProvider_AddRef( (impl->provider = provider) );
 162
 163     hr = IGameControllerProvider_QueryInterface( provider, &IID_IWineGameControllerProvider,
 164                                                  (void **)&impl->wine_provider );
 165     if (FAILED(hr)) return hr;
 166
 167     EnterCriticalSection( &controller_cs );
 168     if (SUCCEEDED(hr = init_controllers()))
 169         hr = IVector_RawGameController_Append( controllers, &impl->IRawGameController_iface );
 170     LeaveCriticalSection( &controller_cs );
 171
 172     return hr;
 173 }
 174
 175 static const struct IGameControllerImplVtbl controller_vtbl =
 176 {
 177     controller_QueryInterface,
 178     controller_AddRef,
 179     controller_Release,
 180     /* IInspectable methods */
 181     controller_GetIids,
 182     controller_GetRuntimeClassName,
 183     controller_GetTrustLevel,
 184     /* IGameControllerImpl methods */
 185     controller_Initialize,
 186 };
 187
 188 DEFINE_IINSPECTABLE_OUTER( input_sink, IGameControllerInputSink, struct controller, IGameController_outer )
 189
 190 static HRESULT WINAPI input_sink_OnInputResumed( IGameControllerInputSink *iface, UINT64 timestamp )
 191 {
 192     FIXME( "iface %p, timestamp %I64u stub!\n", iface, timestamp );
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI input_sink_OnInputSuspended( IGameControllerInputSink *iface, UINT64 timestamp )
 197 {
 198     FIXME( "iface %p, timestamp %I64u stub!\n", iface, timestamp );
 199     return E_NOTIMPL;
 200 }
 201
 202 static const struct IGameControllerInputSinkVtbl input_sink_vtbl =
 203 {
 204     input_sink_QueryInterface,
 205     input_sink_AddRef,
 206     input_sink_Release,
 207     /* IInspectable methods */
 208     input_sink_GetIids,
 209     input_sink_GetRuntimeClassName,
 210     input_sink_GetTrustLevel,
 211     /* IGameControllerInputSink methods */
 212     input_sink_OnInputResumed,
 213     input_sink_OnInputSuspended,
 214 };
 215
 216 DEFINE_IINSPECTABLE_OUTER( raw_controller, IRawGameController, struct controller, IGameController_outer )
 217
 218 static HRESULT WINAPI raw_controller_get_AxisCount( IRawGameController *iface, INT32 *value )
 219 {
 220     struct controller *impl = impl_from_IRawGameController( iface );
 221     return IWineGameControllerProvider_get_AxisCount( impl->wine_provider, value );
 222 }
 223
 224 static HRESULT WINAPI raw_controller_get_ButtonCount( IRawGameController *iface, INT32 *value )
 225 {
 226     struct controller *impl = impl_from_IRawGameController( iface );
 227     return IWineGameControllerProvider_get_ButtonCount( impl->wine_provider, value );
 228 }
 229
 230 static HRESULT WINAPI raw_controller_get_ForceFeedbackMotors( IRawGameController *iface, IVectorView_ForceFeedbackMotor **value )
 231 {
 232     static const struct vector_iids iids =
 233     {
 234         .vector = &IID_IVector_ForceFeedbackMotor,
 235         .view = &IID_IVectorView_ForceFeedbackMotor,
 236         .iterable = &IID_IIterable_ForceFeedbackMotor,
 237         .iterator = &IID_IIterator_ForceFeedbackMotor,
 238     };
 239     struct controller *impl = impl_from_IRawGameController( iface );
 240     IVector_ForceFeedbackMotor *vector;
 241     IForceFeedbackMotor *motor;
 242     HRESULT hr;
 243
 244     TRACE( "iface %p, value %p\n", iface, value );
 245
 246     if (FAILED(hr = vector_create( &iids, (void **)&vector ))) return hr;
 247
 248     if (SUCCEEDED(IWineGameControllerProvider_get_ForceFeedbackMotor( impl->wine_provider, &motor )) && motor)
 249     {
 250         hr = IVector_ForceFeedbackMotor_Append( vector, motor );
 251         IForceFeedbackMotor_Release( motor );
 252     }
 253
 254     if (SUCCEEDED(hr)) hr = IVector_ForceFeedbackMotor_GetView( vector, value );
 255     IVector_ForceFeedbackMotor_Release( vector );
 256
 257     return hr;
 258 }
 259
 260 static HRESULT WINAPI raw_controller_get_HardwareProductId( IRawGameController *iface, UINT16 *value )
 261 {
 262     struct controller *impl = impl_from_IRawGameController( iface );
 263     return IGameControllerProvider_get_HardwareProductId( impl->provider, value );
 264 }
 265
 266 static HRESULT WINAPI raw_controller_get_HardwareVendorId( IRawGameController *iface, UINT16 *value )
 267 {
 268     struct controller *impl = impl_from_IRawGameController( iface );
 269     return IGameControllerProvider_get_HardwareVendorId( impl->provider, value );
 270 }
 271
 272 static HRESULT WINAPI raw_controller_get_SwitchCount( IRawGameController *iface, INT32 *value )
 273 {
 274     struct controller *impl = impl_from_IRawGameController( iface );
 275     return IWineGameControllerProvider_get_SwitchCount( impl->wine_provider, value );
 276 }
 277
 278 static HRESULT WINAPI raw_controller_GetButtonLabel( IRawGameController *iface, INT32 index,
 279                                                      enum GameControllerButtonLabel *value )
 280 {
 281     FIXME( "iface %p, index %d, value %p stub!\n", iface, index, value );
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI raw_controller_GetCurrentReading( IRawGameController *iface, UINT32 buttons_size, BOOLEAN *buttons,
 286                                                         UINT32 switches_size, enum GameControllerSwitchPosition *switches,
 287                                                         UINT32 axes_size, DOUBLE *axes, UINT64 *timestamp )
 288 {
 289     struct controller *impl = impl_from_IRawGameController( iface );
 290     WineGameControllerState state;
 291     HRESULT hr;
 292
 293     TRACE( "iface %p, buttons_size %u, buttons %p, switches_size %u, switches %p, axes_size %u, axes %p, timestamp %p.\n",
 294            iface, buttons_size, buttons, switches_size, switches, axes_size, axes, timestamp );
 295
 296     if (FAILED(hr = IWineGameControllerProvider_get_State( impl->wine_provider, &state ))) return hr;
 297
 298     memcpy( axes, state.axes, axes_size * sizeof(*axes) );
 299     memcpy( buttons, state.buttons, buttons_size * sizeof(*buttons) );
 300     memcpy( switches, state.switches, switches_size * sizeof(*switches) );
 301     *timestamp = state.timestamp;
 302
 303     return hr;
 304 }
 305
 306 static HRESULT WINAPI raw_controller_GetSwitchKind( IRawGameController *iface, INT32 index, enum GameControllerSwitchKind *value )
 307 {
 308     FIXME( "iface %p, index %d, value %p stub!\n", iface, index, value );
 309     return E_NOTIMPL;
 310 }
 311
 312 static const struct IRawGameControllerVtbl raw_controller_vtbl =
 313 {
 314     raw_controller_QueryInterface,
 315     raw_controller_AddRef,
 316     raw_controller_Release,
 317     /* IInspectable methods */
 318     raw_controller_GetIids,
 319     raw_controller_GetRuntimeClassName,
 320     raw_controller_GetTrustLevel,
 321     /* IRawGameController methods */
 322     raw_controller_get_AxisCount,
 323     raw_controller_get_ButtonCount,
 324     raw_controller_get_ForceFeedbackMotors,
 325     raw_controller_get_HardwareProductId,
 326     raw_controller_get_HardwareVendorId,
 327     raw_controller_get_SwitchCount,
 328     raw_controller_GetButtonLabel,
 329     raw_controller_GetCurrentReading,
 330     raw_controller_GetSwitchKind,
 331 };
 332
 333 struct controller_statics
 334 {
 335     IActivationFactory IActivationFactory_iface;
 336     IRawGameControllerStatics IRawGameControllerStatics_iface;
 337     ICustomGameControllerFactory ICustomGameControllerFactory_iface;
 338     LONG ref;
 339 };
 340
 341 static inline struct controller_statics *impl_from_IActivationFactory( IActivationFactory *iface )
 342 {
 343     return CONTAINING_RECORD( iface, struct controller_statics, IActivationFactory_iface );
 344 }
 345
 346 static HRESULT WINAPI factory_QueryInterface( IActivationFactory *iface, REFIID iid, void **out )
 347 {
 348     struct controller_statics *impl = impl_from_IActivationFactory( iface );
 349
 350     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 351
 352     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 353         IsEqualGUID( iid, &IID_IInspectable ) ||
 354         IsEqualGUID( iid, &IID_IAgileObject ) ||
 355         IsEqualGUID( iid, &IID_IActivationFactory ))
 356     {
 357         IInspectable_AddRef( (*out = &impl->IActivationFactory_iface) );
 358         return S_OK;
 359     }
 360
 361     if (IsEqualGUID( iid, &IID_IRawGameControllerStatics ))
 362     {
 363         IInspectable_AddRef( (*out = &impl->IRawGameControllerStatics_iface) );
 364         return S_OK;
 365     }
 366
 367     if (IsEqualGUID( iid, &IID_ICustomGameControllerFactory ))
 368     {
 369         IInspectable_AddRef( (*out = &impl->ICustomGameControllerFactory_iface) );
 370         return S_OK;
 371     }
 372
 373     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 374     *out = NULL;
 375     return E_NOINTERFACE;
 376 }
 377
 378 static ULONG WINAPI factory_AddRef( IActivationFactory *iface )
 379 {
 380     struct controller_statics *impl = impl_from_IActivationFactory( iface );
 381     ULONG ref = InterlockedIncrement( &impl->ref );
 382     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 383     return ref;
 384 }
 385
 386 static ULONG WINAPI factory_Release( IActivationFactory *iface )
 387 {
 388     struct controller_statics *impl = impl_from_IActivationFactory( iface );
 389     ULONG ref = InterlockedDecrement( &impl->ref );
 390     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 391     return ref;
 392 }
 393
 394 static HRESULT WINAPI factory_GetIids( IActivationFactory *iface, ULONG *iid_count, IID **iids )
 395 {
 396     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI factory_GetRuntimeClassName( IActivationFactory *iface, HSTRING *class_name )
 401 {
 402     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI factory_GetTrustLevel( IActivationFactory *iface, TrustLevel *trust_level )
 407 {
 408     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
 413 {
 414     FIXME( "iface %p, instance %p stub!\n", iface, instance );
 415     return E_NOTIMPL;
 416 }
 417
 418 static const struct IActivationFactoryVtbl factory_vtbl =
 419 {
 420     factory_QueryInterface,
 421     factory_AddRef,
 422     factory_Release,
 423     /* IInspectable methods */
 424     factory_GetIids,
 425     factory_GetRuntimeClassName,
 426     factory_GetTrustLevel,
 427     /* IActivationFactory methods */
 428     factory_ActivateInstance,
 429 };
 430
 431 DEFINE_IINSPECTABLE( statics, IRawGameControllerStatics, struct controller_statics, IActivationFactory_iface )
 432
 433 static HRESULT WINAPI statics_add_RawGameControllerAdded( IRawGameControllerStatics *iface,
 434                                                           IEventHandler_RawGameController *handler,
 435                                                           EventRegistrationToken *token )
 436 {
 437     TRACE( "iface %p, handler %p, token %p.\n", iface, handler, token );
 438     if (!handler) return E_INVALIDARG;
 439     return event_handlers_append( &controller_added_handlers, (IEventHandler_IInspectable *)handler, token );
 440 }
 441
 442 static HRESULT WINAPI statics_remove_RawGameControllerAdded( IRawGameControllerStatics *iface, EventRegistrationToken token )
 443 {
 444     TRACE( "iface %p, token %#I64x.\n", iface, token.value );
 445     return event_handlers_remove( &controller_added_handlers, &token );
 446 }
 447
 448 static HRESULT WINAPI statics_add_RawGameControllerRemoved( IRawGameControllerStatics *iface,
 449                                                             IEventHandler_RawGameController *handler,
 450                                                             EventRegistrationToken *token )
 451 {
 452     TRACE( "iface %p, handler %p, token %p.\n", iface, handler, token );
 453     if (!handler) return E_INVALIDARG;
 454     return event_handlers_append( &controller_removed_handlers, (IEventHandler_IInspectable *)handler, token );
 455 }
 456
 457 static HRESULT WINAPI statics_remove_RawGameControllerRemoved( IRawGameControllerStatics *iface, EventRegistrationToken token )
 458 {
 459     TRACE( "iface %p, token %#I64x.\n", iface, token.value );
 460     return event_handlers_remove( &controller_removed_handlers, &token );
 461 }
 462
 463 static HRESULT WINAPI statics_get_RawGameControllers( IRawGameControllerStatics *iface, IVectorView_RawGameController **value )
 464 {
 465     HRESULT hr;
 466
 467     TRACE( "iface %p, value %p.\n", iface, value );
 468
 469     EnterCriticalSection( &controller_cs );
 470     if (SUCCEEDED(hr = init_controllers()))
 471         hr = IVector_RawGameController_GetView( controllers, value );
 472     LeaveCriticalSection( &controller_cs );
 473
 474     return hr;
 475 }
 476
 477 static HRESULT WINAPI statics_FromGameController( IRawGameControllerStatics *iface, IGameController *game_controller,
 478                                                   IRawGameController **value )
 479 {
 480     struct controller_statics *impl = impl_from_IRawGameControllerStatics( iface );
 481     IGameController *controller;
 482     HRESULT hr;
 483
 484     TRACE( "iface %p, game_controller %p, value %p.\n", iface, game_controller, value );
 485
 486     *value = NULL;
 487     hr = IGameControllerFactoryManagerStatics2_TryGetFactoryControllerFromGameController( manager_factory, &impl->ICustomGameControllerFactory_iface,
 488                                                                                           game_controller, &controller );
 489     if (FAILED(hr) || !controller) return hr;
 490
 491     hr = IGameController_QueryInterface( controller, &IID_IRawGameController, (void **)value );
 492     IGameController_Release( controller );
 493
 494     return hr;
 495 }
 496
 497 static const struct IRawGameControllerStaticsVtbl statics_vtbl =
 498 {
 499     statics_QueryInterface,
 500     statics_AddRef,
 501     statics_Release,
 502     /* IInspectable methods */
 503     statics_GetIids,
 504     statics_GetRuntimeClassName,
 505     statics_GetTrustLevel,
 506     /* IRawGameControllerStatics methods */
 507     statics_add_RawGameControllerAdded,
 508     statics_remove_RawGameControllerAdded,
 509     statics_add_RawGameControllerRemoved,
 510     statics_remove_RawGameControllerRemoved,
 511     statics_get_RawGameControllers,
 512     statics_FromGameController,
 513 };
 514
 515 DEFINE_IINSPECTABLE( controller_factory, ICustomGameControllerFactory, struct controller_statics, IActivationFactory_iface )
 516
 517 static HRESULT WINAPI controller_factory_CreateGameController( ICustomGameControllerFactory *iface, IGameControllerProvider *provider,
 518                                                                IInspectable **value )
 519 {
 520     struct controller *impl;
 521
 522     TRACE( "iface %p, provider %p, value %p.\n", iface, provider, value );
 523
 524     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 525     impl->IGameControllerImpl_iface.lpVtbl = &controller_vtbl;
 526     impl->IGameControllerInputSink_iface.lpVtbl = &input_sink_vtbl;
 527     impl->IRawGameController_iface.lpVtbl = &raw_controller_vtbl;
 528     impl->ref = 1;
 529
 530     TRACE( "created RawGameController %p\n", impl );
 531
 532     *value = (IInspectable *)&impl->IGameControllerImpl_iface;
 533     return S_OK;
 534 }
 535
 536 static HRESULT WINAPI controller_factory_OnGameControllerAdded( ICustomGameControllerFactory *iface, IGameController *value )
 537 {
 538     IRawGameController *controller;
 539     HRESULT hr;
 540
 541     TRACE( "iface %p, value %p.\n", iface, value );
 542
 543     if (FAILED(hr = IGameController_QueryInterface( value, &IID_IRawGameController, (void **)&controller )))
 544         return hr;
 545     event_handlers_notify( &controller_added_handlers, (IInspectable *)controller );
 546     IRawGameController_Release( controller );
 547
 548     return S_OK;
 549 }
 550
 551 static HRESULT WINAPI controller_factory_OnGameControllerRemoved( ICustomGameControllerFactory *iface, IGameController *value )
 552 {
 553     IRawGameController *controller;
 554     BOOLEAN found;
 555     UINT32 index;
 556     HRESULT hr;
 557
 558     TRACE( "iface %p, value %p.\n", iface, value );
 559
 560     if (FAILED(hr = IGameController_QueryInterface( value, &IID_IRawGameController, (void **)&controller )))
 561         return hr;
 562
 563     EnterCriticalSection( &controller_cs );
 564     if (SUCCEEDED(hr = init_controllers()))
 565     {
 566         if (FAILED(hr = IVector_RawGameController_IndexOf( controllers, controller, &index, &found )) || !found)
 567             WARN( "Could not find controller %p, hr %#lx!\n", controller, hr );
 568         else
 569             hr = IVector_RawGameController_RemoveAt( controllers, index );
 570     }
 571     LeaveCriticalSection( &controller_cs );
 572
 573     if (FAILED(hr))
 574         WARN( "Failed to remove controller %p, hr %#lx!\n", controller, hr );
 575     else if (found)
 576     {
 577         TRACE( "Removed controller %p.\n", controller );
 578         event_handlers_notify( &controller_removed_handlers, (IInspectable *)controller );
 579     }
 580     IRawGameController_Release( controller );
 581
 582     return S_OK;
 583 }
 584
 585 static const struct ICustomGameControllerFactoryVtbl controller_factory_vtbl =
 586 {
 587     controller_factory_QueryInterface,
 588     controller_factory_AddRef,
 589     controller_factory_Release,
 590     /* IInspectable methods */
 591     controller_factory_GetIids,
 592     controller_factory_GetRuntimeClassName,
 593     controller_factory_GetTrustLevel,
 594     /* ICustomGameControllerFactory methods */
 595     controller_factory_CreateGameController,
 596     controller_factory_OnGameControllerAdded,
 597     controller_factory_OnGameControllerRemoved,
 598 };
 599
 600 static struct controller_statics controller_statics =
 601 {
 602     {&factory_vtbl},
 603     {&statics_vtbl},
 604     {&controller_factory_vtbl},
 605     1,
 606 };
 607
 608 ICustomGameControllerFactory *controller_factory = &controller_statics.ICustomGameControllerFactory_iface;