1931 lines
73 KiB
C++
1931 lines
73 KiB
C++
/***************************************************************************
|
|
* dll.c
|
|
*
|
|
* Standard DLL entry-point functions
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "shellprv.h"
|
|
|
|
#include <ntpsapi.h> // for NtQuery
|
|
#include <ntverp.h>
|
|
#include <advpub.h> // For REGINSTALL
|
|
#include "fstreex.h"
|
|
#include "ids.h"
|
|
#include "filefldr.h"
|
|
#include "uemapp.h"
|
|
#include <xpsp1res.h>
|
|
|
|
#define DECL_CRTFREE
|
|
#include <crtfree.h>
|
|
|
|
#define INSTALL_MSI 1
|
|
#include <msi.h> // For MSI_Install()
|
|
void MSI_Install(LPTSTR pszMSIFile);
|
|
|
|
void DoFusion();
|
|
STDAPI_(void) Control_FillCache_RunDLL( HWND hwndStub, HINSTANCE hAppInstance, LPSTR pszCmdLine, int nCmdShow );
|
|
BOOL CopyRegistryValues (HKEY hKeyBaseSource, LPCTSTR pszSource, HKEY hKeyBaseTarget, LPCTSTR pszTarget);
|
|
|
|
// DllGetVersion - New for IE 4.0 shell integrated mode
|
|
//
|
|
// All we have to do is declare this puppy and CCDllGetVersion does the rest
|
|
//
|
|
DLLVER_DUALBINARY(VER_PRODUCTVERSION_DW, VER_PRODUCTBUILD_QFE);
|
|
|
|
HRESULT CallRegInstall(LPCSTR szSection)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HINSTANCE hinstAdvPack = LoadLibrary(TEXT("ADVPACK.DLL"));
|
|
if (hinstAdvPack)
|
|
{
|
|
REGINSTALL pfnri = (REGINSTALL)GetProcAddress(hinstAdvPack, "RegInstall");
|
|
if (pfnri)
|
|
{
|
|
char szShdocvwPath[MAX_PATH];
|
|
STRENTRY seReg[] = {
|
|
{ "SHDOCVW_PATH", szShdocvwPath },
|
|
{ "25", "%SystemRoot%" },
|
|
{ "11", "%SystemRoot%\\system32" },
|
|
};
|
|
STRTABLE stReg = { ARRAYSIZE(seReg), seReg };
|
|
|
|
// Get the location of shdocvw.dll
|
|
lstrcpyA(szShdocvwPath, "%SystemRoot%\\system32");
|
|
PathAppendA(szShdocvwPath, "shdocvw.dll");
|
|
|
|
hr = pfnri(g_hinst, szSection, &stReg);
|
|
}
|
|
// since we only do this from DllInstall() don't load and unload advpack over and over
|
|
// FreeLibrary(hinstAdvPack);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL UnregisterTypeLibrary(const CLSID* piidLibrary)
|
|
{
|
|
TCHAR szScratch[GUIDSTR_MAX];
|
|
HKEY hk;
|
|
BOOL f = FALSE;
|
|
|
|
// convert the libid into a string.
|
|
//
|
|
SHStringFromGUID(*piidLibrary, szScratch, ARRAYSIZE(szScratch));
|
|
|
|
if (RegOpenKey(HKEY_CLASSES_ROOT, TEXT("TypeLib"), &hk) == ERROR_SUCCESS)
|
|
{
|
|
f = RegDeleteKey(hk, szScratch);
|
|
RegCloseKey(hk);
|
|
}
|
|
|
|
return f;
|
|
}
|
|
|
|
HRESULT Shell32RegTypeLib(void)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
WCHAR wszPath[MAX_PATH];
|
|
|
|
// Load and register our type library.
|
|
//
|
|
GetModuleFileName(HINST_THISDLL, szPath, ARRAYSIZE(szPath));
|
|
SHTCharToUnicode(szPath, wszPath, ARRAYSIZE(wszPath));
|
|
|
|
ITypeLib *pTypeLib;
|
|
HRESULT hr = LoadTypeLib(wszPath, &pTypeLib);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// call the unregister type library as we had some old junk that
|
|
// was registered by a previous version of OleAut32, which is now causing
|
|
// the current version to not work on NT...
|
|
UnregisterTypeLibrary(&LIBID_Shell32);
|
|
hr = RegisterTypeLib(pTypeLib, wszPath, NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
TraceMsg(TF_WARNING, "SHELL32: RegisterTypeLib failed (%x)", hr);
|
|
}
|
|
pTypeLib->Release();
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_WARNING, "SHELL32: LoadTypeLib failed (%x)", hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI CreateShowDesktopOnQuickLaunch()
|
|
{
|
|
// delete the "_Current Item" key used for tip rotation in welcome.exe on every upgrade
|
|
HKEY hkey;
|
|
if ( ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Setup\\Welcome"), 0, MAXIMUM_ALLOWED, &hkey ) )
|
|
{
|
|
RegDeleteValue(hkey, TEXT("_Current Item"));
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
// create the "Show Desktop" icon in the quick launch tray
|
|
TCHAR szPath[MAX_PATH];
|
|
if ( SHGetSpecialFolderPath(NULL, szPath, CSIDL_APPDATA, TRUE) )
|
|
{
|
|
TCHAR szQuickLaunch[MAX_PATH];
|
|
LoadString(g_hinst, IDS_QUICKLAUNCH, szQuickLaunch, ARRAYSIZE(szQuickLaunch));
|
|
|
|
if ( PathAppend( szPath, szQuickLaunch ) )
|
|
{
|
|
WritePrivateProfileSection( TEXT("Shell"), TEXT("Command=2\0IconFile=explorer.exe,3\0"), szPath );
|
|
WritePrivateProfileSection( TEXT("Taskbar"), TEXT("Command=ToggleDesktop\0"), szPath );
|
|
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
void _DoMyDocsPerUserInit(void)
|
|
{
|
|
// mydocs!PerUserInit is invoked to setup the desktop.ini and do all the other work
|
|
// required to make this correct.
|
|
HINSTANCE hInstMyDocs = LoadLibrary(TEXT("mydocs.dll"));
|
|
if (hInstMyDocs != NULL)
|
|
{
|
|
typedef void (*PFNPerUserInit)(void);
|
|
PFNPerUserInit pfnPerUserInit = (PFNPerUserInit)GetProcAddress(hInstMyDocs, "PerUserInit");
|
|
if (pfnPerUserInit)
|
|
{
|
|
pfnPerUserInit();
|
|
}
|
|
FreeLibrary(hInstMyDocs);
|
|
}
|
|
}
|
|
|
|
void _NoDriveAutorunTweak()
|
|
{
|
|
HKEY hkey;
|
|
DWORD dwDisp;
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER,
|
|
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"),
|
|
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisp))
|
|
{
|
|
DWORD dwRest;
|
|
DWORD cbSize = sizeof(dwRest);
|
|
|
|
if (ERROR_SUCCESS != RegQueryValueEx(hkey, TEXT("NoDriveTypeAutoRun"), NULL, NULL,
|
|
(PBYTE)&dwRest, &cbSize))
|
|
{
|
|
dwRest = 0;
|
|
}
|
|
|
|
if ((0x95 == dwRest) || (0 == dwRest))
|
|
{
|
|
// Did not change or is not there, let's put 0x91
|
|
|
|
dwRest = 0x91;
|
|
|
|
RegSetValueEx(hkey, TEXT("NoDriveTypeAutoRun"), 0, REG_DWORD, (PBYTE)&dwRest, sizeof(dwRest));
|
|
}
|
|
else
|
|
{
|
|
// Did change, leave it as is
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
|
|
// code moved from grpconv.exe
|
|
|
|
// we'd much rather have new firm links than old floppy ones
|
|
// clear out any old ones made by previous runs of setup
|
|
void _DeleteOldFloppyLinks(LPITEMIDLIST pidlSendTo, IPersistFile *ppf, IShellLink *psl)
|
|
{
|
|
IShellFolder *psfSendTo;
|
|
if (SUCCEEDED(SHBindToObjectEx(NULL, pidlSendTo, NULL, IID_PPV_ARG(IShellFolder, &psfSendTo))))
|
|
{
|
|
IEnumIDList *penum;
|
|
if (SUCCEEDED(psfSendTo->EnumObjects(NULL, SHCONTF_NONFOLDERS, &penum)))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
ULONG celt;
|
|
while (penum->Next(1, &pidl, &celt) == S_OK)
|
|
{
|
|
// is it a link???
|
|
if (SHGetAttributes(psfSendTo, pidl, SFGAO_LINK))
|
|
{
|
|
// get the target
|
|
LPITEMIDLIST pidlFullPath = ILCombine(pidlSendTo, pidl);
|
|
if (pidlFullPath)
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
if (SHGetPathFromIDList(pidlFullPath, szPath) &&
|
|
SUCCEEDED(ppf->Load(szPath, 0)))
|
|
{
|
|
LPITEMIDLIST pidlTarget;
|
|
if (SUCCEEDED(psl->GetIDList(&pidlTarget)))
|
|
{
|
|
TCHAR szTargetPath[MAX_PATH];
|
|
// its possible for the old drive letters to have changed. for example if you
|
|
// move a removable drive from M:\ to N:\, the shortcut will be invalid, so
|
|
// we check against DRIVE_NO_ROOT_DIR.
|
|
// unfortunately we can't tell if we should remove it if they used to have a zip
|
|
// drive on D:\, and then upgraded and it turned into a hard drive on D:\. the
|
|
// shortcut will resolve as DRIVE_FIXED and we dont remove it because they might
|
|
// have created a shortcut to the fixed drive before the upgrade.
|
|
if (SHGetPathFromIDList(pidlTarget, szTargetPath) &&
|
|
PathIsRoot(szTargetPath) &&
|
|
((DriveType(PathGetDriveNumber(szTargetPath)) == DRIVE_REMOVABLE) ||
|
|
(DriveType(PathGetDriveNumber(szTargetPath)) == DRIVE_NO_ROOT_DIR)))
|
|
{
|
|
Win32DeleteFile(szPath);
|
|
}
|
|
ILFree(pidlTarget);
|
|
}
|
|
}
|
|
ILFree(pidlFullPath);
|
|
}
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
penum->Release();
|
|
}
|
|
psfSendTo->Release();
|
|
}
|
|
}
|
|
|
|
void _DeleteOldRemovableLinks()
|
|
{
|
|
IShellLink *psl;
|
|
if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLink, &psl))))
|
|
{
|
|
IPersistFile *ppf;
|
|
if (SUCCEEDED(psl->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf))) )
|
|
{
|
|
LPITEMIDLIST pidlSendTo = SHCloneSpecialIDList(NULL, CSIDL_SENDTO, TRUE);
|
|
if (pidlSendTo)
|
|
{
|
|
// we no longer build a list of removable drives here, since that's done on the fly
|
|
// by the sendto menu. just delete any links that we owned before.
|
|
_DeleteOldFloppyLinks(pidlSendTo, ppf, psl);
|
|
ILFree(pidlSendTo);
|
|
}
|
|
ppf->Release();
|
|
}
|
|
psl->Release();
|
|
}
|
|
}
|
|
|
|
static const struct
|
|
{
|
|
PCWSTR pszExt;
|
|
}
|
|
_DeleteSendToList[] =
|
|
{
|
|
// make sure these extensions are definitely owned by us, since we're deleting all of them.
|
|
{ L".cdburn" }, // clean up after XP beta2 upgrade
|
|
{ L".publishwizard" } // clean up after XP beta1 upgrade
|
|
};
|
|
|
|
void _DeleteSendToEntries()
|
|
{
|
|
TCHAR szSendTo[MAX_PATH];
|
|
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_SENDTO, NULL, 0, szSendTo)))
|
|
{
|
|
for (int i = 0; i < ARRAYSIZE(_DeleteSendToList); i++)
|
|
{
|
|
TCHAR szSearch[MAX_PATH];
|
|
StrCpyN(szSearch, szSendTo, ARRAYSIZE(szSearch));
|
|
PathAppend(szSearch, TEXT("*"));
|
|
StrCatBuff(szSearch, _DeleteSendToList[i].pszExt, ARRAYSIZE(szSearch));
|
|
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hfind = FindFirstFile(szSearch, &fd);
|
|
if (hfind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
TCHAR szFile[MAX_PATH];
|
|
StrCpyN(szFile, szSendTo, ARRAYSIZE(szFile));
|
|
PathAppend(szFile, fd.cFileName);
|
|
DeleteFile(szFile);
|
|
} while (FindNextFile(hfind, &fd));
|
|
FindClose(hfind);
|
|
}
|
|
}
|
|
}
|
|
|
|
// next kill old removable drives
|
|
_DeleteOldRemovableLinks();
|
|
}
|
|
|
|
DWORD _GetProcessorSpeed() // in MHz
|
|
{
|
|
static DWORD s_dwSpeed = 0;
|
|
if (s_dwSpeed == 0)
|
|
{
|
|
DWORD cb = sizeof(s_dwSpeed);
|
|
SHGetValue(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
|
|
TEXT("~MHz"), NULL, &s_dwSpeed, &cb);
|
|
s_dwSpeed += 1; // fudge factor, my 400 Mhz machine reports 399
|
|
}
|
|
return s_dwSpeed;
|
|
}
|
|
|
|
DWORD _GetPhysicalMemory() // in MBs
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_BASIC_INFORMATION BasicInfo;
|
|
|
|
Status = NtQuerySystemInformation(
|
|
SystemBasicInformation,
|
|
&BasicInfo,
|
|
sizeof(BasicInfo),
|
|
NULL
|
|
);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
return ((BasicInfo.NumberOfPhysicalPages * BasicInfo.PageSize) / (1024 * 1024)) + 1; // fudge factor, my 256 Meg machine reports 255
|
|
}
|
|
else
|
|
{
|
|
return 64; // Default to 64 Meg (something lame, so that we turn a bunch of stuff off)
|
|
}
|
|
}
|
|
|
|
const TCHAR g_cszLetters[] = TEXT("The Quick Brown Fox Jumped Over The Lazy Dog");
|
|
|
|
BOOL _PerfTestSmoothFonts(void)
|
|
{
|
|
int cchLength = lstrlen(g_cszLetters);
|
|
HDC hdc;
|
|
LOGFONT lf;
|
|
HFONT hfont;
|
|
HFONT hfontOld;
|
|
int bkmodeOld;
|
|
int iIter;
|
|
int iIter2;
|
|
int iIter3;
|
|
LARGE_INTEGER liFrequency;
|
|
LARGE_INTEGER liStart;
|
|
LARGE_INTEGER liStop;
|
|
LARGE_INTEGER liTotal;
|
|
COLORREF colorref;
|
|
SIZE size;
|
|
DOUBLE eTime[2];
|
|
BYTE lfQuality[2];
|
|
|
|
HDC hdcScreen = GetDC(NULL);
|
|
hdc = CreateCompatibleDC(hdcScreen);
|
|
HBITMAP hbm = CreateCompatibleBitmap(hdcScreen,200,20);
|
|
HBITMAP hbmOld = (HBITMAP)SelectObject(hdc,hbm);
|
|
ReleaseDC(NULL,hdcScreen);
|
|
|
|
bkmodeOld = SetBkMode(hdc, TRANSPARENT);
|
|
|
|
QueryPerformanceFrequency( &liFrequency );
|
|
|
|
lfQuality[0] = NONANTIALIASED_QUALITY;
|
|
lfQuality[1] = ANTIALIASED_QUALITY;
|
|
|
|
memset(&lf,0,sizeof(lf));
|
|
lstrcpy(lf.lfFaceName,TEXT("Arial"));
|
|
lf.lfWeight = FW_BOLD;
|
|
|
|
for (iIter3 = 0; iIter3 < 2; iIter3++)
|
|
{
|
|
liTotal.QuadPart = 0;
|
|
|
|
for (iIter2 = 0; iIter2 < 5; iIter2++)
|
|
{
|
|
//
|
|
// First, Flush the constructed font cache
|
|
//
|
|
for (iIter = 0; iIter < 64; iIter++)
|
|
{
|
|
lf.lfHeight = -14-iIter; // 10+ pt
|
|
lf.lfQuality = NONANTIALIASED_QUALITY;
|
|
|
|
hfont = CreateFontIndirect(&lf);
|
|
hfontOld = (HFONT)SelectObject(hdc, hfont);
|
|
|
|
TextOut(hdc, 0, 0, g_cszLetters, cchLength);
|
|
|
|
SelectObject(hdc, hfontOld);
|
|
DeleteObject(hfont);
|
|
}
|
|
GdiFlush();
|
|
colorref = GetPixel(hdc,0,0);
|
|
|
|
//
|
|
// Now measure how long it takes to construct and use a this font
|
|
//
|
|
lf.lfHeight = -13; // 10 pt
|
|
lf.lfQuality = lfQuality[iIter3];
|
|
|
|
QueryPerformanceCounter( &liStart );
|
|
hfont = CreateFontIndirect(&lf);
|
|
hfontOld = (HFONT)SelectObject(hdc, hfont);
|
|
|
|
for (iIter = 0; iIter < 10; iIter++)
|
|
{
|
|
TextOut(hdc, 0, 0, g_cszLetters, cchLength);
|
|
}
|
|
|
|
GdiFlush();
|
|
colorref = GetPixel(hdc,0,0);
|
|
|
|
QueryPerformanceCounter( &liStop );
|
|
liTotal.QuadPart += liStop.QuadPart - liStart.QuadPart;
|
|
|
|
GetTextExtentPoint(hdc, g_cszLetters, cchLength, &size);
|
|
|
|
SelectObject(hdc, hfontOld);
|
|
DeleteObject(hfont);
|
|
|
|
}
|
|
|
|
eTime[iIter3] = (double)liTotal.QuadPart / (double)liFrequency.QuadPart;
|
|
}
|
|
|
|
SetBkMode(hdc, bkmodeOld);
|
|
|
|
SelectObject(hdc,hbmOld);
|
|
DeleteObject(hbm);
|
|
DeleteDC(hdc);
|
|
|
|
return (eTime[1]/eTime[0] <= 4.0);
|
|
}
|
|
|
|
BOOL _PerfTestAlphaLayer(void)
|
|
{
|
|
DOUBLE eTime = 100.0; // 100 is too large to enable features
|
|
int cx = 200;
|
|
int cy = 500;
|
|
|
|
LARGE_INTEGER liFrequency;
|
|
QueryPerformanceFrequency( &liFrequency );
|
|
|
|
BITMAPINFO bmi;
|
|
memset(&bmi, 0, sizeof(bmi));
|
|
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bmi.bmiHeader.biWidth = cx;
|
|
bmi.bmiHeader.biHeight = cy;
|
|
bmi.bmiHeader.biPlanes = 1;
|
|
bmi.bmiHeader.biBitCount = 32;
|
|
bmi.bmiHeader.biCompression = BI_RGB;
|
|
|
|
//
|
|
// Create the image we want to alpha blend onto the screen
|
|
//
|
|
HDC hdcScreen = GetDC(NULL);
|
|
HDC hdcImage = CreateCompatibleDC(NULL);
|
|
if (hdcImage != NULL)
|
|
{
|
|
PVOID pbits;
|
|
HBITMAP hbmImage = CreateDIBSection(hdcImage, &bmi, DIB_RGB_COLORS,
|
|
&pbits, NULL, NULL);
|
|
if (hbmImage != NULL)
|
|
{
|
|
HBITMAP hbmOld = (HBITMAP)SelectObject(hdcImage, hbmImage);
|
|
|
|
BitBlt(hdcImage, 0, 0, cx, cy, hdcScreen, 0, 0, SRCCOPY);
|
|
|
|
if (pbits != NULL)
|
|
{
|
|
RGBQUAD *prgb = (RGBQUAD *)pbits;
|
|
for (int y = 0; y < cy; y++)
|
|
{
|
|
for (int x = 0; x < cx; x++)
|
|
{
|
|
BYTE color_r;
|
|
BYTE color_g;
|
|
BYTE color_b;
|
|
|
|
color_r = prgb->rgbRed;
|
|
color_g = prgb->rgbBlue;
|
|
color_b = prgb->rgbGreen;
|
|
|
|
color_r = color_r / 2;
|
|
color_g = color_g / 2;
|
|
color_b = color_b / 2;
|
|
|
|
prgb->rgbRed = color_r;
|
|
prgb->rgbBlue = color_g;
|
|
prgb->rgbGreen = color_b;
|
|
prgb->rgbReserved = 0x80;
|
|
|
|
prgb++;
|
|
}
|
|
}
|
|
}
|
|
|
|
HWND hwnd1 = CreateWindowEx( WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
|
|
TEXT("Button"),
|
|
TEXT("Windows XP"),
|
|
WS_POPUPWINDOW,
|
|
0, 0,
|
|
cx, cy,
|
|
NULL, NULL,
|
|
0,
|
|
NULL);
|
|
|
|
HWND hwnd2 = CreateWindowEx( WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
|
|
TEXT("Button"),
|
|
TEXT("Windows XP"),
|
|
WS_POPUPWINDOW,
|
|
0, 0,
|
|
cx, cy,
|
|
NULL, NULL,
|
|
0,
|
|
NULL);
|
|
|
|
if (hwnd1 != NULL && hwnd2 != NULL)
|
|
{
|
|
SetWindowPos(hwnd1, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
SetWindowPos(hwnd2, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
|
|
BLENDFUNCTION blend;
|
|
blend.BlendOp = AC_SRC_OVER;
|
|
blend.BlendFlags = 0;
|
|
blend.SourceConstantAlpha = 0xFF;
|
|
blend.AlphaFormat = AC_SRC_ALPHA;
|
|
|
|
HDC hdc1 = GetDC(hwnd1);
|
|
HDC hdc2 = GetDC(hwnd2);
|
|
POINT ptSrc;
|
|
SIZE size;
|
|
ptSrc.x = 0;
|
|
ptSrc.y = 0;
|
|
size.cx = cx;
|
|
size.cy = cy;
|
|
|
|
COLORREF colorref;
|
|
LARGE_INTEGER liStart;
|
|
LARGE_INTEGER liStop;
|
|
LARGE_INTEGER liTotal;
|
|
|
|
GdiFlush();
|
|
colorref = GetPixel(hdc1,0,0);
|
|
colorref = GetPixel(hdc2,0,0);
|
|
colorref = GetPixel(hdcScreen,0,0);
|
|
QueryPerformanceCounter( &liStart );
|
|
|
|
for (int iIter = 0; iIter < 10; iIter++)
|
|
{
|
|
UpdateLayeredWindow(hwnd1, hdc1, NULL, &size,
|
|
hdcImage, &ptSrc, 0,
|
|
&blend, ULW_ALPHA);
|
|
UpdateLayeredWindow(hwnd2, hdc2, NULL, &size,
|
|
hdcImage, &ptSrc, 0,
|
|
&blend, ULW_ALPHA);
|
|
}
|
|
|
|
GdiFlush();
|
|
colorref = GetPixel(hdc1,0,0);
|
|
colorref = GetPixel(hdc2,0,0);
|
|
colorref = GetPixel(hdcScreen,0,0);
|
|
QueryPerformanceCounter( &liStop );
|
|
liTotal.QuadPart = liStop.QuadPart - liStart.QuadPart;
|
|
|
|
eTime = ((DOUBLE)liTotal.QuadPart * 1000.0) / (DOUBLE)liFrequency.QuadPart;
|
|
eTime = eTime / 10.0;
|
|
|
|
ReleaseDC(hwnd1, hdc1);
|
|
ReleaseDC(hwnd2, hdc2);
|
|
|
|
}
|
|
|
|
if (hwnd1)
|
|
{
|
|
DestroyWindow(hwnd1);
|
|
}
|
|
if (hwnd2)
|
|
{
|
|
DestroyWindow(hwnd2);
|
|
}
|
|
|
|
SelectObject(hdcImage,hbmOld);
|
|
DeleteObject(hbmImage);
|
|
}
|
|
DeleteDC(hdcImage);
|
|
}
|
|
|
|
ReleaseDC(NULL, hdcScreen);
|
|
|
|
return (eTime <= 75.0);
|
|
}
|
|
|
|
BOOL g_fPerfFont = FALSE;
|
|
BOOL g_fPerfAlpha = FALSE;
|
|
|
|
#define VISUALEFFECTS_KEY TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\VisualEffects")
|
|
|
|
#define VISUALEFFECTS_CHECK TEXT("CheckedValue")
|
|
#define VISUALEFFECTS_UNCHECK TEXT("UncheckedValue")
|
|
#define VISUALEFFECTS_DEFAULT TEXT("DefaultValue")
|
|
#define VISUALEFFECTS_APPLIED TEXT("DefaultApplied")
|
|
#define VISUALEFFECTS_MINCPU TEXT("MinimumCPU")
|
|
#define VISUALEFFECTS_MINMEM TEXT("MinimumMEM")
|
|
#define VISUALEFFECTS_FONT TEXT("DefaultByFontTest")
|
|
#define VISUALEFFECTS_ALPHA TEXT("DefaultByAlphaTest")
|
|
|
|
#define VISUALEFFECTS_VER 1
|
|
|
|
void _ApplyDefaultVisualEffect(HKEY hkey,HKEY hkeyUser)
|
|
{
|
|
//
|
|
// blow this off completely on TS client to avoid stepping
|
|
// on TS client's toes
|
|
//
|
|
if (!IsOS(OS_TERMINALCLIENT))
|
|
{
|
|
DWORD cb;
|
|
DWORD dwDefaultApplied = 0;
|
|
|
|
if (0 != hkeyUser)
|
|
{
|
|
cb = sizeof(dwDefaultApplied);
|
|
RegQueryValueEx(hkeyUser, VISUALEFFECTS_APPLIED, NULL, NULL, (LPBYTE)&dwDefaultApplied, &cb);
|
|
}
|
|
|
|
//
|
|
// Apply defaults only if the version number is old
|
|
//
|
|
if (VISUALEFFECTS_VER > dwDefaultApplied)
|
|
{
|
|
LPTSTR pszValue = NULL; // use the default value
|
|
DWORD dwMinimumCPU = 0;
|
|
DWORD dwMinimumMEM = 0;
|
|
BOOL fFontTestDefault = FALSE;
|
|
BOOL fAlphaTestDefault = FALSE;
|
|
|
|
//
|
|
// see if a minimum physical memory value is specified
|
|
//
|
|
cb = sizeof(dwMinimumMEM);
|
|
RegQueryValueEx(hkey, VISUALEFFECTS_MINMEM, NULL, NULL, (LPBYTE)&dwMinimumMEM, &cb);
|
|
|
|
//
|
|
// see if a minimum CPU speed is specified
|
|
//
|
|
cb = sizeof(dwMinimumCPU);
|
|
RegQueryValueEx(hkey, VISUALEFFECTS_MINCPU, NULL, NULL, (LPBYTE)&dwMinimumCPU, &cb);
|
|
|
|
//
|
|
// see if the font performance test value is needed
|
|
//
|
|
cb = sizeof(fFontTestDefault);
|
|
RegQueryValueEx(hkey, VISUALEFFECTS_FONT, NULL, NULL, (LPBYTE)&fFontTestDefault, &cb);
|
|
|
|
//
|
|
// see if the alpha performance test value is needed
|
|
//
|
|
cb = sizeof(fAlphaTestDefault);
|
|
RegQueryValueEx(hkey, VISUALEFFECTS_ALPHA, NULL, NULL, (LPBYTE)&fAlphaTestDefault, &cb);
|
|
|
|
|
|
if ( dwMinimumCPU > 0
|
|
|| dwMinimumMEM > 0
|
|
|| fFontTestDefault
|
|
|| fAlphaTestDefault)
|
|
{
|
|
pszValue = VISUALEFFECTS_CHECK;
|
|
|
|
if (_GetProcessorSpeed() < dwMinimumCPU)
|
|
{
|
|
pszValue = VISUALEFFECTS_UNCHECK;
|
|
}
|
|
if (_GetPhysicalMemory() < dwMinimumMEM)
|
|
{
|
|
pszValue = VISUALEFFECTS_UNCHECK;
|
|
}
|
|
if (fFontTestDefault && !g_fPerfFont)
|
|
{
|
|
pszValue = VISUALEFFECTS_UNCHECK;
|
|
}
|
|
if (fAlphaTestDefault && !g_fPerfAlpha)
|
|
{
|
|
pszValue = VISUALEFFECTS_UNCHECK;
|
|
}
|
|
}
|
|
|
|
if (IsOS(OS_ANYSERVER))
|
|
{
|
|
//
|
|
// on server, we default to best performance (*everything* off)
|
|
//
|
|
pszValue = VISUALEFFECTS_UNCHECK;
|
|
}
|
|
|
|
DWORD dwValue = 0;
|
|
cb = sizeof(dwValue);
|
|
|
|
if (pszValue)
|
|
{
|
|
//
|
|
// set the default according to the chosen value
|
|
//
|
|
RegQueryValueEx(hkey, pszValue, NULL, NULL, (LPBYTE)&dwValue, &cb);
|
|
|
|
//
|
|
// when figuring out settings that need to adjust the default
|
|
// value the VISUALEFFECTS_DEFAULT value must be re-applied
|
|
// to the per-user key.
|
|
//
|
|
if (0 != hkeyUser)
|
|
{
|
|
RegSetValueEx(hkeyUser, VISUALEFFECTS_DEFAULT, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// read in the default value
|
|
//
|
|
RegQueryValueEx(hkey, VISUALEFFECTS_DEFAULT, NULL, NULL, (LPBYTE)&dwValue, &cb);
|
|
}
|
|
|
|
//
|
|
// how do we apply this setting?
|
|
//
|
|
DWORD uiAction;
|
|
TCHAR szBuf[MAX_PATH];
|
|
|
|
if (cb = sizeof(szBuf),
|
|
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CLSID"), NULL, NULL, (LPBYTE)&szBuf, &cb))
|
|
{
|
|
//
|
|
// by CLSID
|
|
//
|
|
CLSID clsid;
|
|
GUIDFromString(szBuf, &clsid);
|
|
|
|
IRegTreeItem* pti;
|
|
if (SUCCEEDED(CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_PPV_ARG(IRegTreeItem, &pti))))
|
|
{
|
|
pti->SetCheckState(dwValue);
|
|
pti->Release();
|
|
}
|
|
}
|
|
else if (cb = sizeof(uiAction),
|
|
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("SPIActionSet"), NULL, NULL, (LPBYTE)&uiAction, &cb))
|
|
{
|
|
//
|
|
// by SPI
|
|
//
|
|
SHBoolSystemParametersInfo(uiAction, &dwValue);
|
|
}
|
|
else if (cb = sizeof(szBuf),
|
|
ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("RegPath"), NULL, NULL, (LPBYTE)&szBuf, &cb))
|
|
{
|
|
//
|
|
// by reg key
|
|
//
|
|
TCHAR szValueName[96];
|
|
cb = sizeof(szValueName);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("ValueName"), NULL, NULL, (LPBYTE)&szValueName, &cb))
|
|
{
|
|
SHSetValue(HKEY_CURRENT_USER, szBuf, szValueName, REG_DWORD, &dwValue, sizeof(dwValue));
|
|
}
|
|
}
|
|
|
|
if (0 != hkeyUser)
|
|
{
|
|
dwDefaultApplied = VISUALEFFECTS_VER;
|
|
RegSetValueEx(hkeyUser, VISUALEFFECTS_APPLIED, 0, REG_DWORD, (LPBYTE)&dwDefaultApplied, sizeof(dwDefaultApplied));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void _DefaultVisualEffects(void)
|
|
{
|
|
HKEY hkeyUser;
|
|
DWORD dw;
|
|
|
|
g_fPerfFont = _PerfTestSmoothFonts();
|
|
g_fPerfAlpha = _PerfTestAlphaLayer();
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyExW(HKEY_CURRENT_USER, VISUALEFFECTS_KEY, 0, TEXTW(""), 0, KEY_SET_VALUE,
|
|
NULL, &hkeyUser, &dw))
|
|
{
|
|
HKEY hkey;
|
|
REGSAM samDesired = KEY_READ;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, VISUALEFFECTS_KEY, 0, samDesired, &hkey))
|
|
{
|
|
TCHAR szName[96];
|
|
for (int i = 0; ERROR_SUCCESS == RegEnumKey(hkey, i, szName, ARRAYSIZE(szName)); i++)
|
|
{
|
|
HKEY hkeyUserItem;
|
|
|
|
if (ERROR_SUCCESS == RegCreateKeyExW(hkeyUser, szName, 0, TEXTW(""), 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
|
|
NULL, &hkeyUserItem, &dw))
|
|
{
|
|
HKEY hkeyItem;
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(hkey, szName, 0, samDesired, &hkeyItem))
|
|
{
|
|
// only apply the default for the setting if the "NoApplyDefault" reg value is NOT present
|
|
if (RegQueryValueEx(hkeyItem, TEXT("NoApplyDefault"), NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
|
|
{
|
|
_ApplyDefaultVisualEffect(hkeyItem, hkeyUserItem);
|
|
}
|
|
|
|
RegCloseKey(hkeyItem);
|
|
}
|
|
|
|
RegCloseKey(hkeyUserItem);
|
|
}
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
RegCloseKey(hkeyUser);
|
|
}
|
|
}
|
|
|
|
STDAPI CDeskHtmlProp_RegUnReg(BOOL bInstall);
|
|
STDAPI_(BOOL) ApplyRegistrySecurity();
|
|
STDAPI_(void) FixPlusIcons();
|
|
STDAPI_(void) CleanupFileSystem();
|
|
STDAPI_(void) InitializeSharedDocs(BOOL fOnWow64);
|
|
|
|
#define KEEP_FAILURE(hrSum, hrLast) if (FAILED(hrLast)) hrSum = hrLast;
|
|
|
|
#ifdef _WIN64
|
|
// On IA64 machines we need to copy the EULA file (eula.txt) from %SytemRoot%\System32, to
|
|
// %SystemRoot%\SysWOW64. This is needed because when you do help|about on a 32-bit app running
|
|
// under wow64 it will look in the syswow64 directory for the file.
|
|
//
|
|
// Why is shell32.dll doing this and not setup you might ask? The EULA has to be installed by textmode
|
|
// since it is unsigned (and changes for every sku). Since txtmode setup does a MOVE instead of a copy, we
|
|
// cannot have it installed into two places. Thus the easies thing to do is to simply copy the file
|
|
// from the System32 directory to the SysWOW64 directory here. Sigh.
|
|
|
|
BOOL CopyEULAForWow6432()
|
|
{
|
|
BOOL bRet = FALSE;
|
|
TCHAR szEULAPath[MAX_PATH];
|
|
TCHAR szWow6432EULAPath[MAX_PATH];
|
|
|
|
if (GetSystemWindowsDirectory(szEULAPath, ARRAYSIZE(szEULAPath)))
|
|
{
|
|
lstrcpyn(szWow6432EULAPath, szEULAPath, ARRAYSIZE(szWow6432EULAPath));
|
|
|
|
if (PathAppend(szEULAPath, TEXT("System32\\eula.txt")) &&
|
|
PathAppend(szWow6432EULAPath, TEXT("SysWOW64\\eula.txt")))
|
|
{
|
|
// now we have the source (%SystemRoot%\System32\eula.txt) and dest (%SystemRoot%\SysWOW64\eula.txt)
|
|
// paths, lets do the copy!
|
|
|
|
bRet = CopyFile(szEULAPath, szWow6432EULAPath, FALSE);
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
#endif // _WIN64
|
|
|
|
|
|
//
|
|
// Upgrades from Win9x are internally handled by setup as "clean" installs followed by some
|
|
// migration of settings. So, the following function does the job of truly detecting a win9x
|
|
// upgrade.
|
|
// The way it detects: Look in %windir%\system32\$winnt$.inf in the section [Data]
|
|
// for Win9xUpgrade=Yes if it is a Win9x upgrade.
|
|
//
|
|
BOOL IsUpgradeFromWin9x()
|
|
{
|
|
TCHAR szFilePath[MAX_PATH];
|
|
TCHAR szYesOrNo[10];
|
|
|
|
GetSystemDirectory(szFilePath, ARRAYSIZE(szFilePath));
|
|
PathAppend(szFilePath, TEXT("$WINNT$.INF"));
|
|
|
|
GetPrivateProfileString(TEXT("Data"), // Section name.
|
|
TEXT("Win9xUpgrade"), // Key name.
|
|
TEXT("No"), // Default string, if key is missing.
|
|
szYesOrNo,
|
|
ARRAYSIZE(szYesOrNo),
|
|
szFilePath); // Full path to "$winnt$.inf" file.
|
|
|
|
return (0 == lstrcmpi(szYesOrNo, TEXT("Yes")));
|
|
}
|
|
|
|
BOOL IsCleanInstallInProgress()
|
|
{
|
|
LPCTSTR szKeyName = TEXT("SYSTEM\\Setup");
|
|
HKEY hKeySetup;
|
|
BOOL fCleanInstall = FALSE;
|
|
|
|
if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, szKeyName, 0,
|
|
KEY_READ, &hKeySetup) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwSize;
|
|
LONG lResult;
|
|
DWORD dwSystemSetupInProgress = 0;
|
|
|
|
dwSize = sizeof(DWORD);
|
|
lResult = RegQueryValueEx (hKeySetup, TEXT("SystemSetupInProgress"), NULL,
|
|
NULL, (LPBYTE) &dwSystemSetupInProgress, &dwSize);
|
|
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwMiniSetupInProgress = 0;
|
|
dwSize = sizeof(DWORD);
|
|
RegQueryValueEx (hKeySetup, TEXT("MiniSetupInProgress"), NULL,
|
|
NULL, (LPBYTE) &dwMiniSetupInProgress, &dwSize);
|
|
|
|
if(dwSystemSetupInProgress && !dwMiniSetupInProgress)
|
|
{
|
|
DWORD dwUpgradeInProgress = 0;
|
|
dwSize = sizeof(DWORD);
|
|
//Setup is in progress and MiniSetup is NOT in progress.
|
|
//That means that we are in the GUI mode of setup!
|
|
|
|
//On clean installs, this value won't be there and the following call will fail.
|
|
RegQueryValueEx (hKeySetup, TEXT("UpgradeInProgress"), NULL,
|
|
NULL, (LPBYTE) &dwUpgradeInProgress, &dwSize);
|
|
|
|
fCleanInstall = !dwUpgradeInProgress;
|
|
}
|
|
}
|
|
RegCloseKey (hKeySetup);
|
|
}
|
|
|
|
if(fCleanInstall)
|
|
{
|
|
// Caution: An upgrade from Win9x is internally done by setup as a "clean" install.
|
|
// So, we need to figure out if this is really a clean install or an upgrade from
|
|
// win9x.
|
|
|
|
fCleanInstall = !IsUpgradeFromWin9x();
|
|
}
|
|
|
|
return fCleanInstall ;
|
|
}
|
|
|
|
//
|
|
// Set the default MFU to be picked up when each user logs on for the
|
|
// first time. The string block must be 16 strings long (_0 through _15).
|
|
//
|
|
STDAPI SetDefaultMFU(UINT ids)
|
|
{
|
|
HKEY hkMFU;
|
|
LONG lRc = RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\SMDEn"),
|
|
0, NULL, 0, KEY_WRITE, NULL, &hkMFU, NULL);
|
|
if (lRc == ERROR_SUCCESS)
|
|
{
|
|
for (int i = 0; lRc == ERROR_SUCCESS && i < 16; i++)
|
|
{
|
|
TCHAR szValue[80];
|
|
TCHAR szData[80];
|
|
wnsprintf(szValue, ARRAYSIZE(szValue), TEXT("Link%d"), i);
|
|
wnsprintf(szData, ARRAYSIZE(szData), TEXT("@xpsp1res.dll,-%d"), ids + i);
|
|
DWORD cbData = (lstrlen(szData) + 1) * sizeof(TCHAR);
|
|
lRc = RegSetValueEx(hkMFU, szValue, 0, REG_SZ, (LPBYTE)szData, cbData);
|
|
}
|
|
RegCloseKey(hkMFU);
|
|
}
|
|
return HRESULT_FROM_WIN32(lRc);
|
|
}
|
|
|
|
STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine)
|
|
{
|
|
HRESULT hrTemp, hr = S_OK;
|
|
|
|
// 99/05/03 vtan: If you're reading this section then you are considering
|
|
// adding code to the registration/installation of shell32.dll. There are
|
|
// now 3 schemes to accomplish this task:
|
|
|
|
// 1. IE4UINIT.EXE
|
|
// Check HKLM\Software\Microsoft\Active Setup\Installed Components\{89820200-ECBD-11cf-8B85-00AA005B4383}
|
|
// This says that if there is a new version of IE5 to launch ie4uinit.exe.
|
|
// You can add code to this executable if you wish. You need to enlist in
|
|
// the setup project on \\trango\slmadd using "ieenlist setup"
|
|
|
|
// 2. REGSVR32.EXE /n /i:U shell32.dll
|
|
// Check HKLM\Software\Microsoft\Active Setup\Installed Components\{89820200-ECBD-11cf-8B85-00AA005B4340}
|
|
// This is executed using the same scheme as IE4UINIT.EXE except that the
|
|
// executable used is regsvr32.exe with a command line passed to
|
|
// shell32!DllInstall. Add your code in the section for "U" below.
|
|
// If you put the code in the section which is NOT "U" then your
|
|
// code is executed at GUI setup and any changes you make to HKCU
|
|
// go into the default user (template). Be careful when putting
|
|
// things here as winlogon.exe (or some other process) may put
|
|
// your changes into a user profile unconditionally.
|
|
|
|
// 3. HIVEUSD.INX
|
|
// Checks NT build numbers and does command based on the previous build
|
|
// number and the current build number only executing the changes between
|
|
// the builds. If you wish to add something using this method, currently
|
|
// you have to enlist in the setup project on \\rastaman\ntwin using
|
|
// "enlist -fgs \\rastaman\ntwin -p setup". To find hiveusd.inx go to
|
|
// nt\private\setup\inf\win4\inf. Add the build number which the delta
|
|
// is required and a command to launch %SystemRoot%\System32\shmgrate.exe
|
|
// with one or two parameters. The first parameter tells what command to
|
|
// execute. The second parameter is optional. shmgrate.exe then finds
|
|
// shell32.dll and calls shell32!FirstUserLogon. Code here is for upgrading
|
|
// HKCU user profiles from one NT build to another NT build.
|
|
// Code is executed in the process context shmgrate.exe and is executed
|
|
// at a time where no UI is possible. Always use HKLM\Software\Microsoft
|
|
// \Windows NT\CurrentVersion\Image File Execution Options\Debugger with
|
|
// "-d".
|
|
|
|
// Schemes 1 and 2 work on either Win9x or WinNT but have the sometimes
|
|
// unwanted side effect of ALWAYS getting executed on version upgrades.
|
|
// Scheme 3 only gets executed on build number deltas. Because schemes 1
|
|
// and 2 are always executed, if a user changes (or deletes) that setting
|
|
// it will always get put back. Not so with scheme 3.
|
|
|
|
// Ideally, the best solution is have an internal shell32 build number
|
|
// delta scheme which determines the from build and the to build and does
|
|
// a similar mechanism to what hiveusd.inx and shmgrate.exe do. This
|
|
// would probably involve either a common installation function (such as
|
|
// FirstUserLogon()) which is called differently from Win9x and WinNT or
|
|
// common functions to do the upgrade and two entry points (such as
|
|
// FirstUserLogonNT() and FirstUserLogonWin9X().
|
|
|
|
if (bInstall)
|
|
{
|
|
NT_PRODUCT_TYPE type = NtProductWinNt;
|
|
RtlGetNtProductType(&type);
|
|
|
|
// "U" means it's the per user install call
|
|
BOOL fPerUser = pszCmdLine && (StrCmpIW(pszCmdLine, L"U") == 0);
|
|
if (fPerUser)
|
|
{
|
|
// NOTE: Code in this segment get run during first login. We want first
|
|
// login to be as quick as possible so try to minimize this section.
|
|
|
|
// Put per-user install stuff here. Any HKCU registration
|
|
// done here is suspect. (If you are setting defaults, do
|
|
// so in HKLM and use the SHRegXXXUSValue functions.)
|
|
|
|
// WARNING: we get called by the ie4unit.exe (ieunit.inf) scheme:
|
|
// %11%\shell32.dll,NI,U
|
|
// this happens per user, to test this code "regsvr32 /n /i:U shell32.dll"
|
|
|
|
// Some of this stuff we don't want to do on all upgrades (in particular XP Gold -> XP SPn)
|
|
BOOL fUpgradeUserSettings = TRUE;
|
|
WCHAR szVersion[50]; // plenty big for aaaa,bbbb,cccc,dddd
|
|
DWORD cbVersion = sizeof(szVersion);
|
|
if (ERROR_SUCCESS==SHGetValueW(HKEY_CURRENT_USER,
|
|
L"Software\\Microsoft\\Active Setup\\Installed Components\\{89820200-ECBD-11cf-8B85-00AA005B4340}",L"Version", // guid is Shell32's Active Setup
|
|
NULL, szVersion, &cbVersion))
|
|
{
|
|
__int64 nverUpgradeFrom;
|
|
__int64 nverWinXP;
|
|
if (SUCCEEDED(GetVersionFromString64(szVersion, &nverUpgradeFrom)) &&
|
|
SUCCEEDED(GetVersionFromString64(L"6,0,2600,0000", &nverWinXP)))
|
|
{
|
|
fUpgradeUserSettings = nverUpgradeFrom < nverWinXP;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef INSTALL_MSI
|
|
// Install the Office WebFolders shell namespace extension per user.
|
|
MSI_Install(TEXT("webfldrs.msi"));
|
|
#endif
|
|
|
|
hrTemp = CreateShowDesktopOnQuickLaunch();
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
// upgrade the recent folder.
|
|
WCHAR sz[MAX_PATH];
|
|
SHGetFolderPath(NULL, CSIDL_RECENT | CSIDL_FLAG_CREATE | CSIDL_FLAG_PER_USER_INIT, NULL, SHGFP_TYPE_CURRENT, sz);
|
|
SHGetFolderPath(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE | CSIDL_FLAG_PER_USER_INIT, NULL, SHGFP_TYPE_CURRENT, sz);
|
|
|
|
// torch this value on upgrade.
|
|
// insuring the warning that they will see the ugly desktop.ini files
|
|
if (fUpgradeUserSettings)
|
|
{
|
|
SKDeleteValue(SHELLKEY_HKCU_EXPLORER, L"Advanced", L"ShowSuperHidden");
|
|
}
|
|
|
|
HKEY hk = SHGetShellKey(SHELLKEY_HKCULM_MUICACHE, NULL, FALSE);
|
|
if (hk)
|
|
{
|
|
SHDeleteKeyA(hk, NULL);
|
|
RegCloseKey(hk);
|
|
}
|
|
|
|
// delete old sendto entries we dont want any more
|
|
_DeleteSendToEntries();
|
|
|
|
// handle the per user init for this guy
|
|
_DoMyDocsPerUserInit();
|
|
|
|
_DefaultVisualEffects();
|
|
|
|
// handle the per user change of value for NoDriveAutoRun
|
|
if (!IsOS(OS_ANYSERVER))
|
|
{
|
|
_NoDriveAutorunTweak();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Delete any old registration entries, then add the new ones.
|
|
// Keep ADVPACK.DLL loaded across multiple calls to RegInstall.
|
|
// (The inf engine doesn't guarantee DelReg/AddReg order, that's
|
|
// why we explicitly unreg and reg here.)
|
|
//
|
|
hrTemp = CallRegInstall("RegDll");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
// I suppose we should call out NT-only registrations, just in case
|
|
// we ever have to ship a win9x based shell again
|
|
hrTemp = CallRegInstall("RegDllNT");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
// If we are on NT server, do additional stuff
|
|
if (type != NtProductWinNt)
|
|
{
|
|
hrTemp = CallRegInstall("RegDllNTServer");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
}
|
|
else // workstation
|
|
{
|
|
if (!IsOS(OS_PERSONAL))
|
|
{
|
|
hrTemp = CallRegInstall("RegDllNTPro");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
//
|
|
// NTRAID#NTBUG9-418621-2001/06/27-jeffreys
|
|
//
|
|
// If the ForceGuest value is unset, e.g. on upgrade
|
|
// from Win2k, set the SimpleSharing/DefaultValue to 0.
|
|
//
|
|
DWORD dwForceGuest;
|
|
DWORD cb = sizeof(dwForceGuest);
|
|
if (ERROR_SUCCESS != SHGetValue(HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\Lsa"), TEXT("ForceGuest"), NULL, &dwForceGuest, &cb))
|
|
{
|
|
dwForceGuest = 0;
|
|
SHSetValue(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Folder\\SimpleSharing"), TEXT("DefaultValue"), REG_DWORD, &dwForceGuest, sizeof(dwForceGuest));
|
|
}
|
|
}
|
|
|
|
// Service Pack is not allowed to change selfreg.inf
|
|
// so we need to do this manually. Must do this after
|
|
// RegDll so we can overwrite his settings.
|
|
#ifdef _WIN64
|
|
hrTemp = SetDefaultMFU(IDS_SHELL32_PROMFU64_0);
|
|
#else
|
|
hrTemp = SetDefaultMFU(IDS_SHELL32_PROMFU32_0);
|
|
#endif
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
}
|
|
|
|
//
|
|
// If this is clean install, then hide some desktop icons.
|
|
//
|
|
if(IsCleanInstallInProgress())
|
|
{
|
|
hrTemp = CallRegInstall("RegHideDeskIcons");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
}
|
|
|
|
// This is apparently the only way to get setup to remove all the registry backup
|
|
// for old names no longer in use...
|
|
hrTemp = CallRegInstall("CleanupOldRollback1");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
hrTemp = CallRegInstall("CleanupOldRollback2");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
|
|
// REVIEW (ToddB): Move this to DllRegisterServer.
|
|
hrTemp = Shell32RegTypeLib();
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
ApplyRegistrySecurity();
|
|
FixPlusIcons();
|
|
|
|
// Filesystem stuff should be done only on the native platform
|
|
// (don't do it when in the emulator) since there is only one
|
|
// filesystem. Otherwise the 32-bit version writes 32-bit goo
|
|
// into the filesystem that the 64-bit shell32 can't handle
|
|
if (!IsOS(OS_WOW6432))
|
|
{
|
|
CleanupFileSystem();
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
// this will copy eula.txt to the %SystemRoot%\SysWOW64 directory for
|
|
// 32-bit apps running on IA64 under emulation
|
|
CopyEULAForWow6432();
|
|
#endif
|
|
// Initialize the shared documents objects
|
|
InitializeSharedDocs(IsOS(OS_WOW6432));
|
|
|
|
DoFusion();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We only need one unreg call since all our sections share
|
|
// the same backup information
|
|
hrTemp = CallRegInstall("UnregDll");
|
|
KEEP_FAILURE(hrTemp, hr);
|
|
UnregisterTypeLibrary(&LIBID_Shell32);
|
|
}
|
|
|
|
CDeskHtmlProp_RegUnReg(bInstall);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI DllRegisterServer(void)
|
|
{
|
|
// NT5 setup calls this so it is now safe to put code here.
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDAPI DllUnregisterServer(void)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
BOOL CopyRegistryValues (HKEY hKeyBaseSource, LPCTSTR pszSource, HKEY hKeyBaseTarget, LPCTSTR pszTarget)
|
|
{
|
|
DWORD dwDisposition, dwMaxValueNameSize, dwMaxValueDataSize;
|
|
HKEY hKeySource, hKeyTarget;
|
|
BOOL fSuccess = FALSE; //Assume error!
|
|
|
|
hKeySource = hKeyTarget = NULL;
|
|
if ((ERROR_SUCCESS == RegOpenKeyEx(hKeyBaseSource,
|
|
pszSource,
|
|
0,
|
|
KEY_READ,
|
|
&hKeySource)) &&
|
|
(ERROR_SUCCESS == RegCreateKeyEx(hKeyBaseTarget,
|
|
pszTarget,
|
|
0,
|
|
TEXT(""),
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKeyTarget,
|
|
&dwDisposition)) &&
|
|
(ERROR_SUCCESS == RegQueryInfoKey(hKeySource,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwMaxValueNameSize,
|
|
&dwMaxValueDataSize,
|
|
NULL,
|
|
NULL)))
|
|
{
|
|
TCHAR *pszValueName;
|
|
void *pValueData;
|
|
|
|
pszValueName = reinterpret_cast<TCHAR*>(LocalAlloc(LMEM_FIXED, ++dwMaxValueNameSize * sizeof(TCHAR)));
|
|
if (pszValueName != NULL)
|
|
{
|
|
pValueData = LocalAlloc(LMEM_FIXED, dwMaxValueDataSize);
|
|
if (pValueData != NULL)
|
|
{
|
|
DWORD dwIndex, dwType, dwValueNameSize, dwValueDataSize;
|
|
|
|
dwIndex = 0;
|
|
dwValueNameSize = dwMaxValueNameSize;
|
|
dwValueDataSize = dwMaxValueDataSize;
|
|
while (ERROR_SUCCESS == RegEnumValue(hKeySource,
|
|
dwIndex,
|
|
pszValueName,
|
|
&dwValueNameSize,
|
|
NULL,
|
|
&dwType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
&dwValueDataSize))
|
|
{
|
|
RegSetValueEx(hKeyTarget,
|
|
pszValueName,
|
|
0,
|
|
dwType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
dwValueDataSize);
|
|
++dwIndex;
|
|
dwValueNameSize = dwMaxValueNameSize;
|
|
dwValueDataSize = dwMaxValueDataSize;
|
|
}
|
|
LocalFree(pValueData);
|
|
fSuccess = TRUE; //Succeeded!
|
|
}
|
|
LocalFree(pszValueName);
|
|
}
|
|
}
|
|
if(hKeySource)
|
|
RegCloseKey(hKeySource);
|
|
if(hKeyTarget)
|
|
RegCloseKey(hKeyTarget);
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
STDAPI MergeDesktopAndNormalStreams(void)
|
|
{
|
|
static const TCHAR scszBaseRegistryLocation[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer");
|
|
static const int sciMaximumStreams = 128;
|
|
static const TCHAR sccOldMRUListBase = TEXT('a');
|
|
|
|
// Upgrade from NT4 (classic shell) to Windows 2000 (integrated shell)
|
|
|
|
// This involves TWO major changes and one minor change:
|
|
// 1. Merging DesktopStreamMRU and StreamMRU
|
|
// 2. Upgrading the MRUList to MRUListEx
|
|
// 3. Leaving the old settings alone for the roaming user profile scenario
|
|
|
|
// This also involves special casing the users desktop PIDL because this is
|
|
// stored as an absolute path PIDL in DesktopStream and needs to be stored
|
|
// in Streams\Desktop instead.
|
|
|
|
// The conversion is performed in-situ and simultaneously.
|
|
|
|
// 1. Open all the keys we are going to need to do the conversion.
|
|
|
|
HKEY hKeyBase, hKeyDesktopStreamMRU, hKeyDesktopStreams, hKeyStreamMRU, hKeyStreams;
|
|
|
|
hKeyBase = hKeyDesktopStreamMRU = hKeyDesktopStreams = hKeyStreamMRU = hKeyStreams = NULL;
|
|
if ((ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
|
|
scszBaseRegistryLocation,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyBase)) &&
|
|
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
|
|
TEXT("DesktopStreamMRU"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyDesktopStreamMRU)) &&
|
|
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
|
|
TEXT("DesktopStreams"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyDesktopStreams)) &&
|
|
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
|
|
TEXT("StreamMRU"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyStreamMRU)) &&
|
|
(ERROR_SUCCESS == RegOpenKeyEx(hKeyBase,
|
|
TEXT("Streams"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyStreams)) &&
|
|
|
|
// 2. Determine whether this upgrade is needed at all. If the presence of
|
|
// StreamMRU\MRUListEx is detected then stop.
|
|
|
|
(ERROR_SUCCESS != RegQueryValueEx(hKeyStreamMRU,
|
|
TEXT("MRUListEx"),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL)))
|
|
{
|
|
DWORD *pdwMRUListEx, *pdwMRUListExBase;
|
|
|
|
pdwMRUListExBase = pdwMRUListEx = reinterpret_cast<DWORD*>(LocalAlloc(LPTR, sciMaximumStreams * sizeof(DWORD) * 2));
|
|
if (pdwMRUListEx != NULL)
|
|
{
|
|
DWORD dwLastFreeSlot, dwMRUListSize, dwType;
|
|
TCHAR *pszMRUList, szMRUList[sciMaximumStreams];
|
|
|
|
// 3. Read the StreamMRU\MRUList, iterate thru this list
|
|
// and convert as we go.
|
|
|
|
dwLastFreeSlot = 0;
|
|
dwMRUListSize = sizeof(szMRUList);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
|
|
TEXT("MRUList"),
|
|
NULL,
|
|
&dwType,
|
|
reinterpret_cast<LPBYTE>(szMRUList),
|
|
&dwMRUListSize))
|
|
{
|
|
pszMRUList = szMRUList;
|
|
while (*pszMRUList != TEXT('\0'))
|
|
{
|
|
DWORD dwValueDataSize;
|
|
TCHAR szValue[16];
|
|
|
|
// Read the PIDL information based on the letter in
|
|
// the MRUList.
|
|
|
|
szValue[0] = *pszMRUList++;
|
|
szValue[1] = TEXT('\0');
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
|
|
szValue,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwValueDataSize))
|
|
{
|
|
DWORD dwValueType;
|
|
void *pValueData;
|
|
|
|
pValueData = LocalAlloc(LMEM_FIXED, dwValueDataSize);
|
|
if ((pValueData != NULL) &&
|
|
(ERROR_SUCCESS == RegQueryValueEx(hKeyStreamMRU,
|
|
szValue,
|
|
NULL,
|
|
&dwValueType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
&dwValueDataSize)))
|
|
{
|
|
|
|
// Allocate a new number in the MRUListEx for the PIDL.
|
|
|
|
*pdwMRUListEx = szValue[0] - sccOldMRUListBase;
|
|
wsprintf(szValue, TEXT("%d"), *pdwMRUListEx++);
|
|
++dwLastFreeSlot;
|
|
RegSetValueEx(hKeyStreamMRU,
|
|
szValue,
|
|
NULL,
|
|
dwValueType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
dwValueDataSize);
|
|
LocalFree(pValueData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4. Read the DesktopStreamMRU\MRUList, iterate thru this
|
|
// this and append to the new MRUListEx that is being
|
|
// created as well as copying both the PIDL in DesktopStreamMRU
|
|
// and the view information in DesktopStreams.
|
|
|
|
dwMRUListSize = sizeof(szMRUList);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
|
|
TEXT("MRUList"),
|
|
NULL,
|
|
&dwType,
|
|
reinterpret_cast<LPBYTE>(szMRUList),
|
|
&dwMRUListSize))
|
|
{
|
|
bool fConvertedEmptyPIDL;
|
|
TCHAR szDesktopDirectoryPath[MAX_PATH];
|
|
|
|
fConvertedEmptyPIDL = false;
|
|
SHGetFolderPath(NULL, CSIDL_DESKTOPDIRECTORY, NULL, SHGFP_TYPE_CURRENT, szDesktopDirectoryPath);
|
|
pszMRUList = szMRUList;
|
|
while (*pszMRUList != TEXT('\0'))
|
|
{
|
|
DWORD dwValueDataSize;
|
|
TCHAR szSource[16];
|
|
|
|
// Read the PIDL information based on the letter in
|
|
// the MRUList.
|
|
|
|
szSource[0] = *pszMRUList++;
|
|
szSource[1] = TEXT('\0');
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
|
|
szSource,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwValueDataSize))
|
|
{
|
|
DWORD dwValueType;
|
|
void *pValueData;
|
|
|
|
pValueData = LocalAlloc(LMEM_FIXED, dwValueDataSize);
|
|
if ((pValueData != NULL) &&
|
|
(ERROR_SUCCESS == RegQueryValueEx(hKeyDesktopStreamMRU,
|
|
szSource,
|
|
NULL,
|
|
&dwValueType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
&dwValueDataSize)))
|
|
{
|
|
TCHAR szTarget[16], szStreamPath[MAX_PATH];
|
|
|
|
if ((SHGetPathFromIDList(reinterpret_cast<LPCITEMIDLIST>(pValueData), szStreamPath) != 0) &&
|
|
(0 == lstrcmpi(szStreamPath, szDesktopDirectoryPath)))
|
|
{
|
|
if (!fConvertedEmptyPIDL)
|
|
{
|
|
|
|
// 99/05/24 #343721 vtan: Prefer the desktop relative PIDL
|
|
// (empty PIDL) when given a choice of two PIDLs that refer
|
|
// to the desktop. The old absolute PIDL is from SP3 and
|
|
// earlier days. The new relative PIDL is from SP4 and
|
|
// later days. An upgraded SP3 -> SP4 -> SPx -> Windows
|
|
// 2000 system will possibly have old absolute PIDLs.
|
|
// Check for the empty PIDL. If this is encountered already
|
|
// then don't process this stream.
|
|
|
|
fConvertedEmptyPIDL = ILIsEmpty(reinterpret_cast<LPCITEMIDLIST>(pValueData));
|
|
wsprintf(szSource, TEXT("%d"), szSource[0] - sccOldMRUListBase);
|
|
CopyRegistryValues(hKeyDesktopStreams, szSource, hKeyStreams, TEXT("Desktop"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// Allocate a new number in the MRUListEx for the PIDL.
|
|
|
|
*pdwMRUListEx++ = dwLastFreeSlot;
|
|
wsprintf(szTarget, TEXT("%d"), dwLastFreeSlot++);
|
|
if (ERROR_SUCCESS == RegSetValueEx(hKeyStreamMRU,
|
|
szTarget,
|
|
NULL,
|
|
dwValueType,
|
|
reinterpret_cast<LPBYTE>(pValueData),
|
|
dwValueDataSize))
|
|
{
|
|
|
|
// Copy the view information from DesktopStreams to Streams
|
|
|
|
wsprintf(szSource, TEXT("%d"), szSource[0] - sccOldMRUListBase);
|
|
CopyRegistryValues(hKeyDesktopStreams, szSource, hKeyStreams, szTarget);
|
|
}
|
|
}
|
|
LocalFree(pValueData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*pdwMRUListEx++ = static_cast<DWORD>(-1);
|
|
RegSetValueEx(hKeyStreamMRU,
|
|
TEXT("MRUListEx"),
|
|
NULL,
|
|
REG_BINARY,
|
|
reinterpret_cast<LPCBYTE>(pdwMRUListExBase),
|
|
++dwLastFreeSlot * sizeof(DWORD));
|
|
LocalFree(reinterpret_cast<HLOCAL>(pdwMRUListExBase));
|
|
}
|
|
}
|
|
if (hKeyStreams != NULL)
|
|
RegCloseKey(hKeyStreams);
|
|
if (hKeyStreamMRU != NULL)
|
|
RegCloseKey(hKeyStreamMRU);
|
|
if (hKeyDesktopStreams != NULL)
|
|
RegCloseKey(hKeyDesktopStreams);
|
|
if (hKeyDesktopStreamMRU != NULL)
|
|
RegCloseKey(hKeyDesktopStreamMRU);
|
|
if (hKeyBase != NULL)
|
|
RegCloseKey(hKeyBase);
|
|
return(S_OK);
|
|
}
|
|
|
|
static const int s_ciMaximumNumericString = 32;
|
|
|
|
int GetRegistryStringValueAsInteger (HKEY hKey, LPCTSTR pszValue, int iDefaultValue)
|
|
|
|
{
|
|
int iResult;
|
|
DWORD dwType, dwStringSize;
|
|
TCHAR szString[s_ciMaximumNumericString];
|
|
|
|
dwStringSize = sizeof(szString);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
|
|
pszValue,
|
|
NULL,
|
|
&dwType,
|
|
reinterpret_cast<LPBYTE>(szString),
|
|
&dwStringSize) && (dwType == REG_SZ))
|
|
{
|
|
iResult = StrToInt(szString);
|
|
}
|
|
else
|
|
{
|
|
iResult = iDefaultValue;
|
|
}
|
|
return(iResult);
|
|
}
|
|
|
|
void SetRegistryIntegerAsStringValue (HKEY hKey, LPCTSTR pszValue, int iValue)
|
|
|
|
{
|
|
TCHAR szString[s_ciMaximumNumericString];
|
|
|
|
wnsprintf(szString, ARRAYSIZE(szString), TEXT("%d"), iValue);
|
|
TW32(RegSetValueEx(hKey,
|
|
pszValue,
|
|
0,
|
|
REG_SZ,
|
|
reinterpret_cast<LPBYTE>(szString),
|
|
(lstrlen(szString) + sizeof('\0')) * sizeof(TCHAR)));
|
|
}
|
|
|
|
STDAPI MoveAndAdjustIconMetrics(void)
|
|
{
|
|
// 99/06/06 #309198 vtan: The following comes from hiveusd.inx which is
|
|
// where this functionality used to be executed. It used to consist of
|
|
// simple registry deletion and addition. This doesn't work on upgrade
|
|
// when the user has large icons (Shell Icon Size == 48).
|
|
|
|
// In this case that metric must be moved and the new values adjusted
|
|
// so that the metric is preserved should the user then decide to turn
|
|
// off large icons.
|
|
|
|
// To restore old functionality, remove the entry in hiveusd.inx at
|
|
// build 1500 which is where this function is invoked and copy the
|
|
// old text back in.
|
|
|
|
/*
|
|
HKR,"1508\Hive\2","Action",0x00010001,3
|
|
HKR,"1508\Hive\2","KeyName",0000000000,"Control Panel\Desktop\WindowMetrics"
|
|
HKR,"1508\Hive\2","Value",0000000000,"75"
|
|
HKR,"1508\Hive\2","ValueName",0000000000,"IconSpacing"
|
|
HKR,"1508\Hive\3","Action",0x00010001,3
|
|
HKR,"1508\Hive\3","KeyName",0000000000,"Control Panel\Desktop\WindowMetrics"
|
|
HKR,"1508\Hive\3","Value",0000000000,"1"
|
|
HKR,"1508\Hive\3","ValueName",0000000000,"IconTitleWrap"
|
|
*/
|
|
|
|
// Icon metric keys have moved from HKCU\Control Panel\Desktop\Icon*
|
|
// to HKCU\Control Panel\Desktop\WindowMetrics\Icon* but only 3 values
|
|
// should be moved. These are "IconSpacing", "IconTitleWrap" and
|
|
// "IconVerticalSpacing". This code is executed before the deletion
|
|
// entry in hiveusd.inx so that it can get the values before they
|
|
// are deleted. The addition section has been remove (it's above).
|
|
|
|
static const TCHAR s_cszIconSpacing[] = TEXT("IconSpacing");
|
|
static const TCHAR s_cszIconTitleWrap[] = TEXT("IconTitleWrap");
|
|
static const TCHAR s_cszIconVerticalSpacing[] = TEXT("IconVerticalSpacing");
|
|
|
|
static const int s_ciStandardOldIconSpacing = 75;
|
|
static const int s_ciStandardNewIconSpacing = -1125;
|
|
|
|
HKEY hKeyDesktop, hKeyWindowMetrics;
|
|
|
|
hKeyDesktop = hKeyWindowMetrics = NULL;
|
|
if ((ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
|
|
TEXT("Control Panel\\Desktop"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyDesktop)) &&
|
|
(ERROR_SUCCESS == RegOpenKeyEx(hKeyDesktop,
|
|
TEXT("WindowMetrics"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyWindowMetrics)))
|
|
{
|
|
int iIconSpacing, iIconTitleWrap, iIconVerticalSpacing;
|
|
|
|
// 1. Read the values that we wish the move and adjust.
|
|
|
|
iIconSpacing = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconSpacing, s_ciStandardOldIconSpacing);
|
|
iIconTitleWrap = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconTitleWrap, 1);
|
|
iIconVerticalSpacing = GetRegistryStringValueAsInteger(hKeyDesktop, s_cszIconVerticalSpacing, s_ciStandardOldIconSpacing);
|
|
|
|
// 2. Perform the adjustment.
|
|
|
|
iIconSpacing = s_ciStandardNewIconSpacing * iIconSpacing / s_ciStandardOldIconSpacing;
|
|
iIconVerticalSpacing = s_ciStandardNewIconSpacing * iIconVerticalSpacing / s_ciStandardOldIconSpacing;
|
|
|
|
// 3. Write the values back out in the new (moved) location.
|
|
|
|
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconSpacing, iIconSpacing);
|
|
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconTitleWrap, iIconTitleWrap);
|
|
SetRegistryIntegerAsStringValue(hKeyWindowMetrics, s_cszIconVerticalSpacing, iIconVerticalSpacing);
|
|
|
|
// 4. Let winlogon continue processing hiveusd.inx and delete the
|
|
// old entries in the process. We already created the new entries
|
|
// and that has been removed from hiveusd.inx.
|
|
|
|
}
|
|
if (hKeyWindowMetrics != NULL)
|
|
TW32(RegCloseKey(hKeyWindowMetrics));
|
|
if (hKeyDesktop != NULL)
|
|
TW32(RegCloseKey(hKeyDesktop));
|
|
return(S_OK);
|
|
}
|
|
|
|
STDAPI FirstUserLogon(LPCSTR pcszCommand, LPCSTR pcszOptionalArguments)
|
|
{
|
|
const struct
|
|
{
|
|
LPCSTR pcszCommand;
|
|
HRESULT (WINAPI *pfn)();
|
|
}
|
|
sCommands[] =
|
|
{
|
|
{ "MergeDesktopAndNormalStreams", MergeDesktopAndNormalStreams },
|
|
{ "MoveAndAdjustIconMetrics", MoveAndAdjustIconMetrics },
|
|
};
|
|
|
|
HRESULT hr = E_FAIL;
|
|
// Match what shmgrate.exe passed us and execute the command.
|
|
// Only use the optional argument if required. Note this is
|
|
// done ANSI because the original command line is ANSI from
|
|
// shmgrate.exe.
|
|
|
|
for (int i = 0; i < ARRAYSIZE(sCommands); ++i)
|
|
{
|
|
if (lstrcmpA(pcszCommand, sCommands[i].pcszCommand) == 0)
|
|
{
|
|
hr = sCommands[i].pfn();
|
|
break;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
#ifdef INSTALL_MSI
|
|
//
|
|
// WebFolders namespace extension installation.
|
|
// This is the code that initially installs the Office WebFolders
|
|
// shell namespace extension on the computer. Code in shmgrate.exe
|
|
// (see private\windows\shell\migrate) performs per-user
|
|
// web folders registration duties.
|
|
//
|
|
typedef UINT (WINAPI * PFNMSIINSTALLPRODUCT)(LPCTSTR, LPCTSTR);
|
|
typedef INSTALLUILEVEL (WINAPI * PFNMSISETINTERNALUI)(INSTALLUILEVEL, HWND *);
|
|
|
|
#define GETPROC(var, hmod, ptype, fn) ptype var = (ptype)GetProcAddress(hmod, fn)
|
|
|
|
#define API_MSISETINTERNALUI "MsiSetInternalUI"
|
|
#ifdef UNICODE
|
|
# define API_MSIINSTALLPRODUCT "MsiInstallProductW"
|
|
#else
|
|
# define API_MSIINSTALLPRODUCT "MsiInstallProductA"
|
|
#endif
|
|
|
|
void MSI_Install(LPTSTR pszMSIFile)
|
|
{
|
|
HMODULE hmod = LoadLibrary(TEXT("msi.dll"));
|
|
if (hmod)
|
|
{
|
|
BOOL bFreeLib = FALSE;
|
|
GETPROC(pfnMsiSetInternalUI, hmod, PFNMSISETINTERNALUI, API_MSISETINTERNALUI);
|
|
GETPROC(pfnMsiInstallProduct, hmod, PFNMSIINSTALLPRODUCT, API_MSIINSTALLPRODUCT);
|
|
|
|
if (pfnMsiSetInternalUI && pfnMsiInstallProduct)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
GetSystemDirectory(szPath, ARRAYSIZE(szPath));
|
|
PathAppend(szPath, pszMSIFile);
|
|
|
|
//
|
|
// Use "silent" install mode. No UI.
|
|
//
|
|
INSTALLUILEVEL oldUILevel = pfnMsiSetInternalUI(INSTALLUILEVEL_NONE, NULL);
|
|
|
|
// Install the MSI package.
|
|
// Old code did this polling loop on a background thread, but that doesn't
|
|
// work since we're called at DllInstall time, and the process will
|
|
// go away before the install completes. Must do it all on this thread.
|
|
// Wait a little bit before re-trying.
|
|
UINT uRet = 0;
|
|
do {
|
|
uRet = pfnMsiInstallProduct(szPath, TEXT(""));
|
|
} while ((uRet == ERROR_INSTALL_ALREADY_RUNNING) && (Sleep(100),TRUE));
|
|
|
|
pfnMsiSetInternalUI(oldUILevel, NULL);
|
|
}
|
|
|
|
if (bFreeLib)
|
|
FreeLibrary(hmod);
|
|
}
|
|
}
|
|
|
|
#endif // INSTALL_MSI
|
|
|
|
|
|
// now is the time on sprockets when we lock down the registry
|
|
STDAPI_(BOOL) ApplyRegistrySecurity()
|
|
{
|
|
BOOL fSuccess = FALSE; // assume failure
|
|
SHELL_USER_PERMISSION supEveryone;
|
|
SHELL_USER_PERMISSION supSystem;
|
|
SHELL_USER_PERMISSION supAdministrators;
|
|
PSHELL_USER_PERMISSION aPerms[3] = {&supEveryone, &supSystem, &supAdministrators};
|
|
|
|
// we want the "Everyone" to have read access
|
|
supEveryone.susID = susEveryone;
|
|
supEveryone.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supEveryone.dwAccessMask = KEY_READ;
|
|
supEveryone.fInherit = TRUE;
|
|
supEveryone.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
|
|
supEveryone.dwInheritAccessMask = GENERIC_READ;
|
|
|
|
// we want the "SYSTEM" to have full control
|
|
supSystem.susID = susSystem;
|
|
supSystem.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supSystem.dwAccessMask = KEY_ALL_ACCESS;
|
|
supSystem.fInherit = TRUE;
|
|
supSystem.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
|
|
supSystem.dwInheritAccessMask = GENERIC_ALL;
|
|
|
|
// we want the "Administrators" to have full control
|
|
supAdministrators.susID = susAdministrators;
|
|
supAdministrators.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supAdministrators.dwAccessMask = KEY_ALL_ACCESS;
|
|
supAdministrators.fInherit = TRUE;
|
|
supAdministrators.dwInheritMask = (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE);
|
|
supAdministrators.dwInheritAccessMask = GENERIC_ALL;
|
|
|
|
SECURITY_DESCRIPTOR* psd = GetShellSecurityDescriptor(aPerms, ARRAYSIZE(aPerms));
|
|
if (psd)
|
|
{
|
|
HKEY hkLMBitBucket;
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket"), 0, KEY_ALL_ACCESS, &hkLMBitBucket) == ERROR_SUCCESS)
|
|
{
|
|
if (RegSetKeySecurity(hkLMBitBucket, DACL_SECURITY_INFORMATION, psd) == ERROR_SUCCESS)
|
|
{
|
|
// victory is mine!
|
|
fSuccess = TRUE;
|
|
}
|
|
|
|
RegCloseKey(hkLMBitBucket);
|
|
}
|
|
|
|
LocalFree(psd);
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
CComModule _Module;
|
|
|
|
BEGIN_OBJECT_MAP(ObjectMap)
|
|
// nothing in here, use clsobj.c class table instead
|
|
END_OBJECT_MAP()
|
|
|
|
// ATL DllMain, needed to support our ATL classes that depend on _Module
|
|
// REVIEW: confirm that _Module is really needed
|
|
|
|
STDAPI_(BOOL) ATL_DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
|
|
{
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
_Module.Init(ObjectMap, hInstance);
|
|
}
|
|
else if (dwReason == DLL_PROCESS_DETACH)
|
|
{
|
|
_Module.Term();
|
|
}
|
|
return TRUE; // ok
|
|
}
|
|
|
|
#define FUSION_FLAG_SYSTEM32 0
|
|
#define FUSION_FLAG_WINDOWS 1
|
|
#define FUSION_FLAG_PROGRAMFILES 2
|
|
#define FUSION_ENTRY(x, z) {L#x, NULL, z},
|
|
#define FUSION_ENTRY_DEST(x, y, z) {L#x, L#y, z},
|
|
|
|
struct
|
|
{
|
|
PWSTR pszAppName;
|
|
PWSTR pszDestination;
|
|
DWORD dwFlags;
|
|
}
|
|
g_FusionizedApps[] =
|
|
{
|
|
FUSION_ENTRY(ncpa.cpl, FUSION_FLAG_SYSTEM32)
|
|
FUSION_ENTRY(nwc.cpl, FUSION_FLAG_SYSTEM32)
|
|
FUSION_ENTRY(sapi.cpl, FUSION_FLAG_SYSTEM32)
|
|
FUSION_ENTRY(wuaucpl.cpl, FUSION_FLAG_SYSTEM32)
|
|
FUSION_ENTRY(cdplayer.exe, FUSION_FLAG_SYSTEM32)
|
|
FUSION_ENTRY_DEST(msimn.exe, "OutLook Express", FUSION_FLAG_PROGRAMFILES)
|
|
// WARNING: Do NOT add iexplorer or Explorer.exe! This will cause all apps to get fusioned; which is bad, mkay?
|
|
};
|
|
|
|
|
|
|
|
void DoFusion()
|
|
{
|
|
TCHAR szManifest[MAX_PATH];
|
|
|
|
// We will however generate a manifest for other apps
|
|
for (int i = 0; i < ARRAYSIZE(g_FusionizedApps); i++)
|
|
{
|
|
switch(g_FusionizedApps[i].dwFlags)
|
|
{
|
|
case FUSION_FLAG_SYSTEM32:
|
|
GetSystemDirectory(szManifest, ARRAYSIZE(szManifest));
|
|
break;
|
|
|
|
case FUSION_FLAG_WINDOWS:
|
|
GetWindowsDirectory(szManifest, ARRAYSIZE(szManifest));
|
|
break;
|
|
|
|
case FUSION_FLAG_PROGRAMFILES:
|
|
SHGetSpecialFolderPath(NULL, szManifest, CSIDL_PROGRAM_FILES, FALSE);
|
|
PathCombine(szManifest, szManifest, g_FusionizedApps[i].pszDestination);
|
|
break;
|
|
}
|
|
|
|
PathCombine(szManifest, szManifest, g_FusionizedApps[i].pszAppName);
|
|
StrCatBuff(szManifest, TEXT(".manifest"), ARRAYSIZE(szManifest));
|
|
SHSquirtManifest(HINST_THISDLL, IDS_EXPLORERMANIFEST, szManifest);
|
|
}
|
|
|
|
SHGetManifest(szManifest, ARRAYSIZE(szManifest));
|
|
SHSquirtManifest(HINST_THISDLL, IDS_EXPLORERMANIFEST, szManifest);
|
|
}
|