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