projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync to Wine-20040914:
[reactos.git] / reactos / lib / shlwapi / path.c
1 /*
2 * Path Functions
3 *
4 * Copyright 1999, 2000 Juergen Schmied
5 * Copyright 2001, 2002 Jon Griffiths
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include "wine/unicode.h"
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winreg.h"
35 #include "winnls.h"
36 #define NO_SHLWAPI_STREAM
37 #include "shlwapi.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(shell);
41
42 /* Get a function pointer from a DLL handle */
43 #define GET_FUNC(func, module, name, fail) \
44 do { \
45 if (!func) { \
46 if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
47 func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
48 if (!func) return fail; \
49 } \
50 } while (0)
51
52 /* DLL handles for late bound calls */
53 extern HMODULE SHLWAPI_hshell32;
54
55 /* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
56 typedef BOOL (WINAPI *fnpIsNetDrive)(int);
57 static fnpIsNetDrive pIsNetDrive;
58
59 HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR,LPWSTR,DWORD);
60
61 /*************************************************************************
62 * PathAppendA [SHLWAPI.@]
63 *
64 * Append one path to another.
65 *
66 * PARAMS
67 * lpszPath [I/O] Initial part of path, and destination for output
68 * lpszAppend [I] Path to append
69 *
70 * RETURNS
71 * Success: TRUE. lpszPath contains the newly created path.
72 * Failure: FALSE, if either path is NULL, or PathCombineA() fails.
73 *
74 * NOTES
75 * lpszAppend must contain at least one backslash ('\') if not NULL.
76 * Because PathCombineA() is used to join the paths, the resulting
77 * path is also canonicalized.
78 */
79 BOOL WINAPI PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
80 {
81 TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
82
83 if (lpszPath && lpszAppend)
84 {
85 if (!PathIsUNCA(lpszAppend))
86 while (*lpszAppend == '\\')
87 lpszAppend++;
88 if (PathCombineA(lpszPath, lpszPath, lpszAppend))
89 return TRUE;
90 }
91 return FALSE;
92 }
93
94 /*************************************************************************
95 * PathAppendW [SHLWAPI.@]
96 *
97 * See PathAppendA.
98 */
99 BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
100 {
101 TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
102
103 if (lpszPath && lpszAppend)
104 {
105 if (!PathIsUNCW(lpszAppend))
106 while (*lpszAppend == '\\')
107 lpszAppend++;
108 if (PathCombineW(lpszPath, lpszPath, lpszAppend))
109 return TRUE;
110 }
111 return FALSE;
112 }
113
114 /*************************************************************************
115 * PathCombineA [SHLWAPI.@]
116 *
117 * Combine two paths together.
118 *
119 * PARAMS
120 * lpszDest [O] Destination for combined path
121 * lpszDir [I] Directory path
122 * lpszFile [I] File path
123 *
124 * RETURNS
125 * Success: The output path
126 * Failure: NULL, if inputs are invalid.
127 *
128 * NOTES
129 * lpszDest should be at least MAX_PATH in size, and may point to the same
130 * memory location as lpszDir. The combined path is canonicalised.
131 */
132 LPSTR WINAPI PathCombineA(LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
133 {
134 TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
135
136 if (!lpszDest || (!lpszDir && !lpszFile))
137 return NULL; /* Invalid parameters */
138 else
139 {
140 WCHAR szDest[MAX_PATH];
141 WCHAR szDir[MAX_PATH];
142 WCHAR szFile[MAX_PATH];
143 if (lpszDir)
144 MultiByteToWideChar(CP_ACP,0,lpszDir,-1,szDir,MAX_PATH);
145 if (lpszFile)
146 MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
147 PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL);
148 WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
149 }
150 return lpszDest;
151 }
152
153 /*************************************************************************
154 * PathCombineW [SHLWAPI.@]
155 *
156 * See PathCombineA.
157 */
158 LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
159 {
160 WCHAR szTemp[MAX_PATH];
161 BOOL bUseBoth = FALSE, bStrip = FALSE;
162
163 TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
164
165 if (!lpszDest || (!lpszDir && !lpszFile))
166 return lpszDest; /* Invalid parameters */
167
168 if (!lpszFile || !*lpszFile)
169 {
170 /* Use dir only */
171 strncpyW(szTemp, lpszDir, MAX_PATH);
172 }
173 else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
174 {
175 if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
176 {
177 /* Use file only */
178 strncpyW(szTemp, lpszFile, MAX_PATH);
179 }
180 else
181 {
182 bUseBoth = TRUE;
183 bStrip = TRUE;
184 }
185 }
186 else
187 bUseBoth = TRUE;
188
189 if (bUseBoth)
190 {
191 strncpyW(szTemp, lpszDir, MAX_PATH);
192 if (bStrip)
193 {
194 PathStripToRootW(szTemp);
195 lpszFile++; /* Skip '\' */
196 }
197 if (!PathAddBackslashW(szTemp))
198 return NULL;
199 if (strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
200 return NULL;
201 strcatW(szTemp, lpszFile);
202 }
203
204 PathCanonicalizeW(lpszDest, szTemp);
205 return lpszDest;
206 }
207
208 /*************************************************************************
209 * PathAddBackslashA [SHLWAPI.@]
210 *
211 * Append a backslash ('\') to a path if one doesn't exist.
212 *
213 * PARAMS
214 * lpszPath [I/O] The path to append a backslash to.
215 *
216 * RETURNS
217 * Success: The position of the last backslash in the path.
218 * Failure: NULL, if lpszPath is NULL or the path is too large.
219 */
220 LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
221 {
222 size_t iLen;
223
224 TRACE("(%s)\n",debugstr_a(lpszPath));
225
226 if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
227 return NULL;
228
229 if (iLen)
230 {
231 lpszPath += iLen;
232 if (lpszPath[-1] != '\\')
233 {
234 *lpszPath++ = '\\';
235 *lpszPath = '\0';
236 }
237 }
238 return lpszPath;
239 }
240
241 /*************************************************************************
242 * PathAddBackslashW [SHLWAPI.@]
243 *
244 * See PathAddBackslashA.
245 */
246 LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
247 {
248 size_t iLen;
249
250 TRACE("(%s)\n",debugstr_w(lpszPath));
251
252 if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
253 return NULL;
254
255 if (iLen)
256 {
257 lpszPath += iLen;
258 if (lpszPath[-1] != '\\')
259 {
260 *lpszPath++ = '\\';
261 *lpszPath = '\0';
262 }
263 }
264 return lpszPath;
265 }
266
267 /*************************************************************************
268 * PathBuildRootA [SHLWAPI.@]
269 *
270 * Create a root drive string (e.g. "A:\") from a drive number.
271 *
272 * PARAMS
273 * lpszPath [O] Destination for the drive string
274 *
275 * RETURNS
276 * lpszPath
277 *
278 * NOTES
279 * If lpszPath is NULL or drive is invalid, nothing is written to lpszPath.
280 */
281 LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
282 {
283 TRACE("(%p,%d)\n", lpszPath, drive);
284
285 if (lpszPath && drive >= 0 && drive < 26)
286 {
287 lpszPath[0] = 'A' + drive;
288 lpszPath[1] = ':';
289 lpszPath[2] = '\\';
290 lpszPath[3] = '\0';
291 }
292 return lpszPath;
293 }
294
295 /*************************************************************************
296 * PathBuildRootW [SHLWAPI.@]
297 *
298 * See PathBuildRootA.
299 */
300 LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
301 {
302 TRACE("(%p,%d)\n", lpszPath, drive);
303
304 if (lpszPath && drive >= 0 && drive < 26)
305 {
306 lpszPath[0] = 'A' + drive;
307 lpszPath[1] = ':';
308 lpszPath[2] = '\\';
309 lpszPath[3] = '\0';
310 }
311 return lpszPath;
312 }
313
314 /*************************************************************************
315 * PathFindFileNameA [SHLWAPI.@]
316 *
317 * Locate the start of the file name in a path
318 *
319 * PARAMS
320 * lpszPath [I] Path to search
321 *
322 * RETURNS
323 * A pointer to the first character of the file name
324 */
325 LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
326 {
327 LPCSTR lastSlash = lpszPath;
328
329 TRACE("(%s)\n",debugstr_a(lpszPath));
330
331 while (lpszPath && *lpszPath)
332 {
333 if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
334 lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
335 lastSlash = lpszPath + 1;
336 lpszPath = CharNextA(lpszPath);
337 }
338 return (LPSTR)lastSlash;
339 }
340
341 /*************************************************************************
342 * PathFindFileNameW [SHLWAPI.@]
343 *
344 * See PathFindFileNameA.
345 */
346 LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
347 {
348 LPCWSTR lastSlash = lpszPath;
349
350 TRACE("(%s)\n",debugstr_w(lpszPath));
351
352 while (lpszPath && *lpszPath)
353 {
354 if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
355 lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
356 lastSlash = lpszPath + 1;
357 lpszPath = CharNextW(lpszPath);
358 }
359 return (LPWSTR)lastSlash;
360 }
361
362 /*************************************************************************
363 * PathFindExtensionA [SHLWAPI.@]
364 *
365 * Locate the start of the file extension in a path
366 *
367 * PARAMS
368 * lpszPath [I] The path to search
369 *
370 * RETURNS
371 * A pointer to the first character of the extension, the end of
372 * the string if the path has no extension, or NULL If lpszPath is NULL
373 */
374 LPSTR WINAPI PathFindExtensionA( LPCSTR lpszPath )
375 {
376 LPCSTR lastpoint = NULL;
377
378 TRACE("(%s)\n", debugstr_a(lpszPath));
379
380 if (lpszPath)
381 {
382 while (*lpszPath)
383 {
384 if (*lpszPath == '\\' || *lpszPath==' ')
385 lastpoint = NULL;
386 else if (*lpszPath == '.')
387 lastpoint = lpszPath;
388 lpszPath = CharNextA(lpszPath);
389 }
390 }
391 return (LPSTR)(lastpoint ? lastpoint : lpszPath);
392 }
393
394 /*************************************************************************
395 * PathFindExtensionW [SHLWAPI.@]
396 *
397 * See PathFindExtensionA.
398 */
399 LPWSTR WINAPI PathFindExtensionW( LPCWSTR lpszPath )
400 {
401 LPCWSTR lastpoint = NULL;
402
403 TRACE("(%s)\n", debugstr_w(lpszPath));
404
405 if (lpszPath)
406 {
407 while (*lpszPath)
408 {
409 if (*lpszPath == '\\' || *lpszPath==' ')
410 lastpoint = NULL;
411 else if (*lpszPath == '.')
412 lastpoint = lpszPath;
413 lpszPath = CharNextW(lpszPath);
414 }
415 }
416 return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
417 }
418
419 /*************************************************************************
420 * PathGetArgsA [SHLWAPI.@]
421 *
422 * Find the next argument in a string delimited by spaces.
423 *
424 * PARAMS
425 * lpszPath [I] The string to search for arguments in
426 *
427 * RETURNS
428 * The start of the next argument in lpszPath, or NULL if lpszPath is NULL
429 *
430 * NOTES
431 * Spaces in quoted strings are ignored as delimiters.
432 */
433 LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
434 {
435 BOOL bSeenQuote = FALSE;
436
437 TRACE("(%s)\n",debugstr_a(lpszPath));
438
439 if (lpszPath)
440 {
441 while (*lpszPath)
442 {
443 if ((*lpszPath==' ') && !bSeenQuote)
444 return (LPSTR)lpszPath + 1;
445 if (*lpszPath == '"')
446 bSeenQuote = !bSeenQuote;
447 lpszPath = CharNextA(lpszPath);
448 }
449 }
450 return (LPSTR)lpszPath;
451 }
452
453 /*************************************************************************
454 * PathGetArgsW [SHLWAPI.@]
455 *
456 * See PathGetArgsA.
457 */
458 LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
459 {
460 BOOL bSeenQuote = FALSE;
461
462 TRACE("(%s)\n",debugstr_w(lpszPath));
463
464 if (lpszPath)
465 {
466 while (*lpszPath)
467 {
468 if ((*lpszPath==' ') && !bSeenQuote)
469 return (LPWSTR)lpszPath + 1;
470 if (*lpszPath == '"')
471 bSeenQuote = !bSeenQuote;
472 lpszPath = CharNextW(lpszPath);
473 }
474 }
475 return (LPWSTR)lpszPath;
476 }
477
478 /*************************************************************************
479 * PathGetDriveNumberA [SHLWAPI.@]
480 *
481 * Return the drive number from a path
482 *
483 * PARAMS
484 * lpszPath [I] Path to get the drive number from
485 *
486 * RETURNS
487 * Success: The drive number corresponding to the drive in the path
488 * Failure: -1, if lpszPath contains no valid drive
489 */
490 int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
491 {
492 TRACE ("(%s)\n",debugstr_a(lpszPath));
493
494 if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
495 tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
496 return tolower(*lpszPath) - 'a';
497 return -1;
498 }
499
500 /*************************************************************************
501 * PathGetDriveNumberW [SHLWAPI.@]
502 *
503 * See PathGetDriveNumberA.
504 */
505 int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
506 {
507 TRACE ("(%s)\n",debugstr_w(lpszPath));
508
509 if (lpszPath && lpszPath[1] == ':' &&
510 tolowerW(*lpszPath) >= 'a' && tolowerW(*lpszPath) <= 'z')
511 return tolowerW(*lpszPath) - 'a';
512 return -1;
513 }
514
515 /*************************************************************************
516 * PathRemoveFileSpecA [SHLWAPI.@]
517 *
518 * Remove the file specification from a path.
519 *
520 * PARAMS
521 * lpszPath [I/O] Path to remove the file spec from
522 *
523 * RETURNS
524 * TRUE If the path was valid and modified
525 * FALSE Otherwise
526 */
527 BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
528 {
529 LPSTR lpszFileSpec = lpszPath;
530 BOOL bModified = FALSE;
531
532 TRACE("(%s)\n",debugstr_a(lpszPath));
533
534 if(lpszPath)
535 {
536 /* Skip directory or UNC path */
537 if (*lpszPath == '\\')
538 lpszFileSpec = ++lpszPath;
539 if (*lpszPath == '\\')
540 lpszFileSpec = ++lpszPath;
541
542 while (*lpszPath)
543 {
544 if(*lpszPath == '\\')
545 lpszFileSpec = lpszPath; /* Skip dir */
546 else if(*lpszPath == ':')
547 {
548 lpszFileSpec = ++lpszPath; /* Skip drive */
549 if (*lpszPath == '\\')
550 lpszFileSpec++;
551 }
552 if (!(lpszPath = CharNextA(lpszPath)))
553 break;
554 }
555
556 if (*lpszFileSpec)
557 {
558 *lpszFileSpec = '\0';
559 bModified = TRUE;
560 }
561 }
562 return bModified;
563 }
564
565 /*************************************************************************
566 * PathRemoveFileSpecW [SHLWAPI.@]
567 *
568 * See PathRemoveFileSpecA.
569 */
570 BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
571 {
572 LPWSTR lpszFileSpec = lpszPath;
573 BOOL bModified = FALSE;
574
575 TRACE("(%s)\n",debugstr_w(lpszPath));
576
577 if(lpszPath)
578 {
579 /* Skip directory or UNC path */
580 if (*lpszPath == '\\')
581 lpszFileSpec = ++lpszPath;
582 if (*lpszPath == '\\')
583 lpszFileSpec = ++lpszPath;
584
585 while (*lpszPath)
586 {
587 if(*lpszPath == '\\')
588 lpszFileSpec = lpszPath; /* Skip dir */
589 else if(*lpszPath == ':')
590 {
591 lpszFileSpec = ++lpszPath; /* Skip drive */
592 if (*lpszPath == '\\')
593 lpszFileSpec++;
594 }
595 if (!(lpszPath = CharNextW(lpszPath)))
596 break;
597 }
598
599 if (*lpszFileSpec)
600 {
601 *lpszFileSpec = '\0';
602 bModified = TRUE;
603 }
604 }
605 return bModified;
606 }
607
608 /*************************************************************************
609 * PathStripPathA [SHLWAPI.@]
610 *
611 * Remove the initial path from the beginning of a filename
612 *
613 * PARAMS
614 * lpszPath [I/O] Path to remove the initial path from
615 *
616 * RETURNS
617 * Nothing.
618 */
619 void WINAPI PathStripPathA(LPSTR lpszPath)
620 {
621 TRACE("(%s)\n", debugstr_a(lpszPath));
622
623 if (lpszPath)
624 {
625 LPSTR lpszFileName = PathFindFileNameA(lpszPath);
626 if(lpszFileName)
627 RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
628 }
629 }
630
631 /*************************************************************************
632 * PathStripPathW [SHLWAPI.@]
633 *
634 * See PathStripPathA.
635 */
636 void WINAPI PathStripPathW(LPWSTR lpszPath)
637 {
638 LPWSTR lpszFileName;
639
640 TRACE("(%s)\n", debugstr_w(lpszPath));
641 lpszFileName = PathFindFileNameW(lpszPath);
642 if(lpszFileName)
643 RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
644 }
645
646 /*************************************************************************
647 * PathStripToRootA [SHLWAPI.@]
648 *
649 * Reduce a path to its root.
650 *
651 * PARAMS
652 * lpszPath [I/O] the path to reduce
653 *
654 * RETURNS
655 * Success: TRUE if the stripped path is a root path
656 * Failure: FALSE if the path cannot be stripped or is NULL
657 */
658 BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
659 {
660 TRACE("(%s)\n", debugstr_a(lpszPath));
661
662 if (!lpszPath)
663 return FALSE;
664 while(!PathIsRootA(lpszPath))
665 if (!PathRemoveFileSpecA(lpszPath))
666 return FALSE;
667 return TRUE;
668 }
669
670 /*************************************************************************
671 * PathStripToRootW [SHLWAPI.@]
672 *
673 * See PathStripToRootA.
674 */
675 BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
676 {
677 TRACE("(%s)\n", debugstr_w(lpszPath));
678
679 if (!lpszPath)
680 return FALSE;
681 while(!PathIsRootW(lpszPath))
682 if (!PathRemoveFileSpecW(lpszPath))
683 return FALSE;
684 return TRUE;
685 }
686
687 /*************************************************************************
688 * PathRemoveArgsA [SHLWAPI.@]
689 *
690 * Strip space separated arguments from a path.
691 *
692 * PARAMS
693 * lpszPath [I/O] Path to remove arguments from
694 *
695 * RETURNS
696 * Nothing.
697 */
698 void WINAPI PathRemoveArgsA(LPSTR lpszPath)
699 {
700 TRACE("(%s)\n",debugstr_a(lpszPath));
701
702 if(lpszPath)
703 {
704 LPSTR lpszArgs = PathGetArgsA(lpszPath);
705 if (*lpszArgs)
706 lpszArgs[-1] = '\0';
707 else
708 {
709 LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
710 if(*lpszLastChar == ' ')
711 *lpszLastChar = '\0';
712 }
713 }
714 }
715
716 /*************************************************************************
717 * PathRemoveArgsW [SHLWAPI.@]
718 *
719 * See PathRemoveArgsA.
720 */
721 void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
722 {
723 TRACE("(%s)\n",debugstr_w(lpszPath));
724
725 if(lpszPath)
726 {
727 LPWSTR lpszArgs = PathGetArgsW(lpszPath);
728 if (*lpszArgs)
729 lpszArgs[-1] = '\0';
730 else
731 {
732 LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
733 if(*lpszLastChar == ' ')
734 *lpszLastChar = '\0';
735 }
736 }
737 }
738
739 /*************************************************************************
740 * PathRemoveExtensionA [SHLWAPI.@]
741 *
742 * Remove the file extension from a path
743 *
744 * PARAMS
745 * lpszPath [I/O] Path to remove the extension from
746 *
747 * RETURNS
748 * Nothing.
749 */
750 void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
751 {
752 TRACE("(%s)\n", debugstr_a(lpszPath));
753
754 if (lpszPath)
755 {
756 lpszPath = PathFindExtensionA(lpszPath);
757 *lpszPath = '\0';
758 }
759 }
760
761 /*************************************************************************
762 * PathRemoveExtensionW [SHLWAPI.@]
763 *
764 * See PathRemoveExtensionA.
765 */
766 void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
767 {
768 TRACE("(%s)\n", debugstr_w(lpszPath));
769
770 if (lpszPath)
771 {
772 lpszPath = PathFindExtensionW(lpszPath);
773 *lpszPath = '\0';
774 }
775 }
776
777 /*************************************************************************
778 * PathRemoveBackslashA [SHLWAPI.@]
779 *
780 * Remove a trailing backslash from a path.
781 *
782 * PARAMS
783 * lpszPath [I/O] Path to remove backslash from
784 *
785 * RETURNS
786 * Success: A pointer to the end of the path
787 * Failure: NULL, if lpszPath is NULL
788 */
789 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
790 {
791 LPSTR szTemp = NULL;
792
793 TRACE("(%s)\n", debugstr_a(lpszPath));
794
795 if(lpszPath)
796 {
797 szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
798 if (!PathIsRootA(lpszPath) && *szTemp == '\\')
799 *szTemp = '\0';
800 }
801 return szTemp;
802 }
803
804 /*************************************************************************
805 * PathRemoveBackslashW [SHLWAPI.@]
806 *
807 * See PathRemoveBackslashA.
808 */
809 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
810 {
811 LPWSTR szTemp = NULL;
812
813 TRACE("(%s)\n", debugstr_w(lpszPath));
814
815 if(lpszPath)
816 {
817 szTemp = CharPrevW(lpszPath, lpszPath + strlenW(lpszPath));
818 if (!PathIsRootW(lpszPath) && *szTemp == '\\')
819 *szTemp = '\0';
820 }
821 return szTemp;
822 }
823
824 /*************************************************************************
825 * PathRemoveBlanksA [SHLWAPI.@]
826 *
827 * Remove Spaces from the start and end of a path.
828 *
829 * PARAMS
830 * lpszPath [I/O] Path to strip blanks from
831 *
832 * RETURNS
833 * Nothing.
834 */
835 VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
836 {
837 TRACE("(%s)\n", debugstr_a(lpszPath));
838
839 if(lpszPath && *lpszPath)
840 {
841 LPSTR start = lpszPath;
842
843 while (*lpszPath == ' ')
844 lpszPath = CharNextA(lpszPath);
845
846 while(*lpszPath)
847 *start++ = *lpszPath++;
848
849 if (start != lpszPath)
850 while (start[-1] == ' ')
851 start--;
852 *start = '\0';
853 }
854 }
855
856 /*************************************************************************
857 * PathRemoveBlanksW [SHLWAPI.@]
858 *
859 * See PathRemoveBlanksA.
860 */
861 VOID WINAPI PathRemoveBlanksW(LPWSTR lpszPath)
862 {
863 TRACE("(%s)\n", debugstr_w(lpszPath));
864
865 if(lpszPath && *lpszPath)
866 {
867 LPWSTR start = lpszPath;
868
869 while (*lpszPath == ' ')
870 lpszPath++;
871
872 while(*lpszPath)
873 *start++ = *lpszPath++;
874
875 if (start != lpszPath)
876 while (start[-1] == ' ')
877 start--;
878 *start = '\0';
879 }
880 }
881
882 /*************************************************************************
883 * PathQuoteSpacesA [SHLWAPI.@]
884 *
885 * Surround a path containg spaces in quotes.
886 *
887 * PARAMS
888 * lpszPath [I/O] Path to quote
889 *
890 * RETURNS
891 * Nothing.
892 *
893 * NOTES
894 * The path is not changed if it is invalid or has no spaces.
895 */
896 VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
897 {
898 TRACE("(%s)\n", debugstr_a(lpszPath));
899
900 if(lpszPath && StrChrA(lpszPath,' '))
901 {
902 size_t iLen = strlen(lpszPath) + 1;
903
904 if (iLen + 2 < MAX_PATH)
905 {
906 memmove(lpszPath + 1, lpszPath, iLen);
907 lpszPath[0] = '"';
908 lpszPath[iLen] = '"';
909 lpszPath[iLen + 1] = '\0';
910 }
911 }
912 }
913
914 /*************************************************************************
915 * PathQuoteSpacesW [SHLWAPI.@]
916 *
917 * See PathQuoteSpacesA.
918 */
919 VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
920 {
921 TRACE("(%s)\n", debugstr_w(lpszPath));
922
923 if(lpszPath && StrChrW(lpszPath,' '))
924 {
925 int iLen = strlenW(lpszPath) + 1;
926
927 if (iLen + 2 < MAX_PATH)
928 {
929 memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
930 lpszPath[0] = '"';
931 lpszPath[iLen] = '"';
932 lpszPath[iLen + 1] = '\0';
933 }
934 }
935 }
936
937 /*************************************************************************
938 * PathUnquoteSpacesA [SHLWAPI.@]
939 *
940 * Remove quotes ("") from around a path, if present.
941 *
942 * PARAMS
943 * lpszPath [I/O] Path to strip quotes from
944 *
945 * RETURNS
946 * Nothing
947 *
948 * NOTES
949 * If the path contains a single quote only, an empty string will result.
950 * Otherwise quotes are only removed if they appear at the start and end
951 * of the path.
952 */
953 VOID WINAPI PathUnquoteSpacesA(LPSTR lpszPath)
954 {
955 TRACE("(%s)\n", debugstr_a(lpszPath));
956
957 if (lpszPath && *lpszPath == '"')
958 {
959 DWORD dwLen = strlen(lpszPath) - 1;
960
961 if (lpszPath[dwLen] == '"')
962 {
963 lpszPath[dwLen] = '\0';
964 for (; *lpszPath; lpszPath++)
965 *lpszPath = lpszPath[1];
966 }
967 }
968 }
969
970 /*************************************************************************
971 * PathUnquoteSpacesW [SHLWAPI.@]
972 *
973 * See PathUnquoteSpacesA.
974 */
975 VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
976 {
977 TRACE("(%s)\n", debugstr_w(lpszPath));
978
979 if (lpszPath && *lpszPath == '"')
980 {
981 DWORD dwLen = strlenW(lpszPath) - 1;
982
983 if (lpszPath[dwLen] == '"')
984 {
985 lpszPath[dwLen] = '\0';
986 for (; *lpszPath; lpszPath++)
987 *lpszPath = lpszPath[1];
988 }
989 }
990 }
991
992 /*************************************************************************
993 * PathParseIconLocationA [SHLWAPI.@]
994 *
995 * Parse the location of an icon from a path.
996 *
997 * PARAMS
998 * lpszPath [I/O] The path to parse the icon location from.
999 *
1000 * RETURNS
1001 * Success: The number of the icon
1002 * Failure: 0 if the path does not contain an icon location or is NULL
1003 *
1004 * NOTES
1005 * The path has surrounding quotes and spaces removed regardless
1006 * of whether the call succeeds or not.
1007 */
1008 int WINAPI PathParseIconLocationA(LPSTR lpszPath)
1009 {
1010 int iRet = 0;
1011 LPSTR lpszComma;
1012
1013 TRACE("(%s)\n", debugstr_a(lpszPath));
1014
1015 if (lpszPath)
1016 {
1017 if ((lpszComma = strchr(lpszPath, ',')))
1018 {
1019 *lpszComma++ = '\0';
1020 iRet = StrToIntA(lpszComma);
1021 }
1022 PathUnquoteSpacesA(lpszPath);
1023 PathRemoveBlanksA(lpszPath);
1024 }
1025 return iRet;
1026 }
1027
1028 /*************************************************************************
1029 * PathParseIconLocationW [SHLWAPI.@]
1030 *
1031 * See PathParseIconLocationA.
1032 */
1033 int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
1034 {
1035 int iRet = 0;
1036 LPWSTR lpszComma;
1037
1038 TRACE("(%s)\n", debugstr_w(lpszPath));
1039
1040 if (lpszPath)
1041 {
1042 if ((lpszComma = StrChrW(lpszPath, ',')))
1043 {
1044 *lpszComma++ = '\0';
1045 iRet = StrToIntW(lpszComma);
1046 }
1047 PathUnquoteSpacesW(lpszPath);
1048 PathRemoveBlanksW(lpszPath);
1049 }
1050 return iRet;
1051 }
1052
1053 /*************************************************************************
1054 * @ [SHLWAPI.4]
1055 *
1056 * Unicode version of PathFileExistsDefExtA.
1057 */
1058 BOOL WINAPI PathFileExistsDefExtW(LPWSTR lpszPath,DWORD dwWhich)
1059 {
1060 static const WCHAR pszExts[7][5] = { { '.', 'p', 'i', 'f', 0},
1061 { '.', 'c', 'o', 'm', 0},
1062 { '.', 'e', 'x', 'e', 0},
1063 { '.', 'b', 'a', 't', 0},
1064 { '.', 'l', 'n', 'k', 0},
1065 { '.', 'c', 'm', 'd', 0},
1066 { 0, 0, 0, 0, 0} };
1067
1068 TRACE("(%s,%ld)\n", debugstr_w(lpszPath), dwWhich);
1069
1070 if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
1071 return FALSE;
1072
1073 if (dwWhich)
1074 {
1075 LPCWSTR szExt = PathFindExtensionW(lpszPath);
1076 if (!*szExt || dwWhich & 0x40)
1077 {
1078 size_t iChoose = 0;
1079 int iLen = lstrlenW(lpszPath);
1080 if (iLen > (MAX_PATH - 5))
1081 return FALSE;
1082 while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
1083 {
1084 lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
1085 if (PathFileExistsW(lpszPath))
1086 return TRUE;
1087 iChoose++;
1088 dwWhich >>= 1;
1089 }
1090 *(lpszPath + iLen) = (WCHAR)'\0';
1091 return FALSE;
1092 }
1093 }
1094 return PathFileExistsW(lpszPath);
1095 }
1096
1097 /*************************************************************************
1098 * @ [SHLWAPI.3]
1099 *
1100 * Determine if a file exists locally and is of an executable type.
1101 *
1102 * PARAMS
1103 * lpszPath [I/O] File to search for
1104 * dwWhich [I] Type of executable to search for
1105 *
1106 * RETURNS
1107 * TRUE If the file was found. lpszPath contains the file name.
1108 * FALSE Otherwise.
1109 *
1110 * NOTES
1111 * lpszPath is modified in place and must be at least MAX_PATH in length.
1112 * If the function returns FALSE, the path is modified to its orginal state.
1113 * If the given path contains an extension or dwWhich is 0, executable
1114 * extensions are not checked.
1115 *
1116 * Ordinals 3-6 are a classic case of MS exposing limited functionality to
1117 * users (here through PathFindOnPathA()) and keeping advanced functionality for
1118 * their own developers exclusive use. Monopoly, anyone?
1119 */
1120 BOOL WINAPI PathFileExistsDefExtA(LPSTR lpszPath,DWORD dwWhich)
1121 {
1122 BOOL bRet = FALSE;
1123
1124 TRACE("(%s,%ld)\n", debugstr_a(lpszPath), dwWhich);
1125
1126 if (lpszPath)
1127 {
1128 WCHAR szPath[MAX_PATH];
1129 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1130 bRet = PathFileExistsDefExtW(szPath, dwWhich);
1131 if (bRet)
1132 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
1133 }
1134 return bRet;
1135 }
1136
1137 /*************************************************************************
1138 * SHLWAPI_PathFindInOtherDirs
1139 *
1140 * Internal helper for SHLWAPI_PathFindOnPathExA/W.
1141 */
1142 static BOOL WINAPI SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
1143 {
1144 static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
1145 static const WCHAR szPath[] = { 'P','A','T','H','\0'};
1146 DWORD dwLenPATH;
1147 LPCWSTR lpszCurr;
1148 WCHAR *lpszPATH;
1149 WCHAR buff[MAX_PATH];
1150
1151 TRACE("(%s,%08lx)\n", debugstr_w(lpszFile), dwWhich);
1152
1153 /* Try system directories */
1154 GetSystemDirectoryW(buff, MAX_PATH);
1155 if (!PathAppendW(buff, lpszFile))
1156 return FALSE;
1157 if (PathFileExistsDefExtW(buff, dwWhich))
1158 {
1159 strcpyW(lpszFile, buff);
1160 return TRUE;
1161 }
1162 GetWindowsDirectoryW(buff, MAX_PATH);
1163 if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
1164 return FALSE;
1165 if (PathFileExistsDefExtW(buff, dwWhich))
1166 {
1167 strcpyW(lpszFile, buff);
1168 return TRUE;
1169 }
1170 GetWindowsDirectoryW(buff, MAX_PATH);
1171 if (!PathAppendW(buff, lpszFile))
1172 return FALSE;
1173 if (PathFileExistsDefExtW(buff, dwWhich))
1174 {
1175 strcpyW(lpszFile, buff);
1176 return TRUE;
1177 }
1178 /* Try dirs listed in %PATH% */
1179 dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
1180
1181 if (!dwLenPATH || !(lpszPATH = malloc((dwLenPATH + 1) * sizeof (WCHAR))))
1182 return FALSE;
1183
1184 GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
1185 lpszCurr = lpszPATH;
1186 while (lpszCurr)
1187 {
1188 LPCWSTR lpszEnd = lpszCurr;
1189 LPWSTR pBuff = buff;
1190
1191 while (*lpszEnd == ' ')
1192 lpszEnd++;
1193 while (*lpszEnd && *lpszEnd != ';')
1194 *pBuff++ = *lpszEnd++;
1195 *pBuff = '\0';
1196
1197 if (*lpszEnd)
1198 lpszCurr = lpszEnd + 1;
1199 else
1200 lpszCurr = NULL; /* Last Path, terminate after this */
1201
1202 if (!PathAppendW(buff, lpszFile))
1203 {
1204 free(lpszPATH);
1205 return FALSE;
1206 }
1207 if (PathFileExistsDefExtW(buff, dwWhich))
1208 {
1209 strcpyW(lpszFile, buff);
1210 free(lpszPATH);
1211 return TRUE;
1212 }
1213 }
1214 free(lpszPATH);
1215 return FALSE;
1216 }
1217
1218 /*************************************************************************
1219 * @ [SHLWAPI.5]
1220 *
1221 * Search a range of paths for a specific type of executable.
1222 *
1223 * PARAMS
1224 * lpszFile [I/O] File to search for
1225 * lppszOtherDirs [I] Other directories to look in
1226 * dwWhich [I] Type of executable to search for
1227 *
1228 * RETURNS
1229 * Success: TRUE. The path to the executable is stored in lpszFile.
1230 * Failure: FALSE. The path to the executable is unchanged.
1231 */
1232 BOOL WINAPI PathFindOnPathExA(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich)
1233 {
1234 WCHAR szFile[MAX_PATH];
1235 WCHAR buff[MAX_PATH];
1236
1237 TRACE("(%s,%p,%08lx)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
1238
1239 if (!lpszFile || !PathIsFileSpecA(lpszFile))
1240 return FALSE;
1241
1242 MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
1243
1244 /* Search provided directories first */
1245 if (lppszOtherDirs && *lppszOtherDirs)
1246 {
1247 WCHAR szOther[MAX_PATH];
1248 LPCSTR *lpszOtherPath = lppszOtherDirs;
1249
1250 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1251 {
1252 MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
1253 PathCombineW(buff, szOther, szFile);
1254 if (PathFileExistsDefExtW(buff, dwWhich))
1255 {
1256 WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
1257 return TRUE;
1258 }
1259 lpszOtherPath++;
1260 }
1261 }
1262 /* Not found, try system and path dirs */
1263 if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
1264 {
1265 WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
1266 return TRUE;
1267 }
1268 return FALSE;
1269 }
1270
1271 /*************************************************************************
1272 * @ [SHLWAPI.6]
1273 *
1274 * Unicode version of PathFindOnPathExA.
1275 */
1276 BOOL WINAPI PathFindOnPathExW(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich)
1277 {
1278 WCHAR buff[MAX_PATH];
1279
1280 TRACE("(%s,%p,%08lx)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
1281
1282 if (!lpszFile || !PathIsFileSpecW(lpszFile))
1283 return FALSE;
1284
1285 /* Search provided directories first */
1286 if (lppszOtherDirs && *lppszOtherDirs)
1287 {
1288 LPCWSTR *lpszOtherPath = lppszOtherDirs;
1289 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1290 {
1291 PathCombineW(buff, *lpszOtherPath, lpszFile);
1292 if (PathFileExistsDefExtW(buff, dwWhich))
1293 {
1294 strcpyW(lpszFile, buff);
1295 return TRUE;
1296 }
1297 lpszOtherPath++;
1298 }
1299 }
1300 /* Not found, try system and path dirs */
1301 return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
1302 }
1303
1304 /*************************************************************************
1305 * PathFindOnPathA [SHLWAPI.@]
1306 *
1307 * Search a range of paths for an executable.
1308 *
1309 * PARAMS
1310 * lpszFile [I/O] File to search for
1311 * lppszOtherDirs [I] Other directories to look in
1312 *
1313 * RETURNS
1314 * Success: TRUE. The path to the executable is stored in lpszFile.
1315 * Failure: FALSE. The path to the executable is unchanged.
1316 */
1317 BOOL WINAPI PathFindOnPathA(LPSTR lpszFile, LPCSTR *lppszOtherDirs)
1318 {
1319 TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
1320 return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
1321 }
1322
1323 /*************************************************************************
1324 * PathFindOnPathW [SHLWAPI.@]
1325 *
1326 * See PathFindOnPathA.
1327 */
1328 BOOL WINAPI PathFindOnPathW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
1329 {
1330 TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
1331 return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
1332 }
1333
1334 /*************************************************************************
1335 * PathCompactPathExA [SHLWAPI.@]
1336 *
1337 * Compact a path into a given number of characters.
1338 *
1339 * PARAMS
1340 * lpszDest [O] Destination for compacted path
1341 * lpszPath [I] Source path
1342 * cchMax [I] Maximum size of compacted path
1343 * dwFlags [I] Reserved
1344 *
1345 * RETURNS
1346 * Success: TRUE. The compacted path is written to lpszDest.
1347 * Failure: FALSE. lpszPath is undefined.
1348 *
1349 * NOTES
1350 * If cchMax is given as 0, lpszDest will still be NUL terminated.
1351 *
1352 * The Win32 version of this function contains a bug: When cchMax == 7,
1353 * 8 bytes will be written to lpszDest. This bug is fixed in the Wine
1354 * implementation.
1355 *
1356 * Some relative paths will be different when cchMax == 5 or 6. This occurs
1357 * because Win32 will insert a "\" in lpszDest, even if one is
1358 * not present in the original path.
1359 */
1360 BOOL WINAPI PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
1361 UINT cchMax, DWORD dwFlags)
1362 {
1363 BOOL bRet = FALSE;
1364
1365 TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
1366
1367 if (lpszPath && lpszDest)
1368 {
1369 WCHAR szPath[MAX_PATH];
1370 WCHAR szDest[MAX_PATH];
1371
1372 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1373 szDest[0] = '\0';
1374 bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
1375 WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
1376 }
1377 return bRet;
1378 }
1379
1380 /*************************************************************************
1381 * PathCompactPathExW [SHLWAPI.@]
1382 *
1383 * See PathCompactPathExA.
1384 */
1385 BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
1386 UINT cchMax, DWORD dwFlags)
1387 {
1388 static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
1389 LPCWSTR lpszFile;
1390 DWORD dwLen, dwFileLen = 0;
1391
1392 TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
1393
1394 if (!lpszPath)
1395 return FALSE;
1396
1397 if (!lpszDest)
1398 {
1399 WARN("Invalid lpszDest would crash under Win32!\n");
1400 return FALSE;
1401 }
1402
1403 *lpszDest = '\0';
1404
1405 if (cchMax < 2)
1406 return TRUE;
1407
1408 dwLen = strlenW(lpszPath) + 1;
1409
1410 if (dwLen < cchMax)
1411 {
1412 /* Don't need to compact */
1413 memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1414 return TRUE;
1415 }
1416
1417 /* Path must be compacted to fit into lpszDest */
1418 lpszFile = PathFindFileNameW(lpszPath);
1419 dwFileLen = lpszPath + dwLen - lpszFile;
1420
1421 if (dwFileLen == dwLen)
1422 {
1423 /* No root in psth */
1424 if (cchMax <= 4)
1425 {
1426 while (--cchMax > 0) /* No room left for anything but ellipses */
1427 *lpszDest++ = '.';
1428 *lpszDest = '\0';
1429 return TRUE;
1430 }
1431 /* Compact the file name with ellipses at the end */
1432 cchMax -= 4;
1433 memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1434 strcpyW(lpszDest + cchMax, szEllipses);
1435 return TRUE;
1436 }
1437 /* We have a root in the path */
1438 lpszFile--; /* Start compacted filename with the path separator */
1439 dwFileLen++;
1440
1441 if (dwFileLen + 3 > cchMax)
1442 {
1443 /* Compact the file name */
1444 if (cchMax <= 4)
1445 {
1446 while (--cchMax > 0) /* No room left for anything but ellipses */
1447 *lpszDest++ = '.';
1448 *lpszDest = '\0';
1449 return TRUE;
1450 }
1451 strcpyW(lpszDest, szEllipses);
1452 lpszDest += 3;
1453 cchMax -= 4;
1454 *lpszDest++ = *lpszFile++;
1455 if (cchMax <= 4)
1456 {
1457 while (--cchMax > 0) /* No room left for anything but ellipses */
1458 *lpszDest++ = '.';
1459 *lpszDest = '\0';
1460 return TRUE;
1461 }
1462 cchMax -= 4;
1463 memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1464 strcpyW(lpszDest + cchMax, szEllipses);
1465 return TRUE;
1466 }
1467
1468 /* Only the root needs to be Compacted */
1469 dwLen = cchMax - dwFileLen - 3;
1470 memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1471 strcpyW(lpszDest + dwLen, szEllipses);
1472 strcpyW(lpszDest + dwLen + 3, lpszFile);
1473 return TRUE;
1474 }
1475
1476 /*************************************************************************
1477 * PathIsRelativeA [SHLWAPI.@]
1478 *
1479 * Determine if a path is a relative path.
1480 *
1481 * PARAMS
1482 * lpszPath [I] Path to check
1483 *
1484 * RETURNS
1485 * TRUE: The path is relative, or is invalid.
1486 * FALSE: The path is not relative.
1487 */
1488 BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
1489 {
1490 TRACE("(%s)\n",debugstr_a(lpszPath));
1491
1492 if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
1493 return TRUE;
1494 if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1495 return FALSE;
1496 return TRUE;
1497 }
1498
1499 /*************************************************************************
1500 * PathIsRelativeW [SHLWAPI.@]
1501 *
1502 * See PathIsRelativeA.
1503 */
1504 BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
1505 {
1506 TRACE("(%s)\n",debugstr_w(lpszPath));
1507
1508 if (!lpszPath || !*lpszPath)
1509 return TRUE;
1510 if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1511 return FALSE;
1512 return TRUE;
1513 }
1514
1515 /*************************************************************************
1516 * PathIsRootA [SHLWAPI.@]
1517 *
1518 * Determine if a path is a root path.
1519 *
1520 * PARAMS
1521 * lpszPath [I] Path to check
1522 *
1523 * RETURNS
1524 * TRUE If lpszPath is valid and a root path,
1525 * FALSE Otherwise
1526 */
1527 BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
1528 {
1529 TRACE("(%s)\n", debugstr_a(lpszPath));
1530
1531 if (lpszPath && *lpszPath)
1532 {
1533 if (*lpszPath == '\\')
1534 {
1535 if (!lpszPath[1])
1536 return TRUE; /* \ */
1537 else if (lpszPath[1]=='\\')
1538 {
1539 BOOL bSeenSlash = FALSE;
1540 lpszPath += 2;
1541
1542 /* Check for UNC root path */
1543 while (*lpszPath)
1544 {
1545 if (*lpszPath == '\\')
1546 {
1547 if (bSeenSlash)
1548 return FALSE;
1549 bSeenSlash = TRUE;
1550 }
1551 lpszPath = CharNextA(lpszPath);
1552 }
1553 return TRUE;
1554 }
1555 }
1556 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1557 return TRUE; /* X:\ */
1558 }
1559 return FALSE;
1560 }
1561
1562 /*************************************************************************
1563 * PathIsRootW [SHLWAPI.@]
1564 *
1565 * See PathIsRootA.
1566 */
1567 BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
1568 {
1569 TRACE("(%s)\n", debugstr_w(lpszPath));
1570
1571 if (lpszPath && *lpszPath)
1572 {
1573 if (*lpszPath == '\\')
1574 {
1575 if (!lpszPath[1])
1576 return TRUE; /* \ */
1577 else if (lpszPath[1]=='\\')
1578 {
1579 BOOL bSeenSlash = FALSE;
1580 lpszPath += 2;
1581
1582 /* Check for UNC root path */
1583 while (*lpszPath)
1584 {
1585 if (*lpszPath == '\\')
1586 {
1587 if (bSeenSlash)
1588 return FALSE;
1589 bSeenSlash = TRUE;
1590 }
1591 lpszPath = CharNextW(lpszPath);
1592 }
1593 return TRUE;
1594 }
1595 }
1596 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1597 return TRUE; /* X:\ */
1598 }
1599 return FALSE;
1600 }
1601
1602 /*************************************************************************
1603 * PathIsDirectoryA [SHLWAPI.@]
1604 *
1605 * Determine if a path is a valid directory
1606 *
1607 * PARAMS
1608 * lpszPath [I] Path to check.
1609 *
1610 * RETURNS
1611 * FILE_ATTRIBUTE_DIRECTORY if lpszPath exists and can be read (See Notes)
1612 * FALSE if lpszPath is invalid or not a directory.
1613 *
1614 * NOTES
1615 * Although this function is prototyped as returning a BOOL, it returns
1616 * FILE_ATTRIBUTE_DIRECTORY for success. This means that code such as:
1617 *
1618 *| if (PathIsDirectoryA("c:\\windows\\") == TRUE)
1619 *| ...
1620 *
1621 * will always fail.
1622 */
1623 BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
1624 {
1625 DWORD dwAttr;
1626
1627 TRACE("(%s)\n", debugstr_a(lpszPath));
1628
1629 if (!lpszPath || PathIsUNCServerA(lpszPath))
1630 return FALSE;
1631
1632 if (PathIsUNCServerShareA(lpszPath))
1633 {
1634 FIXME("UNC Server Share not yet supported - FAILING\n");
1635 return FALSE;
1636 }
1637
1638 if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1639 return FALSE;
1640 return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1641 }
1642
1643 /*************************************************************************
1644 * PathIsDirectoryW [SHLWAPI.@]
1645 *
1646 * See PathIsDirectoryA.
1647 */
1648 BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
1649 {
1650 DWORD dwAttr;
1651
1652 TRACE("(%s)\n", debugstr_w(lpszPath));
1653
1654 if (!lpszPath || PathIsUNCServerW(lpszPath))
1655 return FALSE;
1656
1657 if (PathIsUNCServerShareW(lpszPath))
1658 {
1659 FIXME("UNC Server Share not yet supported - FAILING\n");
1660 return FALSE;
1661 }
1662
1663 if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1664 return FALSE;
1665 return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1666 }
1667
1668 /*************************************************************************
1669 * PathFileExistsA [SHLWAPI.@]
1670 *
1671 * Determine if a file exists.
1672 *
1673 * PARAMS
1674 * lpszPath [I] Path to check
1675 *
1676 * RETURNS
1677 * TRUE If the file exists and is readable
1678 * FALSE Otherwise
1679 */
1680 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
1681 {
1682 UINT iPrevErrMode;
1683 DWORD dwAttr;
1684
1685 TRACE("(%s)\n",debugstr_a(lpszPath));
1686
1687 if (!lpszPath)
1688 return FALSE;
1689
1690 iPrevErrMode = SetErrorMode(1);
1691 dwAttr = GetFileAttributesA(lpszPath);
1692 SetErrorMode(iPrevErrMode);
1693 return dwAttr == INVALID_FILE_ATTRIBUTES ? FALSE : TRUE;
1694 }
1695
1696 /*************************************************************************
1697 * PathFileExistsW [SHLWAPI.@]
1698 *
1699 * See PathFileExistsA.
1700 */
1701 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
1702 {
1703 UINT iPrevErrMode;
1704 DWORD dwAttr;
1705
1706 TRACE("(%s)\n",debugstr_w(lpszPath));
1707
1708 if (!lpszPath)
1709 return FALSE;
1710
1711 iPrevErrMode = SetErrorMode(1);
1712 dwAttr = GetFileAttributesW(lpszPath);
1713 SetErrorMode(iPrevErrMode);
1714 return dwAttr == INVALID_FILE_ATTRIBUTES ? FALSE : TRUE;
1715 }
1716
1717 /*************************************************************************
1718 * PathFileExistsAndAttributesA [SHLWAPI.445]
1719 *
1720 * Determine if a file exists.
1721 *
1722 * PARAMS
1723 * lpszPath [I] Path to check
1724 * dwAttr [O] attributes of file
1725 *
1726 * RETURNS
1727 * TRUE If the file exists and is readable
1728 * FALSE Otherwise
1729 */
1730 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath, DWORD *dwAttr)
1731 {
1732 UINT iPrevErrMode;
1733 DWORD dwVal = 0;
1734
1735 TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
1736
1737 if (dwAttr)
1738 *dwAttr = INVALID_FILE_ATTRIBUTES;
1739
1740 if (!lpszPath)
1741 return FALSE;
1742
1743 iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1744 dwVal = GetFileAttributesA(lpszPath);
1745 SetErrorMode(iPrevErrMode);
1746 if (dwAttr)
1747 *dwAttr = dwVal;
1748 return (dwVal != INVALID_FILE_ATTRIBUTES);
1749 }
1750
1751 /*************************************************************************
1752 * PathFileExistsAndAttributesW [SHLWAPI.446]
1753 *
1754 * See PathFileExistsA.
1755 */
1756 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath, DWORD *dwAttr)
1757 {
1758 UINT iPrevErrMode;
1759 DWORD dwVal;
1760
1761 TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
1762
1763 if (!lpszPath)
1764 return FALSE;
1765
1766 iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1767 dwVal = GetFileAttributesW(lpszPath);
1768 SetErrorMode(iPrevErrMode);
1769 if (dwAttr)
1770 *dwAttr = dwVal;
1771 return (dwVal != INVALID_FILE_ATTRIBUTES);
1772 }
1773
1774 /*************************************************************************
1775 * PathMatchSingleMaskA [internal]
1776 */
1777 static BOOL WINAPI PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
1778 {
1779 while (*name && *mask && *mask!=';')
1780 {
1781 if (*mask == '*')
1782 {
1783 do
1784 {
1785 if (PathMatchSingleMaskA(name,mask+1))
1786 return TRUE; /* try substrings */
1787 } while (*name++);
1788 return FALSE;
1789 }
1790
1791 if (toupper(*mask) != toupper(*name) && *mask != '?')
1792 return FALSE;
1793
1794 name = CharNextA(name);
1795 mask = CharNextA(mask);
1796 }
1797
1798 if (!*name)
1799 {
1800 while (*mask == '*')
1801 mask++;
1802 if (!*mask || *mask == ';')
1803 return TRUE;
1804 }
1805 return FALSE;
1806 }
1807
1808 /*************************************************************************
1809 * PathMatchSingleMaskW [internal]
1810 */
1811 static BOOL WINAPI PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
1812 {
1813 while (*name && *mask && *mask != ';')
1814 {
1815 if (*mask == '*')
1816 {
1817 do
1818 {
1819 if (PathMatchSingleMaskW(name,mask+1))
1820 return TRUE; /* try substrings */
1821 } while (*name++);
1822 return FALSE;
1823 }
1824
1825 if (toupperW(*mask) != toupperW(*name) && *mask != '?')
1826 return FALSE;
1827
1828 name = CharNextW(name);
1829 mask = CharNextW(mask);
1830 }
1831 if (!*name)
1832 {
1833 while (*mask == '*')
1834 mask++;
1835 if (!*mask || *mask == ';')
1836 return TRUE;
1837 }
1838 return FALSE;
1839 }
1840
1841 /*************************************************************************
1842 * PathMatchSpecA [SHLWAPI.@]
1843 *
1844 * Determine if a path matches one or more search masks.
1845 *
1846 * PARAMS
1847 * lpszPath [I] Path to check
1848 * lpszMask [I] Search mask(s)
1849 *
1850 * RETURNS
1851 * TRUE If lpszPath is valid and is matched
1852 * FALSE Otherwise
1853 *
1854 * NOTES
1855 * Multiple search masks may be given if they are separated by ";". The
1856 * pattern "*.*" is treated specially in that it matches all paths (for
1857 * backwards compatibility with DOS).
1858 */
1859 BOOL WINAPI PathMatchSpecA(LPCSTR lpszPath, LPCSTR lpszMask)
1860 {
1861 TRACE("(%s,%s)\n", lpszPath, lpszMask);
1862
1863 if (!lstrcmpA(lpszMask, "*.*"))
1864 return TRUE; /* Matches every path */
1865
1866 while (*lpszMask)
1867 {
1868 if (PathMatchSingleMaskA(lpszPath, lpszMask))
1869 return TRUE; /* Matches the current mask */
1870
1871 while (*lpszMask && *lpszMask != ';')
1872 lpszMask = CharNextA(lpszMask);
1873
1874 if (*lpszMask == ';')
1875 {
1876 lpszMask++;
1877 while (*lpszMask == ' ')
1878 lpszMask++; /* masks may be separated by "; " */
1879 }
1880 }
1881 return FALSE;
1882 }
1883
1884 /*************************************************************************
1885 * PathMatchSpecW [SHLWAPI.@]
1886 *
1887 * See PathMatchSpecA.
1888 */
1889 BOOL WINAPI PathMatchSpecW(LPCWSTR lpszPath, LPCWSTR lpszMask)
1890 {
1891 static const WCHAR szStarDotStar[] = { '*', '.', '*', '\0' };
1892
1893 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszMask));
1894
1895 if (!lstrcmpW(lpszMask, szStarDotStar))
1896 return TRUE; /* Matches every path */
1897
1898 while (*lpszMask)
1899 {
1900 if (PathMatchSingleMaskW(lpszPath, lpszMask))
1901 return TRUE; /* Matches the current path */
1902
1903 while (*lpszMask && *lpszMask != ';')
1904 lpszMask++;
1905
1906 if (*lpszMask == ';')
1907 {
1908 lpszMask++;
1909 while (*lpszMask == ' ')
1910 lpszMask++; /* Masks may be separated by "; " */
1911 }
1912 }
1913 return FALSE;
1914 }
1915
1916 /*************************************************************************
1917 * PathIsSameRootA [SHLWAPI.@]
1918 *
1919 * Determine if two paths share the same root.
1920 *
1921 * PARAMS
1922 * lpszPath1 [I] Source path
1923 * lpszPath2 [I] Path to compare with
1924 *
1925 * RETURNS
1926 * TRUE If both paths are valid and share the same root.
1927 * FALSE If either path is invalid or the paths do not share the same root.
1928 */
1929 BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
1930 {
1931 LPCSTR lpszStart;
1932 int dwLen;
1933
1934 TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
1935
1936 if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
1937 return FALSE;
1938
1939 dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
1940 if (lpszStart - lpszPath1 > dwLen)
1941 return FALSE; /* Paths not common up to length of the root */
1942 return TRUE;
1943 }
1944
1945 /*************************************************************************
1946 * PathIsSameRootW [SHLWAPI.@]
1947 *
1948 * See PathIsSameRootA.
1949 */
1950 BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
1951 {
1952 LPCWSTR lpszStart;
1953 int dwLen;
1954
1955 TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
1956
1957 if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
1958 return FALSE;
1959
1960 dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
1961 if (lpszStart - lpszPath1 > dwLen)
1962 return FALSE; /* Paths not common up to length of the root */
1963 return TRUE;
1964 }
1965
1966 /*************************************************************************
1967 * PathIsContentTypeA [SHLWAPI.@]
1968 *
1969 * Determine if a file is of a given registered content type.
1970 *
1971 * PARAMS
1972 * lpszPath [I] File to check
1973 * lpszContentType [I] Content type to check for
1974 *
1975 * RETURNS
1976 * TRUE If lpszPath is a given registered content type,
1977 * FALSE Otherwise.
1978 *
1979 * NOTES
1980 * This function looks up the registered content type for lpszPath. If
1981 * a content type is registered, it is compared (case insensitively) to
1982 * lpszContentType. Only if this matches does the function succeed.
1983 */
1984 BOOL WINAPI PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
1985 {
1986 LPCSTR szExt;
1987 DWORD dwDummy;
1988 char szBuff[MAX_PATH];
1989
1990 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
1991
1992 if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
1993 !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
1994 REG_NONE, szBuff, &dwDummy) &&
1995 !strcasecmp(lpszContentType, szBuff))
1996 {
1997 return TRUE;
1998 }
1999 return FALSE;
2000 }
2001
2002 /*************************************************************************
2003 * PathIsContentTypeW [SHLWAPI.@]
2004 *
2005 * See PathIsContentTypeA.
2006 */
2007 BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
2008 {
2009 static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
2010 LPCWSTR szExt;
2011 DWORD dwDummy;
2012 WCHAR szBuff[MAX_PATH];
2013
2014 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
2015
2016 if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
2017 !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
2018 REG_NONE, szBuff, &dwDummy) &&
2019 !strcmpiW(lpszContentType, szBuff))
2020 {
2021 return TRUE;
2022 }
2023 return FALSE;
2024 }
2025
2026 /*************************************************************************
2027 * PathIsFileSpecA [SHLWAPI.@]
2028 *
2029 * Determine if a path is a file specification.
2030 *
2031 * PARAMS
2032 * lpszPath [I] Path to chack
2033 *
2034 * RETURNS
2035 * TRUE If lpszPath is a file specification (i.e. Contains no directories).
2036 * FALSE Otherwise.
2037 */
2038 BOOL WINAPI PathIsFileSpecA(LPCSTR lpszPath)
2039 {
2040 TRACE("(%s)\n", debugstr_a(lpszPath));
2041
2042 if (!lpszPath)
2043 return FALSE;
2044
2045 while (*lpszPath)
2046 {
2047 if (*lpszPath == '\\' || *lpszPath == ':')
2048 return FALSE;
2049 lpszPath = CharNextA(lpszPath);
2050 }
2051 return TRUE;
2052 }
2053
2054 /*************************************************************************
2055 * PathIsFileSpecW [SHLWAPI.@]
2056 *
2057 * See PathIsFileSpecA.
2058 */
2059 BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
2060 {
2061 TRACE("(%s)\n", debugstr_w(lpszPath));
2062
2063 if (!lpszPath)
2064 return FALSE;
2065
2066 while (*lpszPath)
2067 {
2068 if (*lpszPath == '\\' || *lpszPath == ':')
2069 return FALSE;
2070 lpszPath = CharNextW(lpszPath);
2071 }
2072 return TRUE;
2073 }
2074
2075 /*************************************************************************
2076 * PathIsPrefixA [SHLWAPI.@]
2077 *
2078 * Determine if a path is a prefix of another.
2079 *
2080 * PARAMS
2081 * lpszPrefix [I] Prefix
2082 * lpszPath [I] Path to check
2083 *
2084 * RETURNS
2085 * TRUE If lpszPath has lpszPrefix as its prefix,
2086 * FALSE If either path is NULL or lpszPrefix is not a prefix
2087 */
2088 BOOL WINAPI PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
2089 {
2090 TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
2091
2092 if (lpszPrefix && lpszPath &&
2093 PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == (int)strlen(lpszPrefix))
2094 return TRUE;
2095 return FALSE;
2096 }
2097
2098 /*************************************************************************
2099 * PathIsPrefixW [SHLWAPI.@]
2100 *
2101 * See PathIsPrefixA.
2102 */
2103 BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
2104 {
2105 TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
2106
2107 if (lpszPrefix && lpszPath &&
2108 PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == (int)strlenW(lpszPrefix))
2109 return TRUE;
2110 return FALSE;
2111 }
2112
2113 /*************************************************************************
2114 * PathIsSystemFolderA [SHLWAPI.@]
2115 *
2116 * Determine if a path or file attributes are a system folder.
2117 *
2118 * PARAMS
2119 * lpszPath [I] Path to check.
2120 * dwAttrib [I] Attributes to check, if lpszPath is NULL.
2121 *
2122 * RETURNS
2123 * TRUE If lpszPath or dwAttrib are a system folder.
2124 * FALSE If GetFileAttributesA() fails or neither parameter is a system folder.
2125 */
2126 BOOL WINAPI PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
2127 {
2128 TRACE("(%s,0x%08lx)\n", debugstr_a(lpszPath), dwAttrib);
2129
2130 if (lpszPath && *lpszPath)
2131 dwAttrib = GetFileAttributesA(lpszPath);
2132
2133 if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2134 !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2135 return FALSE;
2136 return TRUE;
2137 }
2138
2139 /*************************************************************************
2140 * PathIsSystemFolderW [SHLWAPI.@]
2141 *
2142 * See PathIsSystemFolderA.
2143 */
2144 BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
2145 {
2146 TRACE("(%s,0x%08lx)\n", debugstr_w(lpszPath), dwAttrib);
2147
2148 if (lpszPath && *lpszPath)
2149 dwAttrib = GetFileAttributesW(lpszPath);
2150
2151 if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2152 !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2153 return FALSE;
2154 return TRUE;
2155 }
2156
2157 /*************************************************************************
2158 * PathIsUNCA [SHLWAPI.@]
2159 *
2160 * Determine if a path is in UNC format.
2161 *
2162 * PARAMS
2163 * lpszPath [I] Path to check
2164 *
2165 * RETURNS
2166 * TRUE: The path is UNC.
2167 * FALSE: The path is not UNC or is NULL.
2168 */
2169 BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
2170 {
2171 TRACE("(%s)\n",debugstr_a(lpszPath));
2172
2173 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2174 return TRUE;
2175 return FALSE;
2176 }
2177
2178 /*************************************************************************
2179 * PathIsUNCW [SHLWAPI.@]
2180 *
2181 * See PathIsUNCA.
2182 */
2183 BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
2184 {
2185 TRACE("(%s)\n",debugstr_w(lpszPath));
2186
2187 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2188 return TRUE;
2189 return FALSE;
2190 }
2191
2192 /*************************************************************************
2193 * PathIsUNCServerA [SHLWAPI.@]
2194 *
2195 * Determine if a path is a UNC server name ("\\SHARENAME").
2196 *
2197 * PARAMS
2198 * lpszPath [I] Path to check.
2199 *
2200 * RETURNS
2201 * TRUE If lpszPath is a valid UNC server name.
2202 * FALSE Otherwise.
2203 *
2204 * NOTES
2205 * This routine is bug compatible with Win32: Server names with a
2206 * trailing backslash (e.g. "\\FOO\"), return FALSE incorrectly.
2207 * Fixing this bug may break other shlwapi functions!
2208 */
2209 BOOL WINAPI PathIsUNCServerA(LPCSTR lpszPath)
2210 {
2211 TRACE("(%s)\n", debugstr_a(lpszPath));
2212
2213 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2214 {
2215 while (*lpszPath)
2216 {
2217 if (*lpszPath == '\\')
2218 return FALSE;
2219 lpszPath = CharNextA(lpszPath);
2220 }
2221 return TRUE;
2222 }
2223 return FALSE;
2224 }
2225
2226 /*************************************************************************
2227 * PathIsUNCServerW [SHLWAPI.@]
2228 *
2229 * See PathIsUNCServerA.
2230 */
2231 BOOL WINAPI PathIsUNCServerW(LPCWSTR lpszPath)
2232 {
2233 TRACE("(%s)\n", debugstr_w(lpszPath));
2234
2235 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2236 {
2237 while (*lpszPath)
2238 {
2239 if (*lpszPath == '\\')
2240 return FALSE;
2241 lpszPath = CharNextW(lpszPath);
2242 }
2243 return TRUE;
2244 }
2245 return FALSE;
2246 }
2247
2248 /*************************************************************************
2249 * PathIsUNCServerShareA [SHLWAPI.@]
2250 *
2251 * Determine if a path is a UNC server share ("\\SHARENAME\SHARE").
2252 *
2253 * PARAMS
2254 * lpszPath [I] Path to check.
2255 *
2256 * RETURNS
2257 * TRUE If lpszPath is a valid UNC server share.
2258 * FALSE Otherwise.
2259 *
2260 * NOTES
2261 * This routine is bug compatible with Win32: Server shares with a
2262 * trailing backslash (e.g. "\\FOO\BAR\"), return FALSE incorrectly.
2263 * Fixing this bug may break other shlwapi functions!
2264 */
2265 BOOL WINAPI PathIsUNCServerShareA(LPCSTR lpszPath)
2266 {
2267 TRACE("(%s)\n", debugstr_a(lpszPath));
2268
2269 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2270 {
2271 BOOL bSeenSlash = FALSE;
2272 while (*lpszPath)
2273 {
2274 if (*lpszPath == '\\')
2275 {
2276 if (bSeenSlash)
2277 return FALSE;
2278 bSeenSlash = TRUE;
2279 }
2280 lpszPath = CharNextA(lpszPath);
2281 }
2282 return bSeenSlash;
2283 }
2284 return FALSE;
2285 }
2286
2287 /*************************************************************************
2288 * PathIsUNCServerShareW [SHLWAPI.@]
2289 *
2290 * See PathIsUNCServerShareA.
2291 */
2292 BOOL WINAPI PathIsUNCServerShareW(LPCWSTR lpszPath)
2293 {
2294 TRACE("(%s)\n", debugstr_w(lpszPath));
2295
2296 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2297 {
2298 BOOL bSeenSlash = FALSE;
2299 while (*lpszPath)
2300 {
2301 if (*lpszPath == '\\')
2302 {
2303 if (bSeenSlash)
2304 return FALSE;
2305 bSeenSlash = TRUE;
2306 }
2307 lpszPath = CharNextW(lpszPath);
2308 }
2309 return bSeenSlash;
2310 }
2311 return FALSE;
2312 }
2313
2314 /*************************************************************************
2315 * PathCanonicalizeA [SHLWAPI.@]
2316 *
2317 * Convert a path to its canonical form.
2318 *
2319 * PARAMS
2320 * lpszBuf [O] Output path
2321 * lpszPath [I] Path to cnonicalize
2322 *
2323 * RETURNS
2324 * Success: TRUE. lpszBuf contains the output path,
2325 * Failure: FALSE, If input path is invalid. lpszBuf is undefined
2326 */
2327 BOOL WINAPI PathCanonicalizeA(LPSTR lpszBuf, LPCSTR lpszPath)
2328 {
2329 BOOL bRet = FALSE;
2330
2331 TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
2332
2333 if (lpszBuf)
2334 *lpszBuf = '\0';
2335
2336 if (!lpszBuf || !lpszPath)
2337 SetLastError(ERROR_INVALID_PARAMETER);
2338 else
2339 {
2340 WCHAR szPath[MAX_PATH];
2341 WCHAR szBuff[MAX_PATH];
2342 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2343 bRet = PathCanonicalizeW(szBuff, szPath);
2344 WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
2345 }
2346 return bRet;
2347 }
2348
2349
2350 /*************************************************************************
2351 * PathCanonicalizeW [SHLWAPI.@]
2352 *
2353 * See PathCanonicalizeA.
2354 */
2355 BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
2356 {
2357 LPWSTR lpszDst = lpszBuf;
2358 LPCWSTR lpszSrc = lpszPath;
2359
2360 TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
2361
2362 if (lpszBuf)
2363 *lpszDst = '\0';
2364
2365 if (!lpszBuf || !lpszPath)
2366 {
2367 SetLastError(ERROR_INVALID_PARAMETER);
2368 return FALSE;
2369 }
2370
2371 if (!*lpszPath)
2372 {
2373 *lpszBuf++ = '\\';
2374 *lpszBuf = '\0';
2375 return TRUE;
2376 }
2377
2378 /* Copy path root */
2379 if (*lpszSrc == '\\')
2380 {
2381 *lpszDst++ = *lpszSrc++;
2382 }
2383 else if (*lpszSrc && lpszSrc[1] == ':')
2384 {
2385 /* X:\ */
2386 *lpszDst++ = *lpszSrc++;
2387 *lpszDst++ = *lpszSrc++;
2388 if (*lpszSrc == '\\')
2389 *lpszDst++ = *lpszSrc++;
2390 }
2391
2392 /* Canonicalize the rest of the path */
2393 while (*lpszSrc)
2394 {
2395 if (*lpszSrc == '.')
2396 {
2397 if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
2398 {
2399 lpszSrc += 2; /* Skip .\ */
2400 }
2401 else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
2402 {
2403 /* \.. backs up a directory, over the root if it has no \ following X:.
2404 * .. is ignored if it would remove a UNC server name or inital \\
2405 */
2406 if (lpszDst != lpszBuf)
2407 {
2408 *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
2409 if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
2410 (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
2411 {
2412 if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
2413 {
2414 lpszDst -= 2;
2415 while (lpszDst > lpszBuf && *lpszDst != '\\')
2416 lpszDst--;
2417 if (*lpszDst == '\\')
2418 lpszDst++; /* Reset to last '\' */
2419 else
2420 lpszDst = lpszBuf; /* Start path again from new root */
2421 }
2422 else if (lpszDst[-2] != ':' && !PathIsUNCServerShareW(lpszBuf))
2423 lpszDst -= 2;
2424 }
2425 while (lpszDst > lpszBuf && *lpszDst != '\\')
2426 lpszDst--;
2427 if (lpszDst == lpszBuf)
2428 {
2429 *lpszDst++ = '\\';
2430 lpszSrc++;
2431 }
2432 }
2433 lpszSrc += 2; /* Skip .. in src path */
2434 }
2435 else
2436 *lpszDst++ = *lpszSrc++;
2437 }
2438 else
2439 *lpszDst++ = *lpszSrc++;
2440 }
2441 /* Append \ to naked drive specs */
2442 if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
2443 *lpszDst++ = '\\';
2444 *lpszDst++ = '\0';
2445 return TRUE;
2446 }
2447
2448 /*************************************************************************
2449 * PathFindNextComponentA [SHLWAPI.@]
2450 *
2451 * Find the next component in a path.
2452 *
2453 * PARAMS
2454 * lpszPath [I] Path to find next component in
2455 *
2456 * RETURNS
2457 * Success: A pointer to the next component, or the end of the string.
2458 * Failure: NULL, If lpszPath is invalid
2459 *
2460 * NOTES
2461 * A 'component' is either a backslash character (\) or UNC marker (\\).
2462 * Because of this, relative paths (e.g "c:foo") are regarded as having
2463 * only one component.
2464 */
2465 LPSTR WINAPI PathFindNextComponentA(LPCSTR lpszPath)
2466 {
2467 LPSTR lpszSlash;
2468
2469 TRACE("(%s)\n", debugstr_a(lpszPath));
2470
2471 if(!lpszPath || !*lpszPath)
2472 return NULL;
2473
2474 if ((lpszSlash = StrChrA(lpszPath, '\\')))
2475 {
2476 if (lpszSlash[1] == '\\')
2477 lpszSlash++;
2478 return lpszSlash + 1;
2479 }
2480 return (LPSTR)lpszPath + strlen(lpszPath);
2481 }
2482
2483 /*************************************************************************
2484 * PathFindNextComponentW [SHLWAPI.@]
2485 *
2486 * See PathFindNextComponentA.
2487 */
2488 LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
2489 {
2490 LPWSTR lpszSlash;
2491
2492 TRACE("(%s)\n", debugstr_w(lpszPath));
2493
2494 if(!lpszPath || !*lpszPath)
2495 return NULL;
2496
2497 if ((lpszSlash = StrChrW(lpszPath, '\\')))
2498 {
2499 if (lpszSlash[1] == '\\')
2500 lpszSlash++;
2501 return lpszSlash + 1;
2502 }
2503 return (LPWSTR)lpszPath + strlenW(lpszPath);
2504 }
2505
2506 /*************************************************************************
2507 * PathAddExtensionA [SHLWAPI.@]
2508 *
2509 * Add a file extension to a path
2510 *
2511 * PARAMS
2512 * lpszPath [I/O] Path to add extension to
2513 * lpszExtension [I] Extension to add to lpszPath
2514 *
2515 * RETURNS
2516 * TRUE If the path was modified,
2517 * FALSE If lpszPath or lpszExtension are invalid, lpszPath has an
2518 * extension allready, or the new path length is too big.
2519 *
2520 * FIXME
2521 * What version of shlwapi.dll adds "exe" if lpszExtension is NULL? Win2k
2522 * does not do this, so the behaviour was removed.
2523 */
2524 BOOL WINAPI PathAddExtensionA(LPSTR lpszPath, LPCSTR lpszExtension)
2525 {
2526 size_t dwLen;
2527
2528 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExtension));
2529
2530 if (!lpszPath || !lpszExtension || *(PathFindExtensionA(lpszPath)))
2531 return FALSE;
2532
2533 dwLen = strlen(lpszPath);
2534
2535 if (dwLen + strlen(lpszExtension) >= MAX_PATH)
2536 return FALSE;
2537
2538 strcpy(lpszPath + dwLen, lpszExtension);
2539 return TRUE;
2540 }
2541
2542 /*************************************************************************
2543 * PathAddExtensionW [SHLWAPI.@]
2544 *
2545 * See PathAddExtensionA.
2546 */
2547 BOOL WINAPI PathAddExtensionW(LPWSTR lpszPath, LPCWSTR lpszExtension)
2548 {
2549 size_t dwLen;
2550
2551 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExtension));
2552
2553 if (!lpszPath || !lpszExtension || *(PathFindExtensionW(lpszPath)))
2554 return FALSE;
2555
2556 dwLen = strlenW(lpszPath);
2557
2558 if (dwLen + strlenW(lpszExtension) >= MAX_PATH)
2559 return FALSE;
2560
2561 strcpyW(lpszPath + dwLen, lpszExtension);
2562 return TRUE;
2563 }
2564
2565 /*************************************************************************
2566 * PathMakePrettyA [SHLWAPI.@]
2567 *
2568 * Convert an uppercase DOS filename into lowercase.
2569 *
2570 * PARAMS
2571 * lpszPath [I/O] Path to convert.
2572 *
2573 * RETURNS
2574 * TRUE If the path was an uppercase DOS path and was converted,
2575 * FALSE Otherwise.
2576 */
2577 BOOL WINAPI PathMakePrettyA(LPSTR lpszPath)
2578 {
2579 LPSTR pszIter = lpszPath;
2580
2581 TRACE("(%s)\n", debugstr_a(lpszPath));
2582
2583 if (!pszIter || !*pszIter)
2584 return FALSE;
2585
2586 while (*pszIter)
2587 {
2588 if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
2589 return FALSE; /* Not DOS path */
2590 pszIter++;
2591 }
2592 pszIter = lpszPath + 1;
2593 while (*pszIter)
2594 {
2595 *pszIter = tolower(*pszIter);
2596 pszIter++;
2597 }
2598 return TRUE;
2599 }
2600
2601 /*************************************************************************
2602 * PathMakePrettyW [SHLWAPI.@]
2603 *
2604 * See PathMakePrettyA.
2605 */
2606 BOOL WINAPI PathMakePrettyW(LPWSTR lpszPath)
2607 {
2608 LPWSTR pszIter = lpszPath;
2609
2610 TRACE("(%s)\n", debugstr_w(lpszPath));
2611
2612 if (!pszIter || !*pszIter)
2613 return FALSE;
2614
2615 while (*pszIter)
2616 {
2617 if (islowerW(*pszIter))
2618 return FALSE; /* Not DOS path */
2619 pszIter++;
2620 }
2621 pszIter = lpszPath + 1;
2622 while (*pszIter)
2623 {
2624 *pszIter = tolowerW(*pszIter);
2625 pszIter++;
2626 }
2627 return TRUE;
2628 }
2629
2630 /*************************************************************************
2631 * PathCommonPrefixA [SHLWAPI.@]
2632 *
2633 * Determine the length of the common prefix between two paths.
2634 *
2635 * PARAMS
2636 * lpszFile1 [I] First path for comparison
2637 * lpszFile2 [I] Second path for comparison
2638 * achPath [O] Destination for common prefix string
2639 *
2640 * RETURNS
2641 * The length of the common prefix. This is 0 if there is no common
2642 * prefix between the paths or if any parameters are invalid. If the prefix
2643 * is non-zero and achPath is not NULL, achPath is filled with the common
2644 * part of the prefix and NUL terminated.
2645 *
2646 * NOTES
2647 * A common prefix of 2 is always returned as 3. It is thus possible for
2648 * the length returned to be invalid (i.e. Longer than one or both of the
2649 * strings given as parameters). This Win32 behaviour has been implemented
2650 * here, and cannot be changed (fixed?) without breaking other SHLWAPI calls.
2651 * To work around this when using this function, always check that the byte
2652 * at [common_prefix_len-1] is not a NUL. If it is, deduct 1 from the prefix.
2653 */
2654 int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
2655 {
2656 size_t iLen = 0;
2657 LPCSTR lpszIter1 = lpszFile1;
2658 LPCSTR lpszIter2 = lpszFile2;
2659
2660 TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
2661
2662 if (achPath)
2663 *achPath = '\0';
2664
2665 if (!lpszFile1 || !lpszFile2)
2666 return 0;
2667
2668 /* Handle roots first */
2669 if (PathIsUNCA(lpszFile1))
2670 {
2671 if (!PathIsUNCA(lpszFile2))
2672 return 0;
2673 lpszIter1 += 2;
2674 lpszIter2 += 2;
2675 }
2676 else if (PathIsUNCA(lpszFile2))
2677 return 0; /* Know already lpszFile1 is not UNC */
2678
2679 do
2680 {
2681 /* Update len */
2682 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2683 (!*lpszIter2 || *lpszIter2 == '\\'))
2684 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2685
2686 if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
2687 break; /* Strings differ at this point */
2688
2689 lpszIter1++;
2690 lpszIter2++;
2691 } while (1);
2692
2693 if (iLen == 2)
2694 iLen++; /* Feature/Bug compatible with Win32 */
2695
2696 if (iLen && achPath)
2697 {
2698 memcpy(achPath,lpszFile1,iLen);
2699 achPath[iLen] = '\0';
2700 }
2701 return iLen;
2702 }
2703
2704 /*************************************************************************
2705 * PathCommonPrefixW [SHLWAPI.@]
2706 *
2707 * See PathCommonPrefixA.
2708 */
2709 int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
2710 {
2711 size_t iLen = 0;
2712 LPCWSTR lpszIter1 = lpszFile1;
2713 LPCWSTR lpszIter2 = lpszFile2;
2714
2715 TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
2716
2717 if (achPath)
2718 *achPath = '\0';
2719
2720 if (!lpszFile1 || !lpszFile2)
2721 return 0;
2722
2723 /* Handle roots first */
2724 if (PathIsUNCW(lpszFile1))
2725 {
2726 if (!PathIsUNCW(lpszFile2))
2727 return 0;
2728 lpszIter1 += 2;
2729 lpszIter2 += 2;
2730 }
2731 else if (PathIsUNCW(lpszFile2))
2732 return 0; /* Know already lpszFile1 is not UNC */
2733
2734 do
2735 {
2736 /* Update len */
2737 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2738 (!*lpszIter2 || *lpszIter2 == '\\'))
2739 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2740
2741 if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
2742 break; /* Strings differ at this point */
2743
2744 lpszIter1++;
2745 lpszIter2++;
2746 } while (1);
2747
2748 if (iLen == 2)
2749 iLen++; /* Feature/Bug compatible with Win32 */
2750
2751 if (iLen && achPath)
2752 {
2753 memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
2754 achPath[iLen] = '\0';
2755 }
2756 return iLen;
2757 }
2758
2759 /*************************************************************************
2760 * PathCompactPathA [SHLWAPI.@]
2761 *
2762 * Make a path fit into a given width when printed to a DC.
2763 *
2764 * PARAMS
2765 * hDc [I] Destination DC
2766 * lpszPath [I/O] Path to be printed to hDc
2767 * dx [I] Desired width
2768 *
2769 * RETURNS
2770 * TRUE If the path was modified.
2771 * FALSE Otherwise.
2772 */
2773 BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
2774 {
2775 BOOL bRet = FALSE;
2776
2777 TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
2778
2779 if (lpszPath)
2780 {
2781 WCHAR szPath[MAX_PATH];
2782 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2783 bRet = PathCompactPathW(hDC, szPath, dx);
2784 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
2785 }
2786 return bRet;
2787 }
2788
2789 /*************************************************************************
2790 * PathCompactPathW [SHLWAPI.@]
2791 *
2792 * See PathCompactPathA.
2793 */
2794 BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
2795 {
2796 static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
2797 BOOL bRet = TRUE;
2798 HDC hdc = 0;
2799 WCHAR buff[MAX_PATH];
2800 SIZE size;
2801 DWORD dwLen;
2802
2803 TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
2804
2805 if (!lpszPath)
2806 return bRet;
2807
2808 if (!hDC)
2809 hdc = hDC = GetDC(0);
2810
2811 /* Get the length of the whole path */
2812 dwLen = strlenW(lpszPath);
2813 GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
2814
2815 if ((UINT)size.cx > dx)
2816 {
2817 /* Path too big, must reduce it */
2818 LPWSTR sFile;
2819 DWORD dwEllipsesLen = 0, dwPathLen = 0;
2820
2821 sFile = PathFindFileNameW(lpszPath);
2822 if (sFile != lpszPath)
2823 sFile = CharPrevW(lpszPath, sFile);
2824
2825 /* Get the size of ellipses */
2826 GetTextExtentPointW(hDC, szEllipses, 3, &size);
2827 dwEllipsesLen = size.cx;
2828 /* Get the size of the file name */
2829 GetTextExtentPointW(hDC, sFile, strlenW(sFile), &size);
2830 dwPathLen = size.cx;
2831
2832 if (sFile != lpszPath)
2833 {
2834 LPWSTR sPath = sFile;
2835 BOOL bEllipses = FALSE;
2836
2837 /* The path includes a file name. Include as much of the path prior to
2838 * the file name as possible, allowing for the ellipses, e.g:
2839 * c:\some very long path\filename ==> c:\some v...\filename
2840 */
2841 strncpyW(buff, sFile, MAX_PATH);
2842
2843 do
2844 {
2845 DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
2846
2847 GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
2848 dwTotalLen += size.cx;
2849 if (dwTotalLen <= dx)
2850 break;
2851 sPath = CharPrevW(lpszPath, sPath);
2852 if (!bEllipses)
2853 {
2854 bEllipses = TRUE;
2855 sPath = CharPrevW(lpszPath, sPath);
2856 sPath = CharPrevW(lpszPath, sPath);
2857 }
2858 } while (sPath > lpszPath);
2859
2860 if (sPath > lpszPath)
2861 {
2862 if (bEllipses)
2863 {
2864 strcpyW(sPath, szEllipses);
2865 strcpyW(sPath+3, buff);
2866 }
2867 bRet = TRUE;
2868 goto end;
2869 }
2870 strcpyW(lpszPath, szEllipses);
2871 strcpyW(lpszPath+3, buff);
2872 bRet = FALSE;
2873 goto end;
2874 }
2875
2876 /* Trim the path by adding ellipses to the end, e.g:
2877 * A very long file name.txt ==> A very...
2878 */
2879 dwLen = strlenW(lpszPath);
2880
2881 if (dwLen > MAX_PATH - 3)
2882 dwLen = MAX_PATH - 3;
2883 strncpyW(buff, sFile, dwLen);
2884
2885 do {
2886 dwLen--;
2887 GetTextExtentPointW(hDC, buff, dwLen, &size);
2888 } while (dwLen && size.cx + dwEllipsesLen > dx);
2889
2890 if (!dwLen)
2891 {
2892 DWORD dwWritten = 0;
2893
2894 dwEllipsesLen /= 3; /* Size of a single '.' */
2895
2896 /* Write as much of the Ellipses string as possible */
2897 while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
2898 {
2899 *lpszPath++ = '.';
2900 dwWritten += dwEllipsesLen;
2901 dwLen++;
2902 }
2903 *lpszPath = '\0';
2904 bRet = FALSE;
2905 }
2906 else
2907 {
2908 strcpyW(buff + dwLen, szEllipses);
2909 strcpyW(lpszPath, buff);
2910 }
2911 }
2912
2913 end:
2914 if (hdc)
2915 ReleaseDC(0, hdc);
2916
2917 return bRet;
2918 }
2919
2920 /*************************************************************************
2921 * PathGetCharTypeA [SHLWAPI.@]
2922 *
2923 * Categorise a character from a file path.
2924 *
2925 * PARAMS
2926 * ch [I] Character to get the type of
2927 *
2928 * RETURNS
2929 * A set of GCT_ bit flags (from "shlwapi.h") indicating the character type.
2930 */
2931 UINT WINAPI PathGetCharTypeA(UCHAR ch)
2932 {
2933 return PathGetCharTypeW(ch);
2934 }
2935
2936 /*************************************************************************
2937 * PathGetCharTypeW [SHLWAPI.@]
2938 *
2939 * See PathGetCharTypeA.
2940 */
2941 UINT WINAPI PathGetCharTypeW(WCHAR ch)
2942 {
2943 UINT flags = 0;
2944
2945 TRACE("(%d)\n", ch);
2946
2947 if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
2948 ch == '"' || ch == '|' || ch == '/')
2949 flags = GCT_INVALID; /* Invalid */
2950 else if (ch == '*' || ch=='?')
2951 flags = GCT_WILD; /* Wildchars */
2952 else if ((ch == '\\') || (ch == ':'))
2953 return GCT_SEPARATOR; /* Path separators */
2954 else
2955 {
2956 if (ch < 126)
2957 {
2958 if ((ch & 0x1 && ch != ';') || !ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
2959 ch == '.' || ch == '@' || ch == '^' ||
2960 ch == '\'' || ch == 130 || ch == '`')
2961 flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
2962 }
2963 else
2964 flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
2965 flags |= GCT_LFNCHAR; /* Valid for long file names */
2966 }
2967 return flags;
2968 }
2969
2970 /*************************************************************************
2971 * SHLWAPI_UseSystemForSystemFolders
2972 *
2973 * Internal helper for PathMakeSystemFolderW.
2974 */
2975 static BOOL WINAPI SHLWAPI_UseSystemForSystemFolders()
2976 {
2977 static BOOL bCheckedReg = FALSE;
2978 static BOOL bUseSystemForSystemFolders = FALSE;
2979
2980 if (!bCheckedReg)
2981 {
2982 bCheckedReg = TRUE;
2983
2984 /* Key tells Win what file attributes to use on system folders */
2985 if (SHGetValueA(HKEY_LOCAL_MACHINE,
2986 "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
2987 "UseSystemForSystemFolders", 0, 0, 0))
2988 bUseSystemForSystemFolders = TRUE;
2989 }
2990 return bUseSystemForSystemFolders;
2991 }
2992
2993 /*************************************************************************
2994 * PathMakeSystemFolderA [SHLWAPI.@]
2995 *
2996 * Set system folder attribute for a path.
2997 *
2998 * PARAMS
2999 * lpszPath [I] The path to turn into a system folder
3000 *
3001 * RETURNS
3002 * TRUE If the path was changed to/already was a system folder
3003 * FALSE If the path is invalid or SetFileAttributesA() fails
3004 */
3005 BOOL WINAPI PathMakeSystemFolderA(LPCSTR lpszPath)
3006 {
3007 BOOL bRet = FALSE;
3008
3009 TRACE("(%s)\n", debugstr_a(lpszPath));
3010
3011 if (lpszPath && *lpszPath)
3012 {
3013 WCHAR szPath[MAX_PATH];
3014 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3015 bRet = PathMakeSystemFolderW(szPath);
3016 }
3017 return bRet;
3018 }
3019
3020 /*************************************************************************
3021 * PathMakeSystemFolderW [SHLWAPI.@]
3022 *
3023 * See PathMakeSystemFolderA.
3024 */
3025 BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
3026 {
3027 DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
3028 WCHAR buff[MAX_PATH];
3029
3030 TRACE("(%s)\n", debugstr_w(lpszPath));
3031
3032 if (!lpszPath || !*lpszPath)
3033 return FALSE;
3034
3035 /* If the directory is already a system directory, don't do anything */
3036 GetSystemDirectoryW(buff, MAX_PATH);
3037 if (!strcmpW(buff, lpszPath))
3038 return TRUE;
3039
3040 GetWindowsDirectoryW(buff, MAX_PATH);
3041 if (!strcmpW(buff, lpszPath))
3042 return TRUE;
3043
3044 /* "UseSystemForSystemFolders" Tells Win what attributes to use */
3045 if (SHLWAPI_UseSystemForSystemFolders())
3046 dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
3047
3048 if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
3049 return FALSE;
3050
3051 /* Change file attributes to system attributes */
3052 dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
3053 return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
3054 }
3055
3056 /*************************************************************************
3057 * PathRenameExtensionA [SHLWAPI.@]
3058 *
3059 * Swap the file extension in a path with another extension.
3060 *
3061 * PARAMS
3062 * lpszPath [I/O] Path to swap the extension in
3063 * lpszExt [I] The new extension
3064 *
3065 * RETURNS
3066 * TRUE if lpszPath was modified,
3067 * FALSE if lpszPath or lpszExt is NULL, or the new path is too long
3068 */
3069 BOOL WINAPI PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
3070 {
3071 LPSTR lpszExtension;
3072
3073 TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
3074
3075 lpszExtension = PathFindExtensionA(lpszPath);
3076
3077 if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
3078 return FALSE;
3079
3080 strcpy(lpszExtension, lpszExt);
3081 return TRUE;
3082 }
3083
3084 /*************************************************************************
3085 * PathRenameExtensionW [SHLWAPI.@]
3086 *
3087 * See PathRenameExtensionA.
3088 */
3089 BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
3090 {
3091 LPWSTR lpszExtension;
3092
3093 TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
3094
3095 lpszExtension = PathFindExtensionW(lpszPath);
3096
3097 if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
3098 return FALSE;
3099
3100 strcpyW(lpszExtension, lpszExt);
3101 return TRUE;
3102 }
3103
3104 /*************************************************************************
3105 * PathSearchAndQualifyA [SHLWAPI.@]
3106 *
3107 * Determine if a given path is correct and fully qualified.
3108 *
3109 * PARAMS
3110 * lpszPath [I] Path to check
3111 * lpszBuf [O] Output for correct path
3112 * cchBuf [I] Size of lpszBuf
3113 *
3114 * RETURNS
3115 * Unknown.
3116 */
3117 BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
3118 {
3119 FIXME("(%s,%p,0x%08x)-stub\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
3120 return FALSE;
3121 }
3122
3123 /*************************************************************************
3124 * PathSearchAndQualifyW [SHLWAPI.@]
3125 *
3126 * See PathSearchAndQualifyA.
3127 */
3128 BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
3129 {
3130 FIXME("(%s,%p,0x%08x)-stub\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
3131 return FALSE;
3132 }
3133
3134 /*************************************************************************
3135 * PathSkipRootA [SHLWAPI.@]
3136 *
3137 * Return the portion of a path following the drive letter or mount point.
3138 *
3139 * PARAMS
3140 * lpszPath [I] The path to skip on
3141 *
3142 * RETURNS
3143 * Success: A pointer to the next character after the root.
3144 * Failure: NULL, if lpszPath is invalid, has no root or is a multibyte string.
3145 */
3146 LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
3147 {
3148 TRACE("(%s)\n", debugstr_a(lpszPath));
3149
3150 if (!lpszPath || !*lpszPath)
3151 return NULL;
3152
3153 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3154 {
3155 /* Network share: skip share server and mount point */
3156 lpszPath += 2;
3157 if ((lpszPath = StrChrA(lpszPath, '\\')) &&
3158 (lpszPath = StrChrA(lpszPath + 1, '\\')))
3159 lpszPath++;
3160 return (LPSTR)lpszPath;
3161 }
3162
3163 if (IsDBCSLeadByte(*lpszPath))
3164 return NULL;
3165
3166 /* Check x:\ */
3167 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3168 return (LPSTR)lpszPath + 3;
3169 return NULL;
3170 }
3171
3172 /*************************************************************************
3173 * PathSkipRootW [SHLWAPI.@]
3174 *
3175 * See PathSkipRootA.
3176 */
3177 LPWSTR WINAPI PathSkipRootW(LPCWSTR lpszPath)
3178 {
3179 TRACE("(%s)\n", debugstr_w(lpszPath));
3180
3181 if (!lpszPath || !*lpszPath)
3182 return NULL;
3183
3184 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3185 {
3186 /* Network share: skip share server and mount point */
3187 lpszPath += 2;
3188 if ((lpszPath = StrChrW(lpszPath, '\\')) &&
3189 (lpszPath = StrChrW(lpszPath + 1, '\\')))
3190 lpszPath++;
3191 return (LPWSTR)lpszPath;
3192 }
3193
3194 /* Check x:\ */
3195 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3196 return (LPWSTR)lpszPath + 3;
3197 return NULL;
3198 }
3199
3200 /*************************************************************************
3201 * PathCreateFromUrlA [SHLWAPI.@]
3202 *
3203 * Create a path from a URL
3204 *
3205 * PARAMS
3206 * lpszUrl [I] URL to convert into a path
3207 * lpszPath [O] Output buffer for the resulting Path
3208 * pcchPath [I] Length of lpszPath
3209 * dwFlags [I] Flags controlling the conversion
3210 *
3211 * RETURNS
3212 * Success: S_OK. lpszPath contains the URL in path format,
3213 * Failure: An HRESULT error code such as E_INVALIDARG.
3214 */
3215 HRESULT WINAPI PathCreateFromUrlA(LPCSTR lpszUrl, LPSTR lpszPath,
3216 LPDWORD pcchPath, DWORD dwFlags)
3217 {
3218 LPSTR pszPathPart;
3219 TRACE("(%s,%p,%p,0x%08lx)\n", debugstr_a(lpszUrl), lpszPath, pcchPath, dwFlags);
3220
3221 if (!lpszUrl || !lpszPath || !pcchPath || !*pcchPath)
3222 return E_INVALIDARG;
3223
3224 pszPathPart = StrChrA(lpszUrl, ':');
3225 if ((((pszPathPart - lpszUrl) == 1) && isalpha(*lpszUrl)) ||
3226 !lstrcmpA(lpszUrl, "file:"))
3227 {
3228 return UrlUnescapeA(pszPathPart, lpszPath, pcchPath, dwFlags);
3229 }
3230 /* extracts thing prior to : in pszURL and checks against:
3231 * https
3232 * shell
3233 * local
3234 * about - if match returns E_INVALIDARG
3235 */
3236
3237 return E_INVALIDARG;
3238 }
3239
3240 /*************************************************************************
3241 * PathCreateFromUrlW [SHLWAPI.@]
3242 *
3243 * See PathCreateFromUrlA.
3244 */
3245 HRESULT WINAPI PathCreateFromUrlW(LPCWSTR lpszUrl, LPWSTR lpszPath,
3246 LPDWORD pcchPath, DWORD dwFlags)
3247 {
3248 static const WCHAR stemp[] = { 'f','i','l','e',':','/','/','/',0 };
3249 LPWSTR pwszPathPart;
3250 HRESULT hr;
3251
3252 TRACE("(%s,%p,%p,0x%08lx)\n", debugstr_w(lpszUrl), lpszPath, pcchPath, dwFlags);
3253
3254 if (!lpszUrl || !lpszPath || !pcchPath || !*pcchPath)
3255 return E_INVALIDARG;
3256
3257 /* Path of the form file:///... */
3258 if (!strncmpW(lpszUrl, stemp, 8))
3259 {
3260 lpszUrl += 8;
3261 }
3262 /* Path of the form file://... */
3263 else if (!strncmpW(lpszUrl, stemp, 7))
3264 {
3265 lpszUrl += 7;
3266 }
3267 /* Path of the form file:... */
3268 else if (!strncmpW(lpszUrl, stemp, 5))
3269 {
3270 lpszUrl += 5;
3271 }
3272
3273 /* Ensure that path is of the form c:... or c|... */
3274 if (lpszUrl[1] != ':' && lpszUrl[1] != '|' && isalphaW(*lpszUrl))
3275 return E_INVALIDARG;
3276
3277 hr = UrlUnescapeW((LPWSTR) lpszUrl, lpszPath, pcchPath, dwFlags);
3278 if (lpszPath[1] == '|')
3279 lpszPath[1] = ':';
3280
3281 for (pwszPathPart = lpszPath; *pwszPathPart; pwszPathPart++)
3282 if (*pwszPathPart == '/')
3283 *pwszPathPart = '\\';
3284
3285 TRACE("Returning %s\n",debugstr_w(lpszPath));
3286
3287 return hr;
3288 }
3289
3290 /*************************************************************************
3291 * PathRelativePathToA [SHLWAPI.@]
3292 *
3293 * Create a relative path from one path to another.
3294 *
3295 * PARAMS
3296 * lpszPath [O] Destination for relative path
3297 * lpszFrom [I] Source path
3298 * dwAttrFrom [I] File attribute of source path
3299 * lpszTo [I] Destination path
3300 * dwAttrTo [I] File attributes of destination path
3301 *
3302 * RETURNS
3303 * TRUE If a relative path can be formed. lpszPath contains the new path
3304 * FALSE If the paths are not relavtive or any parameters are invalid
3305 *
3306 * NOTES
3307 * lpszTo should be at least MAX_PATH in length.
3308 *
3309 * Calling this function with relative paths for lpszFrom or lpszTo may
3310 * give erroneous results.
3311 *
3312 * The Win32 version of this function contains a bug where the lpszTo string
3313 * may be referenced 1 byte beyond the end of the string. As a result random
3314 * garbage may be written to the output path, depending on what lies beyond
3315 * the last byte of the string. This bug occurs because of the behaviour of
3316 * PathCommonPrefix() (see notes for that function), and no workaround seems
3317 * possible with Win32.
3318 *
3319 * This bug has been fixed here, so for example the relative path from "\\"
3320 * to "\\" is correctly determined as "." in this implementation.
3321 */
3322 BOOL WINAPI PathRelativePathToA(LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
3323 LPCSTR lpszTo, DWORD dwAttrTo)
3324 {
3325 BOOL bRet = FALSE;
3326
3327 TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\n", lpszPath, debugstr_a(lpszFrom),
3328 dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
3329
3330 if(lpszPath && lpszFrom && lpszTo)
3331 {
3332 WCHAR szPath[MAX_PATH];
3333 WCHAR szFrom[MAX_PATH];
3334 WCHAR szTo[MAX_PATH];
3335 MultiByteToWideChar(CP_ACP,0,lpszFrom,-1,szFrom,MAX_PATH);
3336 MultiByteToWideChar(CP_ACP,0,lpszTo,-1,szTo,MAX_PATH);
3337 bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
3338 WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
3339 }
3340 return bRet;
3341 }
3342
3343 /*************************************************************************
3344 * PathRelativePathToW [SHLWAPI.@]
3345 *
3346 * See PathRelativePathToA.
3347 */
3348 BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
3349 LPCWSTR lpszTo, DWORD dwAttrTo)
3350 {
3351 static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
3352 static const WCHAR szPrevDir[] = { '.', '.', '\0' };
3353 WCHAR szFrom[MAX_PATH];
3354 WCHAR szTo[MAX_PATH];
3355 DWORD dwLen;
3356
3357 TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\n", lpszPath, debugstr_w(lpszFrom),
3358 dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
3359
3360 if(!lpszPath || !lpszFrom || !lpszTo)
3361 return FALSE;
3362
3363 *lpszPath = '\0';
3364 strncpyW(szFrom, lpszFrom, MAX_PATH);
3365 strncpyW(szTo, lpszTo, MAX_PATH);
3366
3367 if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3368 PathRemoveFileSpecW(szFrom);
3369 if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3370 PathRemoveFileSpecW(szTo);
3371
3372 /* Paths can only be relative if they have a common root */
3373 if(!(dwLen = PathCommonPrefixW(szFrom, szTo, 0)))
3374 return FALSE;
3375
3376 /* Strip off lpszFrom components to the root, by adding "..\" */
3377 lpszFrom = szFrom + dwLen;
3378 if (!*lpszFrom)
3379 {
3380 lpszPath[0] = '.';
3381 lpszPath[1] = '\0';
3382 }
3383 if (*lpszFrom == '\\')
3384 lpszFrom++;
3385
3386 while (*lpszFrom)
3387 {
3388 lpszFrom = PathFindNextComponentW(lpszFrom);
3389 strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
3390 }
3391
3392 /* From the root add the components of lpszTo */
3393 lpszTo += dwLen;
3394 /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
3395 * this function.
3396 */
3397 if (*lpszTo && lpszTo[-1])
3398 {
3399 if (*lpszTo != '\\')
3400 lpszTo--;
3401 dwLen = strlenW(lpszPath);
3402 if (dwLen + strlenW(lpszTo) >= MAX_PATH)
3403 {
3404 *lpszPath = '\0';
3405 return FALSE;
3406 }
3407 strcpyW(lpszPath + dwLen, lpszTo);
3408 }
3409 return TRUE;
3410 }
3411
3412 /*************************************************************************
3413 * PathUnmakeSystemFolderA [SHLWAPI.@]
3414 *
3415 * Remove the system folder attributes from a path.
3416 *
3417 * PARAMS
3418 * lpszPath [I] The path to remove attributes from
3419 *
3420 * RETURNS
3421 * Success: TRUE.
3422 * Failure: FALSE, if lpszPath is NULL, empty, not a directory, or calling
3423 * SetFileAttributesA() fails.
3424 */
3425 BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR lpszPath)
3426 {
3427 DWORD dwAttr;
3428
3429 TRACE("(%s)\n", debugstr_a(lpszPath));
3430
3431 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3432 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3433 return FALSE;
3434
3435 dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3436 return SetFileAttributesA(lpszPath, dwAttr);
3437 }
3438
3439 /*************************************************************************
3440 * PathUnmakeSystemFolderW [SHLWAPI.@]
3441 *
3442 * See PathUnmakeSystemFolderA.
3443 */
3444 BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
3445 {
3446 DWORD dwAttr;
3447
3448 TRACE("(%s)\n", debugstr_w(lpszPath));
3449
3450 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3451 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3452 return FALSE;
3453
3454 dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3455 return SetFileAttributesW(lpszPath, dwAttr);
3456 }
3457
3458
3459 /*************************************************************************
3460 * PathSetDlgItemPathA [SHLWAPI.@]
3461 *
3462 * Set the text of a dialog item to a path, shrinking the path to fit
3463 * if it is too big for the item.
3464 *
3465 * PARAMS
3466 * hDlg [I] Dialog handle
3467 * id [I] ID of item in the dialog
3468 * lpszPath [I] Path to set as the items text
3469 *
3470 * RETURNS
3471 * Nothing.
3472 *
3473 * NOTES
3474 * If lpszPath is NULL, a blank string ("") is set (i.e. The previous
3475 * window text is erased).
3476 */
3477 VOID WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR lpszPath)
3478 {
3479 WCHAR szPath[MAX_PATH];
3480
3481 TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
3482
3483 if (lpszPath)
3484 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3485 else
3486 szPath[0] = '\0';
3487 PathSetDlgItemPathW(hDlg, id, szPath);
3488 }
3489
3490 /*************************************************************************
3491 * PathSetDlgItemPathW [SHLWAPI.@]
3492 *
3493 * See PathSetDlgItemPathA.
3494 */
3495 VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
3496 {
3497 WCHAR path[MAX_PATH + 1];
3498 HWND hwItem;
3499 RECT rect;
3500 HDC hdc;
3501 HGDIOBJ hPrevObj;
3502
3503 TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
3504
3505 if (!(hwItem = GetDlgItem(hDlg, id)))
3506 return;
3507
3508 if (lpszPath)
3509 lstrcpynW(path, lpszPath, sizeof(path) / sizeof(WCHAR));
3510 else
3511 path[0] = '\0';
3512
3513 GetClientRect(hwItem, &rect);
3514 hdc = GetDC(hDlg);
3515 hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
3516
3517 if (hPrevObj)
3518 {
3519 PathCompactPathW(hdc, path, rect.right);
3520 SelectObject(hdc, hPrevObj);
3521 }
3522
3523 ReleaseDC(hDlg, hdc);
3524 SetWindowTextW(hwItem, path);
3525 }
3526
3527 /*************************************************************************
3528 * PathIsNetworkPathA [SHLWAPI.@]
3529 *
3530 * Determine if the given path is a network path.
3531 *
3532 * PARAMS
3533 * lpszPath [I] Path to check
3534 *
3535 * RETURNS
3536 * TRUE If lpszPath is a UNC share or mapped network drive, or
3537 * FALSE If lpszPath is a local drive or cannot be determined
3538 */
3539 BOOL WINAPI PathIsNetworkPathA(LPCSTR lpszPath)
3540 {
3541 int dwDriveNum;
3542
3543 TRACE("(%s)\n",debugstr_a(lpszPath));
3544
3545 if (!lpszPath)
3546 return FALSE;
3547 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3548 return TRUE;
3549 dwDriveNum = PathGetDriveNumberA(lpszPath);
3550 if (dwDriveNum == -1)
3551 return FALSE;
3552 GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3553 return pIsNetDrive(dwDriveNum);
3554 }
3555
3556 /*************************************************************************
3557 * PathIsNetworkPathW [SHLWAPI.@]
3558 *
3559 * See PathIsNetworkPathA.
3560 */
3561 BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
3562 {
3563 int dwDriveNum;
3564
3565 TRACE("(%s)\n", debugstr_w(lpszPath));
3566
3567 if (!lpszPath)
3568 return FALSE;
3569 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3570 return TRUE;
3571 dwDriveNum = PathGetDriveNumberW(lpszPath);
3572 if (dwDriveNum == -1)
3573 return FALSE;
3574 GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3575 return pIsNetDrive(dwDriveNum);
3576 }
3577
3578 /*************************************************************************
3579 * PathIsLFNFileSpecA [SHLWAPI.@]
3580 *
3581 * Determine if the given path is a long file name
3582 *
3583 * PARAMS
3584 * lpszPath [I] Path to check
3585 *
3586 * RETURNS
3587 * TRUE If path is a long file name,
3588 * FALSE If path is a valid DOS short file name
3589 */
3590 BOOL WINAPI PathIsLFNFileSpecA(LPCSTR lpszPath)
3591 {
3592 DWORD dwNameLen = 0, dwExtLen = 0;
3593
3594 TRACE("(%s)\n",debugstr_a(lpszPath));
3595
3596 if (!lpszPath)
3597 return FALSE;
3598
3599 while (*lpszPath)
3600 {
3601 if (*lpszPath == ' ')
3602 return TRUE; /* DOS names cannot have spaces */
3603 if (*lpszPath == '.')
3604 {
3605 if (dwExtLen)
3606 return TRUE; /* DOS names have only one dot */
3607 dwExtLen = 1;
3608 }
3609 else if (dwExtLen)
3610 {
3611 dwExtLen++;
3612 if (dwExtLen > 4)
3613 return TRUE; /* DOS extensions are <= 3 chars*/
3614 }
3615 else
3616 {
3617 dwNameLen++;
3618 if (dwNameLen > 8)
3619 return TRUE; /* DOS names are <= 8 chars */
3620 }
3621 lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
3622 }
3623 return FALSE; /* Valid DOS path */
3624 }
3625
3626 /*************************************************************************
3627 * PathIsLFNFileSpecW [SHLWAPI.@]
3628 *
3629 * See PathIsLFNFileSpecA.
3630 */
3631 BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR lpszPath)
3632 {
3633 DWORD dwNameLen = 0, dwExtLen = 0;
3634
3635 TRACE("(%s)\n",debugstr_w(lpszPath));
3636
3637 if (!lpszPath)
3638 return FALSE;
3639
3640 while (*lpszPath)
3641 {
3642 if (*lpszPath == ' ')
3643 return TRUE; /* DOS names cannot have spaces */
3644 if (*lpszPath == '.')
3645 {
3646 if (dwExtLen)
3647 return TRUE; /* DOS names have only one dot */
3648 dwExtLen = 1;
3649 }
3650 else if (dwExtLen)
3651 {
3652 dwExtLen++;
3653 if (dwExtLen > 4)
3654 return TRUE; /* DOS extensions are <= 3 chars*/
3655 }
3656 else
3657 {
3658 dwNameLen++;
3659 if (dwNameLen > 8)
3660 return TRUE; /* DOS names are <= 8 chars */
3661 }
3662 lpszPath++;
3663 }
3664 return FALSE; /* Valid DOS path */
3665 }
3666
3667 /*************************************************************************
3668 * PathIsDirectoryEmptyA [SHLWAPI.@]
3669 *
3670 * Determine if a given directory is empty.
3671 *
3672 * PARAMS
3673 * lpszPath [I] Directory to check
3674 *
3675 * RETURNS
3676 * TRUE If the directory exists and contains no files,
3677 * FALSE Otherwise
3678 */
3679 BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR lpszPath)
3680 {
3681 BOOL bRet = FALSE;
3682
3683 TRACE("(%s)\n",debugstr_a(lpszPath));
3684
3685 if (lpszPath)
3686 {
3687 WCHAR szPath[MAX_PATH];
3688 MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3689 bRet = PathIsDirectoryEmptyW(szPath);
3690 }
3691 return bRet;
3692 }
3693
3694 /*************************************************************************
3695 * PathIsDirectoryEmptyW [SHLWAPI.@]
3696 *
3697 * See PathIsDirectoryEmptyA.
3698 */
3699 BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR lpszPath)
3700 {
3701 static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
3702 WCHAR szSearch[MAX_PATH];
3703 DWORD dwLen;
3704 HANDLE hfind;
3705 BOOL retVal = FALSE;
3706 WIN32_FIND_DATAW find_data;
3707
3708 TRACE("(%s)\n",debugstr_w(lpszPath));
3709
3710 if (!lpszPath || !PathIsDirectoryW(lpszPath))
3711 return FALSE;
3712
3713 strncpyW(szSearch, lpszPath, MAX_PATH);
3714 PathAddBackslashW(szSearch);
3715 dwLen = strlenW(szSearch);
3716 if (dwLen > MAX_PATH - 4)
3717 return FALSE;
3718
3719 strcpyW(szSearch + dwLen, szAllFiles);
3720 hfind = FindFirstFileW(szSearch, &find_data);
3721
3722 if (hfind != INVALID_HANDLE_VALUE &&
3723 find_data.cFileName[0] == '.' &&
3724 find_data.cFileName[1] == '.')
3725 {
3726 /* The only directory entry should be the parent */
3727 if (!FindNextFileW(hfind, &find_data))
3728 retVal = TRUE;
3729 FindClose(hfind);
3730 }
3731 return retVal;
3732 }
3733
3734
3735 /*************************************************************************
3736 * PathFindSuffixArrayA [SHLWAPI.@]
3737 *
3738 * Find a suffix string in an array of suffix strings
3739 *
3740 * PARAMS
3741 * lpszSuffix [I] Suffix string to search for
3742 * lppszArray [I] Array of suffix strings to search
3743 * dwCount [I] Number of elements in lppszArray
3744 *
3745 * RETURNS
3746 * Success: The index of the position of lpszSuffix in lppszArray
3747 * Failure: 0, if any parameters are invalid or lpszSuffix is not found
3748 *
3749 * NOTES
3750 * The search is case sensitive.
3751 * The match is made against the end of the suffix string, so for example:
3752 * lpszSuffix="fooBAR" matches "BAR", but lpszSuffix="fooBARfoo" does not.
3753 */
3754 LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
3755 {
3756 size_t dwLen;
3757 int dwRet = 0;
3758
3759 TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
3760
3761 if (lpszSuffix && lppszArray && dwCount > 0)
3762 {
3763 dwLen = strlen(lpszSuffix);
3764
3765 while (dwRet < dwCount)
3766 {
3767 size_t dwCompareLen = strlen(*lppszArray);
3768 if (dwCompareLen < dwLen)
3769 {
3770 if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3771 return *lppszArray; /* Found */
3772 }
3773 dwRet++;
3774 lppszArray++;
3775 }
3776 }
3777 return NULL;
3778 }
3779
3780 /*************************************************************************
3781 * PathFindSuffixArrayW [SHLWAPI.@]
3782 *
3783 * See PathFindSuffixArrayA.
3784 */
3785 LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
3786 {
3787 size_t dwLen;
3788 int dwRet = 0;
3789
3790 TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
3791
3792 if (lpszSuffix && lppszArray && dwCount > 0)
3793 {
3794 dwLen = strlenW(lpszSuffix);
3795
3796 while (dwRet < dwCount)
3797 {
3798 size_t dwCompareLen = strlenW(*lppszArray);
3799 if (dwCompareLen < dwLen)
3800 {
3801 if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3802 return *lppszArray; /* Found */
3803 }
3804 dwRet++;
3805 lppszArray++;
3806 }
3807 }
3808 return NULL;
3809 }
3810
3811 /*************************************************************************
3812 * PathUndecorateA [SHLWAPI.@]
3813 *
3814 * Undecorate a file path
3815 *
3816 * PARAMS
3817 * lpszPath [I/O] Path to remove any decoration from
3818 *
3819 * RETURNS
3820 * Nothing
3821 *
3822 * NOTES
3823 * A decorations form is "path[n].ext" where "n" is an optional decimal number.
3824 */
3825 VOID WINAPI PathUndecorateA(LPSTR lpszPath)
3826 {
3827 TRACE("(%s)\n",debugstr_a(lpszPath));
3828
3829 if (lpszPath)
3830 {
3831 LPSTR lpszExt = PathFindExtensionA(lpszPath);
3832 if (lpszExt > lpszPath && lpszExt[-1] == ']')
3833 {
3834 LPSTR lpszSkip = lpszExt - 2;
3835 if (*lpszSkip == '[')
3836 lpszSkip++; /* [] (no number) */
3837 else
3838 while (lpszSkip > lpszPath && isdigit(lpszSkip[-1]))
3839 lpszSkip--;
3840 if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3841 {
3842 /* remove the [n] */
3843 lpszSkip--;
3844 while (*lpszExt)
3845 *lpszSkip++ = *lpszExt++;
3846 *lpszSkip = '\0';
3847 }
3848 }
3849 }
3850 }
3851
3852 /*************************************************************************
3853 * PathUndecorateW [SHLWAPI.@]
3854 *
3855 * See PathUndecorateA.
3856 */
3857 VOID WINAPI PathUndecorateW(LPWSTR lpszPath)
3858 {
3859 TRACE("(%s)\n",debugstr_w(lpszPath));
3860
3861 if (lpszPath)
3862 {
3863 LPWSTR lpszExt = PathFindExtensionW(lpszPath);
3864 if (lpszExt > lpszPath && lpszExt[-1] == ']')
3865 {
3866 LPWSTR lpszSkip = lpszExt - 2;
3867 if (*lpszSkip == '[')
3868 lpszSkip++; /* [] (no number) */
3869 else
3870 while (lpszSkip > lpszPath && isdigitW(lpszSkip[-1]))
3871 lpszSkip--;
3872 if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3873 {
3874 /* remove the [n] */
3875 lpszSkip--;
3876 while (*lpszExt)
3877 *lpszSkip++ = *lpszExt++;
3878 *lpszSkip = '\0';
3879 }
3880 }
3881 }
3882 }
3883
3884 /*************************************************************************
3885 * @ [SHLWAPI.440]
3886 *
3887 * Find localised or default web content in "%WINDOWS%\web\".
3888 *
3889 * PARAMS
3890 * lpszFile [I] File name containing content to look for
3891 * lpszPath [O] Buffer to contain the full path to the file
3892 * dwPathLen [I] Length of lpszPath
3893 *
3894 * RETURNS
3895 * Success: S_OK. lpszPath contains the full path to the content.
3896 * Failure: E_FAIL. The content does not exist or lpszPath is too short.
3897 */
3898 HRESULT WINAPI SHGetWebFolderFilePathA(LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)
3899 {
3900 WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
3901 HRESULT hRet;
3902
3903 TRACE("(%s,%p,%ld)\n", lpszFile, lpszPath, dwPathLen);
3904
3905 MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
3906 szPath[0] = '\0';
3907 hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
3908 WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
3909 return hRet;
3910 }
3911
3912 /*************************************************************************
3913 * @ [SHLWAPI.441]
3914 *
3915 * Unicode version of SHGetWebFolderFilePathA.
3916 */
3917 HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD dwPathLen)
3918 {
3919 static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'};
3920 static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'};
3921 #define szWebLen (sizeof(szWeb)/sizeof(WCHAR))
3922 #define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR))
3923 DWORD dwLen, dwFileLen;
3924 LANGID lidSystem, lidUser;
3925
3926 TRACE("(%s,%p,%ld)\n", debugstr_w(lpszFile), lpszPath, dwPathLen);
3927
3928 /* Get base directory for web content */
3929 dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
3930 if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
3931 dwLen--;
3932
3933 dwFileLen = strlenW(lpszFile);
3934
3935 if (dwLen + dwFileLen + szWebLen >= dwPathLen)
3936 return E_FAIL; /* lpszPath too short */
3937
3938 strcpyW(lpszPath+dwLen, szWeb);
3939 dwLen += szWebLen;
3940 dwPathLen = dwPathLen - dwLen; /* Remaining space */
3941
3942 lidSystem = GetSystemDefaultUILanguage();
3943 lidUser = GetUserDefaultUILanguage();
3944
3945 if (lidSystem != lidUser)
3946 {
3947 if (dwFileLen + szWebMuiLen < dwPathLen)
3948 {
3949 /* Use localised content in the users UI language if present */
3950 wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
3951 strcpyW(lpszPath + dwLen + szWebMuiLen, lpszFile);
3952 if (PathFileExistsW(lpszPath))
3953 return S_OK;
3954 }
3955 }
3956
3957 /* Fall back to OS default installed content */
3958 strcpyW(lpszPath + dwLen, lpszFile);
3959 if (PathFileExistsW(lpszPath))
3960 return S_OK;
3961 return E_FAIL;
3962 }
A free Windows-compatible Operating System