jelreginstaller.cpp

Java写的文本编辑器

			CString strJavaExec(pData->strJavaHome);
			strJavaExec += _T("\\javaw.exe");
			nResult = RegSetValueEx(hVersionKey, arszValues[0], 0,
				REG_SZ, (LPBYTE)(LPCTSTR)strJavaExec,
				InstallData::GetBufferByteLen(strJavaExec));
			if(ERROR_SUCCESS == nResult)
			{
				InstallerLog::Log(
					"Writing \"Java Executable\" registry parameter: &s\n",
					(LPCSTR)strJavaExec);
			}
			else
			{
				InstallerLog::Log(
					"Could not write \"Java Executable\" registry parameter.\n");
			}
		}
	}
	// "Java Options" - set if new parameters, update old parameter
	nResult = RegQueryValueEx(hVersionKey, arszValues[1], 0, 0, (LPBYTE)szBuf, &dwValueSize);
	if(!bUseOldParameters || nResult != ERROR_SUCCESS || dwValueSize == 0)
	{
		bUseOldParameters = false;
		CString strJavaOptions(_T("-jar -mx32m"));
//		strJavaOptions.Format(IDS_REG_JAVAPARAM_DEFAULT,
//			pData->arPathNames[pData->nIndexSubjectVer]);
		nResult = RegSetValueEx(hVersionKey, arszValues[1], 0,
			REG_SZ, (LPBYTE)(LPCTSTR)strJavaOptions,
			InstallData::GetBufferByteLen(strJavaOptions));
		if(ERROR_SUCCESS == nResult)
		{
			InstallerLog::Log("Writing \"Java Options\" registry parameter:	%s\n",
				(LPCSTR)strJavaOptions);
		}
		else
		{
			InstallerLog::Log(
				"Could not write \"Java Options\" registry parameter.\n");
		}
	}
	else
	{
		UpdateJarParameter(szBuf);
		nResult = RegSetValueEx(hVersionKey, arszValues[1], 0,
			REG_SZ, (LPBYTE)szBuf,
			(_tcslen(szBuf) + 1) * sizeof(TCHAR));
		if(ERROR_SUCCESS == nResult)
		{
			InstallerLog::Log("Writing \"Java Options\" registry parameter:	%s\n",
				(LPCSTR)szBuf);
		}
		else
		{
			InstallerLog::Log(
				"Could not write \"Java Options\" registry parameter.\n");
		}
	}

	// "jEdit Target" -- must always be set
	CString strJEditTarget;
	nResult = RegQueryValueEx(hVersionKey, arszValues[2], 0, 0, (LPBYTE)szBuf, &dwValueSize);
	if(nResult != ERROR_SUCCESS || dwValueSize == 0
		|| !bUseOldParameters || strstr(szBuf, "jedit.jar") != 0)
	{
		strJEditTarget = _T("\"");
		strJEditTarget += pData->strInstallPath.Left(pData->strInstallPath.GetLength() - 12);
		strJEditTarget += _T("jedit.jar\"");
	}
	else
	{
		strJEditTarget = _T("org.gjt.sp.jedit.jEdit");
	}
	nResult = RegSetValueEx(hVersionKey, arszValues[2], 0,
		REG_SZ, (LPBYTE)(LPCTSTR)strJEditTarget,
		InstallData::GetBufferByteLen(strJEditTarget));
	if(ERROR_SUCCESS == nResult)
	{
		InstallerLog::Log("Writing \"jEdit Target\" registry parameter:	%s\n",
			(LPCSTR)strJEditTarget);
	}
	else
	{
		InstallerLog::Log(
			"Could not write \"jEdit Target\" registry parameter.\n");
	}


	// "jEdit Options" - default is no options
	if(!bUseOldParameters)
	{
		// "jEdit Options"
		char szBuf = 0;
		nResult = RegSetValueEx(hVersionKey, arszValues[3], 0,
			REG_SZ, (LPBYTE)szBuf, sizeof(TCHAR));
		if(ERROR_SUCCESS == nResult)
		{
			InstallerLog::Log(
				"Writing empty \"jEdit Options\" registry parameter.\n");
		}
		else
		{
			InstallerLog::Log(
				"Could not write \"jEdit Options\" registry parameter.\n");
		}
	}

	// "jEdit Working Directory"
	// always change working directory, so you can't get
	// an orphan entry following an uninstall of another version

	CString strWorkingDir(pData->arPathNames[pData->nIndexSubjectVer]);
	nResult = RegSetValueEx(hVersionKey, arszValues[4], 0,
		REG_SZ, (LPBYTE)(LPCTSTR)strWorkingDir,
		InstallData::GetBufferByteLen(strWorkingDir));
	if(ERROR_SUCCESS == nResult)
	{
		InstallerLog::Log(
			"Writing \"jEdit Working Directory\" registry parameter: %s\n",
				(LPCTSTR)strWorkingDir);
	}
	else
	{
		InstallerLog::Log(
			"Could not write \"jEdit Working Directory\" registry parameter.\n");
	}


	// "Launcher GUID"
	nResult = RegSetValueEx(hVersionKey, arszValues[5], 0,
		REG_SZ, (LPBYTE)(LPCTSTR)pData->strInstallGUID,
		InstallData::GetBufferByteLen(pData->strInstallGUID));
	if(ERROR_SUCCESS == nResult)
	{
		InstallerLog::Log(
			"Writing \"Launcher GUID\" registry parameter: %s\n",
				(LPCTSTR)pData->strInstallGUID);
	}
	else
	{
		InstallerLog::Log(
			"Could not write \"Launcher GUID\" registry parameter.\n");
	}

	// "Installation Dir"
	nResult = RegSetValueEx(hVersionKey, arszValues[6], 0,
		REG_SZ, (LPBYTE)(LPCTSTR)pData->strInstallDir,
		InstallData::GetBufferByteLen(pData->strInstallDir));
	if(ERROR_SUCCESS == nResult)
	{
		InstallerLog::Log(
			"Writing \"Installation Dir\" registry parameter: %s\n",
				(LPCTSTR)pData->strInstallDir);
	}
	else
	{
		InstallerLog::Log(
			"Could not write \"Installation Dir\" registry parameter.\n");
	}


	RegCloseKey(hVersionKey);
	RegCloseKey(hLauncherKey);
	InstallerLog::Log("Command line parameters registered.\n");
	return S_OK;
}

// if "jEdit.jar" appears in the parameter,
// get the associated directory and change to the
// current install directory
void JELRegistryInstaller::UpdateJarParameter(LPTSTR lpszParam)
{
	CString strLCParam(lpszParam);
	strLCParam.MakeLower();
	const TCHAR *pJar = lpszParam + strLCParam.Find(_T("jedit.jar"));
	if(pJar <= lpszParam) return;
	bool quoted = false;
	const TCHAR *pStart = lpszParam;
	const TCHAR *p;
	for(p = lpszParam; p < pJar; ++p)
	{
		switch (*p)
		{
			case _T(';'): pStart = p; break;
			case _T(' '): if(!quoted) pStart = p; break;
			case _T('\"'): quoted = !quoted; if(quoted) pStart = p; break;
			default: break;
		}
	}
	// now pStart points to the beginning of the jedit.jar path,
	// or a leading space, quote or semicolon; next we trim
	bool bContinue = true;
	for(p = pStart; bContinue && p < pJar; ++p)
	{
		switch(*p)
		{
			case _T(';'):
			case _T(' '):
			case _T('\"'): pStart = p; break;
			default: bContinue = false; break;
		}
	}
	// now we replace from pStart to pJar with the new install dir
	char szNewParam[MAX_PATH];
	ZeroMemory(szNewParam, MAX_PATH);
	lstrcpyn(szNewParam, lpszParam, pStart - lpszParam);
	CString strPath(pData->strInstallPath.Left(pData->strInstallPath.GetLength() - 12));
	lstrcat(szNewParam, strPath);
	lstrcat(szNewParam, pJar);
	lstrcpy(lpszParam, szNewParam);
}


HRESULT JELRegistryInstaller::Uninstall()
{
	UnregisterCmdLineParameters();
	CString strDir(pData->arPathNames[pData->nIndexSubjectVer]);

	// unregister proxy/stub DLL
	CString strPath(strDir);
	strPath += _T("\\jeservps.dll");
	RegisterDLL(strPath, FALSE);

	// clean up proxy/stub;  this is interface GUID
	CString strPxStubCLSID(_T("CLSID\\{E53269FA-8A5C-42B0-B3BC-82254F4FCED4}"));
	RegDeleteKey(HKEY_CLASSES_ROOT, strPxStubCLSID + _T("\\InProcServer32"));
	RegDeleteKey(HKEY_CLASSES_ROOT, strPxStubCLSID);

	// unregister COM Server
	strPath = strDir;
	strPath += _T("\\jeditsrv.exe");
	RegisterEXE(strPath, FALSE);

	CheckUnregisterCtxMenu();


	// send message to application object to adjust number
	// of installed versions
	DWORD dwMessage = (DWORD)pData->nIndexSubjectVer;
	pOwner->SendMessage((LPVOID)&dwMessage);

	// delete HKEY_CLASSES_ROOT\JEdit.JEditLauncher  and interface key if nothing is left
	if(pData->nInstalledVersions == 0)
	{
		HKEY hLauncherKey;
		if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, _T("JEdit.JEditLauncher"),
			0, KEY_ALL_ACCESS, &hLauncherKey))
		{
			RegDeleteKey(hLauncherKey, _T("CLSID"));
			RegDeleteKey(hLauncherKey, _T("CurVer"));
			RegCloseKey(hLauncherKey);
			RegDeleteKey(HKEY_CLASSES_ROOT, _T("JEdit.JEditLauncher"));
		}
		CString strInterfaceKey(_T("Interface\\{E53269FA-8A5C-42B0-B3BC-82254F4FCED4}"));
		if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, strInterfaceKey,
			0, KEY_ALL_ACCESS, &hLauncherKey))
		{
			RegDeleteKey(hLauncherKey, _T("NumMethods"));
			RegDeleteKey(hLauncherKey, _T("ProxyStubClsid"));
			RegDeleteKey(hLauncherKey, _T("ProxyStubClsid32"));
			RegDeleteKey(hLauncherKey, _T("TypeLib"));
			RegCloseKey(hLauncherKey);
			RegDeleteKey(HKEY_CLASSES_ROOT, strInterfaceKey);
		}
	}
	// otherwise set a new primary version
	else RegisterPrimaryVersion();

	return S_OK;
}

HRESULT JELRegistryInstaller::UnregisterCmdLineParameters()
{
	HKEY hKey;
	// delete command line parameters and any empty parent keys
	CString strLauncherParamKey((LPCSTR)IDS_REG_LAUNCHER_PARAM_KEY);
	int nResult = RegOpenKeyEx(HKEY_CURRENT_USER, strLauncherParamKey,
		0, KEY_ALL_ACCESS,  &hKey);
	if(nResult == ERROR_SUCCESS)
	{
		CString strVersion(pData->arVersionNames[pData->nIndexSubjectVer]);
		RegDeleteKey(hKey, strVersion);
		DWORD dwSubkeys;
		RegQueryInfoKey(hKey, 0, 0, 0, &dwSubkeys, 0, 0, 0, 0, 0, 0, 0);
		if(dwSubkeys == 0)
		{
			RegCloseKey(hKey);
			if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
				_T("Software\\www.jedit.org"), 0, KEY_ALL_ACCESS, &hKey))
			{
				RegDeleteKey(hKey, _T("jEditLauncher"));
				RegQueryInfoKey(hKey, 0, 0, 0, &dwSubkeys, 0, 0, 0, 0, 0, 0, 0);
				if(dwSubkeys == 0)
				{
					RegCloseKey(hKey);
					if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
						_T("Software"), 0, KEY_ALL_ACCESS, &hKey))
					{
						RegDeleteKey(hKey, _T("www.jedit.org"));
					}
				}
			}
		}
	}
	RegCloseKey(hKey);
	return S_OK;
}

// Unregisters ctx menu handler if the current version is installed
HRESULT JELRegistryInstaller::CheckUnregisterCtxMenu()
{
	// first get the CLSID of the installed handler
	CString strCtxMenuKey((LPCSTR)IDS_REG_CTXMENU_KEY);
	CString strCurCtxMenuCLSID;
	HKEY hCtxMenuKey;
	int nResult = RegOpenKeyEx(HKEY_CLASSES_ROOT, strCtxMenuKey, 0,
		KEY_ALL_ACCESS, &hCtxMenuKey);
	if(nResult == ERROR_SUCCESS)
	{
		CStringBuf<>buf(strCurCtxMenuCLSID);
		DWORD dwlength = buf * sizeof(TCHAR);
		nResult = RegQueryValueEx(hCtxMenuKey, 0, 0, 0,
			(LPBYTE)buf, &dwlength);
	}
	RegCloseKey(hCtxMenuKey);

	// now get the path to the handler module from the CLSID
	CString strCurCtxMenuPath;
	CString strServerKey(_T("CLSID\\"));
	strServerKey += strCurCtxMenuCLSID;
	strServerKey += _T("\\InprocServer32");
	nResult = RegOpenKeyEx(HKEY_CLASSES_ROOT, strServerKey, 0,
		KEY_ALL_ACCESS, &hCtxMenuKey);
	if(nResult == ERROR_SUCCESS)
	{
		CStringBuf<>buf(strCurCtxMenuPath);
		DWORD dwlength = buf * sizeof(TCHAR);
		nResult = RegQueryValueEx(hCtxMenuKey, 0, 0, 0,
			(LPBYTE)buf, &dwlength);
	}
	RegCloseKey(hCtxMenuKey);


	// now compare the installed handler's path to
	// the path in this version and delete the key if they match
	CString strPath(pData->arPathNames[pData->nIndexSubjectVer]);
	strPath += _T("\\jeshlstb.dll");
	TCHAR szInstalledPath[MAX_PATH], szCurPath[MAX_PATH];
	GetShortPathName(strCurCtxMenuPath, szInstalledPath, MAX_PATH);
	GetShortPathName(strPath, szCurPath, MAX_PATH);
	HRESULT hr = S_OK;
	if(_tcsicmp(szInstalledPath, szCurPath) == 0)
	{
		RegDeleteKey(HKEY_CLASSES_ROOT, strCtxMenuKey);
		RegisterDLL(szCurPath, FALSE);
	}
	else hr = S_FALSE;
	return hr;
}

HRESULT JELRegistryInstaller::SendMessage(LPVOID p)
{
	p;
	return E_NOTIMPL;
}