2 * Helper program to build unix menu entries
4 * Copyright 1997 Marcus Meissner
5 * Copyright 1998 Juergen Schmied
6 * Copyright 2003 Mike McCormack for CodeWeavers
7 * Copyright 2004 Dmitry Timoshkov
8 * Copyright 2005 Bill Medland
9 * Copyright 2008 Damjan Jovanovic
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 * This program is used to replicate the Windows desktop and start menu
27 * into the native desktop's copies. Desktop entries are merged directly
28 * into the native desktop. The Windows Start Menu corresponds to a Wine
29 * entry within the native "start" menu and replicates the whole tree
30 * structure of the Windows Start Menu. Currently it does not differentiate
31 * between the user's desktop/start menu and the "All Users" copies.
33 * This program will read a Windows shortcut file using the IShellLink
34 * interface, then create a KDE/GNOME menu entry for the shortcut.
36 * winemenubuilder [ -w ] <shortcut.lnk>
38 * If the -w parameter is passed, and the shortcut cannot be created,
39 * this program will wait for the parent process to finish and then try
40 * again. This covers the case when a ShortCut is created before the
41 * executable containing its icon.
44 * Handle data lnk files. There is no icon in the file; the icon is in
45 * the handler for the file type (or pointed to by the lnk file). Also it
46 * might be better to use a native handler (e.g. a native acroread for pdf
48 * Differentiate between the user's entries and the "All Users" entries.
49 * If it is possible to add the desktop files to the native system's
50 * shared location for an "All Users" entry then do so. As a suggestion the
51 * shared menu Wine base could be writable to the wine group, or a wineadm
53 * Clean up fd.o menu icons and .directory files when the menu is deleted
55 * Associate applications under HKCR\Applications to open any MIME type
56 * (by associating with application/octet-stream, or how?).
57 * Clean up fd.o MIME types when they are deleted in Windows, their icons
58 * too. Very hard - once we associate them with fd.o, we can't tell whether
59 * they are ours or not, and the extension <-> MIME type mapping isn't
61 * Wine's HKCR is broken - it doesn't merge HKCU\Software\Classes, so apps
62 * that write associations there won't associate (#17019).
66 #include "wine/port.h"
81 #define NONAMELESSUNION
94 #include "wine/unicode.h"
95 #include "wine/debug.h"
96 #include "wine/list.h"
97 #include "wine/rbtree.h"
99 WINE_DEFAULT_DEBUG_CHANNEL(menubuilder
);
101 #define in_desktop_dir(csidl) ((csidl)==CSIDL_DESKTOPDIRECTORY || \
102 (csidl)==CSIDL_COMMON_DESKTOPDIRECTORY)
103 #define in_startmenu(csidl) ((csidl)==CSIDL_STARTMENU || \
104 (csidl)==CSIDL_COMMON_STARTMENU)
106 #define IS_OPTION_TRUE(ch) \
107 ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
109 /* link file formats */
111 #include "pshpack1.h"
130 GRPICONDIRENTRY idEntries
[1];
169 #define NE_RSCTYPE_ICON 0x8003
170 #define NE_RSCTYPE_GROUP_ICON 0x800e
188 struct rb_string_entry
191 struct wine_rb_entry entry
;
194 DEFINE_GUID(CLSID_WICIcnsEncoder
, 0x312fb6f1,0xb767,0x409d,0x8a,0x6d,0x0f,0xc1,0x54,0xd4,0xf0,0x5c);
196 static char *xdg_config_dir
;
197 static char *xdg_data_dir
;
198 static char *xdg_desktop_dir
;
201 /* Utility routines */
202 static unsigned short crc16(const char* string
)
204 unsigned short crc
= 0;
207 for (i
= 0; string
[i
] != 0; i
++)
210 for (j
= 0; j
< 8; c
>>= 1, j
++)
212 xor_poly
= (c
^ crc
) & 1;
221 static char *strdupA( const char *str
)
225 if (!str
) return NULL
;
226 if ((ret
= HeapAlloc( GetProcessHeap(), 0, strlen(str
) + 1 ))) strcpy( ret
, str
);
230 static char* heap_printf(const char *format
, ...)
239 buffer
= HeapAlloc(GetProcessHeap(), 0, size
);
242 va_start(args
, format
);
243 n
= vsnprintf(buffer
, size
, format
, args
);
251 HeapFree(GetProcessHeap(), 0, buffer
);
254 if (!buffer
) return NULL
;
255 ret
= HeapReAlloc(GetProcessHeap(), 0, buffer
, strlen(buffer
) + 1 );
256 if (!ret
) ret
= buffer
;
260 static int winemenubuilder_rb_string_compare(const void *key
, const struct wine_rb_entry
*entry
)
262 const struct rb_string_entry
*t
= WINE_RB_ENTRY_VALUE(entry
, const struct rb_string_entry
, entry
);
264 return strcmp((char*)key
, t
->string
);
267 static void winemenubuilder_rb_destroy(struct wine_rb_entry
*entry
, void *context
)
269 struct rb_string_entry
*t
= WINE_RB_ENTRY_VALUE(entry
, struct rb_string_entry
, entry
);
270 HeapFree(GetProcessHeap(), 0, t
->string
);
271 HeapFree(GetProcessHeap(), 0, t
);
274 static void write_xml_text(FILE *file
, const char *text
)
277 for (i
= 0; text
[i
]; i
++)
280 fputs("&", file
);
281 else if (text
[i
] == '<')
283 else if (text
[i
] == '>')
285 else if (text
[i
] == '\'')
286 fputs("'", file
);
287 else if (text
[i
] == '"')
288 fputs(""", file
);
290 fputc(text
[i
], file
);
294 static BOOL
create_directories(char *directory
)
299 for (i
= 0; directory
[i
]; i
++)
301 if (i
> 0 && directory
[i
] == '/')
304 mkdir(directory
, 0777);
308 if (mkdir(directory
, 0777) && errno
!= EEXIST
)
314 static char* wchars_to_utf8_chars(LPCWSTR string
)
317 INT size
= WideCharToMultiByte(CP_UTF8
, 0, string
, -1, NULL
, 0, NULL
, NULL
);
318 ret
= HeapAlloc(GetProcessHeap(), 0, size
);
320 WideCharToMultiByte(CP_UTF8
, 0, string
, -1, ret
, size
, NULL
, NULL
);
324 static char* wchars_to_unix_chars(LPCWSTR string
)
327 INT size
= WideCharToMultiByte(CP_UNIXCP
, 0, string
, -1, NULL
, 0, NULL
, NULL
);
328 ret
= HeapAlloc(GetProcessHeap(), 0, size
);
330 WideCharToMultiByte(CP_UNIXCP
, 0, string
, -1, ret
, size
, NULL
, NULL
);
334 static WCHAR
* utf8_chars_to_wchars(LPCSTR string
)
337 INT size
= MultiByteToWideChar(CP_UTF8
, 0, string
, -1, NULL
, 0);
338 ret
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
340 MultiByteToWideChar(CP_UTF8
, 0, string
, -1, ret
, size
);
344 /* Icon extraction routines
346 * FIXME: should use PrivateExtractIcons and friends
347 * FIXME: should not use stdio
350 static HRESULT
convert_to_native_icon(IStream
*icoFile
, int *indices
, int numIndices
,
351 const CLSID
*outputFormat
, const char *outputFileName
, LPCWSTR commentW
)
353 WCHAR
*dosOutputFileName
= NULL
;
354 IWICImagingFactory
*factory
= NULL
;
355 IWICBitmapDecoder
*decoder
= NULL
;
356 IWICBitmapEncoder
*encoder
= NULL
;
357 IWICBitmapScaler
*scaler
= NULL
;
358 IStream
*outputFile
= NULL
;
362 dosOutputFileName
= wine_get_dos_file_name(outputFileName
);
363 if (dosOutputFileName
== NULL
)
365 WINE_ERR("error converting %s to DOS file name\n", outputFileName
);
368 hr
= CoCreateInstance(&CLSID_WICImagingFactory
, NULL
, CLSCTX_INPROC_SERVER
,
369 &IID_IWICImagingFactory
, (void**)&factory
);
372 WINE_ERR("error 0x%08X creating IWICImagingFactory\n", hr
);
375 hr
= IWICImagingFactory_CreateDecoderFromStream(factory
, icoFile
, NULL
,
376 WICDecodeMetadataCacheOnDemand
, &decoder
);
379 WINE_ERR("error 0x%08X creating IWICBitmapDecoder\n", hr
);
382 if (IsEqualCLSID(outputFormat
,&CLSID_WICIcnsEncoder
))
384 hr
= IWICImagingFactory_CreateBitmapScaler(factory
, &scaler
);
387 WINE_WARN("error 0x%08X creating IWICBitmapScaler\n", hr
);
390 hr
= CoCreateInstance(outputFormat
, NULL
, CLSCTX_INPROC_SERVER
,
391 &IID_IWICBitmapEncoder
, (void**)&encoder
);
394 WINE_ERR("error 0x%08X creating bitmap encoder\n", hr
);
397 hr
= SHCreateStreamOnFileW(dosOutputFileName
, STGM_CREATE
| STGM_WRITE
, &outputFile
);
400 WINE_ERR("error 0x%08X creating output file %s\n", hr
, wine_dbgstr_w(dosOutputFileName
));
403 hr
= IWICBitmapEncoder_Initialize(encoder
, outputFile
, WICBitmapEncoderNoCache
);
406 WINE_ERR("error 0x%08X initializing encoder\n", hr
);
410 for (i
= 0; i
< numIndices
; i
++)
412 IWICBitmapFrameDecode
*sourceFrame
= NULL
;
413 IWICBitmapSource
*sourceBitmap
= NULL
;
414 IWICBitmapFrameEncode
*dstFrame
= NULL
;
415 IPropertyBag2
*options
= NULL
;
418 hr
= IWICBitmapDecoder_GetFrame(decoder
, indices
[i
], &sourceFrame
);
421 WINE_ERR("error 0x%08X getting frame %d\n", hr
, indices
[i
]);
424 hr
= WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA
, (IWICBitmapSource
*)sourceFrame
, &sourceBitmap
);
427 WINE_ERR("error 0x%08X converting bitmap to 32bppBGRA\n", hr
);
432 IWICBitmapSource_GetSize(sourceBitmap
, &width
, &height
);
433 if (width
== 64) /* Classic Mode */
435 hr
= IWICBitmapScaler_Initialize( scaler
, sourceBitmap
, 128, 128,
436 WICBitmapInterpolationModeNearestNeighbor
);
438 WINE_ERR("error 0x%08X scaling bitmap\n", hr
);
441 IWICBitmapSource_Release(sourceBitmap
);
442 IWICBitmapScaler_QueryInterface(scaler
, &IID_IWICBitmapSource
, (LPVOID
)&sourceBitmap
);
446 hr
= IWICBitmapEncoder_CreateNewFrame(encoder
, &dstFrame
, &options
);
449 WINE_ERR("error 0x%08X creating encoder frame\n", hr
);
452 hr
= IWICBitmapFrameEncode_Initialize(dstFrame
, options
);
455 WINE_ERR("error 0x%08X initializing encoder frame\n", hr
);
458 hr
= IWICBitmapSource_GetSize(sourceBitmap
, &width
, &height
);
461 WINE_ERR("error 0x%08X getting source bitmap size\n", hr
);
464 hr
= IWICBitmapFrameEncode_SetSize(dstFrame
, width
, height
);
467 WINE_ERR("error 0x%08X setting destination bitmap size\n", hr
);
470 hr
= IWICBitmapFrameEncode_SetResolution(dstFrame
, 96, 96);
473 WINE_ERR("error 0x%08X setting destination bitmap resolution\n", hr
);
476 hr
= IWICBitmapFrameEncode_WriteSource(dstFrame
, sourceBitmap
, NULL
);
479 WINE_ERR("error 0x%08X copying bitmaps\n", hr
);
482 hr
= IWICBitmapFrameEncode_Commit(dstFrame
);
485 WINE_ERR("error 0x%08X committing frame\n", hr
);
490 IWICBitmapFrameDecode_Release(sourceFrame
);
492 IWICBitmapSource_Release(sourceBitmap
);
494 IWICBitmapFrameEncode_Release(dstFrame
);
496 IPropertyBag2_Release(options
);
499 hr
= IWICBitmapEncoder_Commit(encoder
);
502 WINE_ERR("error 0x%08X committing encoder\n", hr
);
507 HeapFree(GetProcessHeap(), 0, dosOutputFileName
);
509 IWICImagingFactory_Release(factory
);
511 IWICBitmapDecoder_Release(decoder
);
513 IWICBitmapScaler_Release(scaler
);
515 IWICBitmapEncoder_Release(encoder
);
517 IStream_Release(outputFile
);
524 NE_TYPEINFO
*iconResources
;
525 WORD alignmentShiftCount
;
528 static int populate_module16_icons(struct IconData16
*iconData16
, GRPICONDIR
*grpIconDir
, ICONDIRENTRY
*iconDirEntries
, BYTE
*icons
, SIZE_T
*iconOffset
)
531 int validEntries
= 0;
533 for (i
= 0; i
< grpIconDir
->idCount
; i
++)
535 BYTE
*iconPtr
= (BYTE
*)iconData16
->iconResources
;
536 NE_NAMEINFO
*matchingIcon
= NULL
;
537 iconPtr
+= sizeof(NE_TYPEINFO
);
538 for (j
= 0; j
< iconData16
->iconResources
->count
; j
++)
540 NE_NAMEINFO
*iconInfo
= (NE_NAMEINFO
*)iconPtr
;
541 if ((iconPtr
+ sizeof(NE_NAMEINFO
)) > (iconData16
->fileBytes
+ iconData16
->fileSize
))
543 WINE_WARN("file too small for icon NE_NAMEINFO\n");
546 if (iconInfo
->id
== (0x8000 | grpIconDir
->idEntries
[i
].nID
))
548 matchingIcon
= iconInfo
;
551 iconPtr
+= sizeof(NE_NAMEINFO
);
554 if (matchingIcon
== NULL
)
556 if (((matchingIcon
->offset
<< iconData16
->alignmentShiftCount
) + grpIconDir
->idEntries
[i
].dwBytesInRes
) > iconData16
->fileSize
)
558 WINE_WARN("file too small for icon contents\n");
562 iconDirEntries
[validEntries
].bWidth
= grpIconDir
->idEntries
[i
].bWidth
;
563 iconDirEntries
[validEntries
].bHeight
= grpIconDir
->idEntries
[i
].bHeight
;
564 iconDirEntries
[validEntries
].bColorCount
= grpIconDir
->idEntries
[i
].bColorCount
;
565 iconDirEntries
[validEntries
].bReserved
= grpIconDir
->idEntries
[i
].bReserved
;
566 iconDirEntries
[validEntries
].wPlanes
= grpIconDir
->idEntries
[i
].wPlanes
;
567 iconDirEntries
[validEntries
].wBitCount
= grpIconDir
->idEntries
[i
].wBitCount
;
568 iconDirEntries
[validEntries
].dwBytesInRes
= grpIconDir
->idEntries
[i
].dwBytesInRes
;
569 iconDirEntries
[validEntries
].dwImageOffset
= *iconOffset
;
571 memcpy(&icons
[*iconOffset
], &iconData16
->fileBytes
[matchingIcon
->offset
<< iconData16
->alignmentShiftCount
], grpIconDir
->idEntries
[i
].dwBytesInRes
);
572 *iconOffset
+= grpIconDir
->idEntries
[i
].dwBytesInRes
;
577 static int populate_module_icons(HMODULE hModule
, GRPICONDIR
*grpIconDir
, ICONDIRENTRY
*iconDirEntries
, BYTE
*icons
, SIZE_T
*iconOffset
)
580 int validEntries
= 0;
582 for (i
= 0; i
< grpIconDir
->idCount
; i
++)
585 LPCWSTR lpName
= MAKEINTRESOURCEW(grpIconDir
->idEntries
[i
].nID
);
586 if ((hResInfo
= FindResourceW(hModule
, lpName
, (LPCWSTR
)RT_ICON
)))
589 if ((hResData
= LoadResource(hModule
, hResInfo
)))
592 DWORD size
= min( grpIconDir
->idEntries
[i
].dwBytesInRes
, ((IMAGE_RESOURCE_DATA_ENTRY
*)hResInfo
)->Size
);
593 if ((pIcon
= LockResource(hResData
)))
595 iconDirEntries
[validEntries
].bWidth
= grpIconDir
->idEntries
[i
].bWidth
;
596 iconDirEntries
[validEntries
].bHeight
= grpIconDir
->idEntries
[i
].bHeight
;
597 iconDirEntries
[validEntries
].bColorCount
= grpIconDir
->idEntries
[i
].bColorCount
;
598 iconDirEntries
[validEntries
].bReserved
= grpIconDir
->idEntries
[i
].bReserved
;
599 iconDirEntries
[validEntries
].wPlanes
= grpIconDir
->idEntries
[i
].wPlanes
;
600 iconDirEntries
[validEntries
].wBitCount
= grpIconDir
->idEntries
[i
].wBitCount
;
601 iconDirEntries
[validEntries
].dwBytesInRes
= size
;
602 iconDirEntries
[validEntries
].dwImageOffset
= *iconOffset
;
604 memcpy(&icons
[*iconOffset
], pIcon
, size
);
607 FreeResource(hResData
);
614 static IStream
*add_module_icons_to_stream(struct IconData16
*iconData16
, HMODULE hModule
, GRPICONDIR
*grpIconDir
)
617 SIZE_T iconsSize
= 0;
619 ICONDIRENTRY
*iconDirEntries
= NULL
;
620 IStream
*stream
= NULL
;
625 int validEntries
= 0;
628 for (i
= 0; i
< grpIconDir
->idCount
; i
++)
629 iconsSize
+= grpIconDir
->idEntries
[i
].dwBytesInRes
;
630 icons
= HeapAlloc(GetProcessHeap(), 0, iconsSize
);
633 WINE_ERR("out of memory allocating icon\n");
637 iconDirEntries
= HeapAlloc(GetProcessHeap(), 0, grpIconDir
->idCount
*sizeof(ICONDIRENTRY
));
638 if (iconDirEntries
== NULL
)
640 WINE_ERR("out of memory allocating icon dir entries\n");
644 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
647 WINE_ERR("error creating icon stream\n");
653 validEntries
= populate_module16_icons(iconData16
, grpIconDir
, iconDirEntries
, icons
, &iconOffset
);
655 validEntries
= populate_module_icons(hModule
, grpIconDir
, iconDirEntries
, icons
, &iconOffset
);
657 if (validEntries
== 0)
659 WINE_ERR("no valid icon entries\n");
663 iconDir
.idReserved
= 0;
665 iconDir
.idCount
= validEntries
;
666 hr
= IStream_Write(stream
, &iconDir
, sizeof(iconDir
), &bytesWritten
);
667 if (FAILED(hr
) || bytesWritten
!= sizeof(iconDir
))
669 WINE_ERR("error 0x%08X writing icon stream\n", hr
);
672 for (i
= 0; i
< validEntries
; i
++)
673 iconDirEntries
[i
].dwImageOffset
+= sizeof(ICONDIR
) + validEntries
*sizeof(ICONDIRENTRY
);
674 hr
= IStream_Write(stream
, iconDirEntries
, validEntries
*sizeof(ICONDIRENTRY
), &bytesWritten
);
675 if (FAILED(hr
) || bytesWritten
!= validEntries
*sizeof(ICONDIRENTRY
))
677 WINE_ERR("error 0x%08X writing icon dir entries to stream\n", hr
);
680 hr
= IStream_Write(stream
, icons
, iconOffset
, &bytesWritten
);
681 if (FAILED(hr
) || bytesWritten
!= iconOffset
)
683 WINE_ERR("error 0x%08X writing icon images to stream\n", hr
);
687 hr
= IStream_Seek(stream
, zero
, STREAM_SEEK_SET
, NULL
);
690 HeapFree(GetProcessHeap(), 0, icons
);
691 HeapFree(GetProcessHeap(), 0, iconDirEntries
);
692 if (FAILED(hr
) && stream
!= NULL
)
694 IStream_Release(stream
);
700 static HRESULT
open_module16_icon(LPCWSTR szFileName
, int nIndex
, IStream
**ppStream
)
702 HANDLE hFile
= INVALID_HANDLE_VALUE
;
703 HANDLE hFileMapping
= NULL
;
705 BYTE
*fileBytes
= NULL
;
706 IMAGE_DOS_HEADER
*dosHeader
;
707 IMAGE_OS2_HEADER
*neHeader
;
709 NE_TYPEINFO
*iconGroupResources
;
710 NE_TYPEINFO
*iconResources
;
711 NE_NAMEINFO
*iconDirPtr
;
713 WORD alignmentShiftCount
;
714 struct IconData16 iconData16
;
717 hFile
= CreateFileW(szFileName
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
718 OPEN_EXISTING
, FILE_FLAG_RANDOM_ACCESS
, NULL
);
719 if (hFile
== INVALID_HANDLE_VALUE
)
721 WINE_WARN("opening %s failed with error %d\n", wine_dbgstr_w(szFileName
), GetLastError());
725 hFileMapping
= CreateFileMappingW(hFile
, NULL
, PAGE_READONLY
| SEC_COMMIT
, 0, 0, NULL
);
726 if (hFileMapping
== NULL
)
728 WINE_WARN("CreateFileMapping failed, error %d\n", GetLastError());
732 fileSize
= GetFileSize(hFile
, NULL
);
734 fileBytes
= MapViewOfFile(hFileMapping
, FILE_MAP_READ
, 0, 0, 0);
735 if (fileBytes
== NULL
)
737 WINE_WARN("MapViewOfFile failed, error %d\n", GetLastError());
741 dosHeader
= (IMAGE_DOS_HEADER
*)fileBytes
;
742 if (sizeof(IMAGE_DOS_HEADER
) >= fileSize
|| dosHeader
->e_magic
!= IMAGE_DOS_SIGNATURE
)
744 WINE_WARN("file too small for MZ header\n");
748 neHeader
= (IMAGE_OS2_HEADER
*)(fileBytes
+ dosHeader
->e_lfanew
);
749 if ((((BYTE
*)neHeader
) + sizeof(IMAGE_OS2_HEADER
)) > (fileBytes
+ fileSize
) ||
750 neHeader
->ne_magic
!= IMAGE_OS2_SIGNATURE
)
752 WINE_WARN("file too small for NE header\n");
756 rsrcTab
= ((BYTE
*)neHeader
) + neHeader
->ne_rsrctab
;
757 if ((rsrcTab
+ 2) > (fileBytes
+ fileSize
))
759 WINE_WARN("file too small for resource table\n");
763 alignmentShiftCount
= *(WORD
*)rsrcTab
;
765 iconGroupResources
= NULL
;
766 iconResources
= NULL
;
769 NE_TYPEINFO
*neTypeInfo
= (NE_TYPEINFO
*)rsrcTab
;
770 if ((rsrcTab
+ sizeof(NE_TYPEINFO
)) > (fileBytes
+ fileSize
))
772 WINE_WARN("file too small for resource table\n");
775 if (neTypeInfo
->type_id
== 0)
777 else if (neTypeInfo
->type_id
== NE_RSCTYPE_GROUP_ICON
)
778 iconGroupResources
= neTypeInfo
;
779 else if (neTypeInfo
->type_id
== NE_RSCTYPE_ICON
)
780 iconResources
= neTypeInfo
;
781 rsrcTab
+= sizeof(NE_TYPEINFO
) + neTypeInfo
->count
*sizeof(NE_NAMEINFO
);
783 if (iconGroupResources
== NULL
)
785 WINE_WARN("no group icon resource type found\n");
788 if (iconResources
== NULL
)
790 WINE_WARN("no icon resource type found\n");
794 if (nIndex
>= iconGroupResources
->count
)
796 WINE_WARN("icon index out of range\n");
800 iconDirPtr
= (NE_NAMEINFO
*)(((BYTE
*)iconGroupResources
) + sizeof(NE_TYPEINFO
) + nIndex
*sizeof(NE_NAMEINFO
));
801 if ((((BYTE
*)iconDirPtr
) + sizeof(NE_NAMEINFO
)) > (fileBytes
+ fileSize
))
803 WINE_WARN("file too small for icon group NE_NAMEINFO\n");
806 iconDir
= (GRPICONDIR
*)(fileBytes
+ (iconDirPtr
->offset
<< alignmentShiftCount
));
807 if ((((BYTE
*)iconDir
) + sizeof(GRPICONDIR
) + iconDir
->idCount
*sizeof(GRPICONDIRENTRY
)) > (fileBytes
+ fileSize
))
809 WINE_WARN("file too small for GRPICONDIR\n");
813 iconData16
.fileBytes
= fileBytes
;
814 iconData16
.fileSize
= fileSize
;
815 iconData16
.iconResources
= iconResources
;
816 iconData16
.alignmentShiftCount
= alignmentShiftCount
;
817 *ppStream
= add_module_icons_to_stream(&iconData16
, NULL
, iconDir
);
822 if (hFile
!= INVALID_HANDLE_VALUE
)
824 if (hFileMapping
!= NULL
)
825 CloseHandle(hFileMapping
);
826 if (fileBytes
!= NULL
)
827 UnmapViewOfFile(fileBytes
);
831 static BOOL CALLBACK
EnumResNameProc(HMODULE hModule
, LPCWSTR lpszType
, LPWSTR lpszName
, LONG_PTR lParam
)
833 ENUMRESSTRUCT
*sEnumRes
= (ENUMRESSTRUCT
*) lParam
;
835 if (!sEnumRes
->nIndex
--)
837 *sEnumRes
->pResInfo
= FindResourceW(hModule
, lpszName
, (LPCWSTR
)RT_GROUP_ICON
);
844 static HRESULT
open_module_icon(LPCWSTR szFileName
, int nIndex
, IStream
**ppStream
)
849 GRPICONDIR
*pIconDir
;
850 ENUMRESSTRUCT sEnumRes
;
853 hModule
= LoadLibraryExW(szFileName
, 0, LOAD_LIBRARY_AS_DATAFILE
);
856 if (GetLastError() == ERROR_BAD_EXE_FORMAT
)
857 return open_module16_icon(szFileName
, nIndex
, ppStream
);
860 WINE_WARN("LoadLibraryExW (%s) failed, error %d\n",
861 wine_dbgstr_w(szFileName
), GetLastError());
862 return HRESULT_FROM_WIN32(GetLastError());
868 hResInfo
= FindResourceW(hModule
, MAKEINTRESOURCEW(-nIndex
), (LPCWSTR
)RT_GROUP_ICON
);
869 WINE_TRACE("FindResourceW (%s) called, return %p, error %d\n",
870 wine_dbgstr_w(szFileName
), hResInfo
, GetLastError());
875 sEnumRes
.pResInfo
= &hResInfo
;
876 sEnumRes
.nIndex
= nIndex
;
877 if (!EnumResourceNamesW(hModule
, (LPCWSTR
)RT_GROUP_ICON
,
878 EnumResNameProc
, (LONG_PTR
)&sEnumRes
) &&
879 sEnumRes
.nIndex
!= -1)
881 WINE_TRACE("EnumResourceNamesW failed, error %d\n", GetLastError());
887 if ((hResData
= LoadResource(hModule
, hResInfo
)))
889 if ((pIconDir
= LockResource(hResData
)))
891 *ppStream
= add_module_icons_to_stream(0, hModule
, pIconDir
);
896 FreeResource(hResData
);
901 WINE_WARN("found no icon\n");
902 FreeLibrary(hModule
);
903 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
906 FreeLibrary(hModule
);
910 static HRESULT
read_ico_direntries(IStream
*icoStream
, ICONDIRENTRY
**ppIconDirEntries
, int *numEntries
)
916 *ppIconDirEntries
= NULL
;
918 hr
= IStream_Read(icoStream
, &iconDir
, sizeof(ICONDIR
), &bytesRead
);
919 if (FAILED(hr
) || bytesRead
!= sizeof(ICONDIR
) ||
920 (iconDir
.idReserved
!= 0) || (iconDir
.idType
!= 1))
922 WINE_WARN("Invalid ico file format (hr=0x%08X, bytesRead=%d)\n", hr
, bytesRead
);
926 *numEntries
= iconDir
.idCount
;
928 if ((*ppIconDirEntries
= HeapAlloc(GetProcessHeap(), 0, sizeof(ICONDIRENTRY
)*iconDir
.idCount
)) == NULL
)
933 hr
= IStream_Read(icoStream
, *ppIconDirEntries
, sizeof(ICONDIRENTRY
)*iconDir
.idCount
, &bytesRead
);
934 if (FAILED(hr
) || bytesRead
!= sizeof(ICONDIRENTRY
)*iconDir
.idCount
)
936 if (SUCCEEDED(hr
)) hr
= E_FAIL
;
942 HeapFree(GetProcessHeap(), 0, *ppIconDirEntries
);
946 static HRESULT
validate_ico(IStream
**ppStream
, ICONDIRENTRY
**ppIconDirEntries
, int *numEntries
)
950 hr
= read_ico_direntries(*ppStream
, ppIconDirEntries
, numEntries
);
955 HeapFree(GetProcessHeap(), 0, *ppIconDirEntries
);
956 *ppIconDirEntries
= NULL
;
958 IStream_Release(*ppStream
);
963 static HRESULT
write_native_icon(IStream
*iconStream
, ICONDIRENTRY
*pIconDirEntry
,
964 int numEntries
, const char *icon_name
, LPCWSTR szFileName
)
966 int nMax
= 0, nMaxBits
= 0;
969 LARGE_INTEGER position
;
972 for (i
= 0; i
< numEntries
; i
++)
974 WINE_TRACE("[%d]: %d x %d @ %d\n", i
, pIconDirEntry
[i
].bWidth
, pIconDirEntry
[i
].bHeight
, pIconDirEntry
[i
].wBitCount
);
975 if (pIconDirEntry
[i
].wBitCount
>= nMaxBits
&&
976 (pIconDirEntry
[i
].bHeight
* pIconDirEntry
[i
].bWidth
) >= nMax
)
979 nMax
= pIconDirEntry
[i
].bHeight
* pIconDirEntry
[i
].bWidth
;
980 nMaxBits
= pIconDirEntry
[i
].wBitCount
;
983 WINE_TRACE("Selected: %d\n", nIndex
);
985 position
.QuadPart
= 0;
986 hr
= IStream_Seek(iconStream
, position
, STREAM_SEEK_SET
, NULL
);
987 if (FAILED(hr
)) return hr
;
988 return convert_to_native_icon(iconStream
, &nIndex
, 1, &CLSID_WICPngEncoder
, icon_name
, szFileName
);
991 static WCHAR
* assoc_query(ASSOCSTR assocStr
, LPCWSTR name
, LPCWSTR extra
)
996 hr
= AssocQueryStringW(0, assocStr
, name
, extra
, NULL
, &size
);
999 value
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
1002 hr
= AssocQueryStringW(0, assocStr
, name
, extra
, value
, &size
);
1005 HeapFree(GetProcessHeap(), 0, value
);
1013 static HRESULT
open_file_type_icon(LPCWSTR szFileName
, IStream
**ppStream
)
1015 static const WCHAR openW
[] = {'o','p','e','n',0};
1019 WCHAR
*executable
= NULL
;
1021 HRESULT hr
= HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
1023 extension
= strrchrW(szFileName
, '.');
1024 if (extension
== NULL
)
1027 icon
= assoc_query(ASSOCSTR_DEFAULTICON
, extension
, NULL
);
1030 comma
= strrchrW(icon
, ',');
1034 index
= atoiW(comma
+ 1);
1036 hr
= open_module_icon(icon
, index
, ppStream
);
1040 executable
= assoc_query(ASSOCSTR_EXECUTABLE
, extension
, openW
);
1042 hr
= open_module_icon(executable
, 0, ppStream
);
1046 HeapFree(GetProcessHeap(), 0, icon
);
1047 HeapFree(GetProcessHeap(), 0, executable
);
1051 static HRESULT
open_default_icon(IStream
**ppStream
)
1053 static const WCHAR user32W
[] = {'u','s','e','r','3','2',0};
1055 return open_module_icon(user32W
, -(INT_PTR
)IDI_WINLOGO
, ppStream
);
1058 static HRESULT
open_icon(LPCWSTR filename
, int index
, BOOL bWait
, IStream
**ppStream
, ICONDIRENTRY
**ppIconDirEntries
, int *numEntries
)
1062 hr
= open_module_icon(filename
, index
, ppStream
);
1065 if(bWait
&& hr
== HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND
))
1067 WINE_WARN("Can't find file: %s, give a chance to parent process to create it\n",
1068 wine_dbgstr_w(filename
));
1073 /* This might be a raw .ico file */
1074 hr
= SHCreateStreamOnFileW(filename
, STGM_READ
, ppStream
);
1078 hr
= validate_ico(ppStream
, ppIconDirEntries
, numEntries
);
1082 hr
= open_file_type_icon(filename
, ppStream
);
1084 hr
= validate_ico(ppStream
, ppIconDirEntries
, numEntries
);
1086 if (FAILED(hr
) && !bWait
)
1088 hr
= open_default_icon(ppStream
);
1090 hr
= validate_ico(ppStream
, ppIconDirEntries
, numEntries
);
1095 static char* compute_native_identifier(int exeIndex
, LPCWSTR icoPathW
)
1097 char* nativeIdentifier
;
1100 char *basename
, *ext
;
1102 icoPathA
= wchars_to_utf8_chars(icoPathW
);
1103 if (icoPathA
== NULL
)
1106 crc
= crc16(icoPathA
);
1107 basename
= strrchr(icoPathA
, '\\');
1108 if (basename
== NULL
)
1109 basename
= icoPathA
;
1115 ext
= strrchr(basename
, '.');
1119 nativeIdentifier
= heap_printf("%04X_%s.%d", crc
, basename
, exeIndex
);
1120 HeapFree(GetProcessHeap(), 0, icoPathA
);
1121 return nativeIdentifier
;
1125 #define ICNS_SLOTS 6
1127 static inline int size_to_slot(int size
)
1134 case 64: return -2; /* Classic Mode */
1143 #define CLASSIC_SLOT 3
1145 static HRESULT
platform_write_icon(IStream
*icoStream
, ICONDIRENTRY
*iconDirEntries
,
1146 int numEntries
, int exeIndex
, LPCWSTR icoPathW
,
1147 const char *destFilename
, char **nativeIdentifier
)
1154 int indexes
[ICNS_SLOTS
];
1157 char *icnsPath
= NULL
;
1161 for (i
= 0; i
< ICNS_SLOTS
; i
++)
1164 best
[i
].maxBits
= 0;
1166 for (i
= 0; i
< numEntries
; i
++)
1169 int width
= iconDirEntries
[i
].bWidth
? iconDirEntries
[i
].bWidth
: 256;
1170 int height
= iconDirEntries
[i
].bHeight
? iconDirEntries
[i
].bHeight
: 256;
1171 BOOL scaled
= FALSE
;
1173 WINE_TRACE("[%d]: %d x %d @ %d\n", i
, width
, height
, iconDirEntries
[i
].wBitCount
);
1174 if (height
!= width
)
1176 slot
= size_to_slot(width
);
1180 slot
= CLASSIC_SLOT
;
1184 if (scaled
&& best
[slot
].maxBits
&& !best
[slot
].scaled
)
1185 continue; /* don't replace unscaled with scaled */
1186 if (iconDirEntries
[i
].wBitCount
>= best
[slot
].maxBits
|| (!scaled
&& best
[slot
].scaled
))
1188 best
[slot
].index
= i
;
1189 best
[slot
].maxBits
= iconDirEntries
[i
].wBitCount
;
1190 best
[slot
].scaled
= scaled
;
1193 /* remove the scaled icon if a larger unscaled icon exists */
1194 if (best
[CLASSIC_SLOT
].scaled
)
1196 for (i
= CLASSIC_SLOT
+1; i
< ICNS_SLOTS
; i
++)
1197 if (best
[i
].index
>= 0 && !best
[i
].scaled
)
1199 best
[CLASSIC_SLOT
].index
= -1;
1205 for (i
= 0; i
< ICNS_SLOTS
; i
++)
1207 if (best
[i
].index
>= 0)
1209 indexes
[numEntries
] = best
[i
].index
;
1215 *nativeIdentifier
= heap_printf("%s", destFilename
);
1217 *nativeIdentifier
= compute_native_identifier(exeIndex
, icoPathW
);
1218 if (*nativeIdentifier
== NULL
)
1223 if (!(tmpdir
= getenv("TMPDIR"))) tmpdir
= "/tmp";
1224 icnsPath
= heap_printf("%s/%s.icns", tmpdir
, *nativeIdentifier
);
1225 if (icnsPath
== NULL
)
1228 WINE_WARN("out of memory creating ICNS path\n");
1232 hr
= IStream_Seek(icoStream
, zero
, STREAM_SEEK_SET
, NULL
);
1235 WINE_WARN("seeking icon stream failed, error 0x%08X\n", hr
);
1238 hr
= convert_to_native_icon(icoStream
, indexes
, numEntries
, &CLSID_WICIcnsEncoder
,
1239 icnsPath
, icoPathW
);
1242 WINE_WARN("converting %s to %s failed, error 0x%08X\n",
1243 wine_dbgstr_w(icoPathW
), wine_dbgstr_a(icnsPath
), hr
);
1248 HeapFree(GetProcessHeap(), 0, icnsPath
);
1252 static void refresh_icon_cache(const char *iconsDir
)
1254 /* The icon theme spec only requires the mtime on the "toplevel"
1255 * directory (whatever that is) to be changed for a refresh,
1256 * but on GNOME you have to create a file in that directory
1257 * instead. Creating a file also works on KDE, Xfce and LXDE.
1259 char *filename
= heap_printf("%s/.wine-refresh-XXXXXX", iconsDir
);
1260 if (filename
!= NULL
)
1262 int fd
= mkstemps(filename
, 0);
1268 HeapFree(GetProcessHeap(), 0, filename
);
1272 static HRESULT
platform_write_icon(IStream
*icoStream
, ICONDIRENTRY
*iconDirEntries
,
1273 int numEntries
, int exeIndex
, LPCWSTR icoPathW
,
1274 const char *destFilename
, char **nativeIdentifier
)
1277 char *iconsDir
= NULL
;
1282 *nativeIdentifier
= heap_printf("%s", destFilename
);
1284 *nativeIdentifier
= compute_native_identifier(exeIndex
, icoPathW
);
1285 if (*nativeIdentifier
== NULL
)
1290 iconsDir
= heap_printf("%s/icons/hicolor", xdg_data_dir
);
1291 if (iconsDir
== NULL
)
1297 for (i
= 0; i
< numEntries
; i
++)
1301 BOOLEAN duplicate
= FALSE
;
1303 char *iconDir
= NULL
;
1304 char *pngPath
= NULL
;
1306 WINE_TRACE("[%d]: %d x %d @ %d\n", i
, iconDirEntries
[i
].bWidth
,
1307 iconDirEntries
[i
].bHeight
, iconDirEntries
[i
].wBitCount
);
1309 for (j
= 0; j
< i
; j
++)
1311 if (iconDirEntries
[j
].bWidth
== iconDirEntries
[i
].bWidth
&&
1312 iconDirEntries
[j
].bHeight
== iconDirEntries
[i
].bHeight
)
1320 for (j
= i
+ 1; j
< numEntries
; j
++)
1322 if (iconDirEntries
[j
].bWidth
== iconDirEntries
[i
].bWidth
&&
1323 iconDirEntries
[j
].bHeight
== iconDirEntries
[i
].bHeight
&&
1324 iconDirEntries
[j
].wBitCount
>= iconDirEntries
[bestIndex
].wBitCount
)
1329 WINE_TRACE("Selected: %d\n", bestIndex
);
1331 w
= iconDirEntries
[bestIndex
].bWidth
? iconDirEntries
[bestIndex
].bWidth
: 256;
1332 h
= iconDirEntries
[bestIndex
].bHeight
? iconDirEntries
[bestIndex
].bHeight
: 256;
1333 iconDir
= heap_printf("%s/%dx%d/apps", iconsDir
, w
, h
);
1334 if (iconDir
== NULL
)
1339 create_directories(iconDir
);
1340 pngPath
= heap_printf("%s/%s.png", iconDir
, *nativeIdentifier
);
1341 if (pngPath
== NULL
)
1347 hr
= IStream_Seek(icoStream
, zero
, STREAM_SEEK_SET
, NULL
);
1350 hr
= convert_to_native_icon(icoStream
, &bestIndex
, 1, &CLSID_WICPngEncoder
,
1354 HeapFree(GetProcessHeap(), 0, iconDir
);
1355 HeapFree(GetProcessHeap(), 0, pngPath
);
1357 refresh_icon_cache(iconsDir
);
1360 HeapFree(GetProcessHeap(), 0, iconsDir
);
1363 #endif /* defined(__APPLE__) */
1365 /* extract an icon from an exe or icon file; helper for IPersistFile_fnSave */
1366 static char *extract_icon(LPCWSTR icoPathW
, int index
, const char *destFilename
, BOOL bWait
)
1368 IStream
*stream
= NULL
;
1369 ICONDIRENTRY
*pIconDirEntries
= NULL
;
1372 char *nativeIdentifier
= NULL
;
1374 WINE_TRACE("path=[%s] index=%d destFilename=[%s]\n", wine_dbgstr_w(icoPathW
), index
, wine_dbgstr_a(destFilename
));
1376 hr
= open_icon(icoPathW
, index
, bWait
, &stream
, &pIconDirEntries
, &numEntries
);
1379 WINE_WARN("opening icon %s index %d failed, hr=0x%08X\n", wine_dbgstr_w(icoPathW
), index
, hr
);
1382 hr
= platform_write_icon(stream
, pIconDirEntries
, numEntries
, index
, icoPathW
, destFilename
, &nativeIdentifier
);
1384 WINE_WARN("writing icon failed, error 0x%08X\n", hr
);
1388 IStream_Release(stream
);
1389 HeapFree(GetProcessHeap(), 0, pIconDirEntries
);
1392 HeapFree(GetProcessHeap(), 0, nativeIdentifier
);
1393 nativeIdentifier
= NULL
;
1395 return nativeIdentifier
;
1398 static HKEY
open_menus_reg_key(void)
1400 static const WCHAR Software_Wine_FileOpenMenuFilesW
[] = {
1401 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','M','e','n','u','F','i','l','e','s',0};
1404 ret
= RegCreateKeyW(HKEY_CURRENT_USER
, Software_Wine_FileOpenMenuFilesW
, &assocKey
);
1405 if (ret
== ERROR_SUCCESS
)
1411 static DWORD
register_menus_entry(const char *unix_file
, const char *windows_file
)
1414 WCHAR
*windows_fileW
;
1418 size
= MultiByteToWideChar(CP_UNIXCP
, 0, unix_file
, -1, NULL
, 0);
1419 unix_fileW
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
1422 MultiByteToWideChar(CP_UNIXCP
, 0, unix_file
, -1, unix_fileW
, size
);
1423 size
= MultiByteToWideChar(CP_UNIXCP
, 0, windows_file
, -1, NULL
, 0);
1424 windows_fileW
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
1428 MultiByteToWideChar(CP_UNIXCP
, 0, windows_file
, -1, windows_fileW
, size
);
1429 hkey
= open_menus_reg_key();
1432 ret
= RegSetValueExW(hkey
, unix_fileW
, 0, REG_SZ
, (const BYTE
*)windows_fileW
,
1433 (strlenW(windows_fileW
) + 1) * sizeof(WCHAR
));
1437 ret
= GetLastError();
1438 HeapFree(GetProcessHeap(), 0, windows_fileW
);
1441 ret
= ERROR_NOT_ENOUGH_MEMORY
;
1442 HeapFree(GetProcessHeap(), 0, unix_fileW
);
1445 ret
= ERROR_NOT_ENOUGH_MEMORY
;
1449 static BOOL
write_desktop_entry(const char *unix_link
, const char *location
, const char *linkname
,
1450 const char *path
, const char *args
, const char *descr
,
1451 const char *workdir
, const char *icon
, const char *wmclass
)
1454 const char *prefix
= getenv("WINEPREFIX");
1455 const char *home
= getenv("HOME");
1457 WINE_TRACE("(%s,%s,%s,%s,%s,%s,%s,%s,%s)\n", wine_dbgstr_a(unix_link
), wine_dbgstr_a(location
),
1458 wine_dbgstr_a(linkname
), wine_dbgstr_a(path
), wine_dbgstr_a(args
),
1459 wine_dbgstr_a(descr
), wine_dbgstr_a(workdir
), wine_dbgstr_a(icon
),
1460 wine_dbgstr_a(wmclass
));
1462 file
= fopen(location
, "w");
1466 fprintf(file
, "[Desktop Entry]\n");
1467 fprintf(file
, "Name=%s\n", linkname
);
1469 fprintf(file
, "Exec=env WINEPREFIX=\"%s\" wine %s %s\n", prefix
, path
, args
);
1471 fprintf(file
, "Exec=env WINEPREFIX=\"%s/.wine\" wine %s %s\n", home
, path
, args
);
1473 fprintf(file
, "Exec=wine %s %s\n", path
, args
);
1474 fprintf(file
, "Type=Application\n");
1475 fprintf(file
, "StartupNotify=true\n");
1476 if (descr
&& *descr
)
1477 fprintf(file
, "Comment=%s\n", descr
);
1478 if (workdir
&& *workdir
)
1479 fprintf(file
, "Path=%s\n", workdir
);
1481 fprintf(file
, "Icon=%s\n", icon
);
1482 if (wmclass
&& *wmclass
)
1483 fprintf(file
, "StartupWMClass=%s\n", wmclass
);
1489 DWORD ret
= register_menus_entry(location
, unix_link
);
1490 if (ret
!= ERROR_SUCCESS
)
1497 static BOOL
write_directory_entry(const char *directory
, const char *location
)
1501 WINE_TRACE("(%s,%s)\n", wine_dbgstr_a(directory
), wine_dbgstr_a(location
));
1503 file
= fopen(location
, "w");
1507 fprintf(file
, "[Desktop Entry]\n");
1508 fprintf(file
, "Type=Directory\n");
1509 if (strcmp(directory
, "wine") == 0)
1511 fprintf(file
, "Name=Wine\n");
1512 fprintf(file
, "Icon=wine\n");
1516 fprintf(file
, "Name=%s\n", directory
);
1517 fprintf(file
, "Icon=folder\n");
1524 static BOOL
write_menu_file(const char *unix_link
, const char *filename
)
1527 FILE *tempfile
= NULL
;
1530 char *menuPath
= NULL
;
1535 WINE_TRACE("(%s)\n", wine_dbgstr_a(filename
));
1539 tempfilename
= heap_printf("%s/wine-menu-XXXXXX", xdg_config_dir
);
1542 int tempfd
= mkstemps(tempfilename
, 0);
1545 tempfile
= fdopen(tempfd
, "w");
1551 else if (errno
== EEXIST
)
1553 HeapFree(GetProcessHeap(), 0, tempfilename
);
1556 HeapFree(GetProcessHeap(), 0, tempfilename
);
1561 fprintf(tempfile
, "<!DOCTYPE Menu PUBLIC \"-//freedesktop//DTD Menu 1.0//EN\"\n");
1562 fprintf(tempfile
, "\"http://www.freedesktop.org/standards/menu-spec/menu-1.0.dtd\">\n");
1563 fprintf(tempfile
, "<Menu>\n");
1564 fprintf(tempfile
, " <Name>Applications</Name>\n");
1566 name
= HeapAlloc(GetProcessHeap(), 0, lstrlenA(filename
) + 1);
1567 if (name
== NULL
) goto end
;
1569 for (i
= 0; filename
[i
]; i
++)
1571 name
[i
] = filename
[i
];
1572 if (filename
[i
] == '/')
1574 char *dir_file_name
;
1577 fprintf(tempfile
, " <Menu>\n");
1578 fprintf(tempfile
, " <Name>%s", count
? "" : "wine-");
1579 write_xml_text(tempfile
, name
);
1580 fprintf(tempfile
, "</Name>\n");
1581 fprintf(tempfile
, " <Directory>%s", count
? "" : "wine-");
1582 write_xml_text(tempfile
, name
);
1583 fprintf(tempfile
, ".directory</Directory>\n");
1584 dir_file_name
= heap_printf("%s/desktop-directories/%s%s.directory",
1585 xdg_data_dir
, count
? "" : "wine-", name
);
1588 if (stat(dir_file_name
, &st
) != 0 && errno
== ENOENT
)
1589 write_directory_entry(lastEntry
, dir_file_name
);
1590 HeapFree(GetProcessHeap(), 0, dir_file_name
);
1593 lastEntry
= &name
[i
+1];
1599 fprintf(tempfile
, " <Include>\n");
1600 fprintf(tempfile
, " <Filename>");
1601 write_xml_text(tempfile
, name
);
1602 fprintf(tempfile
, "</Filename>\n");
1603 fprintf(tempfile
, " </Include>\n");
1604 for (i
= 0; i
< count
; i
++)
1605 fprintf(tempfile
, " </Menu>\n");
1606 fprintf(tempfile
, "</Menu>\n");
1608 menuPath
= heap_printf("%s/%s", xdg_config_dir
, name
);
1609 if (menuPath
== NULL
) goto end
;
1610 strcpy(menuPath
+ strlen(menuPath
) - strlen(".desktop"), ".menu");
1617 ret
= (rename(tempfilename
, menuPath
) == 0);
1618 if (!ret
&& tempfilename
)
1619 remove(tempfilename
);
1620 HeapFree(GetProcessHeap(), 0, tempfilename
);
1622 register_menus_entry(menuPath
, unix_link
);
1623 HeapFree(GetProcessHeap(), 0, name
);
1624 HeapFree(GetProcessHeap(), 0, menuPath
);
1628 static BOOL
write_menu_entry(const char *unix_link
, const char *link
, const char *path
, const char *args
,
1629 const char *descr
, const char *workdir
, const char *icon
, const char *wmclass
)
1631 const char *linkname
;
1632 char *desktopPath
= NULL
;
1634 char *filename
= NULL
;
1637 WINE_TRACE("(%s, %s, %s, %s, %s, %s, %s, %s)\n", wine_dbgstr_a(unix_link
), wine_dbgstr_a(link
),
1638 wine_dbgstr_a(path
), wine_dbgstr_a(args
), wine_dbgstr_a(descr
),
1639 wine_dbgstr_a(workdir
), wine_dbgstr_a(icon
), wine_dbgstr_a(wmclass
));
1641 linkname
= strrchr(link
, '/');
1642 if (linkname
== NULL
)
1647 desktopPath
= heap_printf("%s/applications/wine/%s.desktop", xdg_data_dir
, link
);
1650 WINE_WARN("out of memory creating menu entry\n");
1654 desktopDir
= strrchr(desktopPath
, '/');
1656 if (!create_directories(desktopPath
))
1658 WINE_WARN("couldn't make parent directories for %s\n", wine_dbgstr_a(desktopPath
));
1663 if (!write_desktop_entry(unix_link
, desktopPath
, linkname
, path
, args
, descr
, workdir
, icon
, wmclass
))
1665 WINE_WARN("couldn't make desktop entry %s\n", wine_dbgstr_a(desktopPath
));
1670 filename
= heap_printf("wine/%s.desktop", link
);
1671 if (!filename
|| !write_menu_file(unix_link
, filename
))
1673 WINE_WARN("couldn't make menu file %s\n", wine_dbgstr_a(filename
));
1678 HeapFree(GetProcessHeap(), 0, desktopPath
);
1679 HeapFree(GetProcessHeap(), 0, filename
);
1683 /* This escapes reserved characters in .desktop files' Exec keys. */
1684 static LPSTR
escape(LPCWSTR arg
)
1687 WCHAR
*escaped_string
;
1690 escaped_string
= HeapAlloc(GetProcessHeap(), 0, (4 * strlenW(arg
) + 1) * sizeof(WCHAR
));
1691 if (escaped_string
== NULL
) return NULL
;
1692 for (i
= j
= 0; arg
[i
]; i
++)
1697 escaped_string
[j
++] = '\\';
1698 escaped_string
[j
++] = '\\';
1699 escaped_string
[j
++] = '\\';
1700 escaped_string
[j
++] = '\\';
1720 escaped_string
[j
++] = '\\';
1721 escaped_string
[j
++] = '\\';
1724 escaped_string
[j
++] = arg
[i
];
1728 escaped_string
[j
] = 0;
1730 utf8_string
= wchars_to_utf8_chars(escaped_string
);
1731 if (utf8_string
== NULL
)
1733 WINE_ERR("out of memory\n");
1738 HeapFree(GetProcessHeap(), 0, escaped_string
);
1742 /* Return a heap-allocated copy of the unix format difference between the two
1743 * Windows-format paths.
1744 * locn is the owning location
1745 * link is within locn
1747 static char *relative_path( LPCWSTR link
, LPCWSTR locn
)
1749 char *unix_locn
, *unix_link
;
1750 char *relative
= NULL
;
1752 unix_locn
= wine_get_unix_file_name(locn
);
1753 unix_link
= wine_get_unix_file_name(link
);
1754 if (unix_locn
&& unix_link
)
1756 size_t len_unix_locn
, len_unix_link
;
1757 len_unix_locn
= strlen (unix_locn
);
1758 len_unix_link
= strlen (unix_link
);
1759 if (len_unix_locn
< len_unix_link
&& memcmp (unix_locn
, unix_link
, len_unix_locn
) == 0 && unix_link
[len_unix_locn
] == '/')
1762 char *p
= strrchr (unix_link
+ len_unix_locn
, '/');
1763 p
= strrchr (p
, '.');
1767 len_unix_link
= p
- unix_link
;
1769 len_rel
= len_unix_link
- len_unix_locn
;
1770 relative
= HeapAlloc(GetProcessHeap(), 0, len_rel
);
1773 memcpy (relative
, unix_link
+ len_unix_locn
+ 1, len_rel
);
1778 WINE_WARN("Could not separate the relative link path of %s in %s\n", wine_dbgstr_w(link
), wine_dbgstr_w(locn
));
1779 HeapFree(GetProcessHeap(), 0, unix_locn
);
1780 HeapFree(GetProcessHeap(), 0, unix_link
);
1784 /***********************************************************************
1788 * returns TRUE if successful
1789 * *loc will contain CS_DESKTOPDIRECTORY, CS_STARTMENU, CS_STARTUP etc.
1790 * *relative will contain the address of a heap-allocated copy of the portion
1791 * of the filename that is within the specified location, in unix form
1793 static BOOL
GetLinkLocation( LPCWSTR linkfile
, DWORD
*loc
, char **relative
)
1795 WCHAR filename
[MAX_PATH
], shortfilename
[MAX_PATH
], buffer
[MAX_PATH
];
1796 DWORD len
, i
, r
, filelen
;
1797 const DWORD locations
[] = {
1798 CSIDL_STARTUP
, CSIDL_DESKTOPDIRECTORY
, CSIDL_STARTMENU
,
1799 CSIDL_COMMON_STARTUP
, CSIDL_COMMON_DESKTOPDIRECTORY
,
1800 CSIDL_COMMON_STARTMENU
};
1802 WINE_TRACE("%s\n", wine_dbgstr_w(linkfile
));
1803 filelen
=GetFullPathNameW( linkfile
, MAX_PATH
, shortfilename
, NULL
);
1804 if (filelen
==0 || filelen
>MAX_PATH
)
1807 WINE_TRACE("%s\n", wine_dbgstr_w(shortfilename
));
1809 /* the CSLU Toolkit uses a short path name when creating .lnk files;
1810 * expand or our hardcoded list won't match.
1812 filelen
=GetLongPathNameW(shortfilename
, filename
, MAX_PATH
);
1813 if (filelen
==0 || filelen
>MAX_PATH
)
1816 WINE_TRACE("%s\n", wine_dbgstr_w(filename
));
1818 for( i
=0; i
<ARRAY_SIZE( locations
); i
++ )
1820 if (!SHGetSpecialFolderPathW( 0, buffer
, locations
[i
], FALSE
))
1823 len
= lstrlenW(buffer
);
1824 if (len
>= MAX_PATH
)
1825 continue; /* We've just trashed memory! Hopefully we are OK */
1827 if (len
> filelen
|| filename
[len
]!='\\')
1829 /* do a lstrcmpinW */
1831 r
= lstrcmpiW( filename
, buffer
);
1832 filename
[len
] = '\\';
1836 /* return the remainder of the string and link type */
1837 *loc
= locations
[i
];
1838 *relative
= relative_path (filename
, buffer
);
1839 return (*relative
!= NULL
);
1845 /* gets the target path directly or through MSI */
1846 static HRESULT
get_cmdline( IShellLinkW
*sl
, LPWSTR szPath
, DWORD pathSize
,
1847 LPWSTR szArgs
, DWORD argsSize
)
1849 IShellLinkDataList
*dl
= NULL
;
1850 EXP_DARWIN_LINK
*dar
= NULL
;
1856 hr
= IShellLinkW_GetPath( sl
, szPath
, pathSize
, NULL
, SLGP_RAWPATH
);
1857 if (hr
== S_OK
&& szPath
[0])
1859 IShellLinkW_GetArguments( sl
, szArgs
, argsSize
);
1863 hr
= IShellLinkW_QueryInterface( sl
, &IID_IShellLinkDataList
, (LPVOID
*) &dl
);
1867 hr
= IShellLinkDataList_CopyDataBlock( dl
, EXP_DARWIN_ID_SIG
, (LPVOID
*) &dar
);
1874 hr
= CommandLineFromMsiDescriptor( dar
->szwDarwinID
, NULL
, &cmdSize
);
1875 if (hr
== ERROR_SUCCESS
)
1878 szCmdline
= HeapAlloc( GetProcessHeap(), 0, cmdSize
*sizeof(WCHAR
) );
1879 hr
= CommandLineFromMsiDescriptor( dar
->szwDarwinID
, szCmdline
, &cmdSize
);
1880 WINE_TRACE(" command : %s\n", wine_dbgstr_w(szCmdline
));
1881 if (hr
== ERROR_SUCCESS
)
1885 BOOL in_quotes
= FALSE
;
1887 /* Extract the application path */
1892 if ((*s
==0x0009 || *s
==0x0020) && !in_quotes
)
1894 /* skip the remaining spaces */
1897 } while (*s
==0x0009 || *s
==0x0020);
1900 else if (*s
==0x005c)
1906 else if (*s
==0x0022)
1909 if ((bcount
& 1)==0)
1911 /* Preceded by an even number of '\', this is
1912 * half that number of '\', plus a quote which
1916 in_quotes
=!in_quotes
;
1921 /* Preceded by an odd number of '\', this is
1922 * half that number of '\' followed by a '"'
1932 /* a regular character */
1936 if ((d
-szPath
) == pathSize
)
1938 /* Keep processing the path till we get to the
1939 * arguments, but 'stand still'
1944 /* Close the application path */
1947 lstrcpynW(szArgs
, s
, argsSize
);
1949 HeapFree( GetProcessHeap(), 0, szCmdline
);
1954 IShellLinkDataList_Release( dl
);
1958 static char *slashes_to_minuses(const char *string
)
1961 char *ret
= HeapAlloc(GetProcessHeap(), 0, lstrlenA(string
) + 1);
1964 for (i
= 0; string
[i
]; i
++)
1966 if (string
[i
] == '/')
1977 static BOOL
next_line(FILE *file
, char **line
, int *size
)
1984 *line
= HeapAlloc(GetProcessHeap(), 0, *size
);
1986 while (*line
!= NULL
)
1988 if (fgets(&(*line
)[pos
], *size
- pos
, file
) == NULL
)
1990 HeapFree(GetProcessHeap(), 0, *line
);
1996 pos
= strlen(*line
);
1997 cr
= strchr(*line
, '\n');
2002 line2
= HeapReAlloc(GetProcessHeap(), 0, *line
, *size
);
2007 HeapFree(GetProcessHeap(), 0, *line
);
2020 static BOOL
add_mimes(const char *xdg_data_dir
, struct list
*mime_types
)
2022 char *globs_filename
= NULL
;
2024 globs_filename
= heap_printf("%s/mime/globs", xdg_data_dir
);
2027 FILE *globs_file
= fopen(globs_filename
, "r");
2028 if (globs_file
) /* doesn't have to exist */
2032 while (ret
&& (ret
= next_line(globs_file
, &line
, &size
)) && line
)
2035 struct xdg_mime_type
*mime_type_entry
= NULL
;
2036 if (line
[0] != '#' && (pos
= strchr(line
, ':')))
2038 mime_type_entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct xdg_mime_type
));
2039 if (mime_type_entry
)
2042 mime_type_entry
->mimeType
= strdupA(line
);
2043 mime_type_entry
->glob
= strdupA(pos
+ 1);
2044 mime_type_entry
->lower_glob
= strdupA(pos
+ 1);
2045 if (mime_type_entry
->lower_glob
)
2048 for (l
= mime_type_entry
->lower_glob
; *l
; l
++)
2051 if (mime_type_entry
->mimeType
&& mime_type_entry
->glob
&& mime_type_entry
->lower_glob
)
2052 list_add_tail(mime_types
, &mime_type_entry
->entry
);
2055 HeapFree(GetProcessHeap(), 0, mime_type_entry
->mimeType
);
2056 HeapFree(GetProcessHeap(), 0, mime_type_entry
->glob
);
2057 HeapFree(GetProcessHeap(), 0, mime_type_entry
->lower_glob
);
2058 HeapFree(GetProcessHeap(), 0, mime_type_entry
);
2066 HeapFree(GetProcessHeap(), 0, line
);
2069 HeapFree(GetProcessHeap(), 0, globs_filename
);
2076 static void free_native_mime_types(struct list
*native_mime_types
)
2078 struct xdg_mime_type
*mime_type_entry
, *mime_type_entry2
;
2080 LIST_FOR_EACH_ENTRY_SAFE(mime_type_entry
, mime_type_entry2
, native_mime_types
, struct xdg_mime_type
, entry
)
2082 list_remove(&mime_type_entry
->entry
);
2083 HeapFree(GetProcessHeap(), 0, mime_type_entry
->glob
);
2084 HeapFree(GetProcessHeap(), 0, mime_type_entry
->lower_glob
);
2085 HeapFree(GetProcessHeap(), 0, mime_type_entry
->mimeType
);
2086 HeapFree(GetProcessHeap(), 0, mime_type_entry
);
2090 static BOOL
build_native_mime_types(const char *xdg_data_home
, struct list
*mime_types
)
2092 char *xdg_data_dirs
;
2095 xdg_data_dirs
= getenv("XDG_DATA_DIRS");
2096 if (xdg_data_dirs
== NULL
)
2097 xdg_data_dirs
= heap_printf("/usr/local/share/:/usr/share/");
2099 xdg_data_dirs
= strdupA(xdg_data_dirs
);
2106 ret
= add_mimes(xdg_data_home
, mime_types
);
2109 for (begin
= xdg_data_dirs
; (end
= strchr(begin
, ':')); begin
= end
+ 1)
2112 ret
= add_mimes(begin
, mime_types
);
2118 ret
= add_mimes(begin
, mime_types
);
2120 HeapFree(GetProcessHeap(), 0, xdg_data_dirs
);
2125 free_native_mime_types(mime_types
);
2129 static BOOL
match_glob(struct list
*native_mime_types
, const char *extension
,
2130 int ignoreGlobCase
, char **match
)
2133 struct xdg_mime_type
*mime_type_entry
;
2134 int matchLength
= 0;
2138 LIST_FOR_EACH_ENTRY(mime_type_entry
, native_mime_types
, struct xdg_mime_type
, entry
)
2140 const char *glob
= ignoreGlobCase
? mime_type_entry
->lower_glob
: mime_type_entry
->glob
;
2141 if (fnmatch(glob
, extension
, 0) == 0)
2143 if (*match
== NULL
|| matchLength
< strlen(glob
))
2145 *match
= mime_type_entry
->mimeType
;
2146 matchLength
= strlen(glob
);
2153 *match
= strdupA(*match
);
2163 static BOOL
freedesktop_mime_type_for_extension(struct list
*native_mime_types
,
2164 const char *extensionA
,
2168 WCHAR
*lower_extensionW
;
2170 BOOL ret
= match_glob(native_mime_types
, extensionA
, 0, mime_type
);
2171 if (ret
== FALSE
|| *mime_type
!= NULL
)
2173 len
= strlenW(extensionW
);
2174 lower_extensionW
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1)*sizeof(WCHAR
));
2175 if (lower_extensionW
)
2177 char *lower_extensionA
;
2178 memcpy(lower_extensionW
, extensionW
, (len
+ 1)*sizeof(WCHAR
));
2179 strlwrW(lower_extensionW
);
2180 lower_extensionA
= wchars_to_utf8_chars(lower_extensionW
);
2181 if (lower_extensionA
)
2183 ret
= match_glob(native_mime_types
, lower_extensionA
, 1, mime_type
);
2184 HeapFree(GetProcessHeap(), 0, lower_extensionA
);
2189 WINE_FIXME("out of memory\n");
2191 HeapFree(GetProcessHeap(), 0, lower_extensionW
);
2196 WINE_FIXME("out of memory\n");
2201 static WCHAR
* reg_get_valW(HKEY key
, LPCWSTR subkey
, LPCWSTR name
)
2204 if (RegGetValueW(key
, subkey
, name
, RRF_RT_REG_SZ
, NULL
, NULL
, &size
) == ERROR_SUCCESS
)
2206 WCHAR
*ret
= HeapAlloc(GetProcessHeap(), 0, size
);
2209 if (RegGetValueW(key
, subkey
, name
, RRF_RT_REG_SZ
, NULL
, ret
, &size
) == ERROR_SUCCESS
)
2212 HeapFree(GetProcessHeap(), 0, ret
);
2217 static CHAR
* reg_get_val_utf8(HKEY key
, LPCWSTR subkey
, LPCWSTR name
)
2219 WCHAR
*valW
= reg_get_valW(key
, subkey
, name
);
2222 char *val
= wchars_to_utf8_chars(valW
);
2223 HeapFree(GetProcessHeap(), 0, valW
);
2229 static HKEY
open_associations_reg_key(void)
2231 static const WCHAR Software_Wine_FileOpenAssociationsW
[] = {
2232 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','F','i','l','e','O','p','e','n','A','s','s','o','c','i','a','t','i','o','n','s',0};
2234 if (RegCreateKeyW(HKEY_CURRENT_USER
, Software_Wine_FileOpenAssociationsW
, &assocKey
) == ERROR_SUCCESS
)
2239 static BOOL
has_association_changed(LPCWSTR extensionW
, LPCSTR mimeType
, LPCWSTR progId
,
2240 LPCSTR appName
, LPCSTR openWithIcon
)
2242 static const WCHAR ProgIDW
[] = {'P','r','o','g','I','D',0};
2243 static const WCHAR MimeTypeW
[] = {'M','i','m','e','T','y','p','e',0};
2244 static const WCHAR AppNameW
[] = {'A','p','p','N','a','m','e',0};
2245 static const WCHAR OpenWithIconW
[] = {'O','p','e','n','W','i','t','h','I','c','o','n',0};
2249 if ((assocKey
= open_associations_reg_key()))
2256 valueA
= reg_get_val_utf8(assocKey
, extensionW
, MimeTypeW
);
2257 if (!valueA
|| lstrcmpA(valueA
, mimeType
))
2259 HeapFree(GetProcessHeap(), 0, valueA
);
2261 value
= reg_get_valW(assocKey
, extensionW
, ProgIDW
);
2262 if (!value
|| strcmpW(value
, progId
))
2264 HeapFree(GetProcessHeap(), 0, value
);
2266 valueA
= reg_get_val_utf8(assocKey
, extensionW
, AppNameW
);
2267 if (!valueA
|| lstrcmpA(valueA
, appName
))
2269 HeapFree(GetProcessHeap(), 0, valueA
);
2271 valueA
= reg_get_val_utf8(assocKey
, extensionW
, OpenWithIconW
);
2272 if ((openWithIcon
&& !valueA
) ||
2273 (!openWithIcon
&& valueA
) ||
2274 (openWithIcon
&& valueA
&& lstrcmpA(valueA
, openWithIcon
)))
2276 HeapFree(GetProcessHeap(), 0, valueA
);
2278 RegCloseKey(assocKey
);
2282 WINE_ERR("error opening associations registry key\n");
2288 static void update_association(LPCWSTR extension
, LPCSTR mimeType
, LPCWSTR progId
,
2289 LPCSTR appName
, LPCSTR desktopFile
, LPCSTR openWithIcon
)
2291 static const WCHAR ProgIDW
[] = {'P','r','o','g','I','D',0};
2292 static const WCHAR MimeTypeW
[] = {'M','i','m','e','T','y','p','e',0};
2293 static const WCHAR AppNameW
[] = {'A','p','p','N','a','m','e',0};
2294 static const WCHAR DesktopFileW
[] = {'D','e','s','k','t','o','p','F','i','l','e',0};
2295 static const WCHAR OpenWithIconW
[] = {'O','p','e','n','W','i','t','h','I','c','o','n',0};
2296 HKEY assocKey
= NULL
;
2298 WCHAR
*mimeTypeW
= NULL
;
2299 WCHAR
*appNameW
= NULL
;
2300 WCHAR
*desktopFileW
= NULL
;
2301 WCHAR
*openWithIconW
= NULL
;
2303 assocKey
= open_associations_reg_key();
2304 if (assocKey
== NULL
)
2306 WINE_ERR("could not open file associations key\n");
2310 if (RegCreateKeyW(assocKey
, extension
, &subkey
) != ERROR_SUCCESS
)
2312 WINE_ERR("could not create extension subkey\n");
2316 mimeTypeW
= utf8_chars_to_wchars(mimeType
);
2317 if (mimeTypeW
== NULL
)
2319 WINE_ERR("out of memory\n");
2323 appNameW
= utf8_chars_to_wchars(appName
);
2324 if (appNameW
== NULL
)
2326 WINE_ERR("out of memory\n");
2330 desktopFileW
= utf8_chars_to_wchars(desktopFile
);
2331 if (desktopFileW
== NULL
)
2333 WINE_ERR("out of memory\n");
2339 openWithIconW
= utf8_chars_to_wchars(openWithIcon
);
2340 if (openWithIconW
== NULL
)
2342 WINE_ERR("out of memory\n");
2347 RegSetValueExW(subkey
, MimeTypeW
, 0, REG_SZ
, (const BYTE
*) mimeTypeW
, (lstrlenW(mimeTypeW
) + 1) * sizeof(WCHAR
));
2348 RegSetValueExW(subkey
, ProgIDW
, 0, REG_SZ
, (const BYTE
*) progId
, (lstrlenW(progId
) + 1) * sizeof(WCHAR
));
2349 RegSetValueExW(subkey
, AppNameW
, 0, REG_SZ
, (const BYTE
*) appNameW
, (lstrlenW(appNameW
) + 1) * sizeof(WCHAR
));
2350 RegSetValueExW(subkey
, DesktopFileW
, 0, REG_SZ
, (const BYTE
*) desktopFileW
, (lstrlenW(desktopFileW
) + 1) * sizeof(WCHAR
));
2352 RegSetValueExW(subkey
, OpenWithIconW
, 0, REG_SZ
, (const BYTE
*) openWithIconW
, (lstrlenW(openWithIconW
) + 1) * sizeof(WCHAR
));
2354 RegDeleteValueW(subkey
, OpenWithIconW
);
2357 RegCloseKey(assocKey
);
2358 RegCloseKey(subkey
);
2359 HeapFree(GetProcessHeap(), 0, mimeTypeW
);
2360 HeapFree(GetProcessHeap(), 0, appNameW
);
2361 HeapFree(GetProcessHeap(), 0, desktopFileW
);
2362 HeapFree(GetProcessHeap(), 0, openWithIconW
);
2365 static BOOL
cleanup_associations(void)
2367 static const WCHAR openW
[] = {'o','p','e','n',0};
2368 static const WCHAR DesktopFileW
[] = {'D','e','s','k','t','o','p','F','i','l','e',0};
2370 BOOL hasChanged
= FALSE
;
2371 if ((assocKey
= open_associations_reg_key()))
2377 WCHAR
*extensionW
= NULL
;
2383 HeapFree(GetProcessHeap(), 0, extensionW
);
2384 extensionW
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
2385 if (extensionW
== NULL
)
2387 WINE_ERR("out of memory\n");
2388 ret
= ERROR_OUTOFMEMORY
;
2391 ret
= RegEnumKeyExW(assocKey
, i
, extensionW
, &size
, NULL
, NULL
, NULL
, NULL
);
2393 } while (ret
== ERROR_MORE_DATA
);
2395 if (ret
== ERROR_SUCCESS
)
2398 command
= assoc_query(ASSOCSTR_COMMAND
, extensionW
, openW
);
2399 if (command
== NULL
)
2401 char *desktopFile
= reg_get_val_utf8(assocKey
, extensionW
, DesktopFileW
);
2404 WINE_TRACE("removing file type association for %s\n", wine_dbgstr_w(extensionW
));
2405 remove(desktopFile
);
2407 RegDeleteKeyW(assocKey
, extensionW
);
2409 HeapFree(GetProcessHeap(), 0, desktopFile
);
2413 HeapFree(GetProcessHeap(), 0, command
);
2417 if (ret
!= ERROR_NO_MORE_ITEMS
)
2418 WINE_ERR("error %d while reading registry\n", ret
);
2421 HeapFree(GetProcessHeap(), 0, extensionW
);
2423 RegCloseKey(assocKey
);
2426 WINE_ERR("could not open file associations key\n");
2430 static BOOL
write_freedesktop_mime_type_entry(const char *packages_dir
, const char *dot_extension
,
2431 const char *mime_type
, const char *comment
)
2436 WINE_TRACE("writing MIME type %s, extension=%s, comment=%s\n", wine_dbgstr_a(mime_type
),
2437 wine_dbgstr_a(dot_extension
), wine_dbgstr_a(comment
));
2439 filename
= heap_printf("%s/x-wine-extension-%s.xml", packages_dir
, &dot_extension
[1]);
2442 FILE *packageFile
= fopen(filename
, "w");
2445 fprintf(packageFile
, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
2446 fprintf(packageFile
, "<mime-info xmlns=\"http://www.freedesktop.org/standards/shared-mime-info\">\n");
2447 fprintf(packageFile
, " <mime-type type=\"");
2448 write_xml_text(packageFile
, mime_type
);
2449 fprintf(packageFile
, "\">\n");
2450 fprintf(packageFile
, " <glob pattern=\"*");
2451 write_xml_text(packageFile
, dot_extension
);
2452 fprintf(packageFile
, "\"/>\n");
2455 fprintf(packageFile
, " <comment>");
2456 write_xml_text(packageFile
, comment
);
2457 fprintf(packageFile
, "</comment>\n");
2459 fprintf(packageFile
, " </mime-type>\n");
2460 fprintf(packageFile
, "</mime-info>\n");
2462 fclose(packageFile
);
2465 WINE_ERR("error writing file %s\n", filename
);
2466 HeapFree(GetProcessHeap(), 0, filename
);
2469 WINE_ERR("out of memory\n");
2473 static BOOL
is_extension_banned(LPCWSTR extension
)
2475 /* These are managed through external tools like wine.desktop, to evade malware created file type associations */
2476 static const WCHAR comW
[] = {'.','c','o','m',0};
2477 static const WCHAR exeW
[] = {'.','e','x','e',0};
2478 static const WCHAR msiW
[] = {'.','m','s','i',0};
2480 if (!strcmpiW(extension
, comW
) ||
2481 !strcmpiW(extension
, exeW
) ||
2482 !strcmpiW(extension
, msiW
))
2487 static const char* get_special_mime_type(LPCWSTR extension
)
2489 static const WCHAR lnkW
[] = {'.','l','n','k',0};
2490 if (!strcmpiW(extension
, lnkW
))
2491 return "application/x-ms-shortcut";
2495 static BOOL
write_freedesktop_association_entry(const char *desktopPath
, const char *dot_extension
,
2496 const char *friendlyAppName
, const char *mimeType
,
2497 const char *progId
, const char *openWithIcon
)
2501 const char *prefix
= getenv("WINEPREFIX");
2502 const char *home
= getenv("HOME");
2504 WINE_TRACE("writing association for file type %s, friendlyAppName=%s, MIME type %s, progID=%s, icon=%s to file %s\n",
2505 wine_dbgstr_a(dot_extension
), wine_dbgstr_a(friendlyAppName
), wine_dbgstr_a(mimeType
),
2506 wine_dbgstr_a(progId
), wine_dbgstr_a(openWithIcon
), wine_dbgstr_a(desktopPath
));
2508 desktop
= fopen(desktopPath
, "w");
2511 fprintf(desktop
, "[Desktop Entry]\n");
2512 fprintf(desktop
, "Type=Application\n");
2513 fprintf(desktop
, "Name=%s\n", friendlyAppName
);
2514 fprintf(desktop
, "MimeType=%s;\n", mimeType
);
2516 fprintf(desktop
, "Exec=env WINEPREFIX=\"%s\" wine start /ProgIDOpen %s %%f\n", prefix
, progId
);
2518 fprintf(desktop
, "Exec=env WINEPREFIX=\"%s/.wine\" wine start /ProgIDOpen %s %%f\n", home
, progId
);
2520 fprintf(desktop
, "Exec=wine start /ProgIDOpen %s %%f\n", progId
);
2521 fprintf(desktop
, "NoDisplay=true\n");
2522 fprintf(desktop
, "StartupNotify=true\n");
2524 fprintf(desktop
, "Icon=%s\n", openWithIcon
);
2529 WINE_ERR("error writing association file %s\n", wine_dbgstr_a(desktopPath
));
2533 static BOOL
generate_associations(const char *xdg_data_home
, const char *packages_dir
, const char *applications_dir
)
2535 static const WCHAR openW
[] = {'o','p','e','n',0};
2536 struct wine_rb_tree mimeProgidTree
= { winemenubuilder_rb_string_compare
};
2537 struct list nativeMimeTypes
= LIST_INIT(nativeMimeTypes
);
2540 BOOL hasChanged
= FALSE
;
2542 if (!build_native_mime_types(xdg_data_home
, &nativeMimeTypes
))
2544 WINE_ERR("could not build native MIME types\n");
2550 WCHAR
*extensionW
= NULL
;
2555 HeapFree(GetProcessHeap(), 0, extensionW
);
2556 extensionW
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
));
2557 if (extensionW
== NULL
)
2559 WINE_ERR("out of memory\n");
2560 ret
= ERROR_OUTOFMEMORY
;
2563 ret
= RegEnumKeyExW(HKEY_CLASSES_ROOT
, i
, extensionW
, &size
, NULL
, NULL
, NULL
, NULL
);
2565 } while (ret
== ERROR_MORE_DATA
);
2567 if (ret
== ERROR_SUCCESS
&& extensionW
[0] == '.' && !is_extension_banned(extensionW
))
2569 char *extensionA
= NULL
;
2570 WCHAR
*commandW
= NULL
;
2571 WCHAR
*executableW
= NULL
;
2572 char *openWithIconA
= NULL
;
2573 WCHAR
*friendlyDocNameW
= NULL
;
2574 char *friendlyDocNameA
= NULL
;
2575 WCHAR
*iconW
= NULL
;
2577 WCHAR
*contentTypeW
= NULL
;
2578 char *mimeTypeA
= NULL
;
2579 WCHAR
*friendlyAppNameW
= NULL
;
2580 char *friendlyAppNameA
= NULL
;
2581 WCHAR
*progIdW
= NULL
;
2582 char *progIdA
= NULL
;
2583 char *mimeProgId
= NULL
;
2585 extensionA
= wchars_to_utf8_chars(strlwrW(extensionW
));
2586 if (extensionA
== NULL
)
2588 WINE_ERR("out of memory\n");
2592 friendlyDocNameW
= assoc_query(ASSOCSTR_FRIENDLYDOCNAME
, extensionW
, NULL
);
2593 if (friendlyDocNameW
)
2595 friendlyDocNameA
= wchars_to_utf8_chars(friendlyDocNameW
);
2596 if (friendlyDocNameA
== NULL
)
2598 WINE_ERR("out of memory\n");
2603 iconW
= assoc_query(ASSOCSTR_DEFAULTICON
, extensionW
, NULL
);
2605 contentTypeW
= assoc_query(ASSOCSTR_CONTENTTYPE
, extensionW
, NULL
);
2607 strlwrW(contentTypeW
);
2609 if (!freedesktop_mime_type_for_extension(&nativeMimeTypes
, extensionA
, extensionW
, &mimeTypeA
))
2612 if (mimeTypeA
== NULL
)
2614 if (contentTypeW
!= NULL
&& strchrW(contentTypeW
, '/'))
2615 mimeTypeA
= wchars_to_utf8_chars(contentTypeW
);
2616 else if ((get_special_mime_type(extensionW
)))
2617 mimeTypeA
= strdupA(get_special_mime_type(extensionW
));
2619 mimeTypeA
= heap_printf("application/x-wine-extension-%s", &extensionA
[1]);
2621 if (mimeTypeA
!= NULL
)
2623 /* GNOME seems to ignore the <icon> tag in MIME packages,
2624 * and the default name is more intuitive anyway.
2628 char *flattened_mime
= slashes_to_minuses(mimeTypeA
);
2632 WCHAR
*comma
= strrchrW(iconW
, ',');
2636 index
= atoiW(comma
+ 1);
2638 iconA
= extract_icon(iconW
, index
, flattened_mime
, FALSE
);
2639 HeapFree(GetProcessHeap(), 0, flattened_mime
);
2643 write_freedesktop_mime_type_entry(packages_dir
, extensionA
, mimeTypeA
, friendlyDocNameA
);
2648 WINE_FIXME("out of memory\n");
2653 commandW
= assoc_query(ASSOCSTR_COMMAND
, extensionW
, openW
);
2654 if (commandW
== NULL
)
2655 /* no command => no application is associated */
2658 executableW
= assoc_query(ASSOCSTR_EXECUTABLE
, extensionW
, openW
);
2660 openWithIconA
= compute_native_identifier(0, executableW
);
2662 friendlyAppNameW
= assoc_query(ASSOCSTR_FRIENDLYAPPNAME
, extensionW
, openW
);
2663 if (friendlyAppNameW
)
2665 friendlyAppNameA
= wchars_to_utf8_chars(friendlyAppNameW
);
2666 if (friendlyAppNameA
== NULL
)
2668 WINE_ERR("out of memory\n");
2674 friendlyAppNameA
= heap_printf("A Wine application");
2675 if (friendlyAppNameA
== NULL
)
2677 WINE_ERR("out of memory\n");
2682 progIdW
= reg_get_valW(HKEY_CLASSES_ROOT
, extensionW
, NULL
);
2685 progIdA
= escape(progIdW
);
2686 if (progIdA
== NULL
)
2688 WINE_ERR("out of memory\n");
2693 goto end
; /* no progID => not a file type association */
2695 /* Do not allow duplicate ProgIDs for a MIME type, it causes unnecessary duplication in Open dialogs */
2696 mimeProgId
= heap_printf("%s=>%s", mimeTypeA
, progIdA
);
2699 struct rb_string_entry
*entry
;
2700 if (wine_rb_get(&mimeProgidTree
, mimeProgId
))
2702 HeapFree(GetProcessHeap(), 0, mimeProgId
);
2705 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct rb_string_entry
));
2708 WINE_ERR("out of memory allocating rb_string_entry\n");
2711 entry
->string
= mimeProgId
;
2712 if (wine_rb_put(&mimeProgidTree
, mimeProgId
, &entry
->entry
))
2714 WINE_ERR("error updating rb tree\n");
2719 if (has_association_changed(extensionW
, mimeTypeA
, progIdW
, friendlyAppNameA
, openWithIconA
))
2721 char *desktopPath
= heap_printf("%s/wine-extension-%s.desktop", applications_dir
, &extensionA
[1]);
2724 if (write_freedesktop_association_entry(desktopPath
, extensionA
, friendlyAppNameA
, mimeTypeA
, progIdA
, openWithIconA
))
2727 update_association(extensionW
, mimeTypeA
, progIdW
, friendlyAppNameA
, desktopPath
, openWithIconA
);
2729 HeapFree(GetProcessHeap(), 0, desktopPath
);
2733 if (hasChanged
&& openWithIconA
)
2735 char *outputIconA
= extract_icon(executableW
, 0, openWithIconA
, FALSE
);
2736 HeapFree(GetProcessHeap(), 0, outputIconA
);
2740 HeapFree(GetProcessHeap(), 0, extensionA
);
2741 HeapFree(GetProcessHeap(), 0, commandW
);
2742 HeapFree(GetProcessHeap(), 0, executableW
);
2743 HeapFree(GetProcessHeap(), 0, openWithIconA
);
2744 HeapFree(GetProcessHeap(), 0, friendlyDocNameW
);
2745 HeapFree(GetProcessHeap(), 0, friendlyDocNameA
);
2746 HeapFree(GetProcessHeap(), 0, iconW
);
2747 HeapFree(GetProcessHeap(), 0, iconA
);
2748 HeapFree(GetProcessHeap(), 0, contentTypeW
);
2749 HeapFree(GetProcessHeap(), 0, mimeTypeA
);
2750 HeapFree(GetProcessHeap(), 0, friendlyAppNameW
);
2751 HeapFree(GetProcessHeap(), 0, friendlyAppNameA
);
2752 HeapFree(GetProcessHeap(), 0, progIdW
);
2753 HeapFree(GetProcessHeap(), 0, progIdA
);
2755 HeapFree(GetProcessHeap(), 0, extensionW
);
2756 if (ret
!= ERROR_SUCCESS
)
2760 wine_rb_destroy(&mimeProgidTree
, winemenubuilder_rb_destroy
, NULL
);
2761 free_native_mime_types(&nativeMimeTypes
);
2765 static char *get_start_exe_path(void)
2767 static const WCHAR startW
[] = {'\\','c','o','m','m','a','n','d',
2768 '\\','s','t','a','r','t','.','e','x','e',0};
2769 WCHAR start_path
[MAX_PATH
];
2770 GetWindowsDirectoryW(start_path
, MAX_PATH
);
2771 lstrcatW(start_path
, startW
);
2772 return escape(start_path
);
2775 static char* escape_unix_link_arg(LPCSTR unix_link
)
2778 WCHAR
*unix_linkW
= utf8_chars_to_wchars(unix_link
);
2781 char *escaped_lnk
= escape(unix_linkW
);
2784 ret
= heap_printf("/Unix %s", escaped_lnk
);
2785 HeapFree(GetProcessHeap(), 0, escaped_lnk
);
2787 HeapFree(GetProcessHeap(), 0, unix_linkW
);
2792 static BOOL
InvokeShellLinker( IShellLinkW
*sl
, LPCWSTR link
, BOOL bWait
)
2794 static const WCHAR startW
[] = {'\\','c','o','m','m','a','n','d',
2795 '\\','s','t','a','r','t','.','e','x','e',0};
2796 char *link_name
= NULL
, *icon_name
= NULL
, *work_dir
= NULL
;
2797 char *escaped_path
= NULL
, *escaped_args
= NULL
, *description
= NULL
;
2798 char *wmclass
= NULL
;
2799 WCHAR szTmp
[INFOTIPSIZE
];
2800 WCHAR szDescription
[INFOTIPSIZE
], szPath
[MAX_PATH
], szWorkDir
[MAX_PATH
];
2801 WCHAR szArgs
[INFOTIPSIZE
], szIconPath
[MAX_PATH
], szWMClass
[MAX_PATH
];
2802 int iIconId
= 0, r
= -1;
2805 char *unix_link
= NULL
;
2806 char *start_path
= NULL
;
2810 WINE_ERR("Link name is null\n");
2814 if( !GetLinkLocation( link
, &csidl
, &link_name
) )
2816 WINE_WARN("Unknown link location %s. Ignoring.\n",wine_dbgstr_w(link
));
2819 if (!in_desktop_dir(csidl
) && !in_startmenu(csidl
))
2821 WINE_WARN("Not under desktop or start menu. Ignoring.\n");
2824 WINE_TRACE("Link : %s\n", wine_dbgstr_a(link_name
));
2827 IShellLinkW_GetWorkingDirectory( sl
, szTmp
, MAX_PATH
);
2828 ExpandEnvironmentStringsW(szTmp
, szWorkDir
, MAX_PATH
);
2829 WINE_TRACE("workdir : %s\n", wine_dbgstr_w(szWorkDir
));
2832 IShellLinkW_GetDescription( sl
, szTmp
, INFOTIPSIZE
);
2833 ExpandEnvironmentStringsW(szTmp
, szDescription
, INFOTIPSIZE
);
2834 WINE_TRACE("description: %s\n", wine_dbgstr_w(szDescription
));
2836 get_cmdline( sl
, szTmp
, MAX_PATH
, szArgs
, INFOTIPSIZE
);
2837 ExpandEnvironmentStringsW(szTmp
, szPath
, MAX_PATH
);
2838 WINE_TRACE("path : %s\n", wine_dbgstr_w(szPath
));
2839 WINE_TRACE("args : %s\n", wine_dbgstr_w(szArgs
));
2842 IShellLinkW_GetIconLocation( sl
, szTmp
, MAX_PATH
, &iIconId
);
2843 ExpandEnvironmentStringsW(szTmp
, szIconPath
, MAX_PATH
);
2844 WINE_TRACE("icon file : %s\n", wine_dbgstr_w(szIconPath
) );
2850 LPITEMIDLIST pidl
= NULL
;
2851 IShellLinkW_GetIDList( sl
, &pidl
);
2852 if( pidl
&& SHGetPathFromIDListW( pidl
, szPath
) )
2853 WINE_TRACE("pidl path : %s\n", wine_dbgstr_w(szPath
));
2856 /* extract the icon */
2858 icon_name
= extract_icon( szIconPath
, iIconId
, NULL
, bWait
);
2860 icon_name
= extract_icon( szPath
, iIconId
, NULL
, bWait
);
2862 /* fail - try once again after parent process exit */
2867 WINE_WARN("Unable to extract icon, deferring.\n");
2870 WINE_ERR("failed to extract icon from %s\n",
2871 wine_dbgstr_w( szIconPath
[0] ? szIconPath
: szPath
));
2874 unix_link
= wine_get_unix_file_name(link
);
2875 if (unix_link
== NULL
)
2877 WINE_WARN("couldn't find unix path of %s\n", wine_dbgstr_w(link
));
2881 /* check the path */
2884 static const WCHAR exeW
[] = {'.','e','x','e',0};
2887 /* check for .exe extension */
2888 if (!(p
= strrchrW( szPath
, '.' )) ||
2889 strchrW( p
, '\\' ) || strchrW( p
, '/' ) ||
2890 lstrcmpiW( p
, exeW
))
2892 /* Not .exe - use 'start.exe' to launch this file */
2893 p
= szArgs
+ lstrlenW(szPath
) + 2;
2897 memmove( p
+1, szArgs
, min( (lstrlenW(szArgs
) + 1) * sizeof(szArgs
[0]),
2898 sizeof(szArgs
) - (p
+ 1 - szArgs
) * sizeof(szArgs
[0]) ) );
2904 lstrcpyW(szArgs
+ 1, szPath
);
2905 szArgs
[lstrlenW(szArgs
)] = '"';
2907 GetWindowsDirectoryW(szPath
, MAX_PATH
);
2908 lstrcatW(szPath
, startW
);
2912 /* FIXME: Use AppUserModelID if present. */
2913 WCHAR
*p
= PathFindFileNameW(szPath
);
2915 lstrcpyW(szWMClass
, p
);
2916 CharLowerW(szWMClass
);
2919 /* convert app working dir */
2921 work_dir
= wine_get_unix_file_name( szWorkDir
);
2925 /* if there's no path... try run the link itself */
2926 lstrcpynW(szArgs
, link
, MAX_PATH
);
2927 GetWindowsDirectoryW(szPath
, MAX_PATH
);
2928 lstrcatW(szPath
, startW
);
2931 /* escape the path and parameters */
2932 escaped_path
= escape(szPath
);
2933 escaped_args
= escape(szArgs
);
2934 description
= wchars_to_utf8_chars(szDescription
);
2935 wmclass
= wchars_to_utf8_chars(szWMClass
);
2936 if (escaped_path
== NULL
|| escaped_args
== NULL
|| description
== NULL
|| wmclass
== NULL
)
2938 WINE_ERR("out of memory allocating/escaping parameters\n");
2942 start_path
= get_start_exe_path();
2943 if (start_path
== NULL
)
2945 WINE_ERR("out of memory\n");
2949 /* building multiple menus concurrently has race conditions */
2950 hsem
= CreateSemaphoreA( NULL
, 1, 1, "winemenubuilder_semaphore");
2951 if( WAIT_OBJECT_0
!= MsgWaitForMultipleObjects( 1, &hsem
, FALSE
, INFINITE
, QS_ALLINPUT
) )
2953 WINE_ERR("failed wait for semaphore\n");
2957 if (in_desktop_dir(csidl
))
2960 const char *lastEntry
;
2961 lastEntry
= strrchr(link_name
, '/');
2962 if (lastEntry
== NULL
)
2963 lastEntry
= link_name
;
2966 location
= heap_printf("%s/%s.desktop", xdg_desktop_dir
, lastEntry
);
2969 if (csidl
== CSIDL_COMMON_DESKTOPDIRECTORY
)
2971 char *link_arg
= escape_unix_link_arg(unix_link
);
2974 r
= !write_desktop_entry(unix_link
, location
, lastEntry
,
2975 start_path
, link_arg
, description
, work_dir
, icon_name
, wmclass
);
2976 HeapFree(GetProcessHeap(), 0, link_arg
);
2980 r
= !write_desktop_entry(NULL
, location
, lastEntry
, escaped_path
, escaped_args
, description
, work_dir
, icon_name
, wmclass
);
2982 chmod(location
, 0755);
2983 HeapFree(GetProcessHeap(), 0, location
);
2988 char *link_arg
= escape_unix_link_arg(unix_link
);
2991 r
= !write_menu_entry(unix_link
, link_name
, start_path
, link_arg
, description
, work_dir
, icon_name
, wmclass
);
2992 HeapFree(GetProcessHeap(), 0, link_arg
);
2996 ReleaseSemaphore( hsem
, 1, NULL
);
2999 if (hsem
) CloseHandle( hsem
);
3000 HeapFree( GetProcessHeap(), 0, icon_name
);
3001 HeapFree( GetProcessHeap(), 0, work_dir
);
3002 HeapFree( GetProcessHeap(), 0, link_name
);
3003 HeapFree( GetProcessHeap(), 0, escaped_args
);
3004 HeapFree( GetProcessHeap(), 0, escaped_path
);
3005 HeapFree( GetProcessHeap(), 0, description
);
3006 HeapFree( GetProcessHeap(), 0, wmclass
);
3007 HeapFree( GetProcessHeap(), 0, unix_link
);
3008 HeapFree( GetProcessHeap(), 0, start_path
);
3011 WINE_ERR("failed to build the menu\n" );
3016 static BOOL
InvokeShellLinkerForURL( IUniformResourceLocatorW
*url
, LPCWSTR link
, BOOL bWait
)
3018 char *link_name
= NULL
, *icon_name
= NULL
;
3020 LPWSTR urlPath
= NULL
;
3021 char *escaped_urlPath
= NULL
;
3026 char *unix_link
= NULL
;
3027 IPropertySetStorage
*pPropSetStg
;
3028 IPropertyStorage
*pPropStg
;
3031 char *start_path
= NULL
;
3032 BOOL has_icon
= FALSE
;
3036 WINE_ERR("Link name is null\n");
3040 if( !GetLinkLocation( link
, &csidl
, &link_name
) )
3042 WINE_WARN("Unknown link location %s. Ignoring.\n",wine_dbgstr_w(link
));
3045 if (!in_desktop_dir(csidl
) && !in_startmenu(csidl
))
3047 WINE_WARN("Not under desktop or start menu. Ignoring.\n");
3051 WINE_TRACE("Link : %s\n", wine_dbgstr_a(link_name
));
3053 hr
= url
->lpVtbl
->GetURL(url
, &urlPath
);
3059 WINE_TRACE("path : %s\n", wine_dbgstr_w(urlPath
));
3061 unix_link
= wine_get_unix_file_name(link
);
3062 if (unix_link
== NULL
)
3064 WINE_WARN("couldn't find unix path of %s\n", wine_dbgstr_w(link
));
3068 escaped_urlPath
= escape(urlPath
);
3069 if (escaped_urlPath
== NULL
)
3071 WINE_ERR("couldn't escape url, out of memory\n");
3075 start_path
= get_start_exe_path();
3076 if (start_path
== NULL
)
3078 WINE_ERR("out of memory\n");
3082 ps
[0].ulKind
= PRSPEC_PROPID
;
3083 ps
[0].u
.propid
= PID_IS_ICONFILE
;
3084 ps
[1].ulKind
= PRSPEC_PROPID
;
3085 ps
[1].u
.propid
= PID_IS_ICONINDEX
;
3087 hr
= url
->lpVtbl
->QueryInterface(url
, &IID_IPropertySetStorage
, (void **) &pPropSetStg
);
3090 hr
= IPropertySetStorage_Open(pPropSetStg
, &FMTID_Intshcut
, STGM_READ
| STGM_SHARE_EXCLUSIVE
, &pPropStg
);
3093 hr
= IPropertyStorage_ReadMultiple(pPropStg
, 2, ps
, pv
);
3096 if (pv
[0].vt
== VT_LPWSTR
&& pv
[0].u
.pwszVal
&& pv
[0].u
.pwszVal
[0])
3099 icon_name
= extract_icon( pv
[0].u
.pwszVal
, pv
[1].u
.iVal
, NULL
, bWait
);
3101 WINE_TRACE("URL icon path: %s icon index: %d icon name: %s\n", wine_dbgstr_w(pv
[0].u
.pwszVal
), pv
[1].u
.iVal
, icon_name
);
3103 PropVariantClear(&pv
[0]);
3104 PropVariantClear(&pv
[1]);
3106 IPropertyStorage_Release(pPropStg
);
3108 IPropertySetStorage_Release(pPropSetStg
);
3111 /* fail - try once again after parent process exit */
3112 if( has_icon
&& !icon_name
)
3116 WINE_WARN("Unable to extract icon, deferring.\n");
3120 WINE_ERR("failed to extract icon from %s\n",
3121 wine_dbgstr_w( pv
[0].u
.pwszVal
));
3124 hSem
= CreateSemaphoreA( NULL
, 1, 1, "winemenubuilder_semaphore");
3125 if( WAIT_OBJECT_0
!= MsgWaitForMultipleObjects( 1, &hSem
, FALSE
, INFINITE
, QS_ALLINPUT
) )
3127 WINE_ERR("failed wait for semaphore\n");
3130 if (in_desktop_dir(csidl
))
3133 const char *lastEntry
;
3134 lastEntry
= strrchr(link_name
, '/');
3135 if (lastEntry
== NULL
)
3136 lastEntry
= link_name
;
3139 location
= heap_printf("%s/%s.desktop", xdg_desktop_dir
, lastEntry
);
3142 r
= !write_desktop_entry(NULL
, location
, lastEntry
, start_path
, escaped_urlPath
, NULL
, NULL
, icon_name
, NULL
);
3144 chmod(location
, 0755);
3145 HeapFree(GetProcessHeap(), 0, location
);
3149 r
= !write_menu_entry(unix_link
, link_name
, start_path
, escaped_urlPath
, NULL
, NULL
, icon_name
, NULL
);
3151 ReleaseSemaphore(hSem
, 1, NULL
);
3156 HeapFree( GetProcessHeap(), 0, icon_name
);
3157 HeapFree(GetProcessHeap(), 0, link_name
);
3158 CoTaskMemFree( urlPath
);
3159 HeapFree(GetProcessHeap(), 0, escaped_urlPath
);
3160 HeapFree(GetProcessHeap(), 0, unix_link
);
3164 static BOOL
WaitForParentProcess( void )
3166 PROCESSENTRY32 procentry
;
3167 HANDLE hsnapshot
= NULL
, hprocess
= NULL
;
3168 DWORD ourpid
= GetCurrentProcessId();
3169 BOOL ret
= FALSE
, rc
;
3171 WINE_TRACE("Waiting for parent process\n");
3172 if ((hsnapshot
= CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS
, 0 )) ==
3173 INVALID_HANDLE_VALUE
)
3175 WINE_ERR("CreateToolhelp32Snapshot failed, error %d\n", GetLastError());
3179 procentry
.dwSize
= sizeof(PROCESSENTRY32
);
3180 rc
= Process32First( hsnapshot
, &procentry
);
3183 if (procentry
.th32ProcessID
== ourpid
) break;
3184 rc
= Process32Next( hsnapshot
, &procentry
);
3188 WINE_WARN("Unable to find current process id %d when listing processes\n", ourpid
);
3192 if ((hprocess
= OpenProcess( SYNCHRONIZE
, FALSE
, procentry
.th32ParentProcessID
)) ==
3195 WINE_WARN("OpenProcess failed pid=%d, error %d\n", procentry
.th32ParentProcessID
,
3200 if (MsgWaitForMultipleObjects( 1, &hprocess
, FALSE
, INFINITE
, QS_ALLINPUT
) == WAIT_OBJECT_0
)
3203 WINE_ERR("Unable to wait for parent process, error %d\n", GetLastError());
3206 if (hprocess
) CloseHandle( hprocess
);
3207 if (hsnapshot
) CloseHandle( hsnapshot
);
3211 static BOOL
Process_Link( LPCWSTR linkname
, BOOL bWait
)
3216 WCHAR fullname
[MAX_PATH
];
3219 WINE_TRACE("%s, wait %d\n", wine_dbgstr_w(linkname
), bWait
);
3223 WINE_ERR("link name missing\n");
3227 len
=GetFullPathNameW( linkname
, MAX_PATH
, fullname
, NULL
);
3228 if (len
==0 || len
>MAX_PATH
)
3230 WINE_ERR("couldn't get full path of link file\n");
3234 r
= CoCreateInstance( &CLSID_ShellLink
, NULL
, CLSCTX_INPROC_SERVER
,
3235 &IID_IShellLinkW
, (LPVOID
*) &sl
);
3238 WINE_ERR("No IID_IShellLink\n");
3242 r
= IShellLinkW_QueryInterface( sl
, &IID_IPersistFile
, (LPVOID
*) &pf
);
3245 WINE_ERR("No IID_IPersistFile\n");
3249 r
= IPersistFile_Load( pf
, fullname
, STGM_READ
);
3250 if( SUCCEEDED( r
) )
3252 /* If something fails (eg. Couldn't extract icon)
3253 * wait for parent process and try again
3255 if( ! InvokeShellLinker( sl
, fullname
, bWait
) && bWait
)
3257 WaitForParentProcess();
3258 InvokeShellLinker( sl
, fullname
, FALSE
);
3263 WINE_ERR("unable to load %s\n", wine_dbgstr_w(linkname
));
3266 IPersistFile_Release( pf
);
3267 IShellLinkW_Release( sl
);
3272 static BOOL
Process_URL( LPCWSTR urlname
, BOOL bWait
)
3274 IUniformResourceLocatorW
*url
;
3277 WCHAR fullname
[MAX_PATH
];
3280 WINE_TRACE("%s, wait %d\n", wine_dbgstr_w(urlname
), bWait
);
3284 WINE_ERR("URL name missing\n");
3288 len
=GetFullPathNameW( urlname
, MAX_PATH
, fullname
, NULL
);
3289 if (len
==0 || len
>MAX_PATH
)
3291 WINE_ERR("couldn't get full path of URL file\n");
3295 r
= CoCreateInstance( &CLSID_InternetShortcut
, NULL
, CLSCTX_INPROC_SERVER
,
3296 &IID_IUniformResourceLocatorW
, (LPVOID
*) &url
);
3299 WINE_ERR("No IID_IUniformResourceLocatorW\n");
3303 r
= url
->lpVtbl
->QueryInterface( url
, &IID_IPersistFile
, (LPVOID
*) &pf
);
3306 WINE_ERR("No IID_IPersistFile\n");
3309 r
= IPersistFile_Load( pf
, fullname
, STGM_READ
);
3310 if( SUCCEEDED( r
) )
3312 /* If something fails (eg. Couldn't extract icon)
3313 * wait for parent process and try again
3315 if( ! InvokeShellLinkerForURL( url
, fullname
, bWait
) && bWait
)
3317 WaitForParentProcess();
3318 InvokeShellLinkerForURL( url
, fullname
, FALSE
);
3322 IPersistFile_Release( pf
);
3323 url
->lpVtbl
->Release( url
);
3328 static void RefreshFileTypeAssociations(void)
3331 char *mime_dir
= NULL
;
3332 char *packages_dir
= NULL
;
3333 char *applications_dir
= NULL
;
3336 hSem
= CreateSemaphoreA( NULL
, 1, 1, "winemenubuilder_semaphore");
3337 if( WAIT_OBJECT_0
!= MsgWaitForMultipleObjects( 1, &hSem
, FALSE
, INFINITE
, QS_ALLINPUT
) )
3339 WINE_ERR("failed wait for semaphore\n");
3345 mime_dir
= heap_printf("%s/mime", xdg_data_dir
);
3346 if (mime_dir
== NULL
)
3348 WINE_ERR("out of memory\n");
3351 create_directories(mime_dir
);
3353 packages_dir
= heap_printf("%s/packages", mime_dir
);
3354 if (packages_dir
== NULL
)
3356 WINE_ERR("out of memory\n");
3359 create_directories(packages_dir
);
3361 applications_dir
= heap_printf("%s/applications", xdg_data_dir
);
3362 if (applications_dir
== NULL
)
3364 WINE_ERR("out of memory\n");
3367 create_directories(applications_dir
);
3369 hasChanged
= generate_associations(xdg_data_dir
, packages_dir
, applications_dir
);
3370 hasChanged
|= cleanup_associations();
3373 const char *argv
[3];
3375 argv
[0] = "update-mime-database";
3378 _spawnvp( _P_DETACH
, argv
[0], argv
);
3380 argv
[0] = "update-desktop-database";
3381 argv
[1] = applications_dir
;
3382 _spawnvp( _P_DETACH
, argv
[0], argv
);
3388 ReleaseSemaphore(hSem
, 1, NULL
);
3391 HeapFree(GetProcessHeap(), 0, mime_dir
);
3392 HeapFree(GetProcessHeap(), 0, packages_dir
);
3393 HeapFree(GetProcessHeap(), 0, applications_dir
);
3396 static void cleanup_menus(void)
3400 hkey
= open_menus_reg_key();
3404 LSTATUS lret
= ERROR_SUCCESS
;
3405 for (i
= 0; lret
== ERROR_SUCCESS
; )
3407 WCHAR
*value
= NULL
;
3409 DWORD valueSize
= 4096;
3410 DWORD dataSize
= 4096;
3413 lret
= ERROR_OUTOFMEMORY
;
3414 value
= HeapAlloc(GetProcessHeap(), 0, valueSize
* sizeof(WCHAR
));
3417 data
= HeapAlloc(GetProcessHeap(), 0, dataSize
* sizeof(WCHAR
));
3420 lret
= RegEnumValueW(hkey
, i
, value
, &valueSize
, NULL
, NULL
, (BYTE
*)data
, &dataSize
);
3421 if (lret
!= ERROR_MORE_DATA
)
3425 HeapFree(GetProcessHeap(), 0, value
);
3426 HeapFree(GetProcessHeap(), 0, data
);
3427 value
= data
= NULL
;
3429 if (lret
== ERROR_SUCCESS
)
3433 unix_file
= wchars_to_unix_chars(value
);
3434 windows_file
= wchars_to_unix_chars(data
);
3435 if (unix_file
!= NULL
&& windows_file
!= NULL
)
3437 struct stat filestats
;
3438 if (stat(windows_file
, &filestats
) < 0 && errno
== ENOENT
)
3440 WINE_TRACE("removing menu related file %s\n", unix_file
);
3442 RegDeleteValueW(hkey
, value
);
3449 WINE_ERR("out of memory enumerating menus\n");
3450 lret
= ERROR_OUTOFMEMORY
;
3452 HeapFree(GetProcessHeap(), 0, unix_file
);
3453 HeapFree(GetProcessHeap(), 0, windows_file
);
3455 else if (lret
!= ERROR_NO_MORE_ITEMS
)
3456 WINE_ERR("error %d reading registry\n", lret
);
3457 HeapFree(GetProcessHeap(), 0, value
);
3458 HeapFree(GetProcessHeap(), 0, data
);
3463 WINE_ERR("error opening registry key, menu cleanup failed\n");
3466 static void thumbnail_lnk(LPCWSTR lnkPath
, LPCWSTR outputPath
)
3468 char *utf8lnkPath
= NULL
;
3469 char *utf8OutputPath
= NULL
;
3470 WCHAR
*winLnkPath
= NULL
;
3471 IShellLinkW
*shellLink
= NULL
;
3472 IPersistFile
*persistFile
= NULL
;
3473 WCHAR szTmp
[MAX_PATH
];
3474 WCHAR szPath
[MAX_PATH
];
3475 WCHAR szArgs
[INFOTIPSIZE
];
3476 WCHAR szIconPath
[MAX_PATH
];
3478 IStream
*stream
= NULL
;
3479 ICONDIRENTRY
*pIconDirEntries
= NULL
;
3483 utf8lnkPath
= wchars_to_utf8_chars(lnkPath
);
3484 if (utf8lnkPath
== NULL
)
3486 WINE_ERR("out of memory converting paths\n");
3490 utf8OutputPath
= wchars_to_utf8_chars(outputPath
);
3491 if (utf8OutputPath
== NULL
)
3493 WINE_ERR("out of memory converting paths\n");
3497 winLnkPath
= wine_get_dos_file_name(utf8lnkPath
);
3498 if (winLnkPath
== NULL
)
3500 WINE_ERR("could not convert %s to DOS path\n", utf8lnkPath
);
3504 hr
= CoCreateInstance(&CLSID_ShellLink
, NULL
, CLSCTX_INPROC_SERVER
,
3505 &IID_IShellLinkW
, (LPVOID
*)&shellLink
);
3508 WINE_ERR("could not create IShellLinkW, error 0x%08X\n", hr
);
3512 hr
= IShellLinkW_QueryInterface(shellLink
, &IID_IPersistFile
, (LPVOID
)&persistFile
);
3515 WINE_ERR("could not query IPersistFile, error 0x%08X\n", hr
);
3519 hr
= IPersistFile_Load(persistFile
, winLnkPath
, STGM_READ
);
3522 WINE_ERR("could not read .lnk, error 0x%08X\n", hr
);
3526 get_cmdline(shellLink
, szTmp
, MAX_PATH
, szArgs
, INFOTIPSIZE
);
3527 ExpandEnvironmentStringsW(szTmp
, szPath
, MAX_PATH
);
3529 IShellLinkW_GetIconLocation(shellLink
, szTmp
, MAX_PATH
, &iconId
);
3530 ExpandEnvironmentStringsW(szTmp
, szIconPath
, MAX_PATH
);
3534 LPITEMIDLIST pidl
= NULL
;
3535 IShellLinkW_GetIDList(shellLink
, &pidl
);
3536 if (pidl
&& SHGetPathFromIDListW(pidl
, szPath
))
3537 WINE_TRACE("pidl path : %s\n", wine_dbgstr_w(szPath
));
3542 hr
= open_icon(szIconPath
, iconId
, FALSE
, &stream
, &pIconDirEntries
, &numEntries
);
3544 hr
= write_native_icon(stream
, pIconDirEntries
, numEntries
, utf8OutputPath
, NULL
);
3548 hr
= open_icon(szPath
, iconId
, FALSE
, &stream
, &pIconDirEntries
, &numEntries
);
3550 hr
= write_native_icon(stream
, pIconDirEntries
, numEntries
, utf8OutputPath
, NULL
);
3554 HeapFree(GetProcessHeap(), 0, utf8lnkPath
);
3555 HeapFree(GetProcessHeap(), 0, utf8OutputPath
);
3556 HeapFree(GetProcessHeap(), 0, winLnkPath
);
3557 if (shellLink
!= NULL
)
3558 IShellLinkW_Release(shellLink
);
3559 if (persistFile
!= NULL
)
3560 IPersistFile_Release(persistFile
);
3562 IStream_Release(stream
);
3563 HeapFree(GetProcessHeap(), 0, pIconDirEntries
);
3566 static WCHAR
*next_token( LPWSTR
*p
)
3568 LPWSTR token
= NULL
, t
= *p
;
3573 while( t
&& !token
)
3581 /* unquote the token */
3583 t
= strchrW( token
, '"' );
3592 t
= strchrW( token
, ' ' );
3602 static BOOL
init_xdg(void)
3604 WCHAR shellDesktopPath
[MAX_PATH
];
3605 HRESULT hr
= SHGetFolderPathW(NULL
, CSIDL_DESKTOP
, NULL
, SHGFP_TYPE_CURRENT
, shellDesktopPath
);
3607 xdg_desktop_dir
= wine_get_unix_file_name(shellDesktopPath
);
3608 if (xdg_desktop_dir
== NULL
)
3610 WINE_ERR("error looking up the desktop directory\n");
3614 if (getenv("XDG_CONFIG_HOME"))
3615 xdg_config_dir
= heap_printf("%s/menus/applications-merged", getenv("XDG_CONFIG_HOME"));
3617 xdg_config_dir
= heap_printf("%s/.config/menus/applications-merged", getenv("HOME"));
3620 create_directories(xdg_config_dir
);
3621 if (getenv("XDG_DATA_HOME"))
3622 xdg_data_dir
= strdupA(getenv("XDG_DATA_HOME"));
3624 xdg_data_dir
= heap_printf("%s/.local/share", getenv("HOME"));
3628 create_directories(xdg_data_dir
);
3629 buffer
= heap_printf("%s/desktop-directories", xdg_data_dir
);
3632 mkdir(buffer
, 0777);
3633 HeapFree(GetProcessHeap(), 0, buffer
);
3637 HeapFree(GetProcessHeap(), 0, xdg_config_dir
);
3639 WINE_ERR("out of memory\n");
3643 static BOOL
associations_enabled(void)
3650 if ((hkey
= open_associations_reg_key()))
3653 if (!RegQueryValueExA(hkey
, "Enable", NULL
, NULL
, buf
, &len
))
3654 ret
= IS_OPTION_TRUE(buf
[0]);
3655 RegCloseKey( hkey
);
3661 /***********************************************************************
3665 int PASCAL
wWinMain (HINSTANCE hInstance
, HINSTANCE prev
, LPWSTR cmdline
, int show
)
3667 static const WCHAR dash_aW
[] = {'-','a',0};
3668 static const WCHAR dash_rW
[] = {'-','r',0};
3669 static const WCHAR dash_tW
[] = {'-','t',0};
3670 static const WCHAR dash_uW
[] = {'-','u',0};
3671 static const WCHAR dash_wW
[] = {'-','w',0};
3673 LPWSTR token
= NULL
, p
;
3682 hr
= CoInitialize(NULL
);
3685 WINE_ERR("could not initialize COM, error 0x%08X\n", hr
);
3689 for( p
= cmdline
; p
&& *p
; )
3691 token
= next_token( &p
);
3694 if( !strcmpW( token
, dash_aW
) )
3696 if (associations_enabled())
3697 RefreshFileTypeAssociations();
3700 if( !strcmpW( token
, dash_rW
) )
3705 if( !strcmpW( token
, dash_wW
) )
3707 else if ( !strcmpW( token
, dash_uW
) )
3709 else if ( !strcmpW( token
, dash_tW
) )
3711 WCHAR
*lnkFile
= next_token( &p
);
3714 WCHAR
*outputFile
= next_token( &p
);
3716 thumbnail_lnk(lnkFile
, outputFile
);
3719 else if( token
[0] == '-' )
3721 WINE_ERR( "unknown option %s\n", wine_dbgstr_w(token
) );
3728 bRet
= Process_URL( token
, bWait
);
3730 bRet
= Process_Link( token
, bWait
);
3733 WINE_ERR( "failed to build menu item for %s\n", wine_dbgstr_w(token
) );