dlls/oleacc/client.c

   1 /*
   2  * Copyright 2014 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "oleacc_private.h"
  22
  23 #include "wine/debug.h"
  24 #include "wine/heap.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(oleacc);
  27
  28 typedef struct {
  29     IAccessible IAccessible_iface;
  30     IOleWindow IOleWindow_iface;
  31     IEnumVARIANT IEnumVARIANT_iface;
  32
  33     LONG ref;
  34
  35     HWND hwnd;
  36     HWND enum_pos;
  37 } Client;
  38
  39 static inline Client* impl_from_Client(IAccessible *iface)
  40 {
  41     return CONTAINING_RECORD(iface, Client, IAccessible_iface);
  42 }
  43
  44 static HRESULT WINAPI Client_QueryInterface(IAccessible *iface, REFIID riid, void **ppv)
  45 {
  46     Client *This = impl_from_Client(iface);
  47
  48     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  49
  50     if(IsEqualIID(riid, &IID_IAccessible) ||
  51             IsEqualIID(riid, &IID_IDispatch) ||
  52             IsEqualIID(riid, &IID_IUnknown)) {
  53         *ppv = iface;
  54     }else if(IsEqualIID(riid, &IID_IOleWindow)) {
  55         *ppv = &This->IOleWindow_iface;
  56     }else if(IsEqualIID(riid, &IID_IEnumVARIANT)) {
  57         *ppv = &This->IEnumVARIANT_iface;
  58     }else {
  59         WARN("no interface: %s\n", debugstr_guid(riid));
  60         *ppv = NULL;
  61         return E_NOINTERFACE;
  62     }
  63
  64     IAccessible_AddRef(iface);
  65     return S_OK;
  66 }
  67
  68 static ULONG WINAPI Client_AddRef(IAccessible *iface)
  69 {
  70     Client *This = impl_from_Client(iface);
  71     ULONG ref = InterlockedIncrement(&This->ref);
  72
  73     TRACE("(%p) ref = %u\n", This, ref);
  74     return ref;
  75 }
  76
  77 static ULONG WINAPI Client_Release(IAccessible *iface)
  78 {
  79     Client *This = impl_from_Client(iface);
  80     ULONG ref = InterlockedDecrement(&This->ref);
  81
  82     TRACE("(%p) ref = %u\n", This, ref);
  83
  84     if(!ref)
  85         heap_free(This);
  86     return ref;
  87 }
  88
  89 static HRESULT WINAPI Client_GetTypeInfoCount(IAccessible *iface, UINT *pctinfo)
  90 {
  91     Client *This = impl_from_Client(iface);
  92     FIXME("(%p)->(%p)\n", This, pctinfo);
  93     return E_NOTIMPL;
  94 }
  95
  96 static HRESULT WINAPI Client_GetTypeInfo(IAccessible *iface,
  97         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
  98 {
  99     Client *This = impl_from_Client(iface);
 100     FIXME("(%p)->(%u %x %p)\n", This, iTInfo, lcid, ppTInfo);
 101     return E_NOTIMPL;
 102 }
 103
 104 static HRESULT WINAPI Client_GetIDsOfNames(IAccessible *iface, REFIID riid,
 105         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 106 {
 107     Client *This = impl_from_Client(iface);
 108     FIXME("(%p)->(%s %p %u %x %p)\n", This, debugstr_guid(riid),
 109             rgszNames, cNames, lcid, rgDispId);
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI Client_Invoke(IAccessible *iface, DISPID dispIdMember,
 114         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 115         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 116 {
 117     Client *This = impl_from_Client(iface);
 118     FIXME("(%p)->(%x %s %x %x %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 119             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI Client_get_accParent(IAccessible *iface, IDispatch **ppdispParent)
 124 {
 125     Client *This = impl_from_Client(iface);
 126
 127     TRACE("(%p)->(%p)\n", This, ppdispParent);
 128
 129     return AccessibleObjectFromWindow(This->hwnd, OBJID_WINDOW,
 130             &IID_IDispatch, (void**)ppdispParent);
 131 }
 132
 133 static HRESULT WINAPI Client_get_accChildCount(IAccessible *iface, LONG *pcountChildren)
 134 {
 135     Client *This = impl_from_Client(iface);
 136     HWND cur;
 137
 138     TRACE("(%p)->(%p)\n", This, pcountChildren);
 139
 140     *pcountChildren = 0;
 141     for(cur = GetWindow(This->hwnd, GW_CHILD); cur; cur = GetWindow(cur, GW_HWNDNEXT))
 142         (*pcountChildren)++;
 143
 144     return S_OK;
 145 }
 146
 147 static HRESULT WINAPI Client_get_accChild(IAccessible *iface,
 148         VARIANT varChildID, IDispatch **ppdispChild)
 149 {
 150     Client *This = impl_from_Client(iface);
 151
 152     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varChildID), ppdispChild);
 153
 154     *ppdispChild = NULL;
 155     return E_INVALIDARG;
 156 }
 157
 158 static HRESULT WINAPI Client_get_accName(IAccessible *iface, VARIANT varID, BSTR *pszName)
 159 {
 160     Client *This = impl_from_Client(iface);
 161     WCHAR name[1024];
 162     UINT i, len;
 163
 164     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszName);
 165
 166     *pszName = NULL;
 167     if(convert_child_id(&varID) != CHILDID_SELF || !IsWindow(This->hwnd))
 168         return E_INVALIDARG;
 169
 170     len = SendMessageW(This->hwnd, WM_GETTEXT, ARRAY_SIZE(name), (LPARAM)name);
 171     if(!len)
 172         return S_FALSE;
 173
 174     for(i=0; i<len; i++) {
 175         if(name[i] == '&') {
 176             len--;
 177             memmove(name+i, name+i+1, (len-i)*sizeof(WCHAR));
 178             break;
 179         }
 180     }
 181
 182     *pszName = SysAllocStringLen(name, len);
 183     return *pszName ? S_OK : E_OUTOFMEMORY;
 184 }
 185
 186 static HRESULT WINAPI Client_get_accValue(IAccessible *iface, VARIANT varID, BSTR *pszValue)
 187 {
 188     Client *This = impl_from_Client(iface);
 189
 190     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszValue);
 191
 192     *pszValue = NULL;
 193     if(convert_child_id(&varID) != CHILDID_SELF)
 194         return E_INVALIDARG;
 195     return S_FALSE;
 196 }
 197
 198 static HRESULT WINAPI Client_get_accDescription(IAccessible *iface,
 199         VARIANT varID, BSTR *pszDescription)
 200 {
 201     Client *This = impl_from_Client(iface);
 202
 203     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszDescription);
 204
 205     *pszDescription = NULL;
 206     if(convert_child_id(&varID) != CHILDID_SELF)
 207         return E_INVALIDARG;
 208     return S_FALSE;
 209 }
 210
 211 static HRESULT WINAPI Client_get_accRole(IAccessible *iface, VARIANT varID, VARIANT *pvarRole)
 212 {
 213     Client *This = impl_from_Client(iface);
 214
 215     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pvarRole);
 216
 217     if(convert_child_id(&varID) != CHILDID_SELF) {
 218         V_VT(pvarRole) = VT_EMPTY;
 219         return E_INVALIDARG;
 220     }
 221
 222     V_VT(pvarRole) = VT_I4;
 223     V_I4(pvarRole) = ROLE_SYSTEM_CLIENT;
 224     return S_OK;
 225 }
 226
 227 static HRESULT WINAPI Client_get_accState(IAccessible *iface, VARIANT varID, VARIANT *pvarState)
 228 {
 229     Client *This = impl_from_Client(iface);
 230     LONG style;
 231
 232     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pvarState);
 233
 234     if(convert_child_id(&varID) != CHILDID_SELF) {
 235         V_VT(pvarState) = VT_EMPTY;
 236         return E_INVALIDARG;
 237     }
 238
 239     V_VT(pvarState) = VT_I4;
 240     V_I4(pvarState) = 0;
 241
 242     style = GetWindowLongW(This->hwnd, GWL_STYLE);
 243     if(style & WS_DISABLED)
 244         V_I4(pvarState) |= STATE_SYSTEM_UNAVAILABLE;
 245     else if(IsWindow(This->hwnd))
 246         V_I4(pvarState) |= STATE_SYSTEM_FOCUSABLE;
 247     if(GetFocus() == This->hwnd)
 248         V_I4(pvarState) |= STATE_SYSTEM_FOCUSED;
 249     if(!(style & WS_VISIBLE))
 250         V_I4(pvarState) |= STATE_SYSTEM_INVISIBLE;
 251     return S_OK;
 252 }
 253
 254 static HRESULT WINAPI Client_get_accHelp(IAccessible *iface, VARIANT varID, BSTR *pszHelp)
 255 {
 256     Client *This = impl_from_Client(iface);
 257
 258     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszHelp);
 259
 260     *pszHelp = NULL;
 261     if(convert_child_id(&varID) != CHILDID_SELF)
 262         return E_INVALIDARG;
 263     return S_FALSE;
 264 }
 265
 266 static HRESULT WINAPI Client_get_accHelpTopic(IAccessible *iface,
 267         BSTR *pszHelpFile, VARIANT varID, LONG *pidTopic)
 268 {
 269     Client *This = impl_from_Client(iface);
 270     FIXME("(%p)->(%p %s %p)\n", This, pszHelpFile, debugstr_variant(&varID), pidTopic);
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI Client_get_accKeyboardShortcut(IAccessible *iface,
 275         VARIANT varID, BSTR *pszKeyboardShortcut)
 276 {
 277     Client *This = impl_from_Client(iface);
 278     WCHAR name[1024];
 279     UINT i, len;
 280
 281     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszKeyboardShortcut);
 282
 283     *pszKeyboardShortcut = NULL;
 284     if(convert_child_id(&varID) != CHILDID_SELF)
 285         return E_INVALIDARG;
 286
 287     len = SendMessageW(This->hwnd, WM_GETTEXT, ARRAY_SIZE(name), (LPARAM)name);
 288     for(i=0; i<len; i++) {
 289         if(name[i] == '&')
 290             break;
 291     }
 292     if(i+1 >= len)
 293         return S_FALSE;
 294
 295     *pszKeyboardShortcut = SysAllocString(L"Alt+!");
 296     if(!*pszKeyboardShortcut)
 297         return E_OUTOFMEMORY;
 298
 299     (*pszKeyboardShortcut)[4] = name[i+1];
 300     return S_OK;
 301 }
 302
 303 static HRESULT WINAPI Client_get_accFocus(IAccessible *iface, VARIANT *pvarID)
 304 {
 305     Client *This = impl_from_Client(iface);
 306     FIXME("(%p)->(%p)\n", This, pvarID);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI Client_get_accSelection(IAccessible *iface, VARIANT *pvarID)
 311 {
 312     Client *This = impl_from_Client(iface);
 313     FIXME("(%p)->(%p)\n", This, pvarID);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI Client_get_accDefaultAction(IAccessible *iface,
 318         VARIANT varID, BSTR *pszDefaultAction)
 319 {
 320     Client *This = impl_from_Client(iface);
 321
 322     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(&varID), pszDefaultAction);
 323
 324     *pszDefaultAction = NULL;
 325     if(convert_child_id(&varID) != CHILDID_SELF)
 326         return E_INVALIDARG;
 327     return S_FALSE;
 328 }
 329
 330 static HRESULT WINAPI Client_accSelect(IAccessible *iface, LONG flagsSelect, VARIANT varID)
 331 {
 332     Client *This = impl_from_Client(iface);
 333     FIXME("(%p)->(%x %s)\n", This, flagsSelect, debugstr_variant(&varID));
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI Client_accLocation(IAccessible *iface, LONG *pxLeft,
 338         LONG *pyTop, LONG *pcxWidth, LONG *pcyHeight, VARIANT varID)
 339 {
 340     Client *This = impl_from_Client(iface);
 341     RECT rect;
 342     POINT pt;
 343
 344     TRACE("(%p)->(%p %p %p %p %s)\n", This, pxLeft, pyTop,
 345             pcxWidth, pcyHeight, debugstr_variant(&varID));
 346
 347     *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
 348     if(convert_child_id(&varID) != CHILDID_SELF)
 349         return E_INVALIDARG;
 350
 351     if(!GetClientRect(This->hwnd, &rect))
 352         return S_OK;
 353
 354     pt.x = rect.left;
 355     pt.y = rect.top;
 356     MapWindowPoints(This->hwnd, NULL, &pt, 1);
 357     *pxLeft = pt.x;
 358     *pyTop = pt.y;
 359
 360     pt.x = rect.right;
 361     pt.y = rect.bottom;
 362     MapWindowPoints(This->hwnd, NULL, &pt, 1);
 363     *pcxWidth = pt.x - *pxLeft;
 364     *pcyHeight = pt.y - *pyTop;
 365     return S_OK;
 366 }
 367
 368 static HRESULT WINAPI Client_accNavigate(IAccessible *iface,
 369         LONG navDir, VARIANT varStart, VARIANT *pvarEnd)
 370 {
 371     Client *This = impl_from_Client(iface);
 372     FIXME("(%p)->(%d %s %p)\n", This, navDir, debugstr_variant(&varStart), pvarEnd);
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI Client_accHitTest(IAccessible *iface,
 377         LONG xLeft, LONG yTop, VARIANT *pvarID)
 378 {
 379     Client *This = impl_from_Client(iface);
 380     HWND child;
 381     POINT pt;
 382
 383     TRACE("(%p)->(%d %d %p)\n", This, xLeft, yTop, pvarID);
 384
 385     V_VT(pvarID) = VT_I4;
 386     V_I4(pvarID) = 0;
 387
 388     pt.x = xLeft;
 389     pt.y = yTop;
 390     if(!IsWindowVisible(This->hwnd) || !ScreenToClient(This->hwnd, &pt))
 391         return S_OK;
 392
 393     child = ChildWindowFromPointEx(This->hwnd, pt, CWP_SKIPINVISIBLE);
 394     if(!child || child==This->hwnd)
 395         return S_OK;
 396
 397     V_VT(pvarID) = VT_DISPATCH;
 398     return AccessibleObjectFromWindow(child, OBJID_WINDOW,
 399             &IID_IDispatch, (void**)&V_DISPATCH(pvarID));
 400 }
 401
 402 static HRESULT WINAPI Client_accDoDefaultAction(IAccessible *iface, VARIANT varID)
 403 {
 404     Client *This = impl_from_Client(iface);
 405     FIXME("(%p)->(%s)\n", This, debugstr_variant(&varID));
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI Client_put_accName(IAccessible *iface, VARIANT varID, BSTR pszName)
 410 {
 411     Client *This = impl_from_Client(iface);
 412     FIXME("(%p)->(%s %s)\n", This, debugstr_variant(&varID), debugstr_w(pszName));
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI Client_put_accValue(IAccessible *iface, VARIANT varID, BSTR pszValue)
 417 {
 418     Client *This = impl_from_Client(iface);
 419     FIXME("(%p)->(%s %s)\n", This, debugstr_variant(&varID), debugstr_w(pszValue));
 420     return E_NOTIMPL;
 421 }
 422
 423 static const IAccessibleVtbl ClientVtbl = {
 424     Client_QueryInterface,
 425     Client_AddRef,
 426     Client_Release,
 427     Client_GetTypeInfoCount,
 428     Client_GetTypeInfo,
 429     Client_GetIDsOfNames,
 430     Client_Invoke,
 431     Client_get_accParent,
 432     Client_get_accChildCount,
 433     Client_get_accChild,
 434     Client_get_accName,
 435     Client_get_accValue,
 436     Client_get_accDescription,
 437     Client_get_accRole,
 438     Client_get_accState,
 439     Client_get_accHelp,
 440     Client_get_accHelpTopic,
 441     Client_get_accKeyboardShortcut,
 442     Client_get_accFocus,
 443     Client_get_accSelection,
 444     Client_get_accDefaultAction,
 445     Client_accSelect,
 446     Client_accLocation,
 447     Client_accNavigate,
 448     Client_accHitTest,
 449     Client_accDoDefaultAction,
 450     Client_put_accName,
 451     Client_put_accValue
 452 };
 453
 454 static inline Client* impl_from_Client_OleWindow(IOleWindow *iface)
 455 {
 456     return CONTAINING_RECORD(iface, Client, IOleWindow_iface);
 457 }
 458
 459 static HRESULT WINAPI Client_OleWindow_QueryInterface(IOleWindow *iface, REFIID riid, void **ppv)
 460 {
 461     Client *This = impl_from_Client_OleWindow(iface);
 462     return IAccessible_QueryInterface(&This->IAccessible_iface, riid, ppv);
 463 }
 464
 465 static ULONG WINAPI Client_OleWindow_AddRef(IOleWindow *iface)
 466 {
 467     Client *This = impl_from_Client_OleWindow(iface);
 468     return IAccessible_AddRef(&This->IAccessible_iface);
 469 }
 470
 471 static ULONG WINAPI Client_OleWindow_Release(IOleWindow *iface)
 472 {
 473     Client *This = impl_from_Client_OleWindow(iface);
 474     return IAccessible_Release(&This->IAccessible_iface);
 475 }
 476
 477 static HRESULT WINAPI Client_OleWindow_GetWindow(IOleWindow *iface, HWND *phwnd)
 478 {
 479     Client *This = impl_from_Client_OleWindow(iface);
 480
 481     TRACE("(%p)->(%p)\n", This, phwnd);
 482
 483     *phwnd = This->hwnd;
 484     return S_OK;
 485 }
 486
 487 static HRESULT WINAPI Client_OleWindow_ContextSensitiveHelp(IOleWindow *iface, BOOL fEnterMode)
 488 {
 489     Client *This = impl_from_Client_OleWindow(iface);
 490     FIXME("(%p)->(%x)\n", This, fEnterMode);
 491     return E_NOTIMPL;
 492 }
 493
 494 static const IOleWindowVtbl ClientOleWindowVtbl = {
 495     Client_OleWindow_QueryInterface,
 496     Client_OleWindow_AddRef,
 497     Client_OleWindow_Release,
 498     Client_OleWindow_GetWindow,
 499     Client_OleWindow_ContextSensitiveHelp
 500 };
 501
 502 static inline Client* impl_from_Client_EnumVARIANT(IEnumVARIANT *iface)
 503 {
 504     return CONTAINING_RECORD(iface, Client, IEnumVARIANT_iface);
 505 }
 506
 507 static HRESULT WINAPI Client_EnumVARIANT_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv)
 508 {
 509     Client *This = impl_from_Client_EnumVARIANT(iface);
 510     return IAccessible_QueryInterface(&This->IAccessible_iface, riid, ppv);
 511 }
 512
 513 static ULONG WINAPI Client_EnumVARIANT_AddRef(IEnumVARIANT *iface)
 514 {
 515     Client *This = impl_from_Client_EnumVARIANT(iface);
 516     return IAccessible_AddRef(&This->IAccessible_iface);
 517 }
 518
 519 static ULONG WINAPI Client_EnumVARIANT_Release(IEnumVARIANT *iface)
 520 {
 521     Client *This = impl_from_Client_EnumVARIANT(iface);
 522     return IAccessible_Release(&This->IAccessible_iface);
 523 }
 524
 525 static HRESULT WINAPI Client_EnumVARIANT_Next(IEnumVARIANT *iface,
 526         ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 527 {
 528     Client *This = impl_from_Client_EnumVARIANT(iface);
 529     HWND cur = This->enum_pos, next;
 530     ULONG fetched = 0;
 531     HRESULT hr;
 532
 533     TRACE("(%p)->(%u %p %p)\n", This, celt, rgVar, pCeltFetched);
 534
 535     if(!celt) {
 536         if(pCeltFetched)
 537             *pCeltFetched = 0;
 538         return S_OK;
 539     }
 540
 541     if(!This->enum_pos)
 542         next = GetWindow(This->hwnd, GW_CHILD);
 543     else
 544         next = GetWindow(This->enum_pos, GW_HWNDNEXT);
 545
 546     while(next) {
 547         cur = next;
 548
 549         V_VT(rgVar+fetched) = VT_DISPATCH;
 550         hr = AccessibleObjectFromWindow(cur, OBJID_WINDOW,
 551                 &IID_IDispatch, (void**)&V_DISPATCH(rgVar+fetched));
 552         if(FAILED(hr)) {
 553             V_VT(rgVar+fetched) = VT_EMPTY;
 554             while(fetched > 0) {
 555                 VariantClear(rgVar+fetched-1);
 556                 fetched--;
 557             }
 558             if(pCeltFetched)
 559                 *pCeltFetched = 0;
 560             return hr;
 561         }
 562         fetched++;
 563         if(fetched == celt)
 564             break;
 565
 566         next = GetWindow(cur, GW_HWNDNEXT);
 567     }
 568
 569     This->enum_pos = cur;
 570     if(pCeltFetched)
 571         *pCeltFetched = fetched;
 572     return celt == fetched ? S_OK : S_FALSE;
 573 }
 574
 575 static HRESULT WINAPI Client_EnumVARIANT_Skip(IEnumVARIANT *iface, ULONG celt)
 576 {
 577     Client *This = impl_from_Client_EnumVARIANT(iface);
 578     HWND next;
 579
 580     TRACE("(%p)->(%u)\n", This, celt);
 581
 582     while(celt) {
 583         if(!This->enum_pos)
 584             next = GetWindow(This->hwnd, GW_CHILD);
 585         else
 586             next = GetWindow(This->enum_pos, GW_HWNDNEXT);
 587         if(!next)
 588             return S_FALSE;
 589
 590         This->enum_pos = next;
 591         celt--;
 592     }
 593
 594     return S_OK;
 595 }
 596
 597 static HRESULT WINAPI Client_EnumVARIANT_Reset(IEnumVARIANT *iface)
 598 {
 599     Client *This = impl_from_Client_EnumVARIANT(iface);
 600
 601     TRACE("(%p)\n", This);
 602
 603     This->enum_pos = 0;
 604     return S_OK;
 605 }
 606
 607 static HRESULT WINAPI Client_EnumVARIANT_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 608 {
 609     Client *This = impl_from_Client_EnumVARIANT(iface);
 610     FIXME("(%p)->(%p)\n", This, ppEnum);
 611     return E_NOTIMPL;
 612 }
 613
 614 static const IEnumVARIANTVtbl ClientEnumVARIANTVtbl = {
 615     Client_EnumVARIANT_QueryInterface,
 616     Client_EnumVARIANT_AddRef,
 617     Client_EnumVARIANT_Release,
 618     Client_EnumVARIANT_Next,
 619     Client_EnumVARIANT_Skip,
 620     Client_EnumVARIANT_Reset,
 621     Client_EnumVARIANT_Clone
 622 };
 623
 624 HRESULT create_client_object(HWND hwnd, const IID *iid, void **obj)
 625 {
 626     Client *client;
 627     HRESULT hres;
 628
 629     if(!IsWindow(hwnd))
 630         return E_FAIL;
 631
 632     client = heap_alloc_zero(sizeof(Client));
 633     if(!client)
 634         return E_OUTOFMEMORY;
 635
 636     client->IAccessible_iface.lpVtbl = &ClientVtbl;
 637     client->IOleWindow_iface.lpVtbl = &ClientOleWindowVtbl;
 638     client->IEnumVARIANT_iface.lpVtbl = &ClientEnumVARIANTVtbl;
 639     client->ref = 1;
 640     client->hwnd = hwnd;
 641     client->enum_pos = 0;
 642
 643     hres = IAccessible_QueryInterface(&client->IAccessible_iface, iid, obj);
 644     IAccessible_Release(&client->IAccessible_iface);
 645     return hres;
 646 }