Ignore:
Timestamp:
Jun 9, 2002, 6:37:22 PM (23 years ago)
Author:
sandervl
Message:

Resync with latest Wine

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ole32/compositemoniker.c

    r8441 r8620  
    4040    ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
    4141
    42     /* The ROT (RunningObjectTable implementation) uses the IROTData 
    43      * interface to test whether two monikers are equal. That's why IROTData 
     42    /* The ROT (RunningObjectTable implementation) uses the IROTData
     43     * interface to test whether two monikers are equal. That's why IROTData
    4444     * interface is implemented by monikers.
    4545     */
     
    201201{
    202202    ICOM_THIS(CompositeMonikerImpl,iface);
    203  
     203
    204204    TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
    205205
     
    207207    if ( (This==0) || (ppvObject==0) )
    208208        return E_INVALIDARG;
    209  
     209
    210210    /* Initialize the return parameter */
    211211    *ppvObject = 0;
     
    250250    ICOM_THIS(CompositeMonikerImpl,iface);
    251251    ULONG i;
    252    
     252
    253253    TRACE("(%p)\n",This);
    254254
     
    261261        for (i=0;i<This->tabLastIndex;i++)
    262262            IMoniker_Release(This->tabMoniker[i]);
    263        
     263
    264264        CompositeMonikerImpl_Destroy(This);
    265265
    266266        return 0;
    267267    }
    268     return This->ref;;
     268    return This->ref;
    269269}
    270270
     
    278278    if (pClassID==NULL)
    279279        return E_POINTER;
    280            
     280
    281281    *pClassID = CLSID_CompositeMoniker;
    282        
     282
    283283    return S_OK;
    284284}
     
    307307    CLSID clsid;
    308308    WCHAR string[1]={0};
    309    
    310     ICOM_THIS(CompositeMonikerImpl,iface);   
     309
     310    ICOM_THIS(CompositeMonikerImpl,iface);
    311311
    312312    TRACE("(%p,%p)\n",iface,pStm);
     
    366366        /* resize the table if needed */
    367367        if (++This->tabLastIndex==This->tabSize){
    368                
     368
    369369            This->tabSize+=BLOCK_TAB_SIZE;
    370370            This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
     
    387387    IMoniker *pmk;
    388388    DWORD constant=3;
    389    
     389
    390390    TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
    391391
    392     /* This function calls OleSaveToStream function for each moniker within 
     392    /* This function calls OleSaveToStream function for each moniker within
    393393     * this object.
    394      * When I tested this function in windows, I usually found this constant 
    395      * at the beginning of the stream. I don't known why (there's no 
     394     * When I tested this function in windows, I usually found this constant
     395     * at the beginning of the stream. I don't known why (there's no
    396396     * indication in the specification) !
    397397     */
     
    427427    ULARGE_INTEGER ptmpSize;
    428428
    429     /* The sizeMax of this object is calculated by calling  GetSizeMax on 
     429    /* The sizeMax of this object is calculated by calling  GetSizeMax on
    430430     * each moniker within this object then summing all returned values
    431431     */
     
    465465    IMoniker *tempMk;
    466466    HRESULT res;
    467    
     467
    468468    TRACE("(%p,%p,%p)\n",This,pmkFirst,pmkRest);
    469469
     
    491491
    492492        IMoniker_Enum(pmkFirst,TRUE,&enumMoniker);
    493        
     493
    494494        while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
    495495
    496496
    497497            if (++This->tabLastIndex==This->tabSize){
    498                
     498
    499499                This->tabSize+=BLOCK_TAB_SIZE;
    500500                This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
     
    511511
    512512    IMoniker_IsSystemMoniker(pmkRest,&mkSys);
    513    
     513
    514514    if (mkSys!=MKSYS_GENERICCOMPOSITE){
    515515
     
    518518        res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],pmkRest,TRUE,&tempMk);
    519519
    520         if (res==MK_E_NEEDGENERIC){ 
     520        if (res==MK_E_NEEDGENERIC){
    521521
    522522            /* there's no simplification in this case */
     
    527527            IMoniker_AddRef(pmkRest);
    528528        }
    529         else if (tempMk==NULL){ 
     529        else if (tempMk==NULL){
    530530
    531531            /* we have an antimoniker after a simple moniker so we can make a simplification in this case */
     
    545545        /* resize tabMoniker if needed */
    546546        if (This->tabLastIndex==This->tabSize){
    547                
     547
    548548            This->tabSize+=BLOCK_TAB_SIZE;
    549549
     
    556556    else{
    557557
    558         /* add a composite moniker to the moniker table (do the same thing 
    559          * for each moniker within the composite moniker as a simple moniker 
     558        /* add a composite moniker to the moniker table (do the same thing
     559         * for each moniker within the composite moniker as a simple moniker
    560560         * (see above for how to add a simple moniker case) )
    561561         */
     
    584584
    585585            if (This->tabLastIndex==This->tabSize){
    586                
     586
    587587                This->tabSize+=BLOCK_TAB_SIZE;
    588588
     
    627627    IMoniker *tempMk,*antiMk,*mostRigthMk;
    628628    IEnumMoniker *enumMoniker;
    629    
     629
    630630    TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
    631631
    632632    if (ppvResult==NULL)
    633633        return E_POINTER;
    634    
     634
    635635    *ppvResult=0;
    636636    /* If pmkToLeft is NULL, this method looks for the moniker in the ROT, and if found, queries the retrieved */
     
    656656        IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
    657657        IEnumMoniker_Release(enumMoniker);
    658        
     658
    659659        res=CreateAntiMoniker(&antiMk);
    660660        res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
    661661        IMoniker_Release(antiMk);
    662        
     662
    663663        res=CompositeMonikerImpl_BindToObject(mostRigthMk,pbc,tempMk,riid,ppvResult);
    664664
     
    691691
    692692    if (pmkToLeft!=NULL){
    693        
     693
    694694        IMoniker_Enum(iface,FALSE,&enumMoniker);
    695695        IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
    696696        IEnumMoniker_Release(enumMoniker);
    697        
     697
    698698        res=CreateAntiMoniker(&antiMk);
    699699        res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
    700700        IMoniker_Release(antiMk);
    701        
     701
    702702        res=CompositeMonikerImpl_BindToStorage(mostRigthMk,pbc,tempMk,riid,ppvResult);
    703703
     
    737737        IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
    738738        IEnumMoniker_Release(enumMoniker);
    739        
     739
    740740        res=CreateAntiMoniker(&antiMk);
    741741        res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
     
    754754        IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
    755755        IEnumMoniker_Release(enumMoniker);
    756        
     756
    757757        res=CreateAntiMoniker(&antiMk);
    758758        res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
     
    797797    /* otherwise, the method returns the result of combining the two monikers by calling the */
    798798    /* CreateGenericComposite function */
    799    
     799
    800800    if (fOnlyIfNotGeneric)
    801801        return MK_E_NEEDGENERIC;
    802    
     802
    803803    return CreateGenericComposite(iface,pmkRight,ppmkComposite);
    804804}
     
    815815    if (ppenumMoniker == NULL)
    816816        return E_POINTER;
    817    
     817
    818818    return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabLastIndex,0,fForward,ppenumMoniker);
    819819}
     
    827827    IMoniker *tempMk1,*tempMk2;
    828828    HRESULT res1,res2,res;
    829    
     829
    830830    TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
    831831
     
    839839    if (enumMoniker1==NULL)
    840840        return S_FALSE;
    841    
     841
    842842    IMoniker_Enum(iface,TRUE,&enumMoniker2);
    843843
     
    846846        res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
    847847        res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
    848        
     848
    849849        if((res1==S_OK)&&(res2==S_OK)){
    850850
     
    916916        /* If pmkToLeft is NULL, this method returns S_OK if pmkNewlyRunning is non-NULL and is equal */
    917917        /* to this moniker */
    918        
     918
    919919        if (pmkNewlyRunning!=NULL)
    920920
     
    934934            /* IMoniker::IsRunning on the rightmost component of the composite, passing the remainder of */
    935935            /* the composite as the pmkToLeft parameter for that call.                                   */
    936            
     936
    937937             res=IBindCtx_GetRunningObjectTable(pbc,&rot);
    938938
     
    978978    IMoniker *tempMk,*antiMk,*mostRigthMk;
    979979    IEnumMoniker *enumMoniker;
    980    
     980
    981981    TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pCompositeTime);
    982982
     
    10751075    IEnumMoniker *enumMoniker1,*enumMoniker2;
    10761076    ULONG i,nbCommonMk=0;
    1077    
     1077
    10781078    /* If the other moniker is a composite, this method compares the components of each composite from left  */
    10791079    /* to right. The returned common prefix moniker might also be a composite moniker, depending on how many */
     
    10821082    if (ppmkPrefix==NULL)
    10831083        return E_POINTER;
    1084    
     1084
    10851085    *ppmkPrefix=0;
    10861086
    10871087    if (pmkOther==NULL)
    10881088        return MK_E_NOPREFIX;
    1089    
     1089
    10901090    IMoniker_IsSystemMoniker(pmkOther,&mkSys);
    10911091
     
    11511151            IMoniker_Release(tempMk1);
    11521152            IMoniker_Release(tempMk2);
    1153            
     1153
    11541154            /* compose all common monikers in a composite moniker */
    11551155            for(i=0;i<nbCommonMk;i++){
     
    11621162
    11631163                IMoniker_Release(tempMk1);
    1164                
     1164
    11651165                *ppmkPrefix=tempMk2;
    11661166            }
     
    12031203    DWORD mkSys;
    12041204    HRESULT res1,res2;
    1205    
     1205
    12061206    *restMk=0;
    12071207
     
    12461246    for(;IEnumMoniker_Next(enumMoniker3,1,&tempMk,NULL)==S_OK;nbRestMk++)
    12471247
    1248         IMoniker_Release(tempMk);;
     1248        IMoniker_Release(tempMk);
    12491249
    12501250    if (nbRestMk==0)
     
    13011301
    13021302    /* finds the common prefix of the two monikers */
    1303     res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk);   
     1303    res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk);
    13041304
    13051305    /* if there's no common prefix or the two moniker are equal the relative is the other moniker */
     
    13581358    if (ppszDisplayName==NULL)
    13591359        return E_POINTER;
    1360    
     1360
    13611361    *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR));
    13621362
     
    13701370
    13711371    IMoniker_Enum(iface,TRUE,&enumMoniker);
    1372    
     1372
    13731373    while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
    13741374
     
    14301430    if (!pwdMksys)
    14311431        return E_POINTER;
    1432    
     1432
    14331433    (*pwdMksys)=MKSYS_GENERICCOMPOSITE;
    14341434
     
    14671467{
    14681468    ICOM_THIS_From_IROTData(IMoniker, iface);
    1469    
     1469
    14701470    TRACE("(%p)\n",iface);
    14711471
     
    14911491{
    14921492    ICOM_THIS(EnumMonikerImpl,iface);
    1493  
     1493
    14941494    TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
    14951495
     
    14971497    if ( (This==0) || (ppvObject==0) )
    14981498        return E_INVALIDARG;
    1499  
     1499
    15001500    /* Initialize the return parameter */
    15011501    *ppvObject = 0;
     
    15421542    /* destroy the object if there's no more reference on it */
    15431543    if (This->ref==0){
    1544        
     1544
    15451545        for(i=0;i<This->tabSize;i++)
    15461546            IMoniker_Release(This->tabMoniker[i]);
     
    15511551        return 0;
    15521552    }
    1553     return This->ref;;
     1553    return This->ref;
    15541554}
    15551555
     
    15691569    if (pceltFethed!=NULL)
    15701570        *pceltFethed= i;
    1571    
     1571
    15721572    if (i==celt)
    15731573        return S_OK;
     
    15871587
    15881588    This->currentPos+=celt;
    1589    
     1589
    15901590    return S_OK;
    15911591}
     
    16331633    if (currentPos > tabSize)
    16341634        return E_INVALIDARG;
    1635    
     1635
    16361636    /* Initialize the virtual function table. */
    16371637    ICOM_VTBL(newEnumMoniker)    = &VT_EnumMonikerImpl;
     
    16761676    if (ppmkComposite==NULL)
    16771677        return E_POINTER;
    1678    
     1678
    16791679    *ppmkComposite=0;
    16801680
Note: See TracChangeset for help on using the changeset viewer.