Spelling, grammar and a bit of comment formatting fixes.
[wine] / dlls / ole32 / filemoniker.c
1 /***************************************************************************************
2  *                            FileMonikers implementation
3  *
4  *               Copyright 1999  Noomen Hamza
5  ***************************************************************************************/
6
7 #include <assert.h>
8 #include <string.h>
9 #include "winbase.h"
10 #include "winerror.h"
11 #include "winnls.h"
12 #include "wine/unicode.h"
13 #include "debugtools.h"
14 #include "objbase.h"
15 #include "wine/obj_storage.h"
16 #include "wine/obj_moniker.h"
17 #include "wine/obj_base.h"
18
19 #include "compobj_private.h"
20
21 DEFAULT_DEBUG_CHANNEL(ole);
22
23 /* filemoniker data structure */
24 typedef struct FileMonikerImpl{
25
26     ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
27
28     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether 
29      * two monikers are equal. That's whay IROTData interface is implemented by monikers.
30      */
31     ICOM_VTABLE(IROTData)*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
32
33     ULONG ref; /* reference counter for this object */
34
35     LPOLESTR filePathName; /* path string identified by this filemoniker */
36
37 } FileMonikerImpl;
38
39 /********************************************************************************/
40 /* FileMoniker prototype functions :                                            */
41
42 /* IUnknown prototype functions */
43 static HRESULT WINAPI FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
44 static ULONG   WINAPI FileMonikerImpl_AddRef(IMoniker* iface);
45 static ULONG   WINAPI FileMonikerImpl_Release(IMoniker* iface);
46
47 /* IPersist prototype functions */
48 static HRESULT WINAPI FileMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID);
49
50 /* IPersistStream prototype functions */
51 static HRESULT WINAPI FileMonikerImpl_IsDirty(IMoniker* iface);
52 static HRESULT WINAPI FileMonikerImpl_Load(IMoniker* iface, IStream* pStm);
53 static HRESULT WINAPI FileMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty);
54 static HRESULT WINAPI FileMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
55
56 /* IMoniker prototype functions */
57 static HRESULT WINAPI FileMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
58 static HRESULT WINAPI FileMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
59 static HRESULT WINAPI FileMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
60 static HRESULT WINAPI FileMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
61 static HRESULT WINAPI FileMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker);
62 static HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
63 static HRESULT WINAPI FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
64 static HRESULT WINAPI FileMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
65 static HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pFileTime);
66 static HRESULT WINAPI FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
67 static HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
68 static HRESULT WINAPI FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
69 static HRESULT WINAPI FileMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName);
70 static HRESULT WINAPI FileMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
71 static HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
72
73 /********************************************************************************/
74 /* IROTData prototype functions                                                 */
75
76 /* IUnknown prototype functions */
77 static HRESULT WINAPI FileMonikerROTDataImpl_QueryInterface(IROTData* iface,REFIID riid,VOID** ppvObject);
78 static ULONG   WINAPI FileMonikerROTDataImpl_AddRef(IROTData* iface);
79 static ULONG   WINAPI FileMonikerROTDataImpl_Release(IROTData* iface);
80
81 /* IROTData prototype function */
82 static HRESULT WINAPI FileMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData);
83
84 /* Local function used by filemoniker implementation */
85 HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* iface, LPCOLESTR lpszPathName);
86 HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* iface);
87 int     WINAPI FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** tabStr);
88
89
90 /********************************************************************************/
91 /* Virtual function table for the FileMonikerImpl class which  include IPersist,*/
92 /* IPersistStream and IMoniker functions.                                       */
93 static ICOM_VTABLE(IMoniker) VT_FileMonikerImpl =
94 {
95     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
96     FileMonikerImpl_QueryInterface,
97     FileMonikerImpl_AddRef,
98     FileMonikerImpl_Release,
99     FileMonikerImpl_GetClassID,
100     FileMonikerImpl_IsDirty,
101     FileMonikerImpl_Load,
102     FileMonikerImpl_Save,
103     FileMonikerImpl_GetSizeMax,
104     FileMonikerImpl_BindToObject,
105     FileMonikerImpl_BindToStorage,
106     FileMonikerImpl_Reduce,
107     FileMonikerImpl_ComposeWith,
108     FileMonikerImpl_Enum,
109     FileMonikerImpl_IsEqual,
110     FileMonikerImpl_Hash,
111     FileMonikerImpl_IsRunning,
112     FileMonikerImpl_GetTimeOfLastChange,
113     FileMonikerImpl_Inverse,
114     FileMonikerImpl_CommonPrefixWith,
115     FileMonikerImpl_RelativePathTo,
116     FileMonikerImpl_GetDisplayName,
117     FileMonikerImpl_ParseDisplayName,
118     FileMonikerImpl_IsSystemMoniker
119 };
120
121 /********************************************************************************/
122 /* Virtual function table for the IROTData class.                               */
123 static ICOM_VTABLE(IROTData) VT_ROTDataImpl =
124 {
125     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
126     FileMonikerROTDataImpl_QueryInterface,
127     FileMonikerROTDataImpl_AddRef,
128     FileMonikerROTDataImpl_Release,
129     FileMonikerROTDataImpl_GetComparaisonData
130 };
131
132 /*******************************************************************************
133  *        FileMoniker_QueryInterface
134  *******************************************************************************/
135 HRESULT WINAPI FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
136 {
137     ICOM_THIS(FileMonikerImpl,iface);
138   
139   TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
140
141     /* Perform a sanity check on the parameters.*/
142     if ( (This==0) || (ppvObject==0) )
143         return E_INVALIDARG;
144   
145     /* Initialize the return parameter */
146   *ppvObject = 0;
147
148     /* Compare the riid with the interface IDs implemented by this object.*/
149     if (IsEqualIID(&IID_IUnknown, riid)      ||
150         IsEqualIID(&IID_IPersist, riid)      ||
151         IsEqualIID(&IID_IPersistStream,riid) ||
152         IsEqualIID(&IID_IMoniker, riid)
153        )
154         *ppvObject = iface;
155     
156     else if (IsEqualIID(&IID_IROTData, riid))
157         *ppvObject = (IROTData*)&(This->lpvtbl2);
158
159     /* Check that we obtained an interface.*/
160     if ((*ppvObject)==0)
161         return E_NOINTERFACE;
162   
163     /* Query Interface always increases the reference count by one when it is successful */
164   FileMonikerImpl_AddRef(iface);
165
166     return S_OK;
167 }
168
169 /******************************************************************************
170  *        FileMoniker_AddRef
171  ******************************************************************************/
172 ULONG WINAPI FileMonikerImpl_AddRef(IMoniker* iface)
173 {
174     ICOM_THIS(FileMonikerImpl,iface);
175
176     TRACE("(%p)\n",iface);
177
178     return ++(This->ref);
179 }
180
181 /******************************************************************************
182  *        FileMoniker_Release
183  ******************************************************************************/
184 ULONG WINAPI FileMonikerImpl_Release(IMoniker* iface)
185 {
186     ICOM_THIS(FileMonikerImpl,iface);
187
188     TRACE("(%p)\n",iface);
189
190     This->ref--;
191
192     /* destroy the object if there's no more reference on it */
193     if (This->ref==0){
194
195         FileMonikerImpl_Destroy(This);
196
197         return 0;
198     }
199     return This->ref;;
200 }
201
202 /******************************************************************************
203  *        FileMoniker_GetClassID
204  ******************************************************************************/
205 HRESULT WINAPI FileMonikerImpl_GetClassID(IMoniker* iface,
206                                           CLSID *pClassID)/* Pointer to CLSID of object */
207 {
208     TRACE("(%p,%p),stub!\n",iface,pClassID);
209
210     if (pClassID==NULL)
211         return E_POINTER;
212
213     *pClassID = CLSID_FileMoniker;
214         
215     return S_OK;
216 }
217
218 /******************************************************************************
219  *        FileMoniker_IsDirty
220  ******************************************************************************/
221 HRESULT WINAPI FileMonikerImpl_IsDirty(IMoniker* iface)
222 {
223     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
224        method in the OLE-provided moniker interfaces always return S_FALSE because
225        their internal state never changes. */
226
227     TRACE("(%p)\n",iface);
228
229     return S_FALSE;
230 }
231
232 /******************************************************************************
233  *        FileMoniker_Load
234  ******************************************************************************/
235 HRESULT WINAPI FileMonikerImpl_Load(IMoniker* iface,IStream* pStm)
236 {
237     HRESULT res;
238     CHAR* filePathA;
239     WCHAR* filePathW;
240     ULONG bread;
241     WORD  wbuffer;
242     DWORD dwbuffer,length,i,doubleLenHex,doubleLenDec;
243
244     ICOM_THIS(FileMonikerImpl,iface);
245
246     TRACE("(%p,%p)\n",iface,pStm);
247
248     /* this function locates and reads from the stream the filePath string written by FileMonikerImpl_Save */
249
250     /* first WORD is non significative */
251     res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
252     if (bread!=sizeof(WORD) || wbuffer!=0)
253         return E_FAIL;
254     
255     /* read filePath string length (plus one) */
256     res=IStream_Read(pStm,&length,sizeof(DWORD),&bread);
257     if (bread != sizeof(DWORD))
258         return E_FAIL;
259
260     /* read filePath string */
261     filePathA=HeapAlloc(GetProcessHeap(),0,length);
262     res=IStream_Read(pStm,filePathA,length,&bread);
263     if (bread != length)
264         return E_FAIL;
265
266     /* read the first constant */
267     IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
268     if (bread != sizeof(DWORD) || dwbuffer != 0xDEADFFFF)
269         return E_FAIL;
270         
271     length--;
272         
273     for(i=0;i<10;i++){
274         res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
275         if (bread!=sizeof(WORD) || wbuffer!=0)
276             return E_FAIL;
277     }
278     
279     if (length>8)
280         length=0;
281         
282     doubleLenHex=doubleLenDec=2*length;
283     if (length > 5)
284         doubleLenDec+=6;
285
286     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
287     if (bread!=sizeof(DWORD) || dwbuffer!=doubleLenDec)
288         return E_FAIL;
289
290     if (length==0)
291         return res;
292         
293     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
294     if (bread!=sizeof(DWORD) || dwbuffer!=doubleLenHex)
295         return E_FAIL;
296
297     res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
298     if (bread!=sizeof(WORD) || wbuffer!=0x3)
299         return E_FAIL;
300
301     filePathW=HeapAlloc(GetProcessHeap(),0,(length+1)*sizeof(WCHAR));
302     filePathW[length]=0;
303     res=IStream_Read(pStm,filePathW,doubleLenHex,&bread);
304     if (bread!=doubleLenHex)
305         return E_FAIL;
306
307     if (This->filePathName!=NULL)
308         HeapFree(GetProcessHeap(),0,This->filePathName);
309
310     This->filePathName=filePathW;
311
312     HeapFree(GetProcessHeap(),0,filePathA);
313     
314     return res;
315 }
316
317 /******************************************************************************
318  *        FileMoniker_Save
319  ******************************************************************************/
320 HRESULT WINAPI FileMonikerImpl_Save(IMoniker* iface,
321                                     IStream* pStm,/* pointer to the stream where the object is to be saved */
322                                     BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
323 {
324     /* this function saves data of this object. In the beginning I thougth 
325      * that I have just to write the filePath string on Stream. But, when I 
326      * tested this function whith windows programs samples, I noticed that it 
327      * was not the case. So I analysed data written by this function on 
328      * Windows and what this did function exactly ! But I have no idea about 
329      * its logic !
330      * I guessed data which must be written on stream is:
331      * 1) WORD constant:zero
332      * 2) length of the path string ("\0" included)
333      * 3) path string type A
334      * 4) DWORD constant : 0xDEADFFFF
335      * 5) ten WORD constant: zero
336      * 6) DWORD: double-length of the the path string type W ("\0" not 
337      *    included)
338      * 7) WORD constant: 0x3
339      * 8) filePath unicode string.
340      *    if the length(filePath) > 8 or length(filePath) == 8 stop at step 5)
341      */
342
343     ICOM_THIS(FileMonikerImpl,iface);        
344
345     HRESULT res;
346     LPOLESTR filePathW=This->filePathName;
347     CHAR*     filePathA;
348     DWORD  len;
349
350     DWORD  constant1 = 0xDEADFFFF; /* these constants are detected after analysing the data structure written by */
351     WORD   constant2 = 0x3;        /* FileMoniker_Save function in a windows program system */
352
353     WORD   zero=0;
354     DWORD doubleLenHex;
355     DWORD doubleLenDec;
356     int i=0;
357
358     TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
359
360     if (pStm==NULL)
361         return E_POINTER;
362
363     /* write a DWORD set to 0 : constant */
364     res=IStream_Write(pStm,&zero,sizeof(WORD),NULL);
365
366     /* write length of filePath string ( "\0" included )*/
367     len = WideCharToMultiByte( CP_ACP, 0, filePathW, -1, NULL, 0, NULL, NULL );
368     res=IStream_Write(pStm,&len,sizeof(DWORD),NULL);
369
370     /* write filePath string type A */
371     filePathA=HeapAlloc(GetProcessHeap(),0,len);
372     WideCharToMultiByte( CP_ACP, 0, filePathW, -1, filePathA, len, NULL, NULL );
373     res=IStream_Write(pStm,filePathA,len,NULL);
374     HeapFree(GetProcessHeap(),0,filePathA);
375
376     /* write a DWORD set to 0xDEADFFFF: constant */
377     res=IStream_Write(pStm,&constant1,sizeof(DWORD),NULL);
378         
379     len--;
380     /* write 10 times a DWORD set to 0 : constants */
381     for(i=0;i<10;i++)
382         res=IStream_Write(pStm,&zero,sizeof(WORD),NULL);
383         
384     if (len>8)
385         len=0;
386         
387     doubleLenHex=doubleLenDec=2*len;
388     if (len > 5)
389         doubleLenDec+=6;
390
391     /* write double-length of the path string ( "\0" included )*/
392     res=IStream_Write(pStm,&doubleLenDec,sizeof(DWORD),NULL);
393
394     if (len==0)
395         return res;
396
397     /* write double-length (hexa representation) of the path string ( "\0" included ) */
398     res=IStream_Write(pStm,&doubleLenHex,sizeof(DWORD),NULL);
399
400     /* write a WORD set to 0x3: constant */
401     res=IStream_Write(pStm,&constant2,sizeof(WORD),NULL);
402
403     /* write path unicode string */
404     res=IStream_Write(pStm,filePathW,doubleLenHex,NULL);
405
406     return res;
407 }
408
409 /******************************************************************************
410  *        FileMoniker_GetSizeMax
411  ******************************************************************************/
412 HRESULT WINAPI FileMonikerImpl_GetSizeMax(IMoniker* iface,
413                                           ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
414 {
415     ICOM_THIS(FileMonikerImpl,iface);
416     DWORD len=lstrlenW(This->filePathName);
417     DWORD sizeMAx;
418
419     TRACE("(%p,%p)\n",iface,pcbSize);
420
421     if (pcbSize!=NULL)
422         return E_POINTER;
423
424     /* for more details see FileMonikerImpl_Save coments */
425     
426     sizeMAx =  sizeof(WORD) +           /* first WORD is 0 */
427                sizeof(DWORD)+           /* length of filePath including "\0" in the end of the string */
428                (len+1)+                 /* filePath string */
429                sizeof(DWORD)+           /* constant : 0xDEADFFFF */
430                10*sizeof(WORD)+         /* 10 zero WORD */
431                sizeof(DWORD);           /* size of the unicode filePath: "\0" not included */
432
433     if (len==0 || len > 8)
434         return S_OK;
435     
436     sizeMAx += sizeof(DWORD)+           /* size of the unicode filePath: "\0" not included */
437                sizeof(WORD)+            /* constant : 0x3 */
438                len*sizeof(WCHAR);       /* unicde filePath string */
439     
440     pcbSize->s.LowPart=sizeMAx;
441     pcbSize->s.HighPart=0;
442
443     return S_OK;
444 }
445
446 /******************************************************************************
447  *         FileMoniker_Construct (local function)
448  *******************************************************************************/
449 HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR lpszPathName)
450 {
451     int nb=0,i;
452     int sizeStr=lstrlenW(lpszPathName);
453     LPOLESTR *tabStr=0;
454     WCHAR twoPoint[]={'.','.',0};
455     WCHAR bkSlash[]={'\\',0};
456     BYTE addBkSlash;
457     
458     TRACE("(%p,%p)\n",This,lpszPathName);
459
460     /* Initialize the virtual fgunction table. */
461     This->lpvtbl1      = &VT_FileMonikerImpl;
462     This->lpvtbl2      = &VT_ROTDataImpl;
463     This->ref          = 0;
464
465     This->filePathName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr+1));
466
467     if (This->filePathName==NULL)
468         return E_OUTOFMEMORY;
469
470     strcpyW(This->filePathName,lpszPathName);
471
472     nb=FileMonikerImpl_DecomposePath(This->filePathName,&tabStr);
473
474     if (nb > 0 ){
475
476         addBkSlash=1;
477         if (lstrcmpW(tabStr[0],twoPoint)!=0)
478             addBkSlash=0;
479         else
480             for(i=0;i<nb;i++){
481
482                 if ( (lstrcmpW(tabStr[i],twoPoint)!=0) && (lstrcmpW(tabStr[i],bkSlash)!=0) ){
483                     addBkSlash=0;
484                     break;
485                 }
486                 else
487
488                     if (lstrcmpW(tabStr[i],bkSlash)==0 && i<nb-1 && lstrcmpW(tabStr[i+1],bkSlash)==0){
489                         *tabStr[i]=0;
490                         sizeStr--;
491                         addBkSlash=0;
492                         break;
493                     }
494             }
495
496         if (lstrcmpW(tabStr[nb-1],bkSlash)==0)
497             addBkSlash=0;
498
499         This->filePathName=HeapReAlloc(GetProcessHeap(),0,This->filePathName,(sizeStr+1)*sizeof(WCHAR));
500
501         *This->filePathName=0;
502     
503         for(i=0;tabStr[i]!=NULL;i++)
504             strcatW(This->filePathName,tabStr[i]);
505     
506         if (addBkSlash)
507             strcatW(This->filePathName,bkSlash);
508     }
509
510     for(i=0; tabStr[i]!=NULL;i++)
511         CoTaskMemFree(tabStr[i]);
512     CoTaskMemFree(tabStr);
513
514     return S_OK;
515 }
516
517 /******************************************************************************
518  *        FileMoniker_Destroy (local function)
519  *******************************************************************************/
520 HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* This)
521 {
522     TRACE("(%p)\n",This);
523
524     if (This->filePathName!=NULL)
525             HeapFree(GetProcessHeap(),0,This->filePathName);
526
527     HeapFree(GetProcessHeap(),0,This);
528
529     return S_OK;
530 }
531
532 /******************************************************************************
533  *                  FileMoniker_BindToObject
534  ******************************************************************************/
535 HRESULT WINAPI FileMonikerImpl_BindToObject(IMoniker* iface,
536                                             IBindCtx* pbc,
537                                             IMoniker* pmkToLeft,
538                                             REFIID riid,
539                                             VOID** ppvResult)
540 {
541     HRESULT   res=E_FAIL;
542     CLSID     clsID;
543     IUnknown* pObj=0;
544     IRunningObjectTable *prot=0;
545     IPersistFile  *ppf=0;
546     IClassFactory *pcf=0;
547     IClassActivator *pca=0;
548     
549     ICOM_THIS(FileMonikerImpl,iface);    
550
551     *ppvResult=0;
552
553     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
554
555     if(pmkToLeft==NULL){
556         
557         res=IBindCtx_GetRunningObjectTable(pbc,&prot);
558
559         if (SUCCEEDED(res)){
560             /* if the requested class was loaded befor ! we dont need to reload it */
561             res = IRunningObjectTable_GetObject(prot,iface,&pObj);
562
563             if (res==S_FALSE){
564                 /* first activation of this class */
565                 res=GetClassFile(This->filePathName,&clsID);
566                 if (SUCCEEDED(res)){
567
568                     res=CoCreateInstance(&clsID,NULL,CLSCTX_ALL,&IID_IPersistFile,(void**)&ppf);
569                     if (SUCCEEDED(res)){
570
571                         res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
572                         if (SUCCEEDED(res)){
573
574                             pObj=(IUnknown*)ppf;
575                             IUnknown_AddRef(pObj);
576                         }
577                     }
578                 }
579             }
580         }
581     }
582     else{
583         res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassFactory,(void**)&pcf);
584
585         if (res==E_NOINTERFACE){
586
587             res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
588         
589             if (res==E_NOINTERFACE)
590                 return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED;
591         }
592         if (pcf!=NULL){
593
594             IClassFactory_CreateInstance(pcf,NULL,&IID_IPersistFile,(void**)ppf);
595
596             res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
597
598             if (SUCCEEDED(res)){
599
600                 pObj=(IUnknown*)ppf;
601                 IUnknown_AddRef(pObj);
602             }
603         }
604         if (pca!=NULL){
605
606             FIXME("()\n");
607             
608             /*res=GetClassFile(This->filePathName,&clsID);
609
610             if (SUCCEEDED(res)){
611
612                 res=IClassActivator_GetClassObject(pca,&clsID,CLSCTX_ALL,0,&IID_IPersistFile,(void**)&ppf);
613
614                 if (SUCCEEDED(res)){
615
616                     pObj=(IUnknown*)ppf;
617                     IUnknown_AddRef(pObj);
618                 }
619             }*/
620         }
621     }
622
623     if (pObj!=NULL){
624         /* get the requested interface from the loaded class */
625         res= IUnknown_QueryInterface(pObj,riid,ppvResult);
626
627         IBindCtx_RegisterObjectBound(pbc,(IUnknown*)*ppvResult);
628
629         IUnknown_Release(pObj);
630     }
631
632     if (prot!=NULL)
633         IRunningObjectTable_Release(prot);
634
635     if (ppf!=NULL)
636         IPersistFile_Release(ppf);
637
638     if (pca!=NULL)
639         IClassActivator_Release(pca);
640
641     if (pcf!=NULL)
642         IClassFactory_Release(pcf);
643     
644     return res;
645 }
646
647 /******************************************************************************
648  *        FileMoniker_BindToStorage
649  ******************************************************************************/
650 HRESULT WINAPI FileMonikerImpl_BindToStorage(IMoniker* iface,
651                                              IBindCtx* pbc,
652                                              IMoniker* pmkToLeft,
653                                              REFIID riid,
654                                              VOID** ppvObject)
655 {
656     LPOLESTR filePath=0;
657     IStorage *pstg=0;
658     HRESULT res;
659
660     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvObject);
661
662     if (pmkToLeft==NULL){
663
664         if (IsEqualIID(&IID_IStorage, riid)){
665
666             /* get the file name */
667             FileMonikerImpl_GetDisplayName(iface,pbc,pmkToLeft,&filePath);
668
669             /* verifie if the file contains a storage object */
670             res=StgIsStorageFile(filePath);
671
672             if(res==S_OK){
673
674                 res=StgOpenStorage(filePath,NULL,STGM_READWRITE|STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
675
676                 if (SUCCEEDED(res)){
677
678                     *ppvObject=pstg;
679
680                     IStorage_AddRef(pstg);
681
682                     return res;
683                 }
684             }
685             CoTaskMemFree(filePath);
686         }
687         else
688             if ( (IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)) )
689
690                 return E_UNSPEC;
691             else
692
693                 return E_NOINTERFACE;
694     }
695     else {
696
697         FIXME("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvObject);
698
699         return E_NOTIMPL;
700     }
701     return res;
702 }
703
704 /******************************************************************************
705  *        FileMoniker_Reduce
706  ******************************************************************************/
707 HRESULT WINAPI FileMonikerImpl_Reduce(IMoniker* iface,
708                                       IBindCtx* pbc,
709                                       DWORD dwReduceHowFar,
710                                       IMoniker** ppmkToLeft,
711                                       IMoniker** ppmkReduced)
712 {
713     TRACE("(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
714
715     if (ppmkReduced==NULL)
716         return E_POINTER;
717
718     FileMonikerImpl_AddRef(iface);
719
720     *ppmkReduced=iface;
721
722     return MK_S_REDUCED_TO_SELF;
723 }
724 /******************************************************************************
725  *        FileMoniker_ComposeWith
726  ******************************************************************************/
727 HRESULT WINAPI FileMonikerImpl_ComposeWith(IMoniker* iface,
728                                            IMoniker* pmkRight,
729                                            BOOL fOnlyIfNotGeneric,
730                                            IMoniker** ppmkComposite)
731 {
732     HRESULT res;
733     LPOLESTR str1=0,str2=0,*strDec1=0,*strDec2=0,newStr=0;
734     WCHAR twoPoint[]={'.','.',0};
735     WCHAR bkSlash[]={'\\',0};
736     IBindCtx *bind=0;
737     int i=0,j=0,lastIdx1=0,lastIdx2=0;
738     DWORD mkSys;
739
740     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
741
742     if (ppmkComposite==NULL)
743         return E_POINTER;
744
745     if (pmkRight==NULL)
746         return E_INVALIDARG;
747
748     *ppmkComposite=0;
749     
750     IMoniker_IsSystemMoniker(pmkRight,&mkSys);
751
752     /* check if we have two filemonikers to compose or not */
753     if(mkSys==MKSYS_FILEMONIKER){
754
755         CreateBindCtx(0,&bind);
756
757         FileMonikerImpl_GetDisplayName(iface,bind,NULL,&str1);
758         IMoniker_GetDisplayName(pmkRight,bind,NULL,&str2);
759
760         /* decompose pathnames of the two monikers : (to prepare the path merge operation ) */
761         lastIdx1=FileMonikerImpl_DecomposePath(str1,&strDec1)-1;
762         lastIdx2=FileMonikerImpl_DecomposePath(str2,&strDec2)-1;
763
764         if ((lastIdx1==-1 && lastIdx2>-1)||(lastIdx1==1 && lstrcmpW(strDec1[0],twoPoint)==0))
765             return MK_E_SYNTAX;
766
767         if(lstrcmpW(strDec1[lastIdx1],bkSlash)==0)
768             lastIdx1--;
769
770         /* for etch "..\" in the left of str2 remove the right element from str1 */
771         for(i=0; ( (lastIdx1>=0) && (strDec2[i]!=NULL) && (lstrcmpW(strDec2[i],twoPoint)==0) ) ;i+=2){
772
773             lastIdx1-=2;
774         }
775
776         /* the length of the composed path string  is raised by the sum of the two paths lengths  */
777         newStr=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
778         
779           if (newStr==NULL)
780                 return E_OUTOFMEMORY;
781
782         /* new path is the concatenation of the rest of str1 and str2 */
783         for(*newStr=0,j=0;j<=lastIdx1;j++)
784             strcatW(newStr,strDec1[j]);
785
786         if ((strDec2[i]==NULL && lastIdx1>-1 && lastIdx2>-1) || lstrcmpW(strDec2[i],bkSlash)!=0)
787             strcatW(newStr,bkSlash);
788             
789         for(j=i;j<=lastIdx2;j++)
790             strcatW(newStr,strDec2[j]);
791         
792         /* create a new moniker with the new string */
793         res=CreateFileMoniker(newStr,ppmkComposite);
794
795         /* free all strings space memory used by this function */
796         HeapFree(GetProcessHeap(),0,newStr);
797
798         for(i=0; strDec1[i]!=NULL;i++)
799             CoTaskMemFree(strDec1[i]);
800         for(i=0; strDec2[i]!=NULL;i++)
801             CoTaskMemFree(strDec2[i]);
802         CoTaskMemFree(strDec1);
803         CoTaskMemFree(strDec2);
804
805         CoTaskMemFree(str1);
806         CoTaskMemFree(str2);
807
808         return res;
809     }
810     else if(mkSys==MKSYS_ANTIMONIKER){
811
812         *ppmkComposite=NULL;
813         return S_OK;
814     }
815     else if (fOnlyIfNotGeneric){
816
817         *ppmkComposite=NULL;
818         return MK_E_NEEDGENERIC;
819     }
820     else
821
822         return CreateGenericComposite(iface,pmkRight,ppmkComposite);
823 }
824
825 /******************************************************************************
826  *        FileMoniker_Enum
827  ******************************************************************************/
828 HRESULT WINAPI FileMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
829 {
830     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
831
832     if (ppenumMoniker == NULL)
833         return E_POINTER;
834
835     *ppenumMoniker = NULL;
836
837     return S_OK;
838 }
839
840 /******************************************************************************
841  *        FileMoniker_IsEqual
842  ******************************************************************************/
843 HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
844 {
845     ICOM_THIS(FileMonikerImpl,iface);
846     CLSID clsid;
847     LPOLESTR filePath;
848     IBindCtx* bind;
849     HRESULT res;
850
851     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
852
853     if (pmkOtherMoniker==NULL)
854         return S_FALSE;
855
856     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
857
858     if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker))
859
860         return S_FALSE;
861
862     res=CreateBindCtx(0,&bind);
863     if (FAILED(res))
864         return res;
865
866     IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath);
867     
868     if (lstrcmpiW(filePath,
869                   This->filePathName)!=0)
870
871         return S_FALSE;
872     
873     return S_OK;
874 }
875
876 /******************************************************************************
877  *        FileMoniker_Hash
878  ******************************************************************************/
879 HRESULT WINAPI FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
880 {
881     ICOM_THIS(FileMonikerImpl,iface);
882
883     int  h = 0,i,skip,len;
884     int  off = 0;
885     LPOLESTR val;
886
887     if (pdwHash==NULL)
888         return E_POINTER;
889     
890     val =  This->filePathName;
891     len = lstrlenW(val);
892
893     if (len < 16) {
894         for (i = len ; i > 0; i--) {
895             h = (h * 37) + val[off++];
896         }
897     } else {
898         /* only sample some characters */
899         skip = len / 8;
900         for (i = len ; i > 0; i -= skip, off += skip) {
901             h = (h * 39) + val[off];
902         }
903     }
904
905     *pdwHash=h;
906
907     return S_OK;
908 }
909
910 /******************************************************************************
911  *        FileMoniker_IsRunning
912  ******************************************************************************/
913 HRESULT WINAPI FileMonikerImpl_IsRunning(IMoniker* iface,
914                                          IBindCtx* pbc,
915                                          IMoniker* pmkToLeft,
916                                          IMoniker* pmkNewlyRunning)
917 {
918     IRunningObjectTable* rot;
919     HRESULT res;
920
921     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
922
923     if ( (pmkNewlyRunning!=NULL) && (IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK) )
924         return S_OK;
925
926     if (pbc==NULL)
927         return E_POINTER;
928
929     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
930
931     if (FAILED(res))
932         return res;
933
934     res = IRunningObjectTable_IsRunning(rot,iface);
935
936     IRunningObjectTable_Release(rot);
937
938     return res;
939 }
940
941 /******************************************************************************
942  *        FileMoniker_GetTimeOfLastChange
943  ******************************************************************************/
944 HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
945                                                    IBindCtx* pbc,
946                                                    IMoniker* pmkToLeft,
947                                                    FILETIME* pFileTime)
948 {
949     ICOM_THIS(FileMonikerImpl,iface);
950     IRunningObjectTable* rot;
951     HRESULT res;
952     WIN32_FILE_ATTRIBUTE_DATA info;
953
954     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pFileTime);
955
956     if (pFileTime==NULL)
957         return E_POINTER;
958
959     if (pmkToLeft!=NULL)
960         return E_INVALIDARG;
961
962     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
963
964     if (FAILED(res))
965         return res;
966
967     res= IRunningObjectTable_GetTimeOfLastChange(rot,iface,pFileTime);
968
969     if (FAILED(res)){ /* the moniker is not registred */
970
971         if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
972             return MK_E_NOOBJECT;
973         
974         *pFileTime=info.ftLastWriteTime;
975     }
976
977     return S_OK;
978 }
979
980 /******************************************************************************
981  *        FileMoniker_Inverse
982  ******************************************************************************/
983 HRESULT WINAPI FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
984 {
985
986     TRACE("(%p,%p)\n",iface,ppmk);
987
988     return CreateAntiMoniker(ppmk);
989 }
990
991 /******************************************************************************
992  *        FileMoniker_CommonPrefixWith
993  ******************************************************************************/
994 HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
995 {
996
997     LPOLESTR pathThis,pathOther,*stringTable1,*stringTable2,commonPath;
998     IBindCtx *pbind;
999     DWORD mkSys;
1000     ULONG nb1,nb2,i,sameIdx;
1001     BOOL machimeNameCase=FALSE;
1002
1003     if (ppmkPrefix==NULL)
1004         return E_POINTER;
1005
1006     if (pmkOther==NULL)
1007         return E_INVALIDARG;
1008     
1009     *ppmkPrefix=0;
1010     
1011     /* check if we have the same type of moniker */
1012     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
1013
1014     if(mkSys==MKSYS_FILEMONIKER){
1015
1016         CreateBindCtx(0,&pbind);
1017
1018         /* create a string based on common part of the two paths */
1019
1020         IMoniker_GetDisplayName(iface,pbind,NULL,&pathThis);
1021         IMoniker_GetDisplayName(pmkOther,pbind,NULL,&pathOther);
1022
1023         nb1=FileMonikerImpl_DecomposePath(pathThis,&stringTable1);
1024         nb2=FileMonikerImpl_DecomposePath(pathOther,&stringTable2);
1025
1026         if (nb1==0 || nb2==0)
1027             return MK_E_NOPREFIX;
1028
1029         commonPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(min(lstrlenW(pathThis),lstrlenW(pathOther))+1));
1030
1031         *commonPath=0;
1032         
1033         for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
1034                          (stringTable2[sameIdx]!=NULL) &&
1035                          (lstrcmpiW(stringTable1[sameIdx],stringTable2[sameIdx])==0)); sameIdx++);
1036
1037         if (sameIdx > 1 && *stringTable1[0]=='\\' && *stringTable2[1]=='\\'){
1038
1039             machimeNameCase=TRUE;
1040
1041             for(i=2;i<sameIdx;i++)
1042
1043                 if( (*stringTable1[i]=='\\') && (i+1 < sameIdx) && (*stringTable1[i+1]=='\\') ){
1044                     machimeNameCase=FALSE;
1045                     break;
1046             }
1047         }
1048
1049         if (machimeNameCase && *stringTable1[sameIdx-1]=='\\')
1050             sameIdx--;
1051         
1052         if (machimeNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
1053             return MK_E_NOPREFIX;
1054
1055         for(i=0;i<sameIdx;i++)
1056             strcatW(commonPath,stringTable1[i]);
1057         
1058         for(i=0;i<nb1;i++)
1059             CoTaskMemFree(stringTable1[i]);
1060
1061         CoTaskMemFree(stringTable1);
1062
1063         for(i=0;i<nb2;i++)
1064             CoTaskMemFree(stringTable2[i]);
1065
1066         CoTaskMemFree(stringTable2);
1067
1068         HeapFree(GetProcessHeap(),0,commonPath);
1069         
1070         return CreateFileMoniker(commonPath,ppmkPrefix);
1071     }
1072     else
1073         return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
1074 }
1075
1076 /******************************************************************************
1077  *        DecomposePath (local function)
1078  ******************************************************************************/
1079 int WINAPI FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** stringTable)
1080 {
1081     WCHAR bSlash[] = {'\\',0};
1082     WCHAR word[MAX_PATH];
1083     int i=0,j,tabIndex=0;
1084     LPOLESTR *strgtable ;
1085
1086     int len=lstrlenW(str);
1087
1088     strgtable =CoTaskMemAlloc(len*sizeof(LPOLESTR));
1089     
1090     if (strgtable==NULL)
1091         return E_OUTOFMEMORY;
1092     
1093     while(str[i]!=0){
1094
1095         if(str[i]==bSlash[0]){
1096
1097             strgtable[tabIndex]=CoTaskMemAlloc(2*sizeof(WCHAR));
1098
1099             if (strgtable[tabIndex]==NULL)
1100                 return E_OUTOFMEMORY;
1101
1102             strcpyW(strgtable[tabIndex++],bSlash);
1103
1104             i++;
1105
1106         }
1107         else {
1108
1109             for(j=0; str[i]!=0 && str[i]!=bSlash[0] ; i++,j++)
1110                 word[j]=str[i];
1111
1112             word[j]=0;
1113
1114             strgtable[tabIndex]=CoTaskMemAlloc(sizeof(WCHAR)*(j+1));
1115
1116             if (strgtable[tabIndex]==NULL)
1117                 return E_OUTOFMEMORY;
1118
1119             strcpyW(strgtable[tabIndex++],word);
1120         }
1121     }
1122     strgtable[tabIndex]=NULL;
1123     
1124     *stringTable=strgtable;
1125     
1126     return tabIndex;
1127 }
1128
1129 /******************************************************************************
1130  *        FileMoniker_RelativePathTo
1131  ******************************************************************************/
1132 HRESULT WINAPI FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
1133 {
1134     IBindCtx *bind;
1135     HRESULT res;
1136     LPOLESTR str1=0,str2=0,*tabStr1=0,*tabStr2=0,relPath=0;
1137     DWORD len1=0,len2=0,sameIdx=0,j=0;
1138     WCHAR back[] ={'.','.','\\',0};
1139     
1140     TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
1141
1142     if (ppmkRelPath==NULL)
1143         return E_POINTER;
1144
1145     if (pmOther==NULL)
1146         return E_INVALIDARG;
1147     
1148     res=CreateBindCtx(0,&bind);
1149     if (FAILED(res))
1150         return res;
1151
1152     res=IMoniker_GetDisplayName(iface,bind,NULL,&str1);
1153     if (FAILED(res))
1154         return res;
1155     res=IMoniker_GetDisplayName(pmOther,bind,NULL,&str2);
1156     if (FAILED(res))
1157         return res;
1158
1159     len1=FileMonikerImpl_DecomposePath(str1,&tabStr1);
1160     len2=FileMonikerImpl_DecomposePath(str2,&tabStr2);
1161
1162     if (FAILED(len1) || FAILED(len2))
1163         return E_OUTOFMEMORY;
1164         
1165     /* count the number of similar items from the begin of the two paths */
1166     for(sameIdx=0; ( (tabStr1[sameIdx]!=NULL) &&
1167                    (tabStr2[sameIdx]!=NULL) &&
1168                (lstrcmpiW(tabStr1[sameIdx],tabStr2[sameIdx])==0)); sameIdx++);
1169
1170     /* begin the construction of relativePath */
1171     /* if the two paths have a consecutive similar item from the begin ! the relativePath will be composed */
1172     /* by "..\\" in the begin */
1173     relPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(1+lstrlenW(str1)+lstrlenW(str2)));
1174
1175     *relPath=0;
1176
1177     if (len2>0 && !(len1==1 && len2==1 && sameIdx==0))
1178         for(j=sameIdx;(tabStr1[j] != NULL); j++)
1179             if (*tabStr1[j]!='\\')
1180                 strcatW(relPath,back);
1181
1182     /* add items of the second path (similar items with the first path are not included) to the relativePath */
1183     for(j=sameIdx;tabStr2[j]!=NULL;j++)
1184         strcatW(relPath,tabStr2[j]);
1185     
1186     res=CreateFileMoniker(relPath,ppmkRelPath);
1187     
1188     for(j=0; tabStr1[j]!=NULL;j++)
1189         CoTaskMemFree(tabStr1[j]);
1190     for(j=0; tabStr2[j]!=NULL;j++)
1191         CoTaskMemFree(tabStr2[j]);
1192     CoTaskMemFree(tabStr1);
1193     CoTaskMemFree(tabStr2);
1194     CoTaskMemFree(str1);
1195     CoTaskMemFree(str2);
1196     HeapFree(GetProcessHeap(),0,relPath);
1197
1198     if (len1==0 || len2==0 || (len1==1 && len2==1 && sameIdx==0))
1199         return MK_S_HIM;
1200
1201     return res;
1202 }
1203
1204 /******************************************************************************
1205  *        FileMoniker_GetDisplayName
1206  ******************************************************************************/
1207 HRESULT WINAPI FileMonikerImpl_GetDisplayName(IMoniker* iface,
1208                                               IBindCtx* pbc,
1209                                               IMoniker* pmkToLeft,
1210                                               LPOLESTR *ppszDisplayName)
1211 {
1212     ICOM_THIS(FileMonikerImpl,iface);
1213
1214     int len=lstrlenW(This->filePathName);
1215
1216     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1217
1218     if (ppszDisplayName==NULL)
1219         return E_POINTER;
1220
1221     if (pmkToLeft!=NULL)
1222         return E_INVALIDARG;
1223
1224     *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
1225     if (*ppszDisplayName==NULL)
1226         return E_OUTOFMEMORY;
1227
1228     strcpyW(*ppszDisplayName,This->filePathName);
1229     
1230     return S_OK;
1231 }
1232
1233 /******************************************************************************
1234  *        FileMoniker_ParseDisplayName
1235  ******************************************************************************/
1236 HRESULT WINAPI FileMonikerImpl_ParseDisplayName(IMoniker* iface,
1237                                                 IBindCtx* pbc,
1238                                                 IMoniker* pmkToLeft,
1239                                                 LPOLESTR pszDisplayName,
1240                                                 ULONG* pchEaten,
1241                                                 IMoniker** ppmkOut)
1242 {
1243     FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
1244     return E_NOTIMPL;
1245 }
1246
1247 /******************************************************************************
1248  *        FileMoniker_IsSystemMoniker
1249  ******************************************************************************/
1250 HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1251 {
1252     TRACE("(%p,%p)\n",iface,pwdMksys);
1253
1254     if (!pwdMksys)
1255         return E_POINTER;
1256     
1257     (*pwdMksys)=MKSYS_FILEMONIKER;
1258
1259     return S_OK;
1260 }
1261
1262 /*******************************************************************************
1263  *        FileMonikerIROTData_QueryInterface
1264  *******************************************************************************/
1265 HRESULT WINAPI FileMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
1266 {
1267
1268     ICOM_THIS_From_IROTData(IMoniker, iface);
1269
1270     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1271
1272     return FileMonikerImpl_QueryInterface(This, riid, ppvObject);
1273 }
1274
1275 /***********************************************************************
1276  *        FileMonikerIROTData_AddRef
1277  */
1278 ULONG   WINAPI FileMonikerROTDataImpl_AddRef(IROTData *iface)
1279 {
1280     ICOM_THIS_From_IROTData(IMoniker, iface);
1281
1282     TRACE("(%p)\n",This);
1283
1284     return FileMonikerImpl_AddRef(This);
1285 }
1286
1287 /***********************************************************************
1288  *        FileMonikerIROTData_Release
1289  */
1290 ULONG   WINAPI FileMonikerROTDataImpl_Release(IROTData* iface)
1291 {
1292     ICOM_THIS_From_IROTData(IMoniker, iface);
1293     
1294     TRACE("(%p)\n",This);
1295
1296     return FileMonikerImpl_Release(This);
1297 }
1298
1299 /******************************************************************************
1300  *        FileMonikerIROTData_GetComparaisonData
1301  ******************************************************************************/
1302 HRESULT WINAPI FileMonikerROTDataImpl_GetComparaisonData(IROTData* iface,
1303                                                          BYTE* pbData,
1304                                                          ULONG cbMax,
1305                                                          ULONG* pcbData)
1306 {
1307     FIXME("(),stub!\n");
1308     return E_NOTIMPL;
1309 }
1310
1311 /******************************************************************************
1312  *        CreateFileMoniker (OLE2.28)
1313  ******************************************************************************/
1314 HRESULT WINAPI CreateFileMoniker16(LPCOLESTR16 lpszPathName,LPMONIKER* ppmk)
1315 {
1316
1317     FIXME("(%s,%p),stub!\n",lpszPathName,ppmk);
1318     return E_NOTIMPL;
1319 }
1320
1321 /******************************************************************************
1322  *        CreateFileMoniker (OLE32.55)
1323  ******************************************************************************/
1324 HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER * ppmk)
1325 {
1326     FileMonikerImpl* newFileMoniker = 0;
1327     HRESULT  hr = E_FAIL;
1328     IID riid=IID_IMoniker;
1329
1330     TRACE("(%p,%p)\n",lpszPathName,ppmk);
1331
1332     if (ppmk==NULL)
1333         return E_POINTER;
1334
1335     if(lpszPathName==NULL)
1336         return MK_E_SYNTAX;
1337             
1338     *ppmk=0;
1339         
1340     newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
1341
1342     if (newFileMoniker == 0)
1343         return E_OUTOFMEMORY;
1344
1345     hr = FileMonikerImpl_Construct(newFileMoniker,lpszPathName);
1346
1347     if (SUCCEEDED(hr))
1348         hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&riid,(void**)ppmk);
1349     else
1350         HeapFree(GetProcessHeap(),0,newFileMoniker);
1351
1352     return hr;
1353 }