Exemplo n.º 1
0
bool DecomposeLnk ( Str_c & sPath, Str_c & sParams, bool & bDir )
{
	wchar_t szTarget [MAX_PATH];
	if ( ! SHGetShortcutTarget ( sPath, szTarget, MAX_PATH ) )
		return false;

	sPath = szTarget;
	sPath.RTrim ();

	if ( sPath.Begins ( L"\"" ) )
	{
		int iPos = sPath.Find ( L'\"', 1 );
		if ( iPos == -1 )
			return false;

		if ( iPos + 1 < sPath.Length () )
			sParams = sPath.SubStr ( iPos + 1 );

		sPath.Chop ( sPath.Length () - iPos - 1 );
	}
	else
	{
		int iPos = sPath.Find ( L' ' );
		if ( iPos != -1 )
		{
			sParams = sPath.SubStr ( iPos );
			sPath.Chop ( sPath.Length () - iPos );
		}
	}

	sParams.LTrim ();

	Str_c sPathNoQuotes = sPath;
	sPathNoQuotes.Strip ( L'\"' );
	DWORD dwAttributes = GetFileAttributes ( sPathNoQuotes );
	if ( dwAttributes == 0xFFFFFFFF )
	{
		bDir = false;
		return true;
	}

	bDir = !!( dwAttributes & FILE_ATTRIBUTE_DIRECTORY );
	return true;
}
Exemplo n.º 2
0
HICON GetApplicationIcon(WCHAR* szFilteredPath, bool bSmall, WCHAR* wzExeFile, WCHAR* wzWndText, WCHAR* wzClassName)
{
    WCHAR szEXEPath[MAX_PATH];
    HICON hIcon = NULL;

    if (wzExeFile && wzClassName)
    {
        WCHAR wzRegPath[MAX_PATH];
        HKEY hKey;

        wcscpy(wzRegPath, L"Software\\HTC\\TaskManager\\NoIconProcess");

        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, wzRegPath, 0,KEY_READ,&hKey))
        {
            HKEY hKeyProc;
            if (ERROR_SUCCESS == RegOpenKeyEx(hKey, wzExeFile, 0,KEY_READ,&hKeyProc))
            {
                HKEY hKeyClass;
                if (ERROR_SUCCESS == RegOpenKeyEx(hKeyProc, L"NoClass", 0,KEY_READ,&hKeyClass))
                {
                    RegCloseKey(hKeyClass);
                }
                else
                {
                    if (ERROR_SUCCESS == RegOpenKeyEx(hKeyProc, wzClassName, 0,KEY_READ,&hKeyClass))
                    {
                        WCHAR wzRegValue[MAX_PATH];
                        DWORD dwRegPath = MAX_PATH;
                        DWORD dwRegValue = MAX_PATH * sizeof(WCHAR);
                        if (ERROR_SUCCESS == RegEnumValue(hKeyClass, 0, wzRegPath, &dwRegPath, NULL, NULL, (LPBYTE)wzRegValue, &dwRegValue))
                        {
                            ExtractIconEx(wzRegPath, _wtoi(wzRegValue), NULL, &hIcon, 1);

                            if (hIcon)
                            {
                                return hIcon;
                            }
                        }
                        RegCloseKey(hKeyClass);
                    }
                }
                RegCloseKey(hKeyProc);
            }
            RegCloseKey(hKey);
        }
    }

    if (wzWndText)
    {
        if (SHGetSpecialFolderPath(NULL, szEXEPath, CSIDL_PROGRAMS, FALSE))
        {
            TrimEndSpaces(wzWndText);
            wcscat(szEXEPath, L"\\");
            if (FindLnkIcon(szFilteredPath, szEXEPath, wzWndText))
            {
                Sleep(0);
            }
        }
    }

    WCHAR* wzExt = wcsrchr(szFilteredPath, L'.');

    if (wzExt && 0 == wcsicmp(wzExt, L".lnk"))
    {
        SHGetShortcutTarget(szFilteredPath, szEXEPath, MAX_PATH);

        WCHAR* szEXEPath2 = szEXEPath;
        szEXEPath2 = TrimSpaces(szEXEPath2);

        int iIndex = 0;
        if (!hIcon)
        {
            FILE* hFile = _wfopen(szFilteredPath, L"r");

            if (hFile)
            {
                char szLnkData[500];
                memset(szLnkData, 0, sizeof(szLnkData));
                fread(szLnkData, sizeof(char), sizeof(szLnkData), hFile);
                fclose(hFile);

                char* szQuestion = strchr(szLnkData, '?');

                if (szQuestion)
                {
                    szQuestion++;
                    char* szComma = strchr(szLnkData, ',');

                    if (szComma)
                    {
                        szComma[0] = '\0';
                        szComma++;

                        int cCharacters =  strlen(szQuestion)+1;
                        int iIcon = atoi(szComma);
                        WCHAR* pszW = (LPOLESTR)CoTaskMemAlloc(cCharacters*2);
                        MultiByteToWideChar(CP_ACP, 0, szQuestion, cCharacters, pszW, cCharacters);
                        ExtractIconEx(pszW, iIcon, (bSmall) ? NULL : &hIcon, (!bSmall) ? NULL : &hIcon, 1);
                        CoTaskMemFree(pszW);
                    }
                }
                else
                {
                    char* szColon = strstr(szLnkData, "#:");

                    if (szColon)
                    {
                        szColon++;

                        char* szNewLine = strchr(szLnkData, '\r');
                        if (szNewLine)
                        {
                            szNewLine[0] = '\0';
                        }
                        szNewLine = strchr(szLnkData, '\n');
                        if (szNewLine)
                        {
                            szNewLine[0] = '\0';
                        }

                        WCHAR wzRegPath[MAX_PATH];
                        int cCharacters =  strlen(szColon)+1;
                        WCHAR* pszW = (LPOLESTR)CoTaskMemAlloc(cCharacters*2);
                        MultiByteToWideChar(CP_ACP, 0, szColon, cCharacters, pszW, cCharacters);
                        
                        wcscpy(wzRegPath, L"Software\\Microsoft\\Shell\\Rai\\");
                        wcscat(wzRegPath, pszW);

                        CoTaskMemFree(pszW);

                        HKEY hKey;
                        
                        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, wzRegPath, 0,KEY_READ,&hKey))
                        {
                            DWORD dwSize;
                            DWORD dwType;
                            dwSize = sizeof(wzRegPath);
                            dwType = REG_SZ;

                            RegQueryValueEx(hKey, L"1",0,&dwType,(LPBYTE)wzRegPath,&dwSize);

                            WCHAR* wzRegPath2 = TrimSpaces(wzRegPath);
                            ExtractIconEx(wzRegPath2, 0, (bSmall) ? NULL : &hIcon, (!bSmall) ? NULL : &hIcon, 1);
                        }
                    }
                }
            }
        }

        if (!hIcon)
        {
            ExtractIconEx(szEXEPath2, 0, (bSmall) ? NULL : &hIcon, (!bSmall) ? NULL : &hIcon, 1);
        }
    }
    else
    {
        ExtractIconEx(szFilteredPath, 0, (bSmall) ? NULL : &hIcon, (!bSmall) ? NULL : &hIcon, 1);
    }

    return hIcon;
}