dlls/oledb32/rowpos.c

   1 /* OLE DB Row Position library
   2  *
   3  * Copyright 2013 Nikolay Sivov
   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 #define COBJMACROS
  21
  22 #include "windef.h"
  23 #include "ole2.h"
  24 #include "olectl.h"
  25
  26 #include "oledb.h"
  27 #include "oledberr.h"
  28
  29 #include "oledb_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  33
  34 typedef struct rowpos rowpos;
  35 typedef struct
  36 {
  37     IConnectionPoint IConnectionPoint_iface;
  38     rowpos *container;
  39     IRowPositionChange **sinks;
  40     DWORD sinks_size;
  41 } rowpos_cp;
  42
  43 struct rowpos
  44 {
  45     IRowPosition IRowPosition_iface;
  46     IConnectionPointContainer IConnectionPointContainer_iface;
  47     LONG ref;
  48
  49     IRowset *rowset;
  50     IChapteredRowset *chrst;
  51     HROW row;
  52     HCHAPTER chapter;
  53     DBPOSITIONFLAGS flags;
  54     BOOL cleared;
  55     rowpos_cp cp;
  56 };
  57
  58 static void rowposchange_cp_destroy(rowpos_cp*);
  59
  60 static inline rowpos *impl_from_IRowPosition(IRowPosition *iface)
  61 {
  62     return CONTAINING_RECORD(iface, rowpos, IRowPosition_iface);
  63 }
  64
  65 static inline rowpos *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
  66 {
  67     return CONTAINING_RECORD(iface, rowpos, IConnectionPointContainer_iface);
  68 }
  69
  70 static inline rowpos_cp *impl_from_IConnectionPoint(IConnectionPoint *iface)
  71 {
  72     return CONTAINING_RECORD(iface, rowpos_cp, IConnectionPoint_iface);
  73 }
  74
  75 static HRESULT rowpos_fireevent(rowpos *rp, DBREASON reason, DBEVENTPHASE phase)
  76 {
  77     BOOL cant_deny = phase == DBEVENTPHASE_FAILEDTODO || phase == DBEVENTPHASE_SYNCHAFTER;
  78     HRESULT hr = S_OK;
  79     DWORD i;
  80
  81     for (i = 0; i < rp->cp.sinks_size; i++)
  82         if (rp->cp.sinks[i])
  83         {
  84             hr = IRowPositionChange_OnRowPositionChange(rp->cp.sinks[i], reason, phase, cant_deny);
  85             if (phase == DBEVENTPHASE_FAILEDTODO) return DB_E_CANCELED;
  86             if (hr != S_OK) return hr;
  87         }
  88
  89     return hr;
  90 }
  91
  92 static void rowpos_clearposition(rowpos *rp)
  93 {
  94     if (!rp->cleared)
  95     {
  96         if (rp->rowset)
  97             IRowset_ReleaseRows(rp->rowset, 1, &rp->row, NULL, NULL, NULL);
  98         if (rp->chrst)
  99             IChapteredRowset_ReleaseChapter(rp->chrst, rp->chapter, NULL);
 100     }
 101
 102     rp->row = DB_NULL_HROW;
 103     rp->chapter = DB_NULL_HCHAPTER;
 104     rp->flags = DBPOSITION_NOROW;
 105 }
 106
 107 static HRESULT WINAPI rowpos_QueryInterface(IRowPosition* iface, REFIID riid, void **obj)
 108 {
 109     rowpos *This = impl_from_IRowPosition(iface);
 110
 111     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 112
 113     *obj = NULL;
 114
 115     if (IsEqualIID(riid, &IID_IUnknown) ||
 116         IsEqualIID(riid, &IID_IRowPosition))
 117     {
 118         *obj = iface;
 119     }
 120     else if (IsEqualIID(riid, &IID_IConnectionPointContainer))
 121     {
 122         *obj = &This->IConnectionPointContainer_iface;
 123     }
 124     else
 125     {
 126         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 127         return E_NOINTERFACE;
 128     }
 129
 130     IRowPosition_AddRef(iface);
 131     return S_OK;
 132 }
 133
 134 static ULONG WINAPI rowpos_AddRef(IRowPosition* iface)
 135 {
 136     rowpos *This = impl_from_IRowPosition(iface);
 137     ULONG ref = InterlockedIncrement(&This->ref);
 138     TRACE("(%p)->(%d)\n", This, ref);
 139     return ref;
 140 }
 141
 142 static ULONG WINAPI rowpos_Release(IRowPosition* iface)
 143 {
 144     rowpos *This = impl_from_IRowPosition(iface);
 145     LONG ref = InterlockedDecrement(&This->ref);
 146
 147     TRACE("(%p)->(%d)\n", This, ref);
 148
 149     if (ref == 0)
 150     {
 151         if (This->rowset) IRowset_Release(This->rowset);
 152         if (This->chrst) IChapteredRowset_Release(This->chrst);
 153         rowposchange_cp_destroy(&This->cp);
 154         heap_free(This);
 155     }
 156
 157     return ref;
 158 }
 159
 160 static HRESULT WINAPI rowpos_ClearRowPosition(IRowPosition* iface)
 161 {
 162     rowpos *This = impl_from_IRowPosition(iface);
 163     HRESULT hr;
 164
 165     TRACE("(%p)\n", This);
 166
 167     if (!This->rowset) return E_UNEXPECTED;
 168
 169     hr = rowpos_fireevent(This, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO);
 170     if (hr != S_OK)
 171         return rowpos_fireevent(This, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO);
 172
 173     hr = rowpos_fireevent(This, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO);
 174     if (hr != S_OK)
 175         return rowpos_fireevent(This, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO);
 176
 177     rowpos_clearposition(This);
 178     This->cleared = TRUE;
 179     return S_OK;
 180 }
 181
 182 static HRESULT WINAPI rowpos_GetRowPosition(IRowPosition *iface, HCHAPTER *chapter,
 183     HROW *row, DBPOSITIONFLAGS *flags)
 184 {
 185     rowpos *This = impl_from_IRowPosition(iface);
 186
 187     TRACE("(%p)->(%p %p %p)\n", This, chapter, row, flags);
 188
 189     *chapter = This->chapter;
 190     *row = This->row;
 191     *flags = This->flags;
 192
 193     if (!This->rowset) return E_UNEXPECTED;
 194
 195     return S_OK;
 196 }
 197
 198 static HRESULT WINAPI rowpos_GetRowset(IRowPosition *iface, REFIID riid, IUnknown **rowset)
 199 {
 200     rowpos *This = impl_from_IRowPosition(iface);
 201
 202     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), rowset);
 203
 204     if (!This->rowset) return E_UNEXPECTED;
 205     return IRowset_QueryInterface(This->rowset, riid, (void**)rowset);
 206 }
 207
 208 static HRESULT WINAPI rowpos_Initialize(IRowPosition *iface, IUnknown *rowset)
 209 {
 210     rowpos *This = impl_from_IRowPosition(iface);
 211     HRESULT hr;
 212
 213     TRACE("(%p)->(%p)\n", This, rowset);
 214
 215     if (This->rowset) return DB_E_ALREADYINITIALIZED;
 216
 217     hr = IUnknown_QueryInterface(rowset, &IID_IRowset, (void**)&This->rowset);
 218     if (FAILED(hr)) return hr;
 219
 220     /* this one is optional */
 221     IUnknown_QueryInterface(rowset, &IID_IChapteredRowset, (void**)&This->chrst);
 222     return S_OK;
 223 }
 224
 225 static HRESULT WINAPI rowpos_SetRowPosition(IRowPosition *iface, HCHAPTER chapter,
 226     HROW row, DBPOSITIONFLAGS flags)
 227 {
 228     rowpos *This = impl_from_IRowPosition(iface);
 229     DBREASON reason;
 230     HRESULT hr;
 231
 232     TRACE("(%p)->(%lx %lx %d)\n", This, chapter, row, flags);
 233
 234     if (!This->cleared) return E_UNEXPECTED;
 235
 236     hr = IRowset_AddRefRows(This->rowset, 1, &row, NULL, NULL);
 237     if (FAILED(hr)) return hr;
 238
 239     if (This->chrst)
 240     {
 241         hr = IChapteredRowset_AddRefChapter(This->chrst, chapter, NULL);
 242         if (FAILED(hr))
 243         {
 244             IRowset_ReleaseRows(This->rowset, 1, &row, NULL, NULL, NULL);
 245             return hr;
 246         }
 247     }
 248
 249     reason = This->chrst ? DBREASON_ROWPOSITION_CHAPTERCHANGED : DBREASON_ROWPOSITION_CHANGED;
 250     hr = rowpos_fireevent(This, reason, DBEVENTPHASE_SYNCHAFTER);
 251     if (hr != S_OK)
 252     {
 253         IRowset_ReleaseRows(This->rowset, 1, &row, NULL, NULL, NULL);
 254         if (This->chrst)
 255             IChapteredRowset_ReleaseChapter(This->chrst, chapter, NULL);
 256         return rowpos_fireevent(This, reason, DBEVENTPHASE_FAILEDTODO);
 257     }
 258     else
 259         rowpos_fireevent(This, reason, DBEVENTPHASE_DIDEVENT);
 260
 261     /* previously set chapter and row are released with ClearRowPosition() */
 262     This->chapter = chapter;
 263     This->row = row;
 264     This->flags = flags;
 265     This->cleared = FALSE;
 266
 267     return S_OK;
 268 }
 269
 270 static const struct IRowPositionVtbl rowpos_vtbl =
 271 {
 272     rowpos_QueryInterface,
 273     rowpos_AddRef,
 274     rowpos_Release,
 275     rowpos_ClearRowPosition,
 276     rowpos_GetRowPosition,
 277     rowpos_GetRowset,
 278     rowpos_Initialize,
 279     rowpos_SetRowPosition
 280 };
 281
 282 static HRESULT WINAPI cpc_QueryInterface(IConnectionPointContainer *iface, REFIID riid, void **obj)
 283 {
 284     rowpos *This = impl_from_IConnectionPointContainer(iface);
 285     return IRowPosition_QueryInterface(&This->IRowPosition_iface, riid, obj);
 286 }
 287
 288 static ULONG WINAPI cpc_AddRef(IConnectionPointContainer *iface)
 289 {
 290     rowpos *This = impl_from_IConnectionPointContainer(iface);
 291     return IRowPosition_AddRef(&This->IRowPosition_iface);
 292 }
 293
 294 static ULONG WINAPI cpc_Release(IConnectionPointContainer *iface)
 295 {
 296     rowpos *This = impl_from_IConnectionPointContainer(iface);
 297     return IRowPosition_Release(&This->IRowPosition_iface);
 298 }
 299
 300 static HRESULT WINAPI cpc_EnumConnectionPoints(IConnectionPointContainer *iface, IEnumConnectionPoints **enum_points)
 301 {
 302     rowpos *This = impl_from_IConnectionPointContainer(iface);
 303     FIXME("(%p)->(%p): stub\n", This, enum_points);
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI cpc_FindConnectionPoint(IConnectionPointContainer *iface, REFIID riid, IConnectionPoint **point)
 308 {
 309     rowpos *This = impl_from_IConnectionPointContainer(iface);
 310
 311     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), point);
 312
 313     if (IsEqualIID(riid, &IID_IRowPositionChange))
 314     {
 315         *point = &This->cp.IConnectionPoint_iface;
 316         IConnectionPoint_AddRef(*point);
 317         return S_OK;
 318     }
 319     else
 320     {
 321         FIXME("unsupported riid %s\n", debugstr_guid(riid));
 322         return CONNECT_E_NOCONNECTION;
 323     }
 324 }
 325
 326 static const struct IConnectionPointContainerVtbl rowpos_cpc_vtbl =
 327 {
 328     cpc_QueryInterface,
 329     cpc_AddRef,
 330     cpc_Release,
 331     cpc_EnumConnectionPoints,
 332     cpc_FindConnectionPoint
 333 };
 334
 335 static HRESULT WINAPI rowpos_cp_QueryInterface(IConnectionPoint *iface, REFIID riid, void **obj)
 336 {
 337     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 338     return IConnectionPointContainer_QueryInterface(&This->container->IConnectionPointContainer_iface, riid, obj);
 339 }
 340
 341 static ULONG WINAPI rowpos_cp_AddRef(IConnectionPoint *iface)
 342 {
 343     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 344     return IConnectionPointContainer_AddRef(&This->container->IConnectionPointContainer_iface);
 345 }
 346
 347 static ULONG WINAPI rowpos_cp_Release(IConnectionPoint *iface)
 348 {
 349     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 350     return IConnectionPointContainer_Release(&This->container->IConnectionPointContainer_iface);
 351 }
 352
 353 static HRESULT WINAPI rowpos_cp_GetConnectionInterface(IConnectionPoint *iface, IID *iid)
 354 {
 355     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 356
 357     TRACE("(%p)->(%p)\n", This, iid);
 358
 359     if (!iid) return E_POINTER;
 360
 361     *iid = IID_IRowPositionChange;
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI rowpos_cp_GetConnectionPointContainer(IConnectionPoint *iface, IConnectionPointContainer **container)
 366 {
 367     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 368
 369     TRACE("(%p)->(%p)\n", This, container);
 370
 371     if (!container) return E_POINTER;
 372
 373     *container = &This->container->IConnectionPointContainer_iface;
 374     IConnectionPointContainer_AddRef(*container);
 375     return S_OK;
 376 }
 377
 378 static HRESULT WINAPI rowpos_cp_Advise(IConnectionPoint *iface, IUnknown *unksink, DWORD *cookie)
 379 {
 380     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 381     IRowPositionChange *sink;
 382     HRESULT hr;
 383     DWORD i;
 384
 385     TRACE("(%p)->(%p %p)\n", This, unksink, cookie);
 386
 387     if (!cookie) return E_POINTER;
 388
 389     hr = IUnknown_QueryInterface(unksink, &IID_IRowPositionChange, (void**)&sink);
 390     if (FAILED(hr))
 391     {
 392         FIXME("sink doesn't support IRowPositionChange\n");
 393         return CONNECT_E_CANNOTCONNECT;
 394     }
 395
 396     if (This->sinks)
 397     {
 398         for (i = 0; i < This->sinks_size; i++)
 399         {
 400             if (!This->sinks[i])
 401                 break;
 402         }
 403
 404         if (i == This->sinks_size)
 405         {
 406             This->sinks_size *= 2;
 407             This->sinks = heap_realloc_zero(This->sinks, This->sinks_size*sizeof(*This->sinks));
 408         }
 409     }
 410     else
 411     {
 412         This->sinks_size = 10;
 413         This->sinks = heap_alloc_zero(This->sinks_size*sizeof(*This->sinks));
 414         i = 0;
 415     }
 416
 417     This->sinks[i] = sink;
 418     if (cookie) *cookie = i + 1;
 419
 420     return S_OK;
 421 }
 422
 423 static HRESULT WINAPI rowpos_cp_Unadvise(IConnectionPoint *iface, DWORD cookie)
 424 {
 425     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 426
 427     TRACE("(%p)->(%d)\n", This, cookie);
 428
 429     if (!cookie || cookie > This->sinks_size || !This->sinks[cookie-1])
 430         return CONNECT_E_NOCONNECTION;
 431
 432     IRowPositionChange_Release(This->sinks[cookie-1]);
 433     This->sinks[cookie-1] = NULL;
 434
 435     return S_OK;
 436 }
 437
 438 static HRESULT WINAPI rowpos_cp_EnumConnections(IConnectionPoint *iface, IEnumConnections **enum_c)
 439 {
 440     rowpos_cp *This = impl_from_IConnectionPoint(iface);
 441     FIXME("(%p)->(%p): stub\n", This, enum_c);
 442     return E_NOTIMPL;
 443 }
 444
 445 static const struct IConnectionPointVtbl rowpos_cp_vtbl =
 446 {
 447     rowpos_cp_QueryInterface,
 448     rowpos_cp_AddRef,
 449     rowpos_cp_Release,
 450     rowpos_cp_GetConnectionInterface,
 451     rowpos_cp_GetConnectionPointContainer,
 452     rowpos_cp_Advise,
 453     rowpos_cp_Unadvise,
 454     rowpos_cp_EnumConnections
 455 };
 456
 457 static void rowposchange_cp_init(rowpos_cp *cp, rowpos *container)
 458 {
 459     cp->IConnectionPoint_iface.lpVtbl = &rowpos_cp_vtbl;
 460     cp->container = container;
 461     cp->sinks = NULL;
 462     cp->sinks_size = 0;
 463 }
 464
 465 void rowposchange_cp_destroy(rowpos_cp *cp)
 466 {
 467     DWORD i;
 468     for (i = 0; i < cp->sinks_size; i++)
 469     {
 470         if (cp->sinks[i])
 471             IRowPositionChange_Release(cp->sinks[i]);
 472     }
 473     heap_free(cp->sinks);
 474 }
 475
 476 HRESULT create_oledb_rowpos(IUnknown *outer, void **obj)
 477 {
 478     rowpos *This;
 479
 480     TRACE("(%p, %p)\n", outer, obj);
 481
 482     *obj = NULL;
 483
 484     if(outer) return CLASS_E_NOAGGREGATION;
 485
 486     This = heap_alloc(sizeof(*This));
 487     if(!This) return E_OUTOFMEMORY;
 488
 489     This->IRowPosition_iface.lpVtbl = &rowpos_vtbl;
 490     This->IConnectionPointContainer_iface.lpVtbl = &rowpos_cpc_vtbl;
 491     This->ref = 1;
 492     This->rowset = NULL;
 493     This->chrst = NULL;
 494     This->cleared = FALSE;
 495     rowpos_clearposition(This);
 496     rowposchange_cp_init(&This->cp, This);
 497
 498     *obj = &This->IRowPosition_iface;
 499
 500     return S_OK;
 501 }