dlls/windows.media.speech/listconstraint.c

   1 /* WinRT Windows.Media.SpeechRecognition implementation
   2  *
   3  * Copyright 2022 Bernhard Kölbl
   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
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(speech);
  25
  26 /*
  27  *
  28  * SpeechRecognitionListConstraint
  29  *
  30  */
  31
  32 struct list_constraint
  33 {
  34     ISpeechRecognitionListConstraint ISpeechRecognitionListConstraint_iface;
  35     ISpeechRecognitionConstraint ISpeechRecognitionConstraint_iface;
  36     LONG ref;
  37
  38     BOOLEAN enabled;
  39     IVector_HSTRING *commands;
  40 };
  41
  42 /*
  43  *
  44  * ISpeechRecognitionListConstraint
  45  *
  46  */
  47
  48 static inline struct list_constraint *impl_from_ISpeechRecognitionListConstraint( ISpeechRecognitionListConstraint *iface )
  49 {
  50     return CONTAINING_RECORD(iface, struct list_constraint, ISpeechRecognitionListConstraint_iface);
  51 }
  52
  53 static HRESULT WINAPI list_constraint_QueryInterface( ISpeechRecognitionListConstraint *iface, REFIID iid, void **out )
  54 {
  55     struct list_constraint *impl = impl_from_ISpeechRecognitionListConstraint(iface);
  56
  57     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  58
  59     if (IsEqualGUID(iid, &IID_IUnknown) ||
  60         IsEqualGUID(iid, &IID_IInspectable) ||
  61         IsEqualGUID(iid, &IID_IAgileObject) ||
  62         IsEqualGUID(iid, &IID_ISpeechRecognitionListConstraint))
  63     {
  64         IInspectable_AddRef((*out = &impl->ISpeechRecognitionListConstraint_iface));
  65         return S_OK;
  66     }
  67
  68     if (IsEqualGUID(iid, &IID_ISpeechRecognitionConstraint))
  69     {
  70         IInspectable_AddRef((*out = &impl->ISpeechRecognitionConstraint_iface));
  71         return S_OK;
  72     }
  73
  74     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  75     *out = NULL;
  76     return E_NOINTERFACE;
  77 }
  78
  79 static ULONG WINAPI list_constraint_AddRef( ISpeechRecognitionListConstraint *iface )
  80 {
  81     struct list_constraint *impl = impl_from_ISpeechRecognitionListConstraint(iface);
  82     ULONG ref = InterlockedIncrement(&impl->ref);
  83     TRACE("iface %p, ref %lu.\n", iface, ref);
  84     return ref;
  85 }
  86
  87 static ULONG WINAPI list_constraint_Release( ISpeechRecognitionListConstraint *iface )
  88 {
  89     struct list_constraint *impl = impl_from_ISpeechRecognitionListConstraint(iface);
  90
  91     ULONG ref = InterlockedDecrement(&impl->ref);
  92     TRACE("iface %p, ref %lu.\n", iface, ref);
  93
  94     if (!ref)
  95     {
  96         IVector_HSTRING_Release(impl->commands);
  97         free(impl);
  98     }
  99
 100     return ref;
 101 }
 102
 103 static HRESULT WINAPI list_constraint_GetIids( ISpeechRecognitionListConstraint *iface, ULONG *iid_count, IID **iids )
 104 {
 105     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI list_constraint_GetRuntimeClassName( ISpeechRecognitionListConstraint *iface, HSTRING *class_name )
 110 {
 111     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 112     return E_NOTIMPL;
 113 }
 114
 115 static HRESULT WINAPI list_constraint_GetTrustLevel( ISpeechRecognitionListConstraint *iface, TrustLevel *trust_level )
 116 {
 117     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT WINAPI list_constraint_get_Commands(  ISpeechRecognitionListConstraint *iface, IVector_HSTRING **value )
 122 {
 123     struct list_constraint *impl = impl_from_ISpeechRecognitionListConstraint(iface);
 124     IIterable_HSTRING *iterable;
 125     HRESULT hr;
 126
 127     TRACE("iface %p, value %p.\n", iface, value);
 128
 129     hr = IVector_HSTRING_QueryInterface(impl->commands, &IID_IIterable_HSTRING, (void **)&iterable);
 130     if (FAILED(hr)) return hr;
 131
 132     hr = vector_hstring_create_copy(iterable, value);
 133     IIterable_HSTRING_Release(iterable);
 134
 135     return hr;
 136 }
 137
 138 static const struct ISpeechRecognitionListConstraintVtbl speech_recognition_list_constraint_vtbl =
 139 {
 140     /* IUnknown methods */
 141     list_constraint_QueryInterface,
 142     list_constraint_AddRef,
 143     list_constraint_Release,
 144     /* IInspectable methods */
 145     list_constraint_GetIids,
 146     list_constraint_GetRuntimeClassName,
 147     list_constraint_GetTrustLevel,
 148     /* ISpeechRecognitionListConstraint methods */
 149     list_constraint_get_Commands,
 150 };
 151
 152 /*
 153  *
 154  * ISpeechRecognitionConstraint
 155  *
 156  */
 157
 158 DEFINE_IINSPECTABLE(constraint, ISpeechRecognitionConstraint, struct list_constraint, ISpeechRecognitionListConstraint_iface)
 159
 160 static HRESULT WINAPI constraint_get_IsEnabled( ISpeechRecognitionConstraint *iface, BOOLEAN *value )
 161 {
 162     struct list_constraint *impl = impl_from_ISpeechRecognitionConstraint(iface);
 163     TRACE("iface %p, value %p.\n", iface, value);
 164     *value = impl->enabled;
 165     return S_OK;
 166 }
 167
 168 static HRESULT WINAPI constraint_put_IsEnabled( ISpeechRecognitionConstraint *iface, BOOLEAN value )
 169 {
 170     struct list_constraint *impl = impl_from_ISpeechRecognitionConstraint(iface);
 171     TRACE("iface %p, value %u.\n", iface, value);
 172     impl->enabled = value;
 173     return S_OK;
 174 }
 175
 176 static HRESULT WINAPI constraint_get_Tag( ISpeechRecognitionConstraint *iface, HSTRING *value )
 177 {
 178     FIXME("iface %p, value %p stub!\n", iface, value);
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI constraint_put_Tag( ISpeechRecognitionConstraint *iface, HSTRING value )
 183 {
 184     FIXME("iface %p, value %p stub!\n", iface, value);
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI constraint_get_Type( ISpeechRecognitionConstraint *iface, SpeechRecognitionConstraintType *value )
 189 {
 190     FIXME("iface %p, value %p stub!\n", iface, value);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI constraint_get_Probability( ISpeechRecognitionConstraint *iface, SpeechRecognitionConstraintProbability *value )
 195 {
 196     FIXME("iface %p, value %p stub!\n", iface, value);
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI constraint_put_Probability( ISpeechRecognitionConstraint *iface, SpeechRecognitionConstraintProbability value )
 201 {
 202     FIXME("iface %p, value %u stub!\n", iface, value);
 203     return E_NOTIMPL;
 204 }
 205
 206 static const struct ISpeechRecognitionConstraintVtbl speech_recognition_constraint_vtbl =
 207 {
 208     /* IUnknown methods */
 209     constraint_QueryInterface,
 210     constraint_AddRef,
 211     constraint_Release,
 212     /* IInspectable methods */
 213     constraint_GetIids,
 214     constraint_GetRuntimeClassName,
 215     constraint_GetTrustLevel,
 216     /* ISpeechRecognitionConstraint methods */
 217     constraint_get_IsEnabled,
 218     constraint_put_IsEnabled,
 219     constraint_get_Tag,
 220     constraint_put_Tag,
 221     constraint_get_Type,
 222     constraint_get_Probability,
 223     constraint_put_Probability,
 224 };
 225
 226 /*
 227  *
 228  * Statics for SpeechRecognitionListConstraint
 229  *
 230  */
 231
 232 struct listconstraint_statics
 233 {
 234     IActivationFactory IActivationFactory_iface;
 235     ISpeechRecognitionListConstraintFactory ISpeechRecognitionListConstraintFactory_iface;
 236     LONG ref;
 237 };
 238
 239 /*
 240  *
 241  * IActivationFactory
 242  *
 243  */
 244
 245 static inline struct listconstraint_statics *impl_from_IActivationFactory( IActivationFactory *iface )
 246 {
 247     return CONTAINING_RECORD(iface, struct listconstraint_statics, IActivationFactory_iface);
 248 }
 249
 250 static HRESULT WINAPI factory_QueryInterface( IActivationFactory *iface, REFIID iid, void **out )
 251 {
 252     struct listconstraint_statics *impl = impl_from_IActivationFactory(iface);
 253
 254     TRACE("iface %p, iid %s, out %p stub!\n", iface, debugstr_guid(iid), out);
 255
 256     if (IsEqualGUID(iid, &IID_IUnknown) ||
 257         IsEqualGUID(iid, &IID_IInspectable) ||
 258         IsEqualGUID(iid, &IID_IAgileObject) ||
 259         IsEqualGUID(iid, &IID_IActivationFactory))
 260     {
 261         IInspectable_AddRef((*out = &impl->IActivationFactory_iface));
 262         return S_OK;
 263     }
 264
 265     if (IsEqualGUID(iid, &IID_ISpeechRecognitionListConstraintFactory))
 266     {
 267         IInspectable_AddRef((*out = &impl->ISpeechRecognitionListConstraintFactory_iface));
 268         return S_OK;
 269     }
 270
 271     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 272     *out = NULL;
 273     return E_NOINTERFACE;
 274 }
 275
 276 static ULONG WINAPI factory_AddRef( IActivationFactory *iface )
 277 {
 278     struct listconstraint_statics *impl = impl_from_IActivationFactory(iface);
 279     ULONG ref = InterlockedIncrement(&impl->ref);
 280     TRACE("iface %p, ref %lu.\n", iface, ref);
 281     return ref;
 282 }
 283
 284 static ULONG WINAPI factory_Release( IActivationFactory *iface )
 285 {
 286     struct listconstraint_statics *impl = impl_from_IActivationFactory(iface);
 287     ULONG ref = InterlockedDecrement(&impl->ref);
 288     TRACE("iface %p, ref %lu.\n", iface, ref);
 289     return ref;
 290 }
 291
 292 static HRESULT WINAPI factory_GetIids( IActivationFactory *iface, ULONG *iid_count, IID **iids )
 293 {
 294     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 295     return E_NOTIMPL;
 296 }
 297
 298 static HRESULT WINAPI factory_GetRuntimeClassName( IActivationFactory *iface, HSTRING *class_name )
 299 {
 300     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI factory_GetTrustLevel( IActivationFactory *iface, TrustLevel *trust_level )
 305 {
 306     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
 311 {
 312     TRACE("iface %p, instance %p\n", iface, instance);
 313     return E_NOTIMPL;
 314 }
 315
 316 static const struct IActivationFactoryVtbl activation_factory_vtbl =
 317 {
 318     /* IUnknown methods */
 319     factory_QueryInterface,
 320     factory_AddRef,
 321     factory_Release,
 322     /* IInspectable methods */
 323     factory_GetIids,
 324     factory_GetRuntimeClassName,
 325     factory_GetTrustLevel,
 326     /* IActivationFactory methods */
 327     factory_ActivateInstance,
 328 };
 329
 330 /*
 331  *
 332  * ISpeechRecognitionListConstraintFactory
 333  *
 334  */
 335
 336 DEFINE_IINSPECTABLE(constraint_factory, ISpeechRecognitionListConstraintFactory, struct listconstraint_statics, IActivationFactory_iface)
 337
 338 static HRESULT WINAPI constraint_factory_Create( ISpeechRecognitionListConstraintFactory *iface,
 339                                                  IIterable_HSTRING *commands,
 340                                                  ISpeechRecognitionListConstraint** listconstraint )
 341 {
 342     TRACE("iface %p, commands %p, listconstraint %p.\n", iface, commands, listconstraint);
 343     return ISpeechRecognitionListConstraintFactory_CreateWithTag(iface, commands, NULL, listconstraint);
 344 }
 345
 346 static HRESULT WINAPI constraint_factory_CreateWithTag( ISpeechRecognitionListConstraintFactory *iface,
 347                                                         IIterable_HSTRING *commands,
 348                                                         HSTRING tag,
 349                                                         ISpeechRecognitionListConstraint** listconstraint )
 350 {
 351     struct list_constraint *impl;
 352     HRESULT hr;
 353
 354     TRACE("iface %p, commands %p, tag %p, listconstraint %p.\n", iface, commands, tag, listconstraint);
 355
 356     *listconstraint = NULL;
 357
 358     if (!commands)
 359         return E_POINTER;
 360
 361     if (!(impl = calloc(1, sizeof(*impl)))) return E_OUTOFMEMORY;
 362     if (FAILED(hr = vector_hstring_create_copy(commands, &impl->commands))) goto error;
 363
 364     impl->ISpeechRecognitionListConstraint_iface.lpVtbl = &speech_recognition_list_constraint_vtbl;
 365     impl->ISpeechRecognitionConstraint_iface.lpVtbl = &speech_recognition_constraint_vtbl;
 366     impl->ref = 1;
 367
 368     TRACE("created SpeechRecognitionListConstraint %p.\n", impl);
 369
 370     *listconstraint = &impl->ISpeechRecognitionListConstraint_iface;
 371     return S_OK;
 372
 373 error:
 374     if (impl->commands) IVector_HSTRING_Release(impl->commands);
 375     free(impl);
 376     return hr;
 377 }
 378
 379 static const struct ISpeechRecognitionListConstraintFactoryVtbl speech_recognition_list_constraint_factory_vtbl =
 380 {
 381     /* IUnknown methods */
 382     constraint_factory_QueryInterface,
 383     constraint_factory_AddRef,
 384     constraint_factory_Release,
 385     /* IInspectable methods */
 386     constraint_factory_GetIids,
 387     constraint_factory_GetRuntimeClassName,
 388     constraint_factory_GetTrustLevel,
 389     /* ISpeechRecognitionListConstraintFactory methods */
 390     constraint_factory_Create,
 391     constraint_factory_CreateWithTag,
 392 };
 393
 394 /*
 395  *
 396  * ActivationFactory instances
 397  *
 398  */
 399
 400 static struct listconstraint_statics listconstraint_statics =
 401 {
 402     .IActivationFactory_iface = {&activation_factory_vtbl},
 403     .ISpeechRecognitionListConstraintFactory_iface = {&speech_recognition_list_constraint_factory_vtbl},
 404     .ref = 1
 405 };
 406
 407 IActivationFactory *listconstraint_factory  = &listconstraint_statics.IActivationFactory_iface;