diff --git a/ExplorerPatcher/ExplorerPatcher.vcxproj b/ExplorerPatcher/ExplorerPatcher.vcxproj index f4b3253..fa95f09 100644 --- a/ExplorerPatcher/ExplorerPatcher.vcxproj +++ b/ExplorerPatcher/ExplorerPatcher.vcxproj @@ -259,6 +259,7 @@ true true + true @@ -315,6 +316,7 @@ + diff --git a/ExplorerPatcher/ExplorerPatcher.vcxproj.filters b/ExplorerPatcher/ExplorerPatcher.vcxproj.filters index 085f776..b775f65 100644 --- a/ExplorerPatcher/ExplorerPatcher.vcxproj.filters +++ b/ExplorerPatcher/ExplorerPatcher.vcxproj.filters @@ -126,6 +126,9 @@ Header Files + + Header Files + @@ -205,6 +208,9 @@ Source Files\sws + + Source Files + diff --git a/ExplorerPatcher/GUI.c b/ExplorerPatcher/GUI.c index 23acec3..b38f333 100644 --- a/ExplorerPatcher/GUI.c +++ b/ExplorerPatcher/GUI.c @@ -382,6 +382,30 @@ LSTATUS GUI_Internal_RegSetValueExW( ); return RegSetValueExW(hKey, L"Start_MaximumFrequentApps", 0, dwType, lpData, cbData); } + else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_StartDocked_DisableRecommendedSection")) + { + RegSetKeyValueW( + HKEY_CURRENT_USER, + TEXT(REGPATH_OLD), + L"StartDocked_DisableRecommendedSection", + dwType, + lpData, + cbData + ); + return RegSetValueExW(hKey, L"StartDocked_DisableRecommendedSection", 0, dwType, lpData, cbData); + } + else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_StartUI_EnableRoundedCorners")) + { + RegSetKeyValueW( + HKEY_CURRENT_USER, + TEXT(REGPATH_OLD), + L"StartUI_EnableRoundedCorners", + dwType, + lpData, + cbData + ); + return RegSetValueExW(hKey, L"StartUI_EnableRoundedCorners", 0, dwType, lpData, cbData); + } else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_DisableRoundedCorners")) { return RegisterDWMService(*(DWORD*)lpData, 0); @@ -573,6 +597,14 @@ LSTATUS GUI_Internal_RegQueryValueExW( { return RegQueryValueExW(hKey, L"Start_MaximumFrequentApps", lpReserved, lpType, lpData, lpcbData); } + else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_StartDocked_DisableRecommendedSection")) + { + return RegQueryValueExW(hKey, L"StartDocked_DisableRecommendedSection", lpReserved, lpType, lpData, lpcbData); + } + else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_StartUI_EnableRoundedCorners")) + { + return RegQueryValueExW(hKey, L"StartUI_EnableRoundedCorners", lpReserved, lpType, lpData, lpcbData); + } else if (!wcscmp(lpValueName, L"Virtualized_" _T(EP_CLSID) L"_DisableRoundedCorners")) { HANDLE h_exists = CreateEventW(NULL, FALSE, FALSE, _T(EP_DWM_EVENTNAME)); diff --git a/ExplorerPatcher/dllmain.c b/ExplorerPatcher/dllmain.c index d360d1e..e0aa1ab 100644 --- a/ExplorerPatcher/dllmain.c +++ b/ExplorerPatcher/dllmain.c @@ -24,6 +24,7 @@ #include #include #include +#include "lvt.h" #ifdef _WIN64 #include #endif @@ -8998,6 +8999,10 @@ char VisibilityChangedEventArguments_GetVisible(__int64 a1) DWORD StartMenu_maximumFreqApps = 6; DWORD StartMenu_ShowAllApps = 0; +DWORD StartDocked_DisableRecommendedSection = FALSE; +DWORD StartDocked_DisableRecommendedSectionApply = TRUE; +DWORD StartUI_EnableRoundedCorners = FALSE; +DWORD StartUI_EnableRoundedCornersApply = TRUE; void StartMenu_LoadSettings(BOOL bRestartIfChanged) { @@ -9064,6 +9069,39 @@ void StartMenu_LoadSettings(BOOL bRestartIfChanged) exit(0); } StartMenu_maximumFreqApps = dwVal; + + dwSize = sizeof(DWORD); + dwVal = FALSE; + RegQueryValueExW( + hKey, + TEXT("StartDocked_DisableRecommendedSection"), + 0, + NULL, + &dwVal, + &dwSize + ); + if (dwVal != StartDocked_DisableRecommendedSection) + { + StartDocked_DisableRecommendedSection = dwVal; + StartDocked_DisableRecommendedSectionApply = TRUE; + } + + dwSize = sizeof(DWORD); + dwVal = FALSE; + RegQueryValueExW( + hKey, + TEXT("StartUI_EnableRoundedCorners"), + 0, + NULL, + &dwVal, + &dwSize + ); + if (dwVal != StartUI_EnableRoundedCorners) + { + StartUI_EnableRoundedCorners = dwVal; + StartUI_EnableRoundedCornersApply = TRUE; + } + RegCloseKey(hKey); } @@ -9168,7 +9206,7 @@ INT64 StartDocked_StartSizingFrame_StartSizingFrameHook(void* _this) return rv; } -HANDLE start_CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) +HANDLE StartUI_CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) { WCHAR path[MAX_PATH]; GetWindowsDirectoryW(path, MAX_PATH); @@ -9192,7 +9230,7 @@ HANDLE start_CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShar return CreateFileW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile); } -BOOL start_GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) +BOOL StartUI_GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) { WCHAR path[MAX_PATH]; GetWindowsDirectoryW(path, MAX_PATH); @@ -9216,7 +9254,7 @@ BOOL start_GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfo return GetFileAttributesExW(lpFileName, fInfoLevelId, lpFileInformation); } -HANDLE start_FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) +HANDLE StartUI_FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) { WCHAR path[MAX_PATH]; GetWindowsDirectoryW(path, MAX_PATH); @@ -9240,7 +9278,7 @@ HANDLE start_FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileDat return FindFirstFileW(lpFileName, lpFindFileData); } -LSTATUS start_RegGetValueW(HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData) +LSTATUS StartUI_RegGetValueW(HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData) { if (hkey == HKEY_LOCAL_MACHINE && !_wcsicmp(lpSubKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Mrt\\_Merged") && !_wcsicmp(lpValue, L"ShouldMergeInProc")) { @@ -9250,11 +9288,33 @@ LSTATUS start_RegGetValueW(HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue, DWORD d return RegGetValueW(hkey, lpSubKey, lpValue, dwFlags, pdwType, pvData, pcbData); } -int start_SetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw) +int StartUI_SetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw) { DWORD dwThisPID = GetCurrentProcessId(), dwForeignPID = 0; GetWindowThreadProcessId(GetForegroundWindow(), &dwForeignPID); - ShowWindow(hWnd, (!hRgn && dwThisPID != dwForeignPID) ? SW_HIDE : SW_SHOW); + BOOL bStartIsHiding = (!hRgn && dwThisPID != dwForeignPID); + ShowWindow(hWnd, bStartIsHiding ? SW_HIDE : SW_SHOW); + if (!bStartIsHiding && StartUI_EnableRoundedCornersApply) + { + LVT_StartUI_EnableRoundedCorners(hWnd, StartUI_EnableRoundedCorners); + if (!StartUI_EnableRoundedCorners) + { + StartUI_EnableRoundedCornersApply = FALSE; + } + } + return SetWindowRgn(hWnd, hRgn, bRedraw); +} + +int StartDocked_SetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw) +{ + DWORD dwThisPID = GetCurrentProcessId(), dwForeignPID = 0; + GetWindowThreadProcessId(GetForegroundWindow(), &dwForeignPID); + BOOL bStartIsHiding = (!hRgn && dwThisPID != dwForeignPID); + if (!bStartIsHiding && StartDocked_DisableRecommendedSectionApply) + { + LVT_StartDocked_DisableRecommendedSection(hWnd, StartDocked_DisableRecommendedSection); + StartDocked_DisableRecommendedSectionApply = FALSE; + } return SetWindowRgn(hWnd, hRgn, bRedraw); } @@ -9682,7 +9742,7 @@ void InjectStartMenu() if (dwStartShowClassicMode) { // Fixes hang when Start menu closes - VnPatchDelayIAT(hStartUI, "ext-ms-win-ntuser-draw-l1-1-0.dll", "SetWindowRgn", start_SetWindowRgn); + VnPatchDelayIAT(hStartUI, "ext-ms-win-ntuser-draw-l1-1-0.dll", "SetWindowRgn", StartUI_SetWindowRgn); // Redirects to StartTileData from 22000.51 which works with the legacy menu LoadLibraryW(L"combase.dll"); @@ -9692,10 +9752,14 @@ void InjectStartMenu() // Redirects to pri files from 22000.51 which work with the legacy menu LoadLibraryW(L"MrmCoreR.dll"); HANDLE hMrmCoreR = GetModuleHandleW(L"MrmCoreR.dll"); - VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "CreateFileW", start_CreateFileW); - VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "GetFileAttributesExW", start_GetFileAttributesExW); - VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "FindFirstFileW", start_FindFirstFileW); - VnPatchIAT(hMrmCoreR, "api-ms-win-core-registry-l1-1-0.dll", "RegGetValueW", start_RegGetValueW); + VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "CreateFileW", StartUI_CreateFileW); + VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "GetFileAttributesExW", StartUI_GetFileAttributesExW); + VnPatchIAT(hMrmCoreR, "api-ms-win-core-file-l1-1-0.dll", "FindFirstFileW", StartUI_FindFirstFileW); + VnPatchIAT(hMrmCoreR, "api-ms-win-core-registry-l1-1-0.dll", "RegGetValueW", StartUI_RegGetValueW); + } + else + { + VnPatchDelayIAT(hStartDocked, "ext-ms-win-ntuser-draw-l1-1-0.dll", "SetWindowRgn", StartDocked_SetWindowRgn); } Setting* settings = calloc(4, sizeof(Setting)); diff --git a/ExplorerPatcher/lvt.c b/ExplorerPatcher/lvt.c new file mode 100644 index 0000000..038af48 --- /dev/null +++ b/ExplorerPatcher/lvt.c @@ -0,0 +1,570 @@ +#include "lvt.h" + +Windows_UI_Xaml_IDependencyObject* LVT_FindChildByClassName(Windows_UI_Xaml_IDependencyObject* pRootDependencyObject, Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics, LPCWSTR pwszRefName, INT* prevIndex) +{ + if (!pRootDependencyObject) + { + return NULL; + } + + //WCHAR wszDebug[MAX_PATH]; + HRESULT hr = S_OK; + INT32 Count = -1; + hr = pVisualTreeHelperStatics->lpVtbl->GetChildrenCount(pVisualTreeHelperStatics, pRootDependencyObject, &Count); + if (SUCCEEDED(hr)) + { + for (INT32 Index = (prevIndex ? *prevIndex : 0); Index < Count; ++Index) + { + Windows_UI_Xaml_IDependencyObject* pChild = NULL; + hr = pVisualTreeHelperStatics->lpVtbl->GetChild(pVisualTreeHelperStatics, pRootDependencyObject, Index, &pChild); + if (SUCCEEDED(hr)) + { + HSTRING hsChild = NULL; + pChild->lpVtbl->GetRuntimeClassName(pChild, &hsChild); + if (SUCCEEDED(hr)) + { + PCWSTR pwszName = WindowsGetStringRawBuffer(hsChild, 0); + //swprintf_s(wszDebug, MAX_PATH, L"Name: %s\n", pwszName); + //OutputDebugStringW(wszDebug); + if (!_wcsicmp(pwszName, pwszRefName)) + { + WindowsDeleteString(hsChild); + if (prevIndex) *prevIndex = Index + 1; + return pChild; + } + WindowsDeleteString(hsChild); + } + pChild->lpVtbl->Release(pChild); + } + } + } + + if (prevIndex) *prevIndex = Count; + return NULL; +} + +Windows_UI_Xaml_IDependencyObject* LVT_FindChildByName(Windows_UI_Xaml_IDependencyObject* pRootDependencyObject, Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics, LPCWSTR pwszRefName) +{ + if (!pRootDependencyObject) + { + return NULL; + } + + //WCHAR wszDebug[MAX_PATH]; + HRESULT hr = S_OK; + INT32 Count = -1; + hr = pVisualTreeHelperStatics->lpVtbl->GetChildrenCount(pVisualTreeHelperStatics, pRootDependencyObject, &Count); + if (SUCCEEDED(hr)) + { + for (INT32 Index = 0; Index < Count; ++Index) + { + Windows_UI_Xaml_IDependencyObject* pChild = NULL; + hr = pVisualTreeHelperStatics->lpVtbl->GetChild(pVisualTreeHelperStatics, pRootDependencyObject, Index, &pChild); + if (SUCCEEDED(hr)) + { + Windows_UI_Xaml_IFrameworkElement* pFrameworkElement = NULL; + hr = pChild->lpVtbl->QueryInterface(pChild, &IID_Windows_UI_Xaml_IFrameworkElement, &pFrameworkElement); + if (SUCCEEDED(hr)) + { + HSTRING hsChild = NULL; + pFrameworkElement->lpVtbl->get_Name(pFrameworkElement, &hsChild); + if (SUCCEEDED(hr)) + { + PCWSTR pwszName = WindowsGetStringRawBuffer(hsChild, 0); + //swprintf_s(wszDebug, MAX_PATH, L"Name: %s\n", pwszName); + //OutputDebugStringW(wszDebug); + if (!_wcsicmp(pwszName, pwszRefName)) + { + WindowsDeleteString(hsChild); + pFrameworkElement->lpVtbl->Release(pFrameworkElement); + return pChild; + } + WindowsDeleteString(hsChild); + } + pFrameworkElement->lpVtbl->Release(pFrameworkElement); + } + pChild->lpVtbl->Release(pChild); + } + } + } + + return NULL; +} + +// Referenece: https://www.reddit.com/r/Windows10/comments/nvcrie/windows_11_start_menu_how_to_temporary_make_your/ +void LVT_StartUI_EnableRoundedCorners(HWND hWnd, BOOL bApply) +{ + WCHAR wszDebug[MAX_PATH]; + HRESULT hr = S_OK; + + Windows_UI_Xaml_IDependencyObject* pRootDependencyObject = NULL; + Windows_UI_Xaml_Controls_ICanvasStatics* pCanvasStatics = NULL; + + if (SUCCEEDED(hr)) + { + HSTRING_HEADER hshControlsCanvasStatics; + HSTRING hsControlsCanvasStatics = NULL; + hr = WindowsCreateStringReference(L"Windows.UI.Xaml.Controls.Canvas", 31, &hshControlsCanvasStatics, &hsControlsCanvasStatics); + if (SUCCEEDED(hr) && hsControlsCanvasStatics) + { + hr = RoGetActivationFactory(hsControlsCanvasStatics, &IID_Windows_UI_Xaml_Controls_ICanvasStatics, &pCanvasStatics); + WindowsDeleteString(hsControlsCanvasStatics); + } + } + + if (SUCCEEDED(hr)) + { + HSTRING_HEADER hshWindowStatics; + HSTRING hsWindowStatics = NULL; + hr = WindowsCreateStringReference(L"Windows.UI.Xaml.Window", 22, &hshWindowStatics, &hsWindowStatics); + if (SUCCEEDED(hr) && hsWindowStatics) + { + Windows_UI_Xaml_IWindowStatics* pWindowStatics = NULL; + hr = RoGetActivationFactory(hsWindowStatics, &IID_Windows_UI_Xaml_IWindowStatics, &pWindowStatics); + if (SUCCEEDED(hr)) + { + Windows_UI_Xaml_IWindow* pWindow = NULL; + hr = pWindowStatics->lpVtbl->get_Current(pWindowStatics, &pWindow); + if (SUCCEEDED(hr)) + { + IInspectable* pUIElement = NULL; + hr = pWindow->lpVtbl->get_Content(pWindow, &pUIElement); + if (SUCCEEDED(hr)) + { + hr = pUIElement->lpVtbl->QueryInterface(pUIElement, &IID_Windows_UI_Xaml_IDependencyObject, &pRootDependencyObject); + + pUIElement->lpVtbl->Release(pUIElement); + } + pWindow->lpVtbl->Release(pWindow); + } + pWindowStatics->lpVtbl->Release(pWindowStatics); + } + WindowsDeleteString(hsWindowStatics); + } + } + + if (pRootDependencyObject) + { + HSTRING_HEADER hshVisualTreeHelperStatics; + HSTRING hsVisualTreeHelperStatics = NULL; + hr = WindowsCreateStringReference(L"Windows.UI.Xaml.Media.VisualTreeHelper", 38, &hshVisualTreeHelperStatics, &hsVisualTreeHelperStatics); + if (SUCCEEDED(hr) && hsVisualTreeHelperStatics) + { + Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics = NULL; + hr = RoGetActivationFactory(hsVisualTreeHelperStatics, &IID_Windows_UI_Xaml_IVisualTreeHelperStatics, &pVisualTreeHelperStatics); + if (SUCCEEDED(hr)) + { + Windows_UI_Xaml_IDependencyObject* pStartSizingFrame = LVT_FindChildByClassName(pRootDependencyObject, pVisualTreeHelperStatics, L"StartUI.StartSizingFrame", NULL); + if (pStartSizingFrame) + { + Windows_UI_Xaml_IDependencyObject* pStartSizingFramePanel = LVT_FindChildByClassName(pStartSizingFrame, pVisualTreeHelperStatics, L"StartUI.StartSizingFramePanel", NULL); + if (pStartSizingFramePanel) + { + // Drop shadow + Windows_UI_Xaml_IDependencyObject* pDropShadow = LVT_FindChildByClassName(pStartSizingFramePanel, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Image", NULL); + if (pDropShadow) + { + Windows_UI_Xaml_IUIElement* pIUIElement = NULL; + pDropShadow->lpVtbl->QueryInterface(pDropShadow, &IID_Windows_UI_Xaml_IUIElement, &pIUIElement); + if (pIUIElement) + { + if (bApply) + { + pIUIElement->lpVtbl->put_Visibility(pIUIElement, Windows_UI_Xaml_Visibility_Collapsed); + } + else + { + pIUIElement->lpVtbl->put_Visibility(pIUIElement, Windows_UI_Xaml_Visibility_Visible); + } + pIUIElement->lpVtbl->Release(pIUIElement); + } + pDropShadow->lpVtbl->Release(pDropShadow); + } + Windows_UI_Xaml_IDependencyObject* pContentPresenter = LVT_FindChildByClassName(pStartSizingFramePanel, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.ContentPresenter", NULL); + if (pContentPresenter) + { + Windows_UI_Xaml_IDependencyObject* pFrame = LVT_FindChildByClassName(pContentPresenter, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Frame", NULL); + if (pFrame) + { + // Main menu padding + Windows_UI_Xaml_Controls_IControl* pIBorder = NULL; + pFrame->lpVtbl->QueryInterface(pFrame, &IID_Windows_UI_Xaml_Controls_IControl, &pIBorder); + if (pIBorder) + { + Windows_UI_Xaml_Thickness th; + th.Left = (bApply ? 10.0 : 0.0); + th.Bottom = th.Left; + th.Right = th.Left; + th.Top = th.Left; + pIBorder->lpVtbl->put_Padding(pIBorder, th); + pIBorder->lpVtbl->Release(pIBorder); + } + Windows_UI_Xaml_IDependencyObject* pContentPresenter2 = LVT_FindChildByClassName(pFrame, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.ContentPresenter", NULL); + if (pContentPresenter2) + { + Windows_UI_Xaml_IDependencyObject* pSplitViewFrame = LVT_FindChildByClassName(pContentPresenter2, pVisualTreeHelperStatics, L"StartUI.SplitViewFrame", NULL); + if (pSplitViewFrame) + { + Windows_UI_Xaml_IDependencyObject* pRootGrid = LVT_FindChildByName(pSplitViewFrame, pVisualTreeHelperStatics, L"RootGrid"); + if (pRootGrid) + { + // Main menu corners + Windows_UI_Xaml_IDependencyObject* pAcrylicBorder = LVT_FindChildByName(pRootGrid, pVisualTreeHelperStatics, L"AcrylicBorder"); + if (pAcrylicBorder) + { + Windows_UI_Xaml_Controls_IBorder* pIBorder = NULL; + pAcrylicBorder->lpVtbl->QueryInterface(pAcrylicBorder, &IID_Windows_UI_Xaml_Controls_IBorder, &pIBorder); + if (pIBorder) + { + Windows_UI_Xaml_CornerRadius cr; + cr.BottomLeft = (bApply ? 10.0 : 0.0); + cr.BottomRight = cr.BottomLeft; + cr.TopLeft = cr.BottomLeft; + cr.TopRight = cr.BottomLeft; + pIBorder->lpVtbl->put_CornerRadius(pIBorder, cr); + pIBorder->lpVtbl->Release(pIBorder); + } + pAcrylicBorder->lpVtbl->Release(pAcrylicBorder); + } + // Live tiles corners + Windows_UI_Xaml_IDependencyObject* pRootContent = LVT_FindChildByName(pRootGrid, pVisualTreeHelperStatics, L"RootContent"); + if (pRootContent) + { + Windows_UI_Xaml_IDependencyObject* pGrid = LVT_FindChildByClassName(pRootContent, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Grid", NULL); + if (pGrid) + { + Windows_UI_Xaml_IDependencyObject* pContentRoot = LVT_FindChildByName(pGrid, pVisualTreeHelperStatics, L"ContentRoot"); + if (pContentRoot) + { + Windows_UI_Xaml_IDependencyObject* pBorder = LVT_FindChildByClassName(pContentRoot, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Border", NULL); + if (pBorder) + { + Windows_UI_Xaml_IDependencyObject* pContentPaneGrid = LVT_FindChildByName(pBorder, pVisualTreeHelperStatics, L"ContentPaneGrid"); + if (pContentPaneGrid) + { + Windows_UI_Xaml_IDependencyObject* pGridPane = LVT_FindChildByName(pContentPaneGrid, pVisualTreeHelperStatics, L"GridPane"); + if (pGridPane) + { + Windows_UI_Xaml_IDependencyObject* ppage = LVT_FindChildByName(pGridPane, pVisualTreeHelperStatics, L"page"); + if (ppage) + { + Windows_UI_Xaml_IDependencyObject* pgridRoot = LVT_FindChildByName(ppage, pVisualTreeHelperStatics, L"gridRoot"); + if (pgridRoot) + { + Windows_UI_Xaml_IDependencyObject* pgroupItems = LVT_FindChildByName(pgridRoot, pVisualTreeHelperStatics, L"groupItems"); + if (pgroupItems) + { + Windows_UI_Xaml_IDependencyObject* pBorder2 = LVT_FindChildByClassName(pgroupItems, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Border", NULL); + if (pBorder2) + { + Windows_UI_Xaml_IDependencyObject* pScrollViewer = LVT_FindChildByName(pBorder2, pVisualTreeHelperStatics, L"ScrollViewer"); + if (pScrollViewer) + { + Windows_UI_Xaml_IDependencyObject* pBorder3 = LVT_FindChildByClassName(pScrollViewer, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Border", NULL); + if (pBorder3) + { + Windows_UI_Xaml_IDependencyObject* pGrid2 = LVT_FindChildByClassName(pBorder3, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Grid", NULL); + if (pGrid2) + { + Windows_UI_Xaml_IDependencyObject* pScrollContentPresenter = LVT_FindChildByName(pGrid2, pVisualTreeHelperStatics, L"ScrollContentPresenter"); + if (pScrollContentPresenter) + { + Windows_UI_Xaml_IDependencyObject* pItemsPresenter = LVT_FindChildByClassName(pScrollContentPresenter, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.ItemsPresenter", NULL); + if (pItemsPresenter) + { + Windows_UI_Xaml_IDependencyObject* pTileGrid = LVT_FindChildByClassName(pItemsPresenter, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.TileGrid", NULL); + if (pTileGrid) + { + INT iIndex = 0; + BOOL bSkipFirst = TRUE; + while (TRUE) + { + Windows_UI_Xaml_IDependencyObject* pCurrentGroup = LVT_FindChildByClassName(pTileGrid, pVisualTreeHelperStatics, L"StartUI.TileListViewItem", &iIndex); + if (!pCurrentGroup) + { + break; + } + if (bSkipFirst) + { + bSkipFirst = FALSE; + pCurrentGroup->lpVtbl->Release(pCurrentGroup); + continue; + } + Windows_UI_Xaml_IDependencyObject* pcontentPresenter = LVT_FindChildByName(pCurrentGroup, pVisualTreeHelperStatics, L"contentPresenter"); + if (pcontentPresenter) + { + Windows_UI_Xaml_IDependencyObject* pTileGroupViewControl = LVT_FindChildByClassName(pcontentPresenter, pVisualTreeHelperStatics, L"StartUI.TileGroupViewControl", NULL); + if (pTileGroupViewControl) + { + Windows_UI_Xaml_IDependencyObject* pGrid3 = LVT_FindChildByClassName(pTileGroupViewControl, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Grid", NULL); + if (pGrid3) + { + Windows_UI_Xaml_IDependencyObject* pNestedPanel = LVT_FindChildByName(pGrid3, pVisualTreeHelperStatics, L"NestedPanel"); + if (pNestedPanel) + { + INT jIndex = 0; + while (TRUE) + { + Windows_UI_Xaml_IDependencyObject* pCurrentTile = LVT_FindChildByClassName(pNestedPanel, pVisualTreeHelperStatics, L"StartUI.TileListViewItem", &jIndex); + if (!pCurrentTile) + { + break; + } + Windows_UI_Xaml_IDependencyObject* pcontentPresenter2 = LVT_FindChildByName(pCurrentTile, pVisualTreeHelperStatics, L"contentPresenter"); + if (pcontentPresenter2) + { + Windows_UI_Xaml_IDependencyObject* pTileViewControl = LVT_FindChildByClassName(pcontentPresenter2, pVisualTreeHelperStatics, L"StartUI.TileViewControl", NULL); + if (pTileViewControl) + { + Windows_UI_Xaml_Controls_IGrid2* pIGrid2 = NULL; + pTileViewControl->lpVtbl->QueryInterface(pTileViewControl, &IID_Windows_UI_Xaml_Controls_IGrid2, &pIGrid2); + if (pIGrid2) + { + Windows_UI_Xaml_CornerRadius cr; + cr.BottomLeft = (bApply ? 5.0 : 0.0); + cr.BottomRight = cr.BottomLeft; + cr.TopLeft = cr.BottomLeft; + cr.TopRight = cr.BottomLeft; + pIGrid2->lpVtbl->put_CornerRadius(pIGrid2, cr); + pIGrid2->lpVtbl->Release(pIGrid2); + } + pTileViewControl->lpVtbl->Release(pTileViewControl); + } + pcontentPresenter2->lpVtbl->Release(pcontentPresenter2); + } + pCurrentTile->lpVtbl->Release(pCurrentTile); + } + pNestedPanel->lpVtbl->Release(pNestedPanel); + } + pGrid3->lpVtbl->Release(pGrid3); + } + pTileGroupViewControl->lpVtbl->Release(pTileGroupViewControl); + } + pcontentPresenter->lpVtbl->Release(pcontentPresenter); + } + pCurrentGroup->lpVtbl->Release(pCurrentGroup); + } + pTileGrid->lpVtbl->Release(pTileGrid); + } + pItemsPresenter->lpVtbl->Release(pItemsPresenter); + } + pScrollContentPresenter->lpVtbl->Release(pScrollContentPresenter); + } + pGrid2->lpVtbl->Release(pGrid2); + } + pBorder3->lpVtbl->Release(pBorder3); + } + pScrollViewer->lpVtbl->Release(pScrollViewer); + } + pBorder2->lpVtbl->Release(pBorder2); + } + pgroupItems->lpVtbl->Release(pgroupItems); + } + pgridRoot->lpVtbl->Release(pgridRoot); + } + ppage->lpVtbl->Release(ppage); + } + pGridPane->lpVtbl->Release(pGridPane); + } + pContentPaneGrid->lpVtbl->Release(pContentPaneGrid); + } + pBorder->lpVtbl->Release(pBorder); + } + pContentRoot->lpVtbl->Release(pContentRoot); + } + pGrid->lpVtbl->Release(pGrid); + } + pRootContent->lpVtbl->Release(pRootContent); + } + pRootGrid->lpVtbl->Release(pRootGrid); + } + pSplitViewFrame->lpVtbl->Release(pSplitViewFrame); + } + pContentPresenter2->lpVtbl->Release(pContentPresenter2); + } + pFrame->lpVtbl->Release(pFrame); + } + pContentPresenter->lpVtbl->Release(pContentPresenter); + } + pStartSizingFramePanel->lpVtbl->Release(pStartSizingFramePanel); + } + pStartSizingFrame->lpVtbl->Release(pStartSizingFrame); + } + pVisualTreeHelperStatics->lpVtbl->Release(pVisualTreeHelperStatics); + } + WindowsDeleteString(hsVisualTreeHelperStatics); + } + pRootDependencyObject->lpVtbl->Release(pRootDependencyObject); + } + + if (pCanvasStatics) + { + pCanvasStatics->lpVtbl->Release(pCanvasStatics); + } +} + +// Reference: https://www.reddit.com/r/Windows11/comments/p1ksou/this_is_not_a_concept_microsoft_in_windows_11/ +void LVT_StartDocked_DisableRecommendedSection(HWND hWnd, BOOL bApply) +{ + WCHAR wszDebug[MAX_PATH]; + HRESULT hr = S_OK; + + Windows_UI_Xaml_IDependencyObject* pRootDependencyObject = NULL; + + if (SUCCEEDED(hr)) + { + HSTRING_HEADER hshWindowStatics; + HSTRING hsWindowStatics = NULL; + hr = WindowsCreateStringReference(L"Windows.UI.Xaml.Window", 22, &hshWindowStatics, &hsWindowStatics); + if (SUCCEEDED(hr) && hsWindowStatics) + { + Windows_UI_Xaml_IWindowStatics* pWindowStatics = NULL; + hr = RoGetActivationFactory(hsWindowStatics, &IID_Windows_UI_Xaml_IWindowStatics, &pWindowStatics); + if (SUCCEEDED(hr)) + { + Windows_UI_Xaml_IWindow* pWindow = NULL; + hr = pWindowStatics->lpVtbl->get_Current(pWindowStatics, &pWindow); + if (SUCCEEDED(hr)) + { + IInspectable* pUIElement = NULL; + hr = pWindow->lpVtbl->get_Content(pWindow, &pUIElement); + if (SUCCEEDED(hr)) + { + hr = pUIElement->lpVtbl->QueryInterface(pUIElement, &IID_Windows_UI_Xaml_IDependencyObject, &pRootDependencyObject); + + pUIElement->lpVtbl->Release(pUIElement); + } + pWindow->lpVtbl->Release(pWindow); + } + pWindowStatics->lpVtbl->Release(pWindowStatics); + } + WindowsDeleteString(hsWindowStatics); + } + } + + if (pRootDependencyObject) + { + HSTRING_HEADER hshVisualTreeHelperStatics; + HSTRING hsVisualTreeHelperStatics = NULL; + hr = WindowsCreateStringReference(L"Windows.UI.Xaml.Media.VisualTreeHelper", 38, &hshVisualTreeHelperStatics, &hsVisualTreeHelperStatics); + if (SUCCEEDED(hr) && hsVisualTreeHelperStatics) + { + Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics = NULL; + hr = RoGetActivationFactory(hsVisualTreeHelperStatics, &IID_Windows_UI_Xaml_IVisualTreeHelperStatics, &pVisualTreeHelperStatics); + if (SUCCEEDED(hr)) + { + Windows_UI_Xaml_IDependencyObject* pStartSizingFrame = LVT_FindChildByClassName(pRootDependencyObject, pVisualTreeHelperStatics, L"StartDocked.StartSizingFrame", NULL); + if (pStartSizingFrame) + { + Windows_UI_Xaml_IDependencyObject* pStartSizingFramePanel = LVT_FindChildByClassName(pStartSizingFrame, pVisualTreeHelperStatics, L"StartDocked.StartSizingFramePanel", NULL); + if (pStartSizingFramePanel) + { + Windows_UI_Xaml_IDependencyObject* pContentPresenter = LVT_FindChildByClassName(pStartSizingFramePanel, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.ContentPresenter", NULL); + if (pContentPresenter) + { + Windows_UI_Xaml_IDependencyObject* pFrame = LVT_FindChildByClassName(pContentPresenter, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.Frame", NULL); + if (pFrame) + { + Windows_UI_Xaml_IDependencyObject* pContentPresenter2 = LVT_FindChildByClassName(pFrame, pVisualTreeHelperStatics, L"Windows.UI.Xaml.Controls.ContentPresenter", NULL); + if (pContentPresenter2) + { + Windows_UI_Xaml_IDependencyObject* pLauncherFrame = LVT_FindChildByClassName(pContentPresenter2, pVisualTreeHelperStatics, L"StartDocked.LauncherFrame", NULL); + if (pLauncherFrame) + { + Windows_UI_Xaml_IDependencyObject* pRootGrid = LVT_FindChildByName(pLauncherFrame, pVisualTreeHelperStatics, L"RootGrid"); + if (pRootGrid) + { + Windows_UI_Xaml_IDependencyObject* pRootContent = LVT_FindChildByName(pRootGrid, pVisualTreeHelperStatics, L"RootContent"); + if (pRootContent) + { + Windows_UI_Xaml_IDependencyObject* pMainContent = LVT_FindChildByName(pRootContent, pVisualTreeHelperStatics, L"MainContent"); + if (pMainContent) + { + Windows_UI_Xaml_IDependencyObject* pUndockedRoot = LVT_FindChildByName(pMainContent, pVisualTreeHelperStatics, L"UndockedRoot"); + if (pUndockedRoot) + { + Windows_UI_Xaml_IDependencyObject* pStartInnerFrame = LVT_FindChildByClassName(pUndockedRoot, pVisualTreeHelperStatics, L"StartMenu.StartInnerFrame", NULL); + if (pStartInnerFrame) + { + Windows_UI_Xaml_IDependencyObject* pFrameRoot = LVT_FindChildByName(pStartInnerFrame, pVisualTreeHelperStatics, L"FrameRoot"); + if (pFrameRoot) + { + Windows_UI_Xaml_IDependencyObject* pTopLevelRoot = LVT_FindChildByName(pFrameRoot, pVisualTreeHelperStatics, L"TopLevelRoot"); + if (pTopLevelRoot) + { + Windows_UI_Xaml_IDependencyObject* pStartMenuPinnedList = LVT_FindChildByName(pTopLevelRoot, pVisualTreeHelperStatics, L"StartMenuPinnedList"); + if (pStartMenuPinnedList) + { + Windows_UI_Xaml_IFrameworkElement* pFrameworkElement = NULL; + pStartMenuPinnedList->lpVtbl->QueryInterface(pStartMenuPinnedList, &IID_Windows_UI_Xaml_IFrameworkElement, &pFrameworkElement); + if (pFrameworkElement) + { + if (bApply) + { + pFrameworkElement->lpVtbl->put_Height(pFrameworkElement, 510.0); + } + else + { + pFrameworkElement->lpVtbl->put_Height(pFrameworkElement, 252.0); + } + pFrameworkElement->lpVtbl->Release(pFrameworkElement); + } + Windows_UI_Xaml_IDependencyObject* pRoot = LVT_FindChildByName(pStartMenuPinnedList, pVisualTreeHelperStatics, L"Root"); + if (pRoot) + { + Windows_UI_Xaml_IDependencyObject* pPinnedListPipsPager = LVT_FindChildByName(pRoot, pVisualTreeHelperStatics, L"PinnedListPipsPager"); + if (pPinnedListPipsPager) + { + Windows_UI_Xaml_IUIElement* pIUIElement = NULL; + pPinnedListPipsPager->lpVtbl->QueryInterface(pPinnedListPipsPager, &IID_Windows_UI_Xaml_IUIElement, &pIUIElement); + if (pIUIElement) + { + if (bApply) + { + pIUIElement->lpVtbl->put_Visibility(pIUIElement, Windows_UI_Xaml_Visibility_Collapsed); + } + else + { + pIUIElement->lpVtbl->put_Visibility(pIUIElement, Windows_UI_Xaml_Visibility_Visible); + } + pIUIElement->lpVtbl->Release(pIUIElement); + } + pPinnedListPipsPager->lpVtbl->Release(pPinnedListPipsPager); + } + pRoot->lpVtbl->Release(pRoot); + } + pStartMenuPinnedList->lpVtbl->Release(pStartMenuPinnedList); + } + pTopLevelRoot->lpVtbl->Release(pTopLevelRoot); + } + pFrameRoot->lpVtbl->Release(pFrameRoot); + } + pStartInnerFrame->lpVtbl->Release(pStartInnerFrame); + } + pUndockedRoot->lpVtbl->Release(pUndockedRoot); + } + pMainContent->lpVtbl->Release(pMainContent); + } + pRootContent->lpVtbl->Release(pRootContent); + } + pRootGrid->lpVtbl->Release(pRootGrid); + } + pLauncherFrame->lpVtbl->Release(pLauncherFrame); + } + pContentPresenter2->lpVtbl->Release(pContentPresenter2); + } + pFrame->lpVtbl->Release(pFrame); + } + pContentPresenter->lpVtbl->Release(pContentPresenter); + } + pStartSizingFramePanel->lpVtbl->Release(pStartSizingFramePanel); + } + pStartSizingFrame->lpVtbl->Release(pStartSizingFrame); + } + pVisualTreeHelperStatics->lpVtbl->Release(pVisualTreeHelperStatics); + } + WindowsDeleteString(hsVisualTreeHelperStatics); + } + pRootDependencyObject->lpVtbl->Release(pRootDependencyObject); + } +} \ No newline at end of file diff --git a/ExplorerPatcher/lvt.h b/ExplorerPatcher/lvt.h new file mode 100644 index 0000000..2b60d8a --- /dev/null +++ b/ExplorerPatcher/lvt.h @@ -0,0 +1,935 @@ +#ifndef _H_LVT_H_ +#define _H_LVT_H_ +#include +#include +#include +#include +#include +#include + +typedef struct _Windows_UI_Xaml_CornerRadius +{ + double TopLeft; + double TopRight; + double BottomRight; + double BottomLeft; +} Windows_UI_Xaml_CornerRadius; + +typedef struct _Windows_UI_Xaml_Thickness +{ + double Left; + double Top; + double Right; + double Bottom; +} Windows_UI_Xaml_Thickness; + +typedef enum _Windows_UI_Xaml_Visibility +{ + Windows_UI_Xaml_Visibility_Visible = 0, + Windows_UI_Xaml_Visibility_Collapsed = 1 +} Windows_UI_Xaml_Visibility; + +#pragma region "Windows.UI.Xaml.IWindowStatics" + +DEFINE_GUID(IID_Windows_UI_Xaml_IWindowStatics, + 0x93328409, 0x4ea1, 0x4afa, 0x83, 0xdc, 0x0c, 0x4e, 0x73, 0xe8, 0x8b, 0xb1); + +typedef interface Windows_UI_Xaml_IWindowStatics Windows_UI_Xaml_IWindowStatics; + +typedef struct Windows_UI_Xaml_IWindowStatics_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_Current)( + __RPC__in Windows_UI_Xaml_IWindowStatics* This, + /* [out] */ __RPC__out void** value + ); + + END_INTERFACE +} Windows_UI_Xaml_IWindowStatics_Vtbl; + +interface Windows_UI_Xaml_IWindowStatics // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IWindowStatics_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.IWindow" + +typedef interface Windows_UI_Xaml_IWindow Windows_UI_Xaml_IWindow; + +typedef struct Windows_UI_Xaml_IWindow_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IWindow* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IWindow* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_Bounds)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__out RECT* value + ); + + HRESULT(STDMETHODCALLTYPE* get_Visible)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__out BOOL* value + ); + + HRESULT(STDMETHODCALLTYPE* get_Content)( + __RPC__in Windows_UI_Xaml_IWindow* This, + /* [out] */ __RPC__out IInspectable** value + ); + + END_INTERFACE +} Windows_UI_Xaml_IWindow_Vtbl; + +interface Windows_UI_Xaml_IWindow // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IWindow_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.IDependencyObject" + +DEFINE_GUID(IID_Windows_UI_Xaml_IDependencyObject, + 0x5c526665, 0xf60e, 0x4912, 0xaf, 0x59, 0x5f, 0xe0, 0x68, 0x0f, 0x08, 0x9d); + +typedef interface Windows_UI_Xaml_IDependencyObject Windows_UI_Xaml_IDependencyObject; + +typedef struct Windows_UI_Xaml_IDependencyObject_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* GetValue)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [in] */ __RPC__in IInspectable* dp, + /* [out] */ __RPC__out IInspectable** result); + + HRESULT(STDMETHODCALLTYPE* SetValue)( + __RPC__in Windows_UI_Xaml_IDependencyObject* This, + /* [in] */ __RPC__in IInspectable* dp, + /* [in] */ __RPC__in IInspectable* value); + + END_INTERFACE +} Windows_UI_Xaml_IDependencyObject_Vtbl; + +interface Windows_UI_Xaml_IDependencyObject // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IDependencyObject_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.IVisualTreeHelperStatics" + +DEFINE_GUID(IID_Windows_UI_Xaml_IVisualTreeHelperStatics, + 0xe75758c4, 0xd25d, 0x4b1d, 0x97, 0x1f, 0x59, 0x6f, 0x17, 0xf1, 0x2b, 0xaa); + +typedef interface Windows_UI_Xaml_IVisualTreeHelperStatics Windows_UI_Xaml_IVisualTreeHelperStatics; + +typedef struct Windows_UI_Xaml_IVisualTreeHelperStatics_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* FindElementsInHostCoordinatesPoint)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + HRESULT(STDMETHODCALLTYPE* FindElementsInHostCoordinatesRect)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + HRESULT(STDMETHODCALLTYPE* FindAllElementsInHostCoordinatesPoint)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + HRESULT(STDMETHODCALLTYPE* FindAllElementsInHostCoordinatesRect)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + HRESULT(STDMETHODCALLTYPE* GetChild)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IDependencyObject* reference, + /* [in] */ __RPC__in INT32 childIndex, + /* [out] */ __RPC__out Windows_UI_Xaml_IDependencyObject* result); + + HRESULT(STDMETHODCALLTYPE* GetChildrenCount)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IDependencyObject* reference, + /* [out] */ __RPC__out INT32* result); + + HRESULT(STDMETHODCALLTYPE* GetParent)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IDependencyObject* reference, + /* [out] */ __RPC__out Windows_UI_Xaml_IDependencyObject** result); + + HRESULT(STDMETHODCALLTYPE* DisconnectChildrenRecursive)( + __RPC__in Windows_UI_Xaml_IVisualTreeHelperStatics* This); + + END_INTERFACE +} Windows_UI_Xaml_IVisualTreeHelperStatics_Vtbl; + +interface Windows_UI_Xaml_IVisualTreeHelperStatics // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IVisualTreeHelperStatics_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.IFrameworkElement" + +DEFINE_GUID(IID_Windows_UI_Xaml_IFrameworkElement, + 0xa391d09b, 0x4a99, 0x4b7c, 0x9d, 0x8d, 0x6f, 0xa5, 0xd0, 0x1f, 0x6f, 0xbf); + +typedef interface Windows_UI_Xaml_IFrameworkElement Windows_UI_Xaml_IFrameworkElement; + +typedef struct Windows_UI_Xaml_IFrameworkElement_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_Triggers)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Resources)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Resources)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Tag)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Tag)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Language)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Language)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_ActualWidth)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out DOUBLE* value); + + HRESULT(STDMETHODCALLTYPE* get_ActualHeight)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out DOUBLE* value); + + HRESULT(STDMETHODCALLTYPE* get_Width)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out DOUBLE* value); + + HRESULT(STDMETHODCALLTYPE* put_Width)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [in] */ __RPC__in DOUBLE value); + + HRESULT(STDMETHODCALLTYPE* get_Height)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__out DOUBLE* value); + + HRESULT(STDMETHODCALLTYPE* put_Height)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [in] */ __RPC__in DOUBLE value); + + HRESULT(STDMETHODCALLTYPE* get_MinWidth)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_MinWidth)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_MaxWidth)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_MaxWidth)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_MinHeight)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_MinHeight)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_MaxHeight)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_MaxHeight)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_HorizontalAlignment)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_HorizontalAlignment)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_VerticalAlignment)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_VerticalAlignment)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Margin)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Margin)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Name)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This, + /* [out] */ __RPC__deref_out_opt HSTRING* value); + + HRESULT(STDMETHODCALLTYPE* put_Name)( + __RPC__in Windows_UI_Xaml_IFrameworkElement* This); + + // ... + + END_INTERFACE +} Windows_UI_Xaml_IFrameworkElement_Vtbl; + +interface Windows_UI_Xaml_IFrameworkElement // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IFrameworkElement_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.Controls.IGrid2" + +DEFINE_GUID(IID_Windows_UI_Xaml_Controls_IGrid2, + 0xf76efa41, 0x380e, 0x45db, 0xbe, 0x87, 0x9e, 0x13, 0x26, 0xba, 0x4b, 0x57); + +typedef interface Windows_UI_Xaml_Controls_IGrid2 Windows_UI_Xaml_Controls_IGrid2; + +typedef struct Windows_UI_Xaml_Controls_IGrid2_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* get_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* get_CornerRadius)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [out] */ __RPC__deref_out_opt Windows_UI_Xaml_CornerRadius* value); + + HRESULT(STDMETHODCALLTYPE* put_CornerRadius)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This, + /* [in] */ __RPC__in Windows_UI_Xaml_CornerRadius value); + + HRESULT(STDMETHODCALLTYPE* get_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + HRESULT(STDMETHODCALLTYPE* put_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IGrid2* This); + + END_INTERFACE +} Windows_UI_Xaml_Controls_IGrid2_Vtbl; + +interface Windows_UI_Xaml_Controls_IGrid2 // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_Controls_IGrid2_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.Controls.IBorder" + +DEFINE_GUID(IID_Windows_UI_Xaml_Controls_IBorder, + 0x797c4539, 0x45bd, 0x4633, 0xa0, 0x44, 0xbf, 0xb0, 0x2e, 0xf5, 0x17, 0x0f); + +typedef interface Windows_UI_Xaml_Controls_IBorder Windows_UI_Xaml_Controls_IBorder; + +typedef struct Windows_UI_Xaml_Controls_IBorder_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* get_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* get_Background)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_Background)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* get_CornerRadius)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [out] */ __RPC__deref_out_opt Windows_UI_Xaml_CornerRadius* value); + + HRESULT(STDMETHODCALLTYPE* put_CornerRadius)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This, + /* [in] */ __RPC__in Windows_UI_Xaml_CornerRadius value); + + HRESULT(STDMETHODCALLTYPE* get_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* get_Child)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_Child)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* get_ChildTransitions)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + HRESULT(STDMETHODCALLTYPE* put_ChildTransitions)( + __RPC__in Windows_UI_Xaml_Controls_IBorder* This); + + END_INTERFACE +} Windows_UI_Xaml_Controls_IBorder_Vtbl; + +interface Windows_UI_Xaml_Controls_IBorder // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_Controls_IBorder_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.Controls.IControl" + +DEFINE_GUID(IID_Windows_UI_Xaml_Controls_IControl, + 0xa8912263, 0x2951, 0x4f58, 0xa9, 0xc5, 0x5a, 0x13, 0x4e, 0xaa, 0x7f, 0x07); + +typedef interface Windows_UI_Xaml_Controls_IControl Windows_UI_Xaml_Controls_IControl; + +typedef struct Windows_UI_Xaml_Controls_IControl_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_FontSize)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_FontSize)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_FontFamily)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_FontFamily)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_FontWeight)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_FontWeight)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_FontStyle)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_FontStyle)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_FontStretch)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_FontStretch)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_CharacterSpacing)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_CharacterSpacing)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_Foreground)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_Foreground)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_IsTabStop)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_IsTabStop)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_IsEnabled)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_IsEnabled)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_TabIndex)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_TabIndex)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_TabNavigation)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_TabNavigation)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_Template)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_Template)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [out] */ __RPC__out Windows_UI_Xaml_Thickness* value); + + HRESULT(STDMETHODCALLTYPE* put_Padding)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This, + /* [in] */ __RPC__in Windows_UI_Xaml_Thickness value); + + HRESULT(STDMETHODCALLTYPE* get_HorizontalContentAlignment)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_HorizontalContentAlignment)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_VerticalContentAlignment)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_VerticalContentAlignment)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_Background)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_Background)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderThickness)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* put_BorderBrush)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* get_FocusState)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* add_IsEnabledChanged)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* remove_IsEnabledChanged)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* ApplyTemplate)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + HRESULT(STDMETHODCALLTYPE* Focus)( + __RPC__in Windows_UI_Xaml_Controls_IControl* This); + + END_INTERFACE +} Windows_UI_Xaml_Controls_IControl_Vtbl; + +interface Windows_UI_Xaml_Controls_IControl // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_Controls_IControl_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.IUIElement" + +DEFINE_GUID(IID_Windows_UI_Xaml_IUIElement, + 0x676d0be9, 0xb65c, 0x41c6, 0xba, 0x40, 0x58, 0xcf, 0x87, 0xf2, 0x01, 0xc1); + +typedef interface Windows_UI_Xaml_IUIElement Windows_UI_Xaml_IUIElement; + +typedef struct Windows_UI_Xaml_IUIElement_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_DesiredSize)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_AllowDrop)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_AllowDrop)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Opacity)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Opacity)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Clip)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Clip)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_RenderTransform)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_RenderTransform)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Projection)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_Projection)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_RenderTransformOrigin)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_RenderTransformOrigin)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_IsHitTestVisible)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* put_IsHitTestVisible)( + __RPC__in Windows_UI_Xaml_IUIElement* This); + + HRESULT(STDMETHODCALLTYPE* get_Visibility)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [out] */ __RPC__out Windows_UI_Xaml_Visibility* value); + + HRESULT(STDMETHODCALLTYPE* put_Visibility)( + __RPC__in Windows_UI_Xaml_IUIElement* This, + /* [in] */ __RPC__in Windows_UI_Xaml_Visibility value); + + // ... + + END_INTERFACE +} Windows_UI_Xaml_IUIElement_Vtbl; + +interface Windows_UI_Xaml_IUIElement // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_IUIElement_Vtbl* lpVtbl; +}; +#pragma endregion + +#pragma region "Windows.UI.Xaml.Controls.ICanvasStatics" + +DEFINE_GUID(IID_Windows_UI_Xaml_Controls_ICanvasStatics, + 0x40ce5c46, 0x2962, 0x446f, 0xaa, 0xfb, 0x4c, 0xdc, 0x48, 0x69, 0x39, 0xc9); + +typedef interface Windows_UI_Xaml_Controls_ICanvasStatics Windows_UI_Xaml_Controls_ICanvasStatics; + +typedef struct Windows_UI_Xaml_Controls_ICanvasStatics_Vtbl +{ + BEGIN_INTERFACE + + HRESULT(STDMETHODCALLTYPE* QueryInterface)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void** ppvObject); + + ULONG(STDMETHODCALLTYPE* AddRef)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This); + + ULONG(STDMETHODCALLTYPE* Release)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This); + + HRESULT(STDMETHODCALLTYPE* GetIids)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__out ULONG* iidCount, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*iidCount) IID** iids); + + HRESULT(STDMETHODCALLTYPE* GetRuntimeClassName)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__deref_out_opt HSTRING* className); + + HRESULT(STDMETHODCALLTYPE* GetTrustLevel)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__out TrustLevel* trustLevel); + + HRESULT(STDMETHODCALLTYPE* get_LeftProperty)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__out IInspectable** value); + + HRESULT(STDMETHODCALLTYPE* GetLeft)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [out] */ __RPC__out DOUBLE* result); + + HRESULT(STDMETHODCALLTYPE* SetLeft)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [in] */ __RPC__in DOUBLE length); + + HRESULT(STDMETHODCALLTYPE* get_TopProperty)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__out IInspectable** value); + + HRESULT(STDMETHODCALLTYPE* GetTop)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [out] */ __RPC__out DOUBLE* result); + + HRESULT(STDMETHODCALLTYPE* SetTop)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [in] */ __RPC__in DOUBLE length); + + HRESULT(STDMETHODCALLTYPE* get_ZIndexProperty)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [out] */ __RPC__out IInspectable** value); + + HRESULT(STDMETHODCALLTYPE* GetZIndex)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [out] */ __RPC__out INT32* result); + + HRESULT(STDMETHODCALLTYPE* SetZIndex)( + __RPC__in Windows_UI_Xaml_Controls_ICanvasStatics* This, + /* [in] */ __RPC__in Windows_UI_Xaml_IUIElement* element, + /* [in] */ __RPC__in INT32 value); + + END_INTERFACE +} Windows_UI_Xaml_Controls_ICanvasStatics_Vtbl; + +interface Windows_UI_Xaml_Controls_ICanvasStatics // : IInspectable +{ + CONST_VTBL struct Windows_UI_Xaml_Controls_ICanvasStatics_Vtbl* lpVtbl; +}; +#pragma endregion + +Windows_UI_Xaml_IDependencyObject* LVT_FindChildByClassName(Windows_UI_Xaml_IDependencyObject* pRootDependencyObject, Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics, LPCWSTR pwszRefName, INT* prevIndex); + +Windows_UI_Xaml_IDependencyObject* LVT_FindChildByName(Windows_UI_Xaml_IDependencyObject* pRootDependencyObject, Windows_UI_Xaml_IVisualTreeHelperStatics* pVisualTreeHelperStatics, LPCWSTR pwszRefName); + +void LVT_StartUI_EnableRoundedCorners(HWND, BOOL); + +void LVT_StartDocked_DisableRecommendedSection(HWND, BOOL); +#endif \ No newline at end of file diff --git a/ExplorerPatcher/settings.reg b/ExplorerPatcher/settings.reg index eca610e..bbebb2f 100644 --- a/ExplorerPatcher/settings.reg +++ b/ExplorerPatcher/settings.reg @@ -175,9 +175,6 @@ "Start_ShowClassicMode"=dword:00000000 ;y More Start menu options in the Settings app 🡕 ;ms-settings:personalization-start -[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\StartPage] -;b Open Start at logon -"OpenAtLogon"=dword:00000000 [HKEY_CURRENT_USER\Software\ExplorerPatcher] ;c 22 Maximum number of frequent apps to show ;x 0 None @@ -218,6 +215,9 @@ ;x 9 Monitor #9 "MonitorOverride"=dword:00000001 ;t The following settings only apply to the Windows 11 Start menu: +[HKEY_CURRENT_USER\Software\ExplorerPatcher] +;b Disable the "Recommended" section +;"Virtualized_{D17F1E1A-5919-4427-8F89-A1A8503CA3EB}_StartDocked_DisableRecommendedSection"=dword:00000000 [HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\StartPage] ;b Open Start in All apps by default "MakeAllAppsDefault"=dword:00000000 @@ -226,6 +226,11 @@ ;x 0 Left ;x 1 Center (default) "TaskbarAl"=dword:00000001 +;t The following settings only apply to the Windows 10 Start menu: +[HKEY_CURRENT_USER\Software\ExplorerPatcher] +;b Enable rounded corners +;"Virtualized_{D17F1E1A-5919-4427-8F89-A1A8503CA3EB}_StartUI_EnableRoundedCorners"=dword:00000000 + ;T Window switcher diff --git a/ExplorerPatcher/settings10.reg b/ExplorerPatcher/settings10.reg index fa8845a..910ff74 100644 --- a/ExplorerPatcher/settings10.reg +++ b/ExplorerPatcher/settings10.reg @@ -149,6 +149,8 @@ ;T Start menu +;y More Start menu options in the Settings app 🡕 +;ms-settings:personalization-start [HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\StartPage] ;e When using multiple displays, open Start on this monitor when invoked using ;z 10 the keyboard: @@ -163,8 +165,6 @@ ;x 8 Monitor #8 ;x 9 Monitor #9 "MonitorOverride"=dword:00000001 -;e If the selected monitor is not available, Start will open on the primary display. - ;T Window switcher [HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer]