dlls/ole32/compositemoniker.c

   1 /*
   2  * CompositeMonikers implementation
   3  *
   4  * Copyright 1999  Noomen Hamza
   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 <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "winerror.h"
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35 #include "ole2.h"
  36 #include "moniker.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  39
  40 #define  BLOCK_TAB_SIZE 5 /* represent the first size table and it's increment block size */
  41
  42 /* CompositeMoniker data structure */
  43 typedef struct CompositeMonikerImpl{
  44     IMoniker IMoniker_iface;
  45     IROTData IROTData_iface;
  46     IMarshal IMarshal_iface;
  47     LONG ref;
  48     IMoniker** tabMoniker; /* dynamic table containing all components (monikers) of this composite moniker */
  49     ULONG    tabSize;      /* size of tabMoniker */
  50     ULONG    tabLastIndex; /* first free index in tabMoniker */
  51 } CompositeMonikerImpl;
  52
  53 static inline CompositeMonikerImpl *impl_from_IMoniker(IMoniker *iface)
  54 {
  55     return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMoniker_iface);
  56 }
  57
  58 static inline CompositeMonikerImpl *impl_from_IROTData(IROTData *iface)
  59 {
  60     return CONTAINING_RECORD(iface, CompositeMonikerImpl, IROTData_iface);
  61 }
  62
  63 static inline CompositeMonikerImpl *impl_from_IMarshal(IMarshal *iface)
  64 {
  65     return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMarshal_iface);
  66 }
  67
  68 /* EnumMoniker data structure */
  69 typedef struct EnumMonikerImpl{
  70     IEnumMoniker IEnumMoniker_iface;
  71     LONG ref;
  72     IMoniker** tabMoniker; /* dynamic table containing the enumerated monikers */
  73     ULONG      tabSize; /* size of tabMoniker */
  74     ULONG      currentPos;  /* index pointer on the current moniker */
  75 } EnumMonikerImpl;
  76
  77 static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface)
  78 {
  79     return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
  80 }
  81
  82 static HRESULT EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker,ULONG tabSize,ULONG currentPos,BOOL leftToRigth,IEnumMoniker ** ppmk);
  83
  84 /*******************************************************************************
  85  *        CompositeMoniker_QueryInterface
  86  *******************************************************************************/
  87 static HRESULT WINAPI
  88 CompositeMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
  89 {
  90     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
  91
  92     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
  93
  94     /* Perform a sanity check on the parameters.*/
  95     if ( ppvObject==0 )
  96         return E_INVALIDARG;
  97
  98     /* Initialize the return parameter */
  99     *ppvObject = 0;
 100
 101     /* Compare the riid with the interface IDs implemented by this object.*/
 102     if (IsEqualIID(&IID_IUnknown, riid) ||
 103         IsEqualIID(&IID_IPersist, riid) ||
 104         IsEqualIID(&IID_IPersistStream, riid) ||
 105         IsEqualIID(&IID_IMoniker, riid)
 106        )
 107         *ppvObject = iface;
 108     else if (IsEqualIID(&IID_IROTData, riid))
 109         *ppvObject = &This->IROTData_iface;
 110     else if (IsEqualIID(&IID_IMarshal, riid))
 111         *ppvObject = &This->IMarshal_iface;
 112
 113     /* Check that we obtained an interface.*/
 114     if ((*ppvObject)==0)
 115         return E_NOINTERFACE;
 116
 117     /* Query Interface always increases the reference count by one when it is successful */
 118     IMoniker_AddRef(iface);
 119
 120     return S_OK;
 121 }
 122
 123 /******************************************************************************
 124  *        CompositeMoniker_AddRef
 125  ******************************************************************************/
 126 static ULONG WINAPI
 127 CompositeMonikerImpl_AddRef(IMoniker* iface)
 128 {
 129     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 130
 131     TRACE("(%p)\n",This);
 132
 133     return InterlockedIncrement(&This->ref);
 134 }
 135
 136 static void CompositeMonikerImpl_ReleaseMonikersInTable(CompositeMonikerImpl *This)
 137 {
 138     ULONG i;
 139
 140     for (i = 0; i < This->tabLastIndex; i++)
 141         IMoniker_Release(This->tabMoniker[i]);
 142
 143     This->tabLastIndex = 0;
 144 }
 145
 146 /******************************************************************************
 147  *        CompositeMoniker_Release
 148  ******************************************************************************/
 149 static ULONG WINAPI
 150 CompositeMonikerImpl_Release(IMoniker* iface)
 151 {
 152     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 153     ULONG ref;
 154
 155     TRACE("(%p)\n",This);
 156
 157     ref = InterlockedDecrement(&This->ref);
 158
 159     /* destroy the object if there are no more references to it */
 160     if (ref == 0){
 161
 162         /* release all the components before destroying this object */
 163         CompositeMonikerImpl_ReleaseMonikersInTable(This);
 164
 165         HeapFree(GetProcessHeap(),0,This->tabMoniker);
 166         HeapFree(GetProcessHeap(),0,This);
 167     }
 168     return ref;
 169 }
 170
 171 /******************************************************************************
 172  *        CompositeMoniker_GetClassID
 173  ******************************************************************************/
 174 static HRESULT WINAPI
 175 CompositeMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 176 {
 177     TRACE("(%p,%p)\n",iface,pClassID);
 178
 179     if (pClassID==NULL)
 180         return E_POINTER;
 181
 182     *pClassID = CLSID_CompositeMoniker;
 183
 184     return S_OK;
 185 }
 186
 187 /******************************************************************************
 188  *        CompositeMoniker_IsDirty
 189  ******************************************************************************/
 190 static HRESULT WINAPI
 191 CompositeMonikerImpl_IsDirty(IMoniker* iface)
 192 {
 193     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 194        method in the OLE-provided moniker interfaces always return S_FALSE because
 195        their internal state never changes. */
 196
 197     TRACE("(%p)\n",iface);
 198
 199     return S_FALSE;
 200 }
 201
 202 /******************************************************************************
 203  *        CompositeMoniker_Load
 204  ******************************************************************************/
 205 static HRESULT WINAPI
 206 CompositeMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 207 {
 208     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 209     HRESULT res;
 210     DWORD moniker_count;
 211     DWORD i;
 212
 213     TRACE("(%p,%p)\n",iface,pStm);
 214
 215     /* this function call OleLoadFromStream function for each moniker within this object */
 216
 217     res=IStream_Read(pStm,&moniker_count,sizeof(DWORD),NULL);
 218     if (res != S_OK)
 219     {
 220         ERR("couldn't reading moniker count from stream\n");
 221         return E_FAIL;
 222     }
 223
 224     CompositeMonikerImpl_ReleaseMonikersInTable(This);
 225
 226     for (i = 0; i < moniker_count; i++)
 227     {
 228         res=OleLoadFromStream(pStm,&IID_IMoniker,(void**)&This->tabMoniker[This->tabLastIndex]);
 229         if (FAILED(res))
 230         {
 231             ERR("couldn't load moniker from stream, res = 0x%08x\n", res);
 232             break;
 233         }
 234
 235         /* resize the table if needed */
 236         if (++This->tabLastIndex==This->tabSize){
 237
 238             This->tabSize+=BLOCK_TAB_SIZE;
 239             This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
 240
 241             if (This->tabMoniker==NULL)
 242             return E_OUTOFMEMORY;
 243         }
 244     }
 245
 246     return res;
 247 }
 248
 249 /******************************************************************************
 250  *        CompositeMoniker_Save
 251  ******************************************************************************/
 252 static HRESULT WINAPI
 253 CompositeMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
 254 {
 255     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 256     HRESULT res;
 257     IEnumMoniker *enumMk;
 258     IMoniker *pmk;
 259     DWORD moniker_count = This->tabLastIndex;
 260
 261     TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
 262
 263     /* This function calls OleSaveToStream function for each moniker within
 264      * this object.
 265      * When I tested this function in windows, I usually found this constant
 266      * at the beginning of the stream. I don't known why (there's no
 267      * indication in the specification) !
 268      */
 269     res=IStream_Write(pStm,&moniker_count,sizeof(moniker_count),NULL);
 270     if (FAILED(res)) return res;
 271
 272     IMoniker_Enum(iface,TRUE,&enumMk);
 273
 274     while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
 275
 276         res=OleSaveToStream((IPersistStream*)pmk,pStm);
 277
 278         IMoniker_Release(pmk);
 279
 280         if (FAILED(res)){
 281
 282             IEnumMoniker_Release(enumMk);
 283             return res;
 284         }
 285     }
 286
 287     IEnumMoniker_Release(enumMk);
 288
 289     return S_OK;
 290 }
 291
 292 /******************************************************************************
 293  *        CompositeMoniker_GetSizeMax
 294  ******************************************************************************/
 295 static HRESULT WINAPI
 296 CompositeMonikerImpl_GetSizeMax(IMoniker* iface,ULARGE_INTEGER* pcbSize)
 297 {
 298     IEnumMoniker *enumMk;
 299     IMoniker *pmk;
 300     ULARGE_INTEGER ptmpSize;
 301
 302     /* The sizeMax of this object is calculated by calling  GetSizeMax on
 303      * each moniker within this object then summing all returned values
 304      */
 305
 306     TRACE("(%p,%p)\n",iface,pcbSize);
 307
 308     if (!pcbSize)
 309         return E_POINTER;
 310
 311     pcbSize->QuadPart = sizeof(DWORD);
 312
 313     IMoniker_Enum(iface,TRUE,&enumMk);
 314
 315     while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
 316
 317         IMoniker_GetSizeMax(pmk,&ptmpSize);
 318
 319         IMoniker_Release(pmk);
 320
 321         pcbSize->QuadPart = ptmpSize.QuadPart + sizeof(CLSID);
 322     }
 323
 324     IEnumMoniker_Release(enumMk);
 325
 326     return S_OK;
 327 }
 328
 329 /******************************************************************************
 330  *                  CompositeMoniker_BindToObject
 331  ******************************************************************************/
 332 static HRESULT WINAPI
 333 CompositeMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc,
 334                IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult)
 335 {
 336     HRESULT   res;
 337     IRunningObjectTable *prot;
 338     IMoniker *tempMk,*antiMk,*mostRigthMk;
 339     IEnumMoniker *enumMoniker;
 340
 341     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 342
 343     if (ppvResult==NULL)
 344         return E_POINTER;
 345
 346     *ppvResult=0;
 347     /* If pmkToLeft is NULL, this method looks for the moniker in the ROT, and if found, queries the retrieved */
 348     /* object for the requested interface pointer. */
 349     if(pmkToLeft==NULL){
 350
 351         res=IBindCtx_GetRunningObjectTable(pbc,&prot);
 352
 353         if (SUCCEEDED(res)){
 354
 355             /* if the requested class was loaded before ! we don't need to reload it */
 356             res = IRunningObjectTable_GetObject(prot,iface,(IUnknown**)ppvResult);
 357
 358             if (res==S_OK)
 359                 return res;
 360         }
 361     }
 362     else{
 363         /* If pmkToLeft is not NULL, the method recursively calls IMoniker::BindToObject on the rightmost */
 364         /* component of the composite, passing the rest of the composite as the pmkToLeft parameter for that call */
 365
 366         IMoniker_Enum(iface,FALSE,&enumMoniker);
 367         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 368         IEnumMoniker_Release(enumMoniker);
 369
 370         res=CreateAntiMoniker(&antiMk);
 371         res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 372         IMoniker_Release(antiMk);
 373
 374         res=IMoniker_BindToObject(mostRigthMk,pbc,tempMk,riid,ppvResult);
 375
 376         IMoniker_Release(tempMk);
 377         IMoniker_Release(mostRigthMk);
 378     }
 379
 380     return res;
 381 }
 382
 383 /******************************************************************************
 384  *        CompositeMoniker_BindToStorage
 385  ******************************************************************************/
 386 static HRESULT WINAPI
 387 CompositeMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc,
 388                IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult)
 389 {
 390     HRESULT   res;
 391     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftMk;
 392     IEnumMoniker *enumMoniker;
 393
 394     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 395
 396     *ppvResult=0;
 397
 398     /* This method recursively calls BindToStorage on the rightmost component of the composite, */
 399     /* passing the rest of the composite as the pmkToLeft parameter for that call. */
 400
 401     if (pmkToLeft)
 402     {
 403         res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
 404         if (FAILED(res)) return res;
 405     }
 406     else
 407         leftMk = iface;
 408
 409     IMoniker_Enum(iface, FALSE, &enumMoniker);
 410     IEnumMoniker_Next(enumMoniker, 1, &mostRigthMk, NULL);
 411     IEnumMoniker_Release(enumMoniker);
 412
 413     res = CreateAntiMoniker(&antiMk);
 414     if (FAILED(res)) return res;
 415     res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
 416     if (FAILED(res)) return res;
 417     IMoniker_Release(antiMk);
 418
 419     res = IMoniker_BindToStorage(mostRigthMk, pbc, tempMk, riid, ppvResult);
 420
 421     IMoniker_Release(tempMk);
 422
 423     IMoniker_Release(mostRigthMk);
 424
 425     if (pmkToLeft)
 426         IMoniker_Release(leftMk);
 427
 428     return res;
 429 }
 430
 431 /******************************************************************************
 432  *        CompositeMoniker_Reduce
 433  ******************************************************************************/
 434 static HRESULT WINAPI
 435 CompositeMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 436                IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 437 {
 438     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftReducedComposedMk,*mostRigthReducedMk;
 439     IEnumMoniker *enumMoniker;
 440
 441     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 442
 443     if (ppmkReduced==NULL)
 444         return E_POINTER;
 445
 446     /* This method recursively calls Reduce for each of its component monikers. */
 447
 448     if (ppmkToLeft==NULL){
 449
 450         IMoniker_Enum(iface,FALSE,&enumMoniker);
 451         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 452         IEnumMoniker_Release(enumMoniker);
 453
 454         CreateAntiMoniker(&antiMk);
 455         IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 456         IMoniker_Release(antiMk);
 457
 458         return IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,&tempMk, ppmkReduced);
 459     }
 460     else if (*ppmkToLeft==NULL)
 461
 462         return IMoniker_Reduce(iface,pbc,dwReduceHowFar,NULL,ppmkReduced);
 463
 464     else{
 465
 466         /* separate the composite moniker in to left and right moniker */
 467         IMoniker_Enum(iface,FALSE,&enumMoniker);
 468         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 469         IEnumMoniker_Release(enumMoniker);
 470
 471         CreateAntiMoniker(&antiMk);
 472         IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 473         IMoniker_Release(antiMk);
 474
 475         /* If any of the components  reduces itself, the method returns S_OK and passes back a composite */
 476         /* of the reduced components */
 477         if (IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,NULL,&mostRigthReducedMk) &&
 478             IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,&tempMk,&leftReducedComposedMk)
 479            )
 480
 481             return CreateGenericComposite(leftReducedComposedMk,mostRigthReducedMk,ppmkReduced);
 482
 483         else{
 484             /* If no reduction occurred, the method passes back the same moniker and returns MK_S_REDUCED_TO_SELF.*/
 485
 486             IMoniker_AddRef(iface);
 487
 488             *ppmkReduced=iface;
 489
 490             return MK_S_REDUCED_TO_SELF;
 491         }
 492     }
 493 }
 494
 495 /******************************************************************************
 496  *        CompositeMoniker_ComposeWith
 497  ******************************************************************************/
 498 static HRESULT WINAPI
 499 CompositeMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
 500                BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
 501 {
 502     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 503
 504     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 505         return E_POINTER;
 506
 507     *ppmkComposite=0;
 508
 509     /* If fOnlyIfNotGeneric is TRUE, this method sets *pmkComposite to NULL and returns MK_E_NEEDGENERIC; */
 510     /* otherwise, the method returns the result of combining the two monikers by calling the */
 511     /* CreateGenericComposite function */
 512
 513     if (fOnlyIfNotGeneric)
 514         return MK_E_NEEDGENERIC;
 515
 516     return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 517 }
 518
 519 /******************************************************************************
 520  *        CompositeMoniker_Enum
 521  ******************************************************************************/
 522 static HRESULT WINAPI
 523 CompositeMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 524 {
 525     CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 526
 527     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 528
 529     if (ppenumMoniker == NULL)
 530         return E_POINTER;
 531
 532     return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabLastIndex,0,fForward,ppenumMoniker);
 533 }
 534
 535 /******************************************************************************
 536  *        CompositeMoniker_IsEqual
 537  ******************************************************************************/
 538 static HRESULT WINAPI
 539 CompositeMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 540 {
 541     IEnumMoniker *enumMoniker1,*enumMoniker2;
 542     IMoniker *tempMk1,*tempMk2;
 543     HRESULT res1,res2,res;
 544     BOOL done;
 545
 546     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
 547
 548     if (pmkOtherMoniker==NULL)
 549         return S_FALSE;
 550
 551     /* This method returns S_OK if the components of both monikers are equal when compared in the */
 552     /* left-to-right order.*/
 553     IMoniker_Enum(pmkOtherMoniker,TRUE,&enumMoniker1);
 554
 555     if (enumMoniker1==NULL)
 556         return S_FALSE;
 557
 558     IMoniker_Enum(iface,TRUE,&enumMoniker2);
 559
 560     do {
 561
 562         res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 563         res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
 564
 565         if((res1==S_OK)&&(res2==S_OK)){
 566             done = (res = IMoniker_IsEqual(tempMk1,tempMk2)) == S_FALSE;
 567         }
 568         else
 569         {
 570             res = (res1==S_FALSE) && (res2==S_FALSE);
 571             done = TRUE;
 572         }
 573
 574         if (res1==S_OK)
 575             IMoniker_Release(tempMk1);
 576
 577         if (res2==S_OK)
 578             IMoniker_Release(tempMk2);
 579     } while (!done);
 580
 581     IEnumMoniker_Release(enumMoniker1);
 582     IEnumMoniker_Release(enumMoniker2);
 583
 584     return res;
 585 }
 586 /******************************************************************************
 587  *        CompositeMoniker_Hash
 588  ******************************************************************************/
 589 static HRESULT WINAPI
 590 CompositeMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 591 {
 592     IEnumMoniker *enumMoniker;
 593     IMoniker *tempMk;
 594     HRESULT res;
 595     DWORD tempHash;
 596
 597     TRACE("(%p,%p)\n",iface,pdwHash);
 598
 599     if (pdwHash==NULL)
 600         return E_POINTER;
 601
 602     res = IMoniker_Enum(iface,TRUE,&enumMoniker);
 603     if(FAILED(res))
 604         return res;
 605
 606     *pdwHash = 0;
 607
 608     while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
 609         res = IMoniker_Hash(tempMk, &tempHash);
 610         if(FAILED(res))
 611             break;
 612         *pdwHash = *pdwHash ^ tempHash;
 613
 614         IMoniker_Release(tempMk);
 615     }
 616
 617     IEnumMoniker_Release(enumMoniker);
 618
 619     return res;
 620 }
 621
 622 /******************************************************************************
 623  *        CompositeMoniker_IsRunning
 624  ******************************************************************************/
 625 static HRESULT WINAPI
 626 CompositeMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc,
 627                IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning)
 628 {
 629     IRunningObjectTable* rot;
 630     HRESULT res;
 631     IMoniker *tempMk,*antiMk,*mostRigthMk;
 632     IEnumMoniker *enumMoniker;
 633
 634     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 635
 636     /* If pmkToLeft is non-NULL, this method composes pmkToLeft with this moniker and calls IsRunning on the result.*/
 637     if (pmkToLeft!=NULL){
 638
 639         CreateGenericComposite(pmkToLeft,iface,&tempMk);
 640
 641         res = IMoniker_IsRunning(tempMk,pbc,NULL,pmkNewlyRunning);
 642
 643         IMoniker_Release(tempMk);
 644
 645         return res;
 646     }
 647     else
 648         /* If pmkToLeft is NULL, this method returns S_OK if pmkNewlyRunning is non-NULL and is equal */
 649         /* to this moniker */
 650
 651         if (pmkNewlyRunning!=NULL)
 652
 653             if (IMoniker_IsEqual(iface,pmkNewlyRunning)==S_OK)
 654                 return S_OK;
 655
 656             else
 657                 return S_FALSE;
 658
 659         else{
 660
 661             if (pbc==NULL)
 662                 return E_INVALIDARG;
 663
 664             /* If pmkToLeft and pmkNewlyRunning are both NULL, this method checks the ROT to see whether */
 665             /* the moniker is running. If so, the method returns S_OK; otherwise, it recursively calls   */
 666             /* IMoniker::IsRunning on the rightmost component of the composite, passing the remainder of */
 667             /* the composite as the pmkToLeft parameter for that call.                                   */
 668
 669              res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 670
 671             if (FAILED(res))
 672                 return res;
 673
 674             res = IRunningObjectTable_IsRunning(rot,iface);
 675             IRunningObjectTable_Release(rot);
 676
 677             if(res==S_OK)
 678                 return S_OK;
 679
 680             else{
 681
 682                 IMoniker_Enum(iface,FALSE,&enumMoniker);
 683                 IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 684                 IEnumMoniker_Release(enumMoniker);
 685
 686                 res=CreateAntiMoniker(&antiMk);
 687                 res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 688                 IMoniker_Release(antiMk);
 689
 690                 res=IMoniker_IsRunning(mostRigthMk,pbc,tempMk,pmkNewlyRunning);
 691
 692                 IMoniker_Release(tempMk);
 693                 IMoniker_Release(mostRigthMk);
 694
 695                 return res;
 696             }
 697         }
 698 }
 699
 700 /******************************************************************************
 701  *        CompositeMoniker_GetTimeOfLastChange
 702  ******************************************************************************/
 703 static HRESULT WINAPI
 704 CompositeMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
 705                IMoniker* pmkToLeft, FILETIME* pCompositeTime)
 706 {
 707     HRESULT res;
 708     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftMk;
 709     IEnumMoniker *enumMoniker;
 710
 711     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pCompositeTime);
 712
 713     if (pCompositeTime==NULL)
 714         return E_INVALIDARG;
 715
 716     /* This method creates a composite of pmkToLeft (if non-NULL) and this moniker and uses the ROT to  */
 717     /* retrieve the time of last change. If the object is not in the ROT, the method recursively calls  */
 718     /* IMoniker::GetTimeOfLastChange on the rightmost component of the composite, passing the remainder */
 719     /* of the composite as the pmkToLeft parameter for that call.                                       */
 720     if (pmkToLeft)
 721     {
 722         IRunningObjectTable* rot;
 723
 724         res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
 725
 726         res = IBindCtx_GetRunningObjectTable(pbc,&rot);
 727         if (FAILED(res))
 728         {
 729             IMoniker_Release(leftMk);
 730             return res;
 731         }
 732
 733         if (IRunningObjectTable_GetTimeOfLastChange(rot,leftMk,pCompositeTime)==S_OK)
 734         {
 735             IMoniker_Release(leftMk);
 736             return res;
 737         }
 738     }
 739     else
 740         leftMk = iface;
 741
 742     IMoniker_Enum(iface, FALSE, &enumMoniker);
 743     IEnumMoniker_Next(enumMoniker, 1, &mostRigthMk, NULL);
 744     IEnumMoniker_Release(enumMoniker);
 745
 746     res = CreateAntiMoniker(&antiMk);
 747     res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
 748     IMoniker_Release(antiMk);
 749
 750     res = IMoniker_GetTimeOfLastChange(mostRigthMk, pbc, tempMk, pCompositeTime);
 751
 752     IMoniker_Release(tempMk);
 753     IMoniker_Release(mostRigthMk);
 754
 755     if (pmkToLeft)
 756         IMoniker_Release(leftMk);
 757
 758     return res;
 759 }
 760
 761 /******************************************************************************
 762  *        CompositeMoniker_Inverse
 763  ******************************************************************************/
 764 static HRESULT WINAPI
 765 CompositeMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 766 {
 767     HRESULT res;
 768     IMoniker *tempMk,*antiMk,*mostRigthMk,*tempInvMk,*mostRigthInvMk;
 769     IEnumMoniker *enumMoniker;
 770
 771     TRACE("(%p,%p)\n",iface,ppmk);
 772
 773     if (ppmk==NULL)
 774         return E_POINTER;
 775
 776     /* This method returns a composite moniker that consists of the inverses of each of the components */
 777     /* of the original composite, stored in reverse order */
 778
 779     res=CreateAntiMoniker(&antiMk);
 780     res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 781     IMoniker_Release(antiMk);
 782
 783     if (tempMk==NULL)
 784
 785         return IMoniker_Inverse(iface,ppmk);
 786
 787     else{
 788
 789         IMoniker_Enum(iface,FALSE,&enumMoniker);
 790         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 791         IEnumMoniker_Release(enumMoniker);
 792
 793         IMoniker_Inverse(mostRigthMk,&mostRigthInvMk);
 794         CompositeMonikerImpl_Inverse(tempMk,&tempInvMk);
 795
 796         res=CreateGenericComposite(mostRigthInvMk,tempInvMk,ppmk);
 797
 798         IMoniker_Release(tempMk);
 799         IMoniker_Release(mostRigthMk);
 800         IMoniker_Release(tempInvMk);
 801         IMoniker_Release(mostRigthInvMk);
 802
 803         return res;
 804     }
 805 }
 806
 807 /******************************************************************************
 808  *        CompositeMoniker_CommonPrefixWith
 809  ******************************************************************************/
 810 static HRESULT WINAPI
 811 CompositeMonikerImpl_CommonPrefixWith(IMoniker* iface, IMoniker* pmkOther,
 812                IMoniker** ppmkPrefix)
 813 {
 814     DWORD mkSys;
 815     HRESULT res1,res2;
 816     IMoniker *tempMk1,*tempMk2,*mostLeftMk1,*mostLeftMk2;
 817     IEnumMoniker *enumMoniker1,*enumMoniker2;
 818     ULONG i,nbCommonMk=0;
 819
 820     /* If the other moniker is a composite, this method compares the components of each composite from left  */
 821     /* to right. The returned common prefix moniker might also be a composite moniker, depending on how many */
 822     /* of the leftmost components were common to both monikers.                                              */
 823
 824     if (ppmkPrefix==NULL)
 825         return E_POINTER;
 826
 827     *ppmkPrefix=0;
 828
 829     if (pmkOther==NULL)
 830         return MK_E_NOPREFIX;
 831
 832     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
 833
 834     if(mkSys==MKSYS_GENERICCOMPOSITE){
 835
 836         IMoniker_Enum(iface,TRUE,&enumMoniker1);
 837         IMoniker_Enum(pmkOther,TRUE,&enumMoniker2);
 838
 839         while(1){
 840
 841             res1=IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
 842             res2=IEnumMoniker_Next(enumMoniker2,1,&mostLeftMk2,NULL);
 843
 844             if ((res1==S_FALSE) && (res2==S_FALSE)){
 845
 846                 /* If the monikers are equal, the method returns MK_S_US and sets ppmkPrefix to this moniker.*/
 847                 *ppmkPrefix=iface;
 848                 IMoniker_AddRef(iface);
 849                 return  MK_S_US;
 850             }
 851             else if ((res1==S_OK) && (res2==S_OK)){
 852
 853                 if (IMoniker_IsEqual(mostLeftMk1,mostLeftMk2)==S_OK)
 854
 855                     nbCommonMk++;
 856
 857                 else
 858                     break;
 859
 860             }
 861             else if (res1==S_OK){
 862
 863                 /* If the other moniker is a prefix of this moniker, the method returns MK_S_HIM and sets */
 864                 /* ppmkPrefix to the other moniker.                                                       */
 865                 *ppmkPrefix=pmkOther;
 866                 return MK_S_HIM;
 867             }
 868             else{
 869                 /* If this moniker is a prefix of the other, this method returns MK_S_ME and sets ppmkPrefix */
 870                 /* to this moniker.                                                                          */
 871                 *ppmkPrefix=iface;
 872                 return MK_S_ME;
 873             }
 874         }
 875
 876         IEnumMoniker_Release(enumMoniker1);
 877         IEnumMoniker_Release(enumMoniker2);
 878
 879         /* If there is no common prefix, this method returns MK_E_NOPREFIX and sets ppmkPrefix to NULL. */
 880         if (nbCommonMk==0)
 881             return MK_E_NOPREFIX;
 882
 883         IEnumMoniker_Reset(enumMoniker1);
 884
 885         IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 886
 887         /* if we have more than one common moniker the result will be a composite moniker */
 888         if (nbCommonMk>1){
 889
 890             /* initialize the common prefix moniker with the composite of two first moniker (from the left)*/
 891             IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
 892             CreateGenericComposite(tempMk1,tempMk2,ppmkPrefix);
 893             IMoniker_Release(tempMk1);
 894             IMoniker_Release(tempMk2);
 895
 896             /* compose all common monikers in a composite moniker */
 897             for(i=0;i<nbCommonMk;i++){
 898
 899                 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 900
 901                 CreateGenericComposite(*ppmkPrefix,tempMk1,&tempMk2);
 902
 903                 IMoniker_Release(*ppmkPrefix);
 904
 905                 IMoniker_Release(tempMk1);
 906
 907                 *ppmkPrefix=tempMk2;
 908             }
 909             return S_OK;
 910         }
 911         else{
 912             /* if we have only one common moniker the result will be a simple moniker which is the most-left one*/
 913             *ppmkPrefix=tempMk1;
 914
 915             return S_OK;
 916         }
 917     }
 918     else{
 919         /* If the other moniker is not a composite, the method simply compares it to the leftmost component
 920          of this moniker.*/
 921
 922         IMoniker_Enum(iface,TRUE,&enumMoniker1);
 923
 924         IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
 925
 926         if (IMoniker_IsEqual(pmkOther,mostLeftMk1)==S_OK){
 927
 928             *ppmkPrefix=pmkOther;
 929
 930             return MK_S_HIM;
 931         }
 932         else
 933             return MK_E_NOPREFIX;
 934     }
 935 }
 936
 937 /***************************************************************************************************
 938  *        GetAfterCommonPrefix (local function)
 939  *  This function returns a moniker that consist of the remainder when the common prefix is removed
 940  ***************************************************************************************************/
 941 static VOID GetAfterCommonPrefix(IMoniker* pGenMk,IMoniker* commonMk,IMoniker** restMk)
 942 {
 943     IMoniker *tempMk,*tempMk1,*tempMk2;
 944     IEnumMoniker *enumMoniker1,*enumMoniker2,*enumMoniker3;
 945     ULONG nbRestMk=0;
 946     DWORD mkSys;
 947     HRESULT res1,res2;
 948
 949     *restMk=0;
 950
 951     /* to create an enumerator for pGenMk with current position pointed on the first element after common  */
 952     /* prefix: enum the two monikers (left-right) then compare these enumerations (left-right) and stop  */
 953     /* on the first difference. */
 954     IMoniker_Enum(pGenMk,TRUE,&enumMoniker1);
 955
 956     IMoniker_IsSystemMoniker(commonMk,&mkSys);
 957
 958     if (mkSys==MKSYS_GENERICCOMPOSITE){
 959
 960         IMoniker_Enum(commonMk,TRUE,&enumMoniker2);
 961         while(1){
 962
 963             res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 964             res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
 965
 966             if ((res1==S_FALSE)||(res2==S_FALSE)){
 967
 968                 if (res1==S_OK)
 969
 970                     nbRestMk++;
 971
 972                 IMoniker_Release(tempMk1);
 973                 IMoniker_Release(tempMk2);
 974
 975                 break;
 976             }
 977             IMoniker_Release(tempMk1);
 978             IMoniker_Release(tempMk2);
 979         }
 980     }
 981     else{
 982         IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 983         IMoniker_Release(tempMk1);
 984     }
 985
 986     /* count the number of elements in the enumerator after the common prefix */
 987     IEnumMoniker_Clone(enumMoniker1,&enumMoniker3);
 988
 989     for(;IEnumMoniker_Next(enumMoniker3,1,&tempMk,NULL)==S_OK;nbRestMk++)
 990
 991         IMoniker_Release(tempMk);
 992
 993     if (nbRestMk==0)
 994         return;
 995
 996     /* create a generic composite moniker with monikers located after the common prefix */
 997     IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 998
 999     if (nbRestMk==1){
1000
1001         *restMk= tempMk1;
1002         return;
1003     }
1004     else {
1005
1006         IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
1007
1008         CreateGenericComposite(tempMk1,tempMk2,restMk);
1009
1010         IMoniker_Release(tempMk1);
1011
1012         IMoniker_Release(tempMk2);
1013
1014         while(IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL)==S_OK){
1015
1016             CreateGenericComposite(*restMk,tempMk1,&tempMk2);
1017
1018             IMoniker_Release(tempMk1);
1019
1020             IMoniker_Release(*restMk);
1021
1022             *restMk=tempMk2;
1023         }
1024     }
1025 }
1026
1027 /******************************************************************************
1028  *        CompositeMoniker_RelativePathTo
1029  ******************************************************************************/
1030 static HRESULT WINAPI
1031 CompositeMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmkOther,
1032                IMoniker** ppmkRelPath)
1033 {
1034     HRESULT res;
1035     IMoniker *restOtherMk=0,*restThisMk=0,*invRestThisMk=0,*commonMk=0;
1036
1037     TRACE("(%p,%p,%p)\n",iface,pmkOther,ppmkRelPath);
1038
1039     if (ppmkRelPath==NULL)
1040         return E_POINTER;
1041
1042     *ppmkRelPath=0;
1043
1044     /* This method finds the common prefix of the two monikers and creates two monikers that consist     */
1045     /* of the remainder when the common prefix is removed. Then it creates the inverse for the remainder */
1046     /* of this moniker and composes the remainder of the other moniker on the right of it.               */
1047
1048     /* finds the common prefix of the two monikers */
1049     res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk);
1050
1051     /* if there's no common prefix or the two moniker are equal the relative is the other moniker */
1052     if ((res== MK_E_NOPREFIX)||(res==MK_S_US)){
1053
1054         *ppmkRelPath=pmkOther;
1055         IMoniker_AddRef(pmkOther);
1056         return MK_S_HIM;
1057     }
1058
1059     GetAfterCommonPrefix(iface,commonMk,&restThisMk);
1060     GetAfterCommonPrefix(pmkOther,commonMk,&restOtherMk);
1061
1062     /* if other is a prefix of this moniker the relative path is the inverse of the remainder path of this */
1063     /* moniker when the common prefix is removed                                                           */
1064     if (res==MK_S_HIM){
1065
1066         IMoniker_Inverse(restThisMk,ppmkRelPath);
1067         IMoniker_Release(restThisMk);
1068     }
1069     /* if this moniker is a prefix of other moniker the relative path is the remainder path of other moniker */
1070     /* when the common prefix is removed                                                                     */
1071     else if (res==MK_S_ME){
1072
1073         *ppmkRelPath=restOtherMk;
1074         IMoniker_AddRef(restOtherMk);
1075     }
1076     /* the relative path is the inverse for the remainder of this moniker and the remainder of the other  */
1077     /* moniker on the right of it.                                                                        */
1078     else if (res==S_OK){
1079
1080         IMoniker_Inverse(restThisMk,&invRestThisMk);
1081         IMoniker_Release(restThisMk);
1082         CreateGenericComposite(invRestThisMk,restOtherMk,ppmkRelPath);
1083         IMoniker_Release(invRestThisMk);
1084         IMoniker_Release(restOtherMk);
1085     }
1086     return S_OK;
1087 }
1088
1089 /******************************************************************************
1090  *        CompositeMoniker_GetDisplayName
1091  ******************************************************************************/
1092 static HRESULT WINAPI
1093 CompositeMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
1094                IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
1095 {
1096     ULONG lengthStr=1;
1097     IEnumMoniker *enumMoniker;
1098     IMoniker* tempMk;
1099     LPOLESTR tempStr;
1100
1101     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1102
1103     if (ppszDisplayName==NULL)
1104         return E_POINTER;
1105
1106     *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR));
1107
1108     if (*ppszDisplayName==NULL)
1109         return E_OUTOFMEMORY;
1110
1111     /* This method returns the concatenation of the display names returned by each component moniker of */
1112     /* the composite */
1113
1114     **ppszDisplayName=0;
1115
1116     IMoniker_Enum(iface,TRUE,&enumMoniker);
1117
1118     while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
1119
1120         IMoniker_GetDisplayName(tempMk,pbc,NULL,&tempStr);
1121
1122         lengthStr+=lstrlenW(tempStr);
1123
1124         *ppszDisplayName=CoTaskMemRealloc(*ppszDisplayName,lengthStr * sizeof(WCHAR));
1125
1126         if (*ppszDisplayName==NULL)
1127             return E_OUTOFMEMORY;
1128
1129         strcatW(*ppszDisplayName,tempStr);
1130
1131         CoTaskMemFree(tempStr);
1132         IMoniker_Release(tempMk);
1133     }
1134
1135     IEnumMoniker_Release(enumMoniker);
1136
1137     return S_OK;
1138 }
1139
1140 /******************************************************************************
1141  *        CompositeMoniker_ParseDisplayName
1142  ******************************************************************************/
1143 static HRESULT WINAPI
1144 CompositeMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
1145                IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten,
1146                IMoniker** ppmkOut)
1147 {
1148     IEnumMoniker *enumMoniker;
1149     IMoniker *tempMk,*mostRigthMk,*antiMk;
1150     /* This method recursively calls IMoniker::ParseDisplayName on the rightmost component of the composite,*/
1151     /* passing everything else as the pmkToLeft parameter for that call. */
1152
1153     /* get the most right moniker */
1154     IMoniker_Enum(iface,FALSE,&enumMoniker);
1155     IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
1156     IEnumMoniker_Release(enumMoniker);
1157
1158     /* get the left moniker */
1159     CreateAntiMoniker(&antiMk);
1160     IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
1161     IMoniker_Release(antiMk);
1162
1163     return IMoniker_ParseDisplayName(mostRigthMk,pbc,tempMk,pszDisplayName,pchEaten,ppmkOut);
1164 }
1165
1166 /******************************************************************************
1167  *        CompositeMoniker_IsSystemMoniker
1168  ******************************************************************************/
1169 static HRESULT WINAPI
1170 CompositeMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1171 {
1172     TRACE("(%p,%p)\n",iface,pwdMksys);
1173
1174     if (!pwdMksys)
1175         return E_POINTER;
1176
1177     (*pwdMksys)=MKSYS_GENERICCOMPOSITE;
1178
1179     return S_OK;
1180 }
1181
1182 /*******************************************************************************
1183  *        CompositeMonikerIROTData_QueryInterface
1184  *******************************************************************************/
1185 static HRESULT WINAPI
1186 CompositeMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,
1187                VOID** ppvObject)
1188 {
1189     CompositeMonikerImpl *This = impl_from_IROTData(iface);
1190
1191     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
1192
1193     return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
1194 }
1195
1196 /***********************************************************************
1197  *        CompositeMonikerIROTData_AddRef
1198  */
1199 static ULONG WINAPI
1200 CompositeMonikerROTDataImpl_AddRef(IROTData *iface)
1201 {
1202     CompositeMonikerImpl *This = impl_from_IROTData(iface);
1203
1204     TRACE("(%p)\n",iface);
1205
1206     return IMoniker_AddRef(&This->IMoniker_iface);
1207 }
1208
1209 /***********************************************************************
1210  *        CompositeMonikerIROTData_Release
1211  */
1212 static ULONG WINAPI CompositeMonikerROTDataImpl_Release(IROTData* iface)
1213 {
1214     CompositeMonikerImpl *This = impl_from_IROTData(iface);
1215
1216     TRACE("(%p)\n",iface);
1217
1218     return IMoniker_Release(&This->IMoniker_iface);
1219 }
1220
1221 /******************************************************************************
1222  *        CompositeMonikerIROTData_GetComparisonData
1223  ******************************************************************************/
1224 static HRESULT WINAPI
1225 CompositeMonikerROTDataImpl_GetComparisonData(IROTData* iface,
1226                BYTE* pbData, ULONG cbMax, ULONG* pcbData)
1227 {
1228     CompositeMonikerImpl *This = impl_from_IROTData(iface);
1229     IEnumMoniker *pEnumMk;
1230     IMoniker *pmk;
1231     HRESULT hr;
1232
1233     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
1234
1235     *pcbData = sizeof(CLSID);
1236
1237     hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1238     if (FAILED(hr)) return hr;
1239
1240     while(IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1241     {
1242         IROTData *pROTData;
1243         hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1244         if (FAILED(hr))
1245             ERR("moniker doesn't support IROTData interface\n");
1246
1247         if (SUCCEEDED(hr))
1248         {
1249             ULONG cbData;
1250             hr = IROTData_GetComparisonData(pROTData, NULL, 0, &cbData);
1251             IROTData_Release(pROTData);
1252             if (SUCCEEDED(hr) || (hr == E_OUTOFMEMORY))
1253             {
1254                 *pcbData += cbData;
1255                 hr = S_OK;
1256             }
1257             else
1258                 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1259         }
1260
1261         IMoniker_Release(pmk);
1262
1263         if (FAILED(hr))
1264         {
1265             IEnumMoniker_Release(pEnumMk);
1266             return hr;
1267         }
1268     }
1269     if (cbMax < *pcbData)
1270         return E_OUTOFMEMORY;
1271
1272     IEnumMoniker_Reset(pEnumMk);
1273
1274     memcpy(pbData, &CLSID_CompositeMoniker, sizeof(CLSID));
1275     pbData += sizeof(CLSID);
1276     cbMax -= sizeof(CLSID);
1277
1278     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1279     {
1280         IROTData *pROTData;
1281         hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1282         if (FAILED(hr))
1283             ERR("moniker doesn't support IROTData interface\n");
1284
1285         if (SUCCEEDED(hr))
1286         {
1287             ULONG cbData;
1288             hr = IROTData_GetComparisonData(pROTData, pbData, cbMax, &cbData);
1289             IROTData_Release(pROTData);
1290             if (SUCCEEDED(hr))
1291             {
1292                 pbData += cbData;
1293                 cbMax -= cbData;
1294             }
1295             else
1296                 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1297         }
1298
1299         IMoniker_Release(pmk);
1300
1301         if (FAILED(hr))
1302         {
1303             IEnumMoniker_Release(pEnumMk);
1304             return hr;
1305         }
1306     }
1307
1308     IEnumMoniker_Release(pEnumMk);
1309
1310     return S_OK;
1311 }
1312
1313 static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1314 {
1315     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1316
1317     TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppv);
1318
1319     return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppv);
1320 }
1321
1322 static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef(IMarshal *iface)
1323 {
1324     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1325
1326     TRACE("(%p)\n",iface);
1327
1328     return CompositeMonikerImpl_AddRef(&This->IMoniker_iface);
1329 }
1330
1331 static ULONG WINAPI CompositeMonikerMarshalImpl_Release(IMarshal *iface)
1332 {
1333     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1334
1335     TRACE("(%p)\n",iface);
1336
1337     return CompositeMonikerImpl_Release(&This->IMoniker_iface);
1338 }
1339
1340 static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass(
1341   IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext,
1342   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1343 {
1344     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1345
1346     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1347         dwDestContext, pvDestContext, mshlflags, pCid);
1348
1349     return IMoniker_GetClassID(&This->IMoniker_iface, pCid);
1350 }
1351
1352 static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax(
1353   IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext,
1354   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1355 {
1356     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1357     IEnumMoniker *pEnumMk;
1358     IMoniker *pmk;
1359     HRESULT hr;
1360     ULARGE_INTEGER size;
1361
1362     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1363         dwDestContext, pvDestContext, mshlflags, pSize);
1364
1365     *pSize = 0x10; /* to match native */
1366
1367     hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1368     if (FAILED(hr)) return hr;
1369
1370     hr = IMoniker_GetSizeMax(&This->IMoniker_iface, &size);
1371
1372     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1373     {
1374         ULONG size;
1375
1376         hr = CoGetMarshalSizeMax(&size, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1377         if (SUCCEEDED(hr))
1378             *pSize += size;
1379
1380         IMoniker_Release(pmk);
1381
1382         if (FAILED(hr))
1383         {
1384             IEnumMoniker_Release(pEnumMk);
1385             return hr;
1386         }
1387     }
1388
1389     IEnumMoniker_Release(pEnumMk);
1390
1391     return S_OK;
1392 }
1393
1394 static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface(IMarshal *iface, IStream *pStm,
1395     REFIID riid, void* pv, DWORD dwDestContext,
1396     void* pvDestContext, DWORD mshlflags)
1397 {
1398     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1399     IEnumMoniker *pEnumMk;
1400     IMoniker *pmk;
1401     HRESULT hr;
1402     ULONG i = 0;
1403
1404     TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1405         dwDestContext, pvDestContext, mshlflags);
1406
1407     hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1408     if (FAILED(hr)) return hr;
1409
1410     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1411     {
1412         hr = CoMarshalInterface(pStm, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1413
1414         IMoniker_Release(pmk);
1415
1416         if (FAILED(hr))
1417         {
1418             IEnumMoniker_Release(pEnumMk);
1419             return hr;
1420         }
1421         i++;
1422     }
1423
1424     if (i != 2)
1425         FIXME("moniker count of %d not supported\n", i);
1426
1427     IEnumMoniker_Release(pEnumMk);
1428
1429     return S_OK;
1430 }
1431
1432 static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface(IMarshal *iface, IStream *pStm,
1433     REFIID riid, void **ppv)
1434 {
1435     CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1436     HRESULT hr;
1437
1438     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1439
1440     CompositeMonikerImpl_ReleaseMonikersInTable(This);
1441
1442     /* resize the table if needed */
1443     if (This->tabLastIndex + 2 > This->tabSize)
1444     {
1445         This->tabSize += max(BLOCK_TAB_SIZE, 2);
1446         This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
1447
1448         if (This->tabMoniker==NULL)
1449             return E_OUTOFMEMORY;
1450     }
1451
1452     hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1453     if (FAILED(hr))
1454     {
1455         ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1456         return hr;
1457     }
1458     This->tabLastIndex++;
1459     hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1460     if (FAILED(hr))
1461     {
1462         ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1463         return hr;
1464     }
1465     This->tabLastIndex++;
1466
1467     return IMoniker_QueryInterface(&This->IMoniker_iface, riid, ppv);
1468 }
1469
1470 static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData(IMarshal *iface, IStream *pStm)
1471 {
1472     TRACE("(%p)\n", pStm);
1473     /* can't release a state-based marshal as nothing on server side to
1474      * release */
1475     return S_OK;
1476 }
1477
1478 static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject(IMarshal *iface,
1479     DWORD dwReserved)
1480 {
1481     TRACE("(0x%x)\n", dwReserved);
1482     /* can't disconnect a state-based marshal as nothing on server side to
1483      * disconnect from */
1484     return S_OK;
1485 }
1486
1487 /******************************************************************************
1488  *        EnumMonikerImpl_QueryInterface
1489  ******************************************************************************/
1490 static HRESULT WINAPI
1491 EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1492 {
1493     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1494
1495     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1496
1497     /* Perform a sanity check on the parameters.*/
1498     if ( ppvObject==0 )
1499         return E_INVALIDARG;
1500
1501     /* Initialize the return parameter */
1502     *ppvObject = 0;
1503
1504     /* Compare the riid with the interface IDs implemented by this object.*/
1505     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
1506         *ppvObject = iface;
1507
1508     /* Check that we obtained an interface.*/
1509     if ((*ppvObject)==0)
1510         return E_NOINTERFACE;
1511
1512     /* Query Interface always increases the reference count by one when it is successful */
1513     IEnumMoniker_AddRef(iface);
1514
1515     return S_OK;
1516 }
1517
1518 /******************************************************************************
1519  *        EnumMonikerImpl_AddRef
1520  ******************************************************************************/
1521 static ULONG WINAPI
1522 EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1523 {
1524     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1525
1526     TRACE("(%p)\n",This);
1527
1528     return InterlockedIncrement(&This->ref);
1529
1530 }
1531
1532 /******************************************************************************
1533  *        EnumMonikerImpl_Release
1534  ******************************************************************************/
1535 static ULONG WINAPI
1536 EnumMonikerImpl_Release(IEnumMoniker* iface)
1537 {
1538     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1539     ULONG i;
1540     ULONG ref;
1541     TRACE("(%p)\n",This);
1542
1543     ref = InterlockedDecrement(&This->ref);
1544
1545     /* destroy the object if there are no more references to it */
1546     if (ref == 0) {
1547
1548         for(i=0;i<This->tabSize;i++)
1549             IMoniker_Release(This->tabMoniker[i]);
1550
1551         HeapFree(GetProcessHeap(),0,This->tabMoniker);
1552         HeapFree(GetProcessHeap(),0,This);
1553     }
1554     return ref;
1555 }
1556
1557 /******************************************************************************
1558  *        EnumMonikerImpl_Next
1559  ******************************************************************************/
1560 static HRESULT WINAPI
1561 EnumMonikerImpl_Next(IEnumMoniker* iface,ULONG celt, IMoniker** rgelt,
1562                ULONG* pceltFethed)
1563 {
1564     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1565     ULONG i;
1566
1567     /* retrieve the requested number of moniker from the current position */
1568     for(i=0;((This->currentPos < This->tabSize) && (i < celt));i++)
1569     {
1570         rgelt[i]=This->tabMoniker[This->currentPos++];
1571         IMoniker_AddRef(rgelt[i]);
1572     }
1573
1574     if (pceltFethed!=NULL)
1575         *pceltFethed= i;
1576
1577     if (i==celt)
1578         return S_OK;
1579     else
1580         return S_FALSE;
1581 }
1582
1583 /******************************************************************************
1584  *        EnumMonikerImpl_Skip
1585  ******************************************************************************/
1586 static HRESULT WINAPI
1587 EnumMonikerImpl_Skip(IEnumMoniker* iface,ULONG celt)
1588 {
1589     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1590
1591     if ((This->currentPos+celt) >= This->tabSize)
1592         return S_FALSE;
1593
1594     This->currentPos+=celt;
1595
1596     return S_OK;
1597 }
1598
1599 /******************************************************************************
1600  *        EnumMonikerImpl_Reset
1601  ******************************************************************************/
1602 static HRESULT WINAPI
1603 EnumMonikerImpl_Reset(IEnumMoniker* iface)
1604 {
1605     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1606
1607     This->currentPos=0;
1608
1609     return S_OK;
1610 }
1611
1612 /******************************************************************************
1613  *        EnumMonikerImpl_Clone
1614  ******************************************************************************/
1615 static HRESULT WINAPI
1616 EnumMonikerImpl_Clone(IEnumMoniker* iface,IEnumMoniker** ppenum)
1617 {
1618     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1619
1620     return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabSize,This->currentPos,TRUE,ppenum);
1621 }
1622
1623 /********************************************************************************/
1624 /* Virtual function table for the IROTData class                                */
1625 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1626 {
1627     EnumMonikerImpl_QueryInterface,
1628     EnumMonikerImpl_AddRef,
1629     EnumMonikerImpl_Release,
1630     EnumMonikerImpl_Next,
1631     EnumMonikerImpl_Skip,
1632     EnumMonikerImpl_Reset,
1633     EnumMonikerImpl_Clone
1634 };
1635
1636 /******************************************************************************
1637  *        EnumMonikerImpl_CreateEnumMoniker
1638  ******************************************************************************/
1639 static HRESULT
1640 EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker, ULONG tabSize,
1641                ULONG currentPos, BOOL leftToRight, IEnumMoniker ** ppmk)
1642 {
1643     EnumMonikerImpl* newEnumMoniker;
1644     ULONG i;
1645
1646     if (currentPos > tabSize)
1647         return E_INVALIDARG;
1648
1649     newEnumMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1650
1651     if (newEnumMoniker == 0)
1652         return STG_E_INSUFFICIENTMEMORY;
1653
1654     /* Initialize the virtual function table. */
1655     newEnumMoniker->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1656     newEnumMoniker->ref          = 1;
1657
1658     newEnumMoniker->tabSize=tabSize;
1659     newEnumMoniker->currentPos=currentPos;
1660
1661     newEnumMoniker->tabMoniker=HeapAlloc(GetProcessHeap(),0,tabSize*sizeof(newEnumMoniker->tabMoniker[0]));
1662
1663     if (newEnumMoniker->tabMoniker==NULL) {
1664         HeapFree(GetProcessHeap(), 0, newEnumMoniker);
1665         return E_OUTOFMEMORY;
1666     }
1667
1668     if (leftToRight)
1669         for (i=0;i<tabSize;i++){
1670
1671             newEnumMoniker->tabMoniker[i]=tabMoniker[i];
1672             IMoniker_AddRef(tabMoniker[i]);
1673         }
1674     else
1675         for (i = tabSize; i > 0; i--){
1676
1677             newEnumMoniker->tabMoniker[tabSize-i]=tabMoniker[i - 1];
1678             IMoniker_AddRef(tabMoniker[i - 1]);
1679         }
1680
1681     *ppmk=&newEnumMoniker->IEnumMoniker_iface;
1682
1683     return S_OK;
1684 }
1685
1686 /********************************************************************************/
1687 /* Virtual function table for the CompositeMonikerImpl class which includes     */
1688 /* IPersist, IPersistStream and IMoniker functions.                             */
1689
1690 static const IMonikerVtbl VT_CompositeMonikerImpl =
1691 {
1692     CompositeMonikerImpl_QueryInterface,
1693     CompositeMonikerImpl_AddRef,
1694     CompositeMonikerImpl_Release,
1695     CompositeMonikerImpl_GetClassID,
1696     CompositeMonikerImpl_IsDirty,
1697     CompositeMonikerImpl_Load,
1698     CompositeMonikerImpl_Save,
1699     CompositeMonikerImpl_GetSizeMax,
1700     CompositeMonikerImpl_BindToObject,
1701     CompositeMonikerImpl_BindToStorage,
1702     CompositeMonikerImpl_Reduce,
1703     CompositeMonikerImpl_ComposeWith,
1704     CompositeMonikerImpl_Enum,
1705     CompositeMonikerImpl_IsEqual,
1706     CompositeMonikerImpl_Hash,
1707     CompositeMonikerImpl_IsRunning,
1708     CompositeMonikerImpl_GetTimeOfLastChange,
1709     CompositeMonikerImpl_Inverse,
1710     CompositeMonikerImpl_CommonPrefixWith,
1711     CompositeMonikerImpl_RelativePathTo,
1712     CompositeMonikerImpl_GetDisplayName,
1713     CompositeMonikerImpl_ParseDisplayName,
1714     CompositeMonikerImpl_IsSystemMoniker
1715 };
1716
1717 /********************************************************************************/
1718 /* Virtual function table for the IROTData class.                               */
1719 static const IROTDataVtbl VT_ROTDataImpl =
1720 {
1721     CompositeMonikerROTDataImpl_QueryInterface,
1722     CompositeMonikerROTDataImpl_AddRef,
1723     CompositeMonikerROTDataImpl_Release,
1724     CompositeMonikerROTDataImpl_GetComparisonData
1725 };
1726
1727 static const IMarshalVtbl VT_MarshalImpl =
1728 {
1729     CompositeMonikerMarshalImpl_QueryInterface,
1730     CompositeMonikerMarshalImpl_AddRef,
1731     CompositeMonikerMarshalImpl_Release,
1732     CompositeMonikerMarshalImpl_GetUnmarshalClass,
1733     CompositeMonikerMarshalImpl_GetMarshalSizeMax,
1734     CompositeMonikerMarshalImpl_MarshalInterface,
1735     CompositeMonikerMarshalImpl_UnmarshalInterface,
1736     CompositeMonikerMarshalImpl_ReleaseMarshalData,
1737     CompositeMonikerMarshalImpl_DisconnectObject
1738 };
1739
1740 /******************************************************************************
1741  *         Composite-Moniker_Construct (local function)
1742  *******************************************************************************/
1743 static HRESULT
1744 CompositeMonikerImpl_Construct(IMoniker **ppMoniker, IMoniker *pmkFirst, IMoniker *pmkRest)
1745 {
1746     DWORD mkSys;
1747     IEnumMoniker *enumMoniker;
1748     IMoniker *tempMk;
1749     HRESULT res;
1750     CompositeMonikerImpl *This;
1751
1752     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1753
1754     if (!This)
1755         return E_OUTOFMEMORY;
1756
1757     TRACE("(%p,%p,%p)\n",This,pmkFirst,pmkRest);
1758
1759     /* Initialize the virtual function table. */
1760     This->IMoniker_iface.lpVtbl = &VT_CompositeMonikerImpl;
1761     This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
1762     This->IMarshal_iface.lpVtbl = &VT_MarshalImpl;
1763     This->ref          = 1;
1764
1765     This->tabSize=BLOCK_TAB_SIZE;
1766     This->tabLastIndex=0;
1767
1768     This->tabMoniker=HeapAlloc(GetProcessHeap(),0,This->tabSize*sizeof(This->tabMoniker[0]));
1769     if (This->tabMoniker==NULL) {
1770         HeapFree(GetProcessHeap(), 0, This);
1771         return E_OUTOFMEMORY;
1772     }
1773
1774     if (!pmkFirst && !pmkRest)
1775     {
1776         *ppMoniker = &This->IMoniker_iface;
1777         return S_OK;
1778     }
1779
1780     IMoniker_IsSystemMoniker(pmkFirst,&mkSys);
1781
1782     /* put the first moniker contents in the beginning of the table */
1783     if (mkSys!=MKSYS_GENERICCOMPOSITE){
1784
1785         This->tabMoniker[(This->tabLastIndex)++]=pmkFirst;
1786         IMoniker_AddRef(pmkFirst);
1787     }
1788     else{
1789
1790         IMoniker_Enum(pmkFirst,TRUE,&enumMoniker);
1791
1792         while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1793
1794
1795             if (++This->tabLastIndex==This->tabSize){
1796                 LPVOID tab_moniker = This->tabMoniker;
1797
1798                 This->tabSize+=BLOCK_TAB_SIZE;
1799                 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1800
1801                 if (This->tabMoniker==NULL){
1802                     HeapFree(GetProcessHeap(), 0, tab_moniker);
1803                     HeapFree(GetProcessHeap(), 0, This);
1804                     return E_OUTOFMEMORY;
1805                 }
1806             }
1807         }
1808
1809         IEnumMoniker_Release(enumMoniker);
1810     }
1811
1812     /* put the rest moniker contents after the first one and make simplification if needed */
1813
1814     IMoniker_IsSystemMoniker(pmkRest,&mkSys);
1815
1816     if (mkSys!=MKSYS_GENERICCOMPOSITE){
1817
1818         /* add a simple moniker to the moniker table */
1819
1820         res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],pmkRest,TRUE,&tempMk);
1821
1822         if (res==MK_E_NEEDGENERIC){
1823
1824             /* there's no simplification in this case */
1825             This->tabMoniker[This->tabLastIndex]=pmkRest;
1826
1827             This->tabLastIndex++;
1828
1829             IMoniker_AddRef(pmkRest);
1830         }
1831         else if (tempMk==NULL){
1832
1833             /* we have an antimoniker after a simple moniker so we can make a simplification in this case */
1834             IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1835
1836             This->tabLastIndex--;
1837         }
1838         else if (SUCCEEDED(res)){
1839
1840             /* the non-generic composition was successful so we can make a simplification in this case */
1841             IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1842
1843             This->tabMoniker[This->tabLastIndex-1]=tempMk;
1844         } else
1845             return res;
1846
1847         /* resize tabMoniker if needed */
1848         if (This->tabLastIndex==This->tabSize){
1849             LPVOID tab_moniker = This->tabMoniker;
1850
1851             This->tabSize+=BLOCK_TAB_SIZE;
1852
1853             This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1854
1855             if (This->tabMoniker==NULL){
1856                 HeapFree(GetProcessHeap(), 0, tab_moniker);
1857                 HeapFree(GetProcessHeap(), 0, This);
1858                 return E_OUTOFMEMORY;
1859             }
1860         }
1861     }
1862     else{
1863
1864         /* add a composite moniker to the moniker table (do the same thing
1865          * for each moniker within the composite moniker as a simple moniker
1866          * (see above for how to add a simple moniker case) )
1867          */
1868         IMoniker_Enum(pmkRest,TRUE,&enumMoniker);
1869
1870         while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1871
1872             res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],This->tabMoniker[This->tabLastIndex],TRUE,&tempMk);
1873
1874             if (res==MK_E_NEEDGENERIC){
1875
1876                 This->tabLastIndex++;
1877             }
1878             else if (tempMk==NULL){
1879
1880                 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1881                 IMoniker_Release(This->tabMoniker[This->tabLastIndex]);
1882                 This->tabLastIndex--;
1883             }
1884             else{
1885
1886                 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1887
1888                 This->tabMoniker[This->tabLastIndex-1]=tempMk;
1889             }
1890
1891             if (This->tabLastIndex==This->tabSize){
1892                 LPVOID tab_moniker = This->tabMoniker;
1893
1894                 This->tabSize+=BLOCK_TAB_SIZE;
1895
1896                 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
1897
1898                 if (This->tabMoniker==NULL){
1899                     HeapFree(GetProcessHeap(), 0, tab_moniker);
1900                     HeapFree(GetProcessHeap(), 0, This);
1901                     return E_OUTOFMEMORY;
1902                 }
1903             }
1904         }
1905
1906         IEnumMoniker_Release(enumMoniker);
1907     }
1908
1909     /* only one moniker, then just return it */
1910     if (This->tabLastIndex == 1)
1911     {
1912         *ppMoniker = This->tabMoniker[0];
1913         IMoniker_AddRef(*ppMoniker);
1914         IMoniker_Release(&This->IMoniker_iface);
1915     }
1916     else
1917         *ppMoniker = &This->IMoniker_iface;
1918
1919     return S_OK;
1920 }
1921
1922 /******************************************************************************
1923  *        CreateGenericComposite        [OLE32.@]
1924  ******************************************************************************/
1925 HRESULT WINAPI
1926 CreateGenericComposite(IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
1927 {
1928     IMoniker* moniker = 0;
1929     HRESULT        hr = S_OK;
1930
1931     TRACE("(%p,%p,%p)\n",pmkFirst,pmkRest,ppmkComposite);
1932
1933     if (ppmkComposite==NULL)
1934         return E_POINTER;
1935
1936     *ppmkComposite=0;
1937
1938     if (pmkFirst==NULL && pmkRest!=NULL){
1939
1940         *ppmkComposite=pmkRest;
1941         return S_OK;
1942     }
1943     else if (pmkFirst!=NULL && pmkRest==NULL){
1944         *ppmkComposite=pmkFirst;
1945         return S_OK;
1946     }
1947     else  if (pmkFirst==NULL && pmkRest==NULL)
1948         return S_OK;
1949
1950     hr = CompositeMonikerImpl_Construct(&moniker,pmkFirst,pmkRest);
1951
1952     if (FAILED(hr))
1953         return hr;
1954
1955     hr = IMoniker_QueryInterface(moniker,&IID_IMoniker,(void**)ppmkComposite);
1956     IMoniker_Release(moniker);
1957
1958     return hr;
1959 }
1960
1961 /******************************************************************************
1962  *        MonikerCommonPrefixWith       [OLE32.@]
1963  ******************************************************************************/
1964 HRESULT WINAPI
1965 MonikerCommonPrefixWith(IMoniker* pmkThis,IMoniker* pmkOther,IMoniker** ppmkCommon)
1966 {
1967     FIXME("(),stub!\n");
1968     return E_NOTIMPL;
1969 }
1970
1971 static HRESULT WINAPI CompositeMonikerCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1972 {
1973     *ppv = NULL;
1974     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1975     {
1976         *ppv = iface;
1977         IClassFactory_AddRef(iface);
1978         return S_OK;
1979     }
1980     return E_NOINTERFACE;
1981 }
1982
1983 static ULONG WINAPI CompositeMonikerCF_AddRef(LPCLASSFACTORY iface)
1984 {
1985     return 2; /* non-heap based object */
1986 }
1987
1988 static ULONG WINAPI CompositeMonikerCF_Release(LPCLASSFACTORY iface)
1989 {
1990     return 1; /* non-heap based object */
1991 }
1992
1993 static HRESULT WINAPI CompositeMonikerCF_CreateInstance(LPCLASSFACTORY iface,
1994     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1995 {
1996     IMoniker* pMoniker;
1997     HRESULT  hr;
1998
1999     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
2000
2001     *ppv = NULL;
2002
2003     if (pUnk)
2004         return CLASS_E_NOAGGREGATION;
2005
2006     hr = CompositeMonikerImpl_Construct(&pMoniker, NULL, NULL);
2007
2008     if (SUCCEEDED(hr))
2009     {
2010         hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
2011         IMoniker_Release(pMoniker);
2012     }
2013
2014     return hr;
2015 }
2016
2017 static HRESULT WINAPI CompositeMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
2018 {
2019     FIXME("(%d), stub!\n",fLock);
2020     return S_OK;
2021 }
2022
2023 static const IClassFactoryVtbl CompositeMonikerCFVtbl =
2024 {
2025     CompositeMonikerCF_QueryInterface,
2026     CompositeMonikerCF_AddRef,
2027     CompositeMonikerCF_Release,
2028     CompositeMonikerCF_CreateInstance,
2029     CompositeMonikerCF_LockServer
2030 };
2031 static const IClassFactoryVtbl *CompositeMonikerCF = &CompositeMonikerCFVtbl;
2032
2033 HRESULT CompositeMonikerCF_Create(REFIID riid, LPVOID *ppv)
2034 {
2035     return IClassFactory_QueryInterface((IClassFactory *)&CompositeMonikerCF, riid, ppv);
2036 }