Ignore:
Timestamp:
Sep 15, 2001, 11:32:00 AM (24 years ago)
Author:
sandervl
Message:

restored old version + wine update

File:
1 edited

Legend:

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

    r6648 r6711  
    1 /* $Id: filemoniker.c,v 1.2 2001-09-05 13:17:09 bird Exp $ */
    21/***************************************************************************************
    3  *                        FileMonikers implementation
     2 *                            FileMonikers implementation
    43 *
    54 *               Copyright 1999  Noomen Hamza
     
    2726    ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
    2827
    29     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
     28    /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether 
    3029     * two monikers are equal. That's whay IROTData interface is implemented by monikers.
    3130     */
     
    137136{
    138137    ICOM_THIS(FileMonikerImpl,iface);
    139 
     138 
    140139  TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
    141140
    142141    /* Perform a sanity check on the parameters.*/
    143142    if ( (This==0) || (ppvObject==0) )
    144     return E_INVALIDARG;
    145 
     143        return E_INVALIDARG;
     144 
    146145    /* Initialize the return parameter */
    147146  *ppvObject = 0;
     
    154153       )
    155154        *ppvObject = iface;
    156 
     155   
    157156    else if (IsEqualIID(&IID_IROTData, riid))
    158157        *ppvObject = (IROTData*)&(This->lpvtbl2);
     
    161160    if ((*ppvObject)==0)
    162161        return E_NOINTERFACE;
    163 
     162 
    164163    /* Query Interface always increases the reference count by one when it is successful */
    165164  FileMonikerImpl_AddRef(iface);
     
    213212
    214213    *pClassID = CLSID_FileMoniker;
    215 
     214       
    216215    return S_OK;
    217216}
     
    253252    if (bread!=sizeof(WORD) || wbuffer!=0)
    254253        return E_FAIL;
    255 
     254   
    256255    /* read filePath string length (plus one) */
    257256    res=IStream_Read(pStm,&length,sizeof(DWORD),&bread);
     
    269268    if (bread != sizeof(DWORD) || dwbuffer != 0xDEADFFFF)
    270269        return E_FAIL;
    271 
     270       
    272271    length--;
    273 
     272       
    274273    for(i=0;i<10;i++){
    275274        res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
     
    277276            return E_FAIL;
    278277    }
    279 
     278   
    280279    if (length>8)
    281280        length=0;
    282 
     281       
    283282    doubleLenHex=doubleLenDec=2*length;
    284283    if (length > 5)
     
    291290    if (length==0)
    292291        return res;
    293 
     292       
    294293    res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
    295294    if (bread!=sizeof(DWORD) || dwbuffer!=doubleLenHex)
     
    312311
    313312    HeapFree(GetProcessHeap(),0,filePathA);
    314 
     313   
    315314    return res;
    316315}
     
    325324    /* this function saves data of this object. In the begining I thougth that I have just to write
    326325     * the filePath string on Stream. But, when I tested this function whith windows programs samples !
    327      * I noted that it was not the case. So I analysed data written by this function on Windows system and
     326     * I noted that it was not the case. So I analysed data written by this function on Windows system and 
    328327     * what did this function do exactly ! but I have no idear a bout its logic !
    329328     * I guessed data who must be written on stream wich is:
     
    334333     */
    335334
    336     ICOM_THIS(FileMonikerImpl,iface);
     335    ICOM_THIS(FileMonikerImpl,iface);       
    337336
    338337    HRESULT res;
     
    369368    /* write a DWORD set to 0xDEADFFFF: constant */
    370369    res=IStream_Write(pStm,&constant1,sizeof(DWORD),NULL);
    371 
     370       
    372371    len--;
    373372    /* write 10 times a DWORD set to 0 : constants */
    374373    for(i=0;i<10;i++)
    375374        res=IStream_Write(pStm,&zero,sizeof(WORD),NULL);
    376 
     375       
    377376    if (len>8)
    378377        len=0;
    379 
     378       
    380379    doubleLenHex=doubleLenDec=2*len;
    381380    if (len > 5)
     
    416415
    417416    /* for more details see FileMonikerImpl_Save coments */
    418 
     417   
    419418    sizeMAx =  sizeof(WORD) +           /* first WORD is 0 */
    420419               sizeof(DWORD)+           /* length of filePath including "\0" in the end of the string */
     
    426425    if (len==0 || len > 8)
    427426        return S_OK;
    428 
     427   
    429428    sizeMAx += sizeof(DWORD)+           /* size of the unicode filePath: "\0" not included */
    430429               sizeof(WORD)+            /* constant : 0x3 */
    431430               len*sizeof(WCHAR);       /* unicde filePath string */
    432 
     431   
    433432    pcbSize->s.LowPart=sizeMAx;
    434433    pcbSize->s.HighPart=0;
     
    448447    WCHAR bkSlash[]={'\\',0};
    449448    BYTE addBkSlash;
    450 
     449   
    451450    TRACE("(%p,%p)\n",This,lpszPathName);
    452451
     
    493492
    494493        *This->filePathName=0;
    495 
     494   
    496495        for(i=0;tabStr[i]!=NULL;i++)
    497496            strcatW(This->filePathName,tabStr[i]);
    498 
     497   
    499498        if (addBkSlash)
    500499            strcatW(This->filePathName,bkSlash);
     
    539538    IClassFactory *pcf=0;
    540539    IClassActivator *pca=0;
    541 
    542     ICOM_THIS(FileMonikerImpl,iface);
     540   
     541    ICOM_THIS(FileMonikerImpl,iface);   
    543542
    544543    *ppvResult=0;
     
    547546
    548547    if(pmkToLeft==NULL){
    549 
     548       
    550549        res=IBindCtx_GetRunningObjectTable(pbc,&prot);
    551550
     
    579578
    580579            res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
    581 
     580       
    582581            if (res==E_NOINTERFACE)
    583582                return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED;
     
    598597
    599598            FIXME("()");
    600 
     599           
    601600            /*res=GetClassFile(This->filePathName,&clsID);
    602601
     
    634633    if (pcf!=NULL)
    635634        IClassFactory_Release(pcf);
    636 
     635   
    637636    return res;
    638637}
     
    737736
    738737    if (pmkRight==NULL)
    739     return E_INVALIDARG;
     738        return E_INVALIDARG;
    740739
    741740    *ppmkComposite=0;
    742 
     741   
    743742    IMoniker_IsSystemMoniker(pmkRight,&mkSys);
    744743
     
    769768        /* the length of the composed path string  is raised by the sum of the two paths lengths  */
    770769        newStr=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
    771 
    772       if (newStr==NULL)
    773         return E_OUTOFMEMORY;
     770       
     771          if (newStr==NULL)
     772                return E_OUTOFMEMORY;
    774773
    775774        /* new path is the concatenation of the rest of str1 and str2 */
     
    779778        if ((strDec2[i]==NULL && lastIdx1>-1 && lastIdx2>-1) || lstrcmpW(strDec2[i],bkSlash)!=0)
    780779            strcatW(newStr,bkSlash);
    781 
     780           
    782781        for(j=i;j<=lastIdx2;j++)
    783782            strcatW(newStr,strDec2[j]);
    784 
     783       
    785784        /* create a new moniker with the new string */
    786785        res=CreateFileMoniker(newStr,ppmkComposite);
     
    858857
    859858    IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath);
    860 
     859   
    861860    if (lstrcmpiW(filePath,
    862861                  This->filePathName)!=0)
    863862
    864863        return S_FALSE;
    865 
     864   
    866865    return S_OK;
    867866}
     
    880879    if (pdwHash==NULL)
    881880        return E_POINTER;
    882 
     881   
    883882    val =  This->filePathName;
    884883    len = lstrlenW(val);
     
    887886        for (i = len ; i > 0; i--) {
    888887            h = (h * 37) + val[off++];
    889     }
     888        }
    890889    } else {
    891890        /* only sample some characters */
    892     skip = len / 8;
    893     for (i = len ; i > 0; i -= skip, off += skip) {
     891        skip = len / 8;
     892        for (i = len ; i > 0; i -= skip, off += skip) {
    894893            h = (h * 39) + val[off];
    895     }
     894        }
    896895}
    897896
     
    964963        if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
    965964            return MK_E_NOOBJECT;
    966 
     965       
    967966        *pFileTime=info.ftLastWriteTime;
    968967}
     
    999998    if (pmkOther==NULL)
    1000999        return E_INVALIDARG;
    1001 
     1000   
    10021001    *ppmkPrefix=0;
    1003 
     1002   
    10041003    /* check if we have the same type of moniker */
    10051004    IMoniker_IsSystemMoniker(pmkOther,&mkSys);
     
    10231022
    10241023        *commonPath=0;
    1025 
     1024       
    10261025        for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
    10271026                         (stringTable2[sameIdx]!=NULL) &&
     
    10421041        if (machimeNameCase && *stringTable1[sameIdx-1]=='\\')
    10431042            sameIdx--;
    1044 
     1043       
    10451044        if (machimeNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
    10461045            return MK_E_NOPREFIX;
     
    10481047        for(i=0;i<sameIdx;i++)
    10491048            strcatW(commonPath,stringTable1[i]);
    1050 
     1049       
    10511050        for(i=0;i<nb1;i++)
    10521051            CoTaskMemFree(stringTable1[i]);
     
    10601059
    10611060        HeapFree(GetProcessHeap(),0,commonPath);
    1062 
     1061       
    10631062        return CreateFileMoniker(commonPath,ppmkPrefix);
    10641063    }
     
    10801079
    10811080    strgtable =CoTaskMemAlloc(len*sizeof(LPOLESTR));
    1082 
     1081   
    10831082    if (strgtable==NULL)
    1084     return E_OUTOFMEMORY;
    1085 
     1083        return E_OUTOFMEMORY;
     1084   
    10861085    while(str[i]!=0){
    10871086
     
    10911090
    10921091            if (strgtable[tabIndex]==NULL)
    1093             return E_OUTOFMEMORY;
     1092                return E_OUTOFMEMORY;
    10941093
    10951094            strcpyW(strgtable[tabIndex++],bSlash);
     
    11141113    }
    11151114    strgtable[tabIndex]=NULL;
    1116 
     1115   
    11171116    *stringTable=strgtable;
    1118 
     1117   
    11191118    return tabIndex;
    11201119}
     
    11301129    DWORD len1=0,len2=0,sameIdx=0,j=0;
    11311130    WCHAR back[] ={'.','.','\\',0};
    1132 
     1131   
    11331132    TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
    11341133
     
    11381137    if (pmOther==NULL)
    11391138        return E_INVALIDARG;
    1140 
     1139   
    11411140    res=CreateBindCtx(0,&bind);
    11421141    if (FAILED(res))
    1143     return res;
     1142        return res;
    11441143
    11451144    res=IMoniker_GetDisplayName(iface,bind,NULL,&str1);
    11461145    if (FAILED(res))
    1147     return res;
     1146        return res;
    11481147    res=IMoniker_GetDisplayName(pmOther,bind,NULL,&str2);
    11491148    if (FAILED(res))
    1150     return res;
     1149        return res;
    11511150
    11521151    len1=FileMonikerImpl_DecomposePath(str1,&tabStr1);
     
    11541153
    11551154    if (FAILED(len1) || FAILED(len2))
    1156     return E_OUTOFMEMORY;
    1157 
     1155        return E_OUTOFMEMORY;
     1156       
    11581157    /* count the number of similar items from the begin of the two paths */
    11591158    for(sameIdx=0; ( (tabStr1[sameIdx]!=NULL) &&
    1160            (tabStr2[sameIdx]!=NULL) &&
     1159                   (tabStr2[sameIdx]!=NULL) &&
    11611160               (lstrcmpiW(tabStr1[sameIdx],tabStr2[sameIdx])==0)); sameIdx++);
    11621161
     
    11761175    for(j=sameIdx;tabStr2[j]!=NULL;j++)
    11771176        strcatW(relPath,tabStr2[j]);
    1178 
     1177   
    11791178    res=CreateFileMoniker(relPath,ppmkRelPath);
    1180 
     1179   
    11811180    for(j=0; tabStr1[j]!=NULL;j++)
    11821181        CoTaskMemFree(tabStr1[j]);
     
    12201219
    12211220    strcpyW(*ppszDisplayName,This->filePathName);
    1222 
     1221   
    12231222    return S_OK;
    12241223}
     
    12471246    if (!pwdMksys)
    12481247        return E_POINTER;
    1249 
     1248   
    12501249    (*pwdMksys)=MKSYS_FILEMONIKER;
    12511250
     
    12841283{
    12851284    ICOM_THIS_From_IROTData(IMoniker, iface);
    1286 
     1285   
    12871286    TRACE("(%p)\n",This);
    12881287
     
    13281327    if(lpszPathName==NULL)
    13291328        return MK_E_SYNTAX;
    1330 
     1329           
    13311330    *ppmk=0;
    1332 
     1331       
    13331332    newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
    13341333
     
    13391338
    13401339    if (SUCCEEDED(hr))
    1341     hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&riid,(void**)ppmk);
     1340        hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&riid,(void**)ppmk);
    13421341    else
    13431342        HeapFree(GetProcessHeap(),0,newFileMoniker);
Note: See TracChangeset for help on using the changeset viewer.