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