utility.cpp

#include "utility.h"
#include <fstream>
#include <algorithm>

LPARAM TreeView_GetItemParam(HWND hwnd, HTREEITEM hti)
{
	TVITEM tvi = {};
	tvi.hItem = hti;
	tvi.mask = TVIF_PARAM;

	TreeView_GetItem(hwnd, &tvi);

	return tvi.lParam;
}

tchar::tstring RegGetFullKeyName(HKEY hRootKey)
{
    tchar::tstring rootName = TEXT("");

    // Map the predefined root keys to their names
    if (hRootKey == HKEY_CLASSES_ROOT)
        rootName = TEXT("HKEY_CLASSES_ROOT");
    else if (hRootKey == HKEY_CURRENT_USER)
        rootName = TEXT("HKEY_CURRENT_USER");
    else if (hRootKey == HKEY_LOCAL_MACHINE)
        rootName = TEXT("HKEY_LOCAL_MACHINE");
    else if (hRootKey == HKEY_USERS)
        rootName = TEXT("HKEY_USERS");
    else if (hRootKey == HKEY_CURRENT_CONFIG)
        rootName = TEXT("HKEY_CURRENT_CONFIG");

    return rootName;
}

tchar::tstring RegGetFullKeyName(HKEY hRootKey, const tchar::tstring& subKey)
{
    tchar::tstring rootName = TEXT("");

    // Map the predefined root keys to their names
    if (hRootKey == HKEY_CLASSES_ROOT)
        rootName = TEXT("HKEY_CLASSES_ROOT");
    else if (hRootKey == HKEY_CURRENT_USER)
        rootName = TEXT("HKEY_CURRENT_USER");
    else if (hRootKey == HKEY_LOCAL_MACHINE)
        rootName = TEXT("HKEY_LOCAL_MACHINE");
    else if (hRootKey == HKEY_USERS)
        rootName = TEXT("HKEY_USERS");
    else if (hRootKey == HKEY_CURRENT_CONFIG)
        rootName = TEXT("HKEY_CURRENT_CONFIG");

    // If subKey is empty, just return the root
    if (subKey.empty())
        return rootName;

    // Otherwise, append the subkey with backslash
    return rootName + TEXT("\\") + subKey;
}

std::vector<std::string> SplitCommandLine(LPCSTR cmdLine)
{
    std::vector<std::string> args;
    std::string current;
    bool inQuotes = false;

    while (*cmdLine) 
    {
        if (*cmdLine == '"')
        {
            inQuotes = !inQuotes;
            ++cmdLine;
        }
        else if (!inQuotes && (*cmdLine == ' ' || *cmdLine == '\t'))
        {
            if (!current.empty())
            {
                args.push_back(current);
                current.clear();
            }
            while (*cmdLine == ' ' || *cmdLine == '\t') ++cmdLine; // skip spaces
        }
        else
        {
            current += *cmdLine++;
        }
    }
    if (!current.empty())
        args.push_back(current);

    return args;
}

BOOL SplitRegistryPath(const tchar::tstring& fullPath, HKEY* outRoot, tchar::tstring* outSubKey)
{
    // Define a mapping from string to HKEY
    struct RootMap { LPCTSTR name; HKEY key; };
    static RootMap roots[] = {
        { TEXT("HKEY_CLASSES_ROOT"), HKEY_CLASSES_ROOT },
        { TEXT("HKCR"), HKEY_CLASSES_ROOT },
        { TEXT("HKEY_CURRENT_USER"), HKEY_CURRENT_USER },
        { TEXT("HKCU"), HKEY_CURRENT_USER },
        { TEXT("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE },
        { TEXT("HKLM"), HKEY_LOCAL_MACHINE },
        { TEXT("HKEY_USERS"), HKEY_USERS },
        { TEXT("HKU"), HKEY_USERS },
        { TEXT("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG },
        { TEXT("HKCC"), HKEY_CURRENT_CONFIG },
        { TEXT("HKEY_DYN_DATA"), HKEY_DYN_DATA },
        { TEXT("HKDD"), HKEY_DYN_DATA },
        { TEXT("HKEY_PERFORMANCE_DATA"), HKEY_PERFORMANCE_DATA },
        { TEXT("HKPD"), HKEY_PERFORMANCE_DATA }
    };

    // Find the first backslash
    size_t pos = fullPath.find(TEXT('\\'));
    tchar::tstring rootStr = (pos == tchar::tstring::npos) ? fullPath : fullPath.substr(0, pos);
    *outSubKey = (pos == tchar::tstring::npos) ? TEXT("") : fullPath.substr(pos + 1);

    // Match root string
    std::transform(rootStr.begin(), rootStr.end(), rootStr.begin(), tchar::totupper);
    for (const auto& r : roots)
    {
        if (rootStr == r.name)
        {
            *outRoot = r.key;
            return TRUE;
        }
    }

    // Not found
    return FALSE;
}

std::vector<tchar::tstring> SplitSubKeys(const tchar::tstring& subKey)
{
    std::vector<tchar::tstring> parts;
    size_t start = 0;
    size_t pos;

    while ((pos = subKey.find(TEXT('\\'), start)) != tchar::tstring::npos)
    {
        parts.push_back(subKey.substr(start, pos - start));
        start = pos + 1;
    }

    if (start < subKey.length())
        parts.push_back(subKey.substr(start));

    return parts;
}

bool IsElevated()
{
    HANDLE hToken;
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
        return false;

    TOKEN_ELEVATION elev{};
    DWORD cb;
    GetTokenInformation(hToken, TokenElevation, &elev, sizeof(elev), &cb);
    CloseHandle(hToken);
    return elev.TokenIsElevated;
}

#ifdef UNICODE
wint_t tchar::totupper(wint_t ch)
{
    return towupper(ch);
}
#else
int tchar::totupper(int ch)
{
    return toupper(ch);
}
#endif

tchar::tstring RemoveMenuAmpersands(const tchar::tstring& s)
{
    tchar::tstring out;
    out.reserve(s.size());

    for (size_t i = 0; i < s.size(); ++i)
    {
        if (s[i] == '&')
        {
            if (i + 1 < s.size() && s[i + 1] == '&')
            {
                out.push_back('&'); // escaped ampersand
                ++i;
            }
            // skip mnemonic '&'
        }
        else
        {
            out.push_back(s[i]);
        }
    }
    return out;
}