Initial ImportHEADmaster

19 files changed, 2923 insertions, 0 deletions

diff --git a/Common/CmptData.cpp b/Common/CmptData.cpp
new file mode 100644
index 0000000..2fd8878
--- /dev/null
+++ b/Common/CmptData.cpp
@@ -0,0 +1,200 @@
+// ShutdownData.cpp: implementation of the CPropertyBagImpl class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "CmptData.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CPropertyBag::CPropertyBag()
+{
+	m_pBag = NULL;
+}
+
+CPropertyBag::~CPropertyBag()
+{
+	m_pBag = NULL;
+}
+
+HRESULT CPropertyBag::Initialize(IUnknown * pUnk)
+{
+	if(pUnk == NULL) 
+	{
+		if(m_pBag != NULL) 
+		{
+			m_pBag->Release();
+			m_pBag = NULL;
+			return S_OK;
+		}
+		else
+			return E_UNEXPECTED;
+	}
+
+	HRESULT hr;
+
+	hr = pUnk->QueryInterface(IID_IPropertyBag, (void**) &m_pBag);
+
+	if(FAILED(hr))
+		m_pBag = NULL;
+
+	return hr;
+
+}
+
+HRESULT CPropertyBag::Initialize(int cUnks, IUnknown** ppUnks)
+{
+	HRESULT hr = S_FALSE;
+
+	for (UINT i = 0; i < cUnks; i++)
+	{
+		hr = Initialize(ppUnks[i]);
+
+		if(SUCCEEDED(hr))
+			return hr;
+	}
+
+	return hr;
+}
+
+int CPropertyBag::GetInt(const string& sKeyName, int nDefault) const
+{
+	if(m_pBag == NULL)
+		return nDefault;
+
+	CComVariant var;
+
+	if(SUCCEEDED(m_pBag->Read(CComBSTR(sKeyName), &var, NULL))) 
+	{
+		if(var.vt == VT_I4)
+		{
+			return var.lVal;
+		}
+		else
+			return nDefault;
+	}
+	else 
+	{
+		return nDefault;
+	}
+}
+
+string CPropertyBag::GetString(const string& sKeyName, const string& sDefault) const
+{
+	USES_CONVERSION;
+
+	if(m_pBag == NULL)
+		return sDefault;
+	
+	CComVariant var;
+	string sRet;
+
+	if(SUCCEEDED(m_pBag->Read(CComBSTR(sKeyName), &var, NULL))) 
+	{
+		if(var.vt == VT_BSTR)
+		{
+			sRet = OLE2T(var.bstrVal);
+			return sRet;
+		}
+		else
+			return sDefault;
+	}
+	else {
+		return sDefault;
+	}
+
+
+}
+
+HRESULT CPropertyBag::WriteInt(const string& sKeyName, int nValue)
+{
+	if(m_pBag == NULL)
+		return E_POINTER;
+
+	CComVariant var;
+
+	var.vt = VT_I4;
+	var.lVal = nValue;
+
+	return m_pBag->Write(CComBSTR(sKeyName), &var);
+
+}
+
+HRESULT CPropertyBag::WriteString(const string& sKeyName, const string& sValue)
+{
+	if(m_pBag == NULL)
+		return E_POINTER;
+
+	CComVariant var;
+	CComBSTR bsVal(sValue);
+
+	var.vt = VT_BSTR;
+	var.bstrVal = bsVal;
+
+	return m_pBag->Write(CComBSTR(sKeyName), &var);
+}
+
+
+HRESULT CPropertyBag::DeleteProperty(const string& sKeyName)
+{
+	if(m_pBag == NULL)
+		return E_POINTER;
+
+	CComVariant var;
+
+	var.Clear();
+
+	return m_pBag->Write(CComBSTR(sKeyName), &var);
+}
+
+UINT CPropertyBag::GetStringSet(const string& sFormat, string_array& asData) const
+{
+	UINT nCnt = 0;		
+	string sVal;
+	string sKeyName;
+
+	// Format Key Name
+	sKeyName.format(sFormat, nCnt++);
+
+	// Add URLs to List Box
+	while((sVal = GetString(sKeyName, NS_NO_KEY)) != NS_NO_KEY) 
+	{
+		asData.push_back(sVal);
+	
+		// Format Key Name
+		sKeyName.format(sFormat, nCnt++);
+	}
+
+	return --nCnt;
+}
+
+UINT CPropertyBag::WriteStringSet(const string& sFormat, const string_array& asData)
+{
+	UINT nCnt = 0;		// Number of URLs from Registry
+	string sKeyName;
+
+	string_array::const_iterator iter = asData.begin();
+	for(; iter != asData.end(); iter++)
+	{
+		sKeyName.format(sFormat, nCnt++);
+		WriteString(sKeyName, *iter);
+	}
+
+	UINT nRet = nCnt - 1;
+	sKeyName.format(sFormat, nCnt++);
+	CComVariant var;
+
+	while(SUCCEEDED(m_pBag->Read(CComBSTR(sKeyName), &var, NULL)) &&
+		  var.vt != VT_EMPTY && var.vt != VT_NULL)
+	{
+		// Format Registry Key
+		DeleteProperty(sKeyName);
+		sKeyName.format(sFormat, nCnt++);
+		var.Clear();
+	}
+
+	return nRet;
+	
+}
diff --git a/Common/CmptData.h b/Common/CmptData.h
new file mode 100644
index 0000000..985de2d
--- /dev/null
+++ b/Common/CmptData.h
@@ -0,0 +1,49 @@
+// ShutdownData.h: interface for the CShutdownData class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(PROPERTYBAGIMPL_H__6CC5C4C0_1F0A_11D2_B2D4_0020182B97FC__INCLUDED_)
+#define PROPERTYBAGIMPL_H__6CC5C4C0_1F0A_11D2_B2D4_0020182B97FC__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#define NS_NO_KEY				_T("No Key")
+#define NS_BACKUP_REG_SOURCE	_T("Source%.4d")
+#define NS_BACKUP_REG_DEST		_T("Destination")
+#define NS_BACKUP_REG_ENGINE	_T("Engine")
+#define NS_IGNORE_REG_EXT		_T("Ignore%.4d")
+#define NS_ENCRYPT_REG_FILES	_T("Path%.4d")
+#define NS_ENCRYPT_REG_DISABLE	_T("Disable")
+#define NS_ENCRYPT_REG_READONLY _T("ReadOnly")
+
+class CPropertyBag 
+{
+
+public:
+	CPropertyBag();
+	virtual ~CPropertyBag();
+
+	HRESULT DeleteProperty(const string& sKeyName);
+	HRESULT WriteString(const string& sKeyName, const string& sValue);
+	HRESULT WriteInt(const string& sKeyName, int nValue);
+	string GetString(const string& sKeyName, const string& sDefault) const;
+	int GetInt(const string& sKeyName, int nDefault) const;
+
+	// Chooses the first IPropertyBag it finds
+	HRESULT Initialize(int cUnks, IUnknown** ppUnks);
+	HRESULT Initialize(IUnknown* pUnk);
+
+	bool IsInitialized()
+		{ return m_pBag != NULL; };
+
+	UINT GetStringSet(const string& sFormat, string_array& asData) const;
+	UINT WriteStringSet(const string& sFormat, const string_array& asData);
+
+// Data 
+protected:
+	IPropertyBag* m_pBag;
+};
+
+#endif // !defined(AFX_PROPERTYBAGIMPL_H__6CC5C4C0_1F0A_11D2_B2D4_0020182B97FC__INCLUDED_)
diff --git a/Common/ComponentArray.cpp b/Common/ComponentArray.cpp
new file mode 100644
index 0000000..7bab44c
--- /dev/null
+++ b/Common/ComponentArray.cpp
@@ -0,0 +1,281 @@
+// ComponentArray.cpp: implementation of the CComponentArray class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "ComponentArray.h"
+#include "defines.h"
+
+#include <algorithm>
+using std::find;
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CComponentArray::CComponentArray() { }
+
+CComponentArray::~CComponentArray() 
+{
+	UnloadComponents();
+}
+
+//////////////////////////////////////////////////////////////////
+// LoadComponents from Registry (Public Function)
+//
+// returns number of components.
+
+UINT CComponentArray::LoadComponents()
+{
+	// Can only load if empty
+	ASSERT(empty());
+
+	// Make sure List of Installed Components is Loaded
+	LoadInstalledComponents();
+
+
+	// Open Key
+	CRegKey regKey;
+	if(regKey.Create(HKEY_CURRENT_USER, NS_REG_COMPONENTS)
+		!= ERROR_SUCCESS)
+
+			return 0;
+
+	// Enumerate Subkeys which should contain Component ID's (GetIDFromKey)
+	DWORD dwCnt = 0;
+	DWORD dwLoadedCnt = 0;
+	string sKeyName;
+	while(!RegEnumKey(regKey.m_hKey, dwCnt, sKeyName.get_buffer(MAX_PATH), MAX_PATH))
+	{
+		sKeyName.release_buffer();
+
+		dwCnt++;
+
+		// Add the Component
+		if(SUCCEEDED(AddComponent(sKeyName)))
+			dwLoadedCnt++;	// Increment Return Value
+	}
+
+	// Check if there's anymore that are Installed
+	// But the user didn't have previously loaded (CheckOffInstalledComponent)
+	while(!m_asInstalledComponents.empty())
+	{
+		// Add the Component
+		if(SUCCEEDED(AddComponent(m_asInstalledComponents[0])))
+			dwLoadedCnt++;
+	}
+
+	// Remove All NULL Spaces in array as we put each component
+	// at location requested by registry
+	iterator iter = begin();
+	for(int nCnt = 0; nCnt < size(); nCnt++)
+	{
+		while((*this)[nCnt] == NULL)
+			erase(begin() + nCnt);
+	}
+
+	if(empty())
+		return 0;
+
+	// Move DOS Components to End of Array
+	CComponentHolder* pComponent = NULL;
+	CComponentHolder* pLastComp = at(size() - 1);
+	for(nCnt = 0; nCnt < size() && pComponent != pLastComp; nCnt++)
+	{
+		pComponent = at(nCnt);
+
+		if(pComponent->GetType() == COMPONENT_DOS)
+		{
+			erase(begin() + nCnt);
+			push_back(pComponent);
+		}
+	}
+
+	// Return Number of Components
+	return (UINT)dwLoadedCnt;
+}
+
+//////////////////////////////////////////////////////////////////
+//  Loads the component into memory and adds it to array at 
+//  location requested. 
+
+HRESULT CComponentArray::AddComponent(const string& sKeyName)
+{
+	CComponentHolder* pComponent;
+	HRESULT hr;
+
+
+	// Get the Component ID from a Registry KeyName
+	// eg: 'NightSecurity.ClearInetCache' would come from 'NightSecurity.ClearInetCache 2'
+	string sID = GetIDFromKey(sKeyName);
+
+
+	// Load and Initialize Component
+	pComponent = new CComponentHolder;
+	hr = pComponent->Initialize(sID, NS_REG_COMPONENTS + (_T("\\") + sKeyName));
+
+
+	// If Failed then return NULL
+	if(SUCCEEDED(hr)) 
+	{
+
+		// Get the Component's Position
+		int nPos = pComponent->GetPos();
+
+
+		// Add at nPos
+		// If nPos is already used insert before
+		if(nPos < size()) 
+		{
+
+			if(at(nPos) == NULL) 
+				at(nPos) = pComponent;
+			else 
+				insert(begin() + nPos, pComponent);
+
+		}
+		else 
+		{
+				resize(nPos + 1, NULL);
+				at(nPos) = pComponent;
+		}
+
+
+	}
+
+	// Check it off from Installed List
+	CheckOffInstalledComponent(sID);
+
+
+	return hr;
+}
+
+
+/////////////////////////////////////////////////////////
+// LoadInstalledComponents : Loads list of installed 
+// components for access later on
+// 
+UINT CComponentArray::LoadInstalledComponents()
+{
+
+	// Open Key
+	CRegKey regKey;
+	if(regKey.Create(HKEY_LOCAL_MACHINE, NS_REG_INSTALLEDCOMPONENTS)
+					!= ERROR_SUCCESS)
+
+			return 0;
+
+
+
+	// Enumerate Subkeys which should be the IDs of Components
+	DWORD dwCnt = 0;
+	string sKeyName;
+	while(!RegEnumKey(regKey.m_hKey, dwCnt, sKeyName.get_buffer(MAX_PATH), MAX_PATH))
+	{
+
+		sKeyName.release_buffer();
+
+		// Add to List
+		m_asInstalledComponents.push_back(sKeyName);
+
+		dwCnt++;
+	}
+
+
+	// Return Number of Components
+	return (UINT)dwCnt;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Checks off the component from the Installed Components list
+// Loaded with Installed Components
+
+bool CComponentArray::CheckOffInstalledComponent(const string& sID)
+{
+	int nFound = -1;
+
+	string_array::iterator iter;
+	iter = find(m_asInstalledComponents.begin(), 
+				m_asInstalledComponents.end(), sID);
+
+	// If we found one then remove it
+	// Have to remove it outside of loop or we mess up the 
+	// Array Index
+	if(iter != m_asInstalledComponents.end()) 
+	{
+		m_asInstalledComponents.erase(iter);
+		return true;
+	}
+
+	// Couldn't Find
+	return false;
+}
+
+
+//////////////////////////////////////////////////////////////////
+// Remove the components from memory
+
+UINT CComponentArray::UnloadComponents()
+{
+	int nCnt = 0;
+
+	while(!empty())
+	{
+		nCnt++;
+
+		// First let it do it's Clean Up
+		at(0)->Release();
+		// Then Delete it
+		delete at(0);
+		// Then Remove it from Array
+		erase(begin());
+	}
+
+	// Return Number of Components
+	return nCnt;
+}
+
+
+//////////////////////////////////////////////////////////////////
+// Takes a Component registry key and extracts the Program ID
+// ID should come before space in Key
+// eg: 'NightSecurity.ClearInetCache' would come from 'NightSecurity.ClearInetCache 2'
+
+string CComponentArray::GetIDFromKey(const string& sKeyName)
+{
+	// ID should come before space in Key
+	// eg: 'NightSecurity.ClearInetCache' would come from 'NightSecurity.ClearInetCache 2'
+
+	string::size_type pos = sKeyName.find(_T(' '));
+
+	// return first part
+	// find return string::npos if fails (which also means end of string)
+	return sKeyName.substr(0, pos);
+
+}
+
+
+//////////////////////////////////////////////////////////////////
+// Saves each components data to the Registry
+
+HRESULT CComponentArray::SaveComponentData()
+{
+	HRESULT hrRet = S_OK;
+
+	// Ask Each Component to Save it's own Data
+	iterator iter = begin();
+	for(; iter != end(); iter++)
+	{
+
+		// CComponentHolder checks to make sure that the
+		// Components are loaded, so we don't have to 
+		// include error checking here.
+		HRESULT hr = (*iter)->GetData()->Save();
+		if(FAILED(hr))
+			hrRet = hr;
+		
+	}
+
+	return hrRet;
+}
diff --git a/Common/ComponentArray.h b/Common/ComponentArray.h
new file mode 100644
index 0000000..892faae
--- /dev/null
+++ b/Common/ComponentArray.h
@@ -0,0 +1,80 @@
+//////////////////////////////////////////////////////////////////
+//  
+// ComponentArray.h: interface for the CComponentArray class.
+// 
+// Class that holds all the components for the application
+// Need to call LoadComponents before you can use them
+//
+// Derived from a vector so you can access the components each 
+// as it's own CComponentHolder, but takes care of the Loading
+// and Unloading itself.
+//
+// 'Installed Components' are components that haven't been used
+// yet by a user, but have been installed on the system. 
+// The Loading code first loops through all the user's components
+// and then sees if it's missing anything that's installed but 
+// hasn't been used yet.
+//
+// The reason for a distiction between a Program ID and a Registry
+// Key is to support multiple instances of components in the future
+// if needed. Each component would be inited from it's own Key. The
+// keys could also be used as Stream ID's in a OLE Storage etc...
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(COMPONENTARRAY_H__ADB16FE6_1B31_11D2_B2D4_0020182B97FC__INCLUDED_)
+#define COMPONENTARRAY_H__ADB16FE6_1B31_11D2_B2D4_0020182B97FC__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include "..\Common\ComponentHolder.h"
+
+#include <mystring.h>
+#include <vector>
+using std::vector;
+
+// An Array of CComponentHolder's with inbuilt Loading and Unloading
+
+typedef vector<CComponentHolder*> ArrayComponents;
+typedef vector<string> string_array;
+class CComponentArray 
+	: public ArrayComponents
+{
+public:
+	CComponentArray();
+	virtual ~CComponentArray();
+
+public:
+
+	// Load Components from Registry
+	UINT LoadComponents();
+
+	// Remove Components from Memory
+	UINT UnloadComponents();
+
+	// Save Comoponents Data to Registry
+	HRESULT SaveComponentData();
+
+protected:
+
+	/////////////////////////////////////////////////////////
+	// List of All Installed Components
+	// Used to Compare with User's Current Components
+	string_array m_asInstalledComponents;
+
+	// Load List of All Installed Components
+	UINT LoadInstalledComponents();
+
+	// Called when Loading a Component
+	bool CheckOffInstalledComponent(const string& sID);
+	HRESULT AddComponent(const string& sID);
+
+	// Gets the Component ID from a Registry KeyName
+	// eg: 'NightSecurity.ClearInetCache' would come from 'NightSecurity.ClearInetCache 2'
+	string GetIDFromKey(const string& sKeyName);
+
+};
+
+#endif // !defined(COMPONENTARRAY_H__ADB16FE6_1B31_11D2_B2D4_0020182B97FC__INCLUDED_)
diff --git a/Common/ComponentData.cpp b/Common/ComponentData.cpp
new file mode 100644
index 0000000..5b4d75d
--- /dev/null
+++ b/Common/ComponentData.cpp
@@ -0,0 +1,407 @@
+// ComponentData.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "ComponentData.h"
+#include "types.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+#ifdef _DEBUG
+
+void DumpVariant(VARIANT& var)
+{
+	USES_CONVERSION;
+
+	switch(var.vt)
+	{
+	case VT_NULL:
+		ATLTRACE(_T("VT_NULL"));
+		break;
+	case VT_EMPTY:
+		ATLTRACE(_T("VT_EMPTY"));
+		break;
+	case VT_UI1:
+		ATLTRACE(_T("VT_UI1: "));
+		ATLTRACE(_T("%u"), (int)var.bVal);
+		break;
+	case VT_I2:
+		ATLTRACE(_T("VT_I2: "));
+		ATLTRACE(_T("%d"), (int)var.bVal);
+		break;
+	case VT_I4:
+		ATLTRACE(_T("VT_I4: "));
+		ATLTRACE(_T("%d"), (int)var.bVal);
+		break;
+	case VT_R4:
+		ATLTRACE(_T("VT_R4: "));
+		ATLTRACE(_T("%f"), (double)var.bVal);
+		break;
+	case VT_R8:
+		ATLTRACE(_T("VT_R8: "));
+		ATLTRACE(_T("%f"), (double)var.bVal);
+		break;
+	case VT_BOOL:
+		ATLTRACE(_T("VT_BOOL: "));
+		ATLTRACE(_T("%s"), var.boolVal ? _T("true") : _T("false"));
+		break;
+	case VT_ERROR:
+		ATLTRACE(_T("VT_ERROR: "));
+		ATLTRACE(_T("%d"), var.scode);
+		break;
+	case VT_CY:
+		ATLTRACE(_T("VT_CY: "));
+		ATLTRACE(_T("%d"), var.cyVal);
+		break;
+	case VT_DATE:
+		ATLTRACE(_T("VT_DATE "));
+		break;
+	case VT_BSTR:
+		ATLTRACE(_T("VT_BSTR: "));
+		ATLTRACE(_T("%s"), OLE2T(var.bstrVal));
+		break;
+	case VT_UNKNOWN:
+		ATLTRACE(_T("VT_UNKNOWN: "));
+		break;
+	default:
+		ATLTRACE(_T("VT_ Other"));
+		break;
+	}
+}
+
+#define TRACEVARIANT(var) DumpVariant(var)
+
+#else
+
+#define TRACEVARIANT(var) ((void)0)
+#endif
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+// CComponentData
+
+
+CComponentData::CComponentData()
+{
+}
+
+CComponentData::~CComponentData()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CComponentData message handlers
+
+HRESULT CComponentData::Initialize(const string & sKey)
+{
+	// Need a registry key to read from
+	if(sKey.empty())
+		return E_INVALIDARG;
+
+	m_sKey = sKey;
+
+  return S_OK;
+
+}
+
+
+//////////////////////////////////////////////////////////////////
+//  Does the actual saving to the Registry
+
+HRESULT CComponentData::Save(string sKey  /* = "" */)
+{
+	ATLTRACE(_T("DATA SAVE\n==========\n"));
+
+	long lRet = 0;
+	CRegKey regKey;
+
+
+	// Set to Internal Key if sKey Is Empty
+	if(sKey.empty()) sKey = m_sKey;
+
+
+	// Try and open Our Key
+	if((lRet = regKey.Create(HKEY_CURRENT_USER, sKey)) != ERROR_SUCCESS)
+		return HRESULT_FROM_WIN32(lRet);
+
+
+	// Now do actual saving
+	// Only support number and String types for now
+	DWORD dwData = 0;
+	
+	string_variant_map::iterator iter = m_mapValues.begin();
+
+	for( ;iter != m_mapValues.end(); iter++)
+	{
+		ATLTRACE(_T("Saving: %s    --    Value: "), iter->first.c_str());
+		TRACEVARIANT(iter->second);
+		ATLTRACE(_T("\n"));
+
+		switch(iter->second.vt)
+		{
+			// Number Types
+			case VT_UI1:
+			case VT_I2:
+			case VT_I4:
+			case VT_R4:
+			case VT_R8:
+			case VT_CY:
+
+				lRet = regKey.SetValue(iter->second.lVal, iter->first);
+//				ASSERT(lRet == ERROR_SUCCESS);
+				break;
+
+			// It's a String
+			case VT_BSTR:
+
+				lRet = regKey.SetValue(string(iter->second.bstrVal), iter->first);
+//				ASSERT(lRet == ERROR_SUCCESS);
+				break;
+
+
+			// Delete the Key if NULL or Empty value
+			case VT_NULL:
+			case VT_EMPTY:
+
+				lRet = regKey.DeleteValue(iter->first);
+//				ASSERT(lRet == ERROR_SUCCESS);
+				break;
+
+			default:
+				break;
+
+
+
+		}
+	
+	}
+
+	return S_OK;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Passes the caller a IUnknown to the the underlying IPropertyBag
+
+/*IUnknown* CComponentData::GetIUnknown(bool bAddRef)
+{
+	// If asked not to increment then Release
+	if(bAddRef)
+		this->AddRef();
+
+
+	return GetUnknown();
+}
+*/
+
+//////////////////////////////////////////////////////////////////
+// Reads actual Value from Registry
+
+HRESULT CComponentData::Read(const string & sValName, VARIANT& varVal)
+{
+	// First Lookup the Value in the current map
+	string_variant_map::iterator iter = m_mapValues.find(sValName);
+	if(iter != m_mapValues.end())
+		return ::VariantCopy(&varVal, &(iter->second));
+
+
+
+	// Make sure we are initialized with a key
+	if(m_sKey == "")
+		return E_UNEXPECTED;
+
+	// Open Key
+	CRegKey regDataKey;
+	if(regDataKey.Create(HKEY_CURRENT_USER, m_sKey) == ERROR_SUCCESS)
+	{
+
+		// Get Size and Type of Registry Value
+		DWORD dwType = NULL;
+		DWORD dwSize;
+		if(::RegQueryValueEx(regDataKey.m_hKey, sValName, 0, &dwType, NULL, &dwSize) == ERROR_SUCCESS)
+		{
+
+
+			// We Only Support DWORD and String
+			switch(dwType) 
+			{
+
+			case REG_DWORD:
+
+				// Get DWORD Value
+				DWORD dwData;
+				dwSize = sizeof(DWORD);
+				if(::RegQueryValueEx(regDataKey.m_hKey, sValName, 0, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS)
+				{
+
+					// Make sure we have a clean variant
+					::VariantClear(&varVal);
+					// Return a 4 byte Integer
+					varVal.vt = VT_I4;
+					varVal.lVal = dwData;
+
+
+					regDataKey.Close();
+					return S_OK;
+	
+				}
+				break;
+
+
+			case REG_SZ:
+
+
+				// Get String Value
+				string sData;
+				if(::RegQueryValueEx(regDataKey.m_hKey, sValName, 0, &dwType, (LPBYTE)sData.get_buffer(dwSize), &dwSize) == ERROR_SUCCESS)
+				{
+					// Have to Release before we can AllocSysString
+					sData.release_buffer();
+
+
+					// Make sure we have a clean variant
+					::VariantClear(&varVal);
+					// Return a BSTR (Client responsible for cleanup)
+					varVal.vt = VT_BSTR;
+					varVal.bstrVal = _bstr_t(sData);
+
+					regDataKey.Close();
+					return S_OK;
+	
+				}
+				break;
+			}
+
+
+		}
+		
+		regDataKey.Close();
+		return REGDB_E_KEYMISSING;
+
+	}
+
+	regDataKey.Close();
+	return REGDB_E_READREGDB;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Saves the value passed to Internal Map where it stays until
+// saved by the function Save
+
+HRESULT CComponentData::Write(const string& sValName, const VARIANT & varVal)
+{
+	HRESULT hr;
+	CComVariant varCopy = varVal;
+
+	// Check what we've got
+	// We only support DWORD and String
+	switch(varVal.vt) 
+	{
+
+		case VT_UI1:
+		case VT_I2:
+		case VT_I4:
+		case VT_R4:
+		case VT_R8:
+		case VT_CY:
+
+			// First try and make a 4 byte integer out of it (DWORD)
+			hr = VariantChangeType(&varCopy, &varCopy, 0, VT_I4);
+			if(FAILED(hr))
+				return hr;
+
+		case VT_BSTR:
+		case VT_NULL:
+		case VT_EMPTY:
+
+			// Add Item to Variant Map
+			m_mapValues.erase(sValName);
+			m_mapValues.insert(make_pair(sValName, varCopy));
+			return S_OK;
+			break;
+
+
+		default:
+
+			return E_INVALIDARG;
+			break;
+
+	}
+
+	return S_OK;
+
+}
+
+
+
+/////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+// IPropertyBag
+
+STDMETHODIMP CComponentData::Read(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog)
+{
+//    TRACE("CComponentData::XPropertyBag::Read\n");
+
+	// Pass calls 
+	ATLTRACE(_T("Read: %s    --    Value: "), (LPCTSTR)string(pszPropName));
+	HRESULT hr = Read(string(pszPropName), *pVar);
+	TRACEVARIANT(*pVar);
+	ATLTRACE(_T("\n"));
+	return hr;
+}
+
+STDMETHODIMP CComponentData::Write(LPCOLESTR pszPropName, VARIANT* pVar)
+{
+//    TRACE("CComponentData::XPropertyBag::Write\n");
+
+	// Pass calls 
+	ATLTRACE(_T("Write: %s    --    Value: "), (LPCTSTR)string(pszPropName));
+	TRACEVARIANT(*pVar);
+	ATLTRACE(_T("\n"));
+	return Write(string(pszPropName), *pVar);
+
+}
+
+
+//////////////////////////////////////////////////////////////////
+// Host specific Functions (returns default if error or can't find)
+
+int CComponentData::GetInt(const string& sKey, int nDefault)
+{
+	CComVariant var;
+
+	var.vt = VT_I4;
+	var.lVal = nDefault;
+
+	if(FAILED(Read(sKey, var)))
+		return nDefault;
+	else 
+		return var.lVal;
+}
+
+//////////////////////////////////////////////////////////////////
+// Host specific Function 
+
+bool CComponentData::WriteInt(const string& sKey, int nValue)
+{
+	CComVariant var;
+
+	var.vt = VT_I4;
+	var.lVal = nValue;
+
+	return SUCCEEDED(Write(sKey, var));
+
+}
+
+bool CComponentData::Delete(const string& sKey)
+{
+	CComVariant var;
+	var.vt = VT_NULL;
+	return SUCCEEDED(Write(sKey, var));
+}
diff --git a/Common/ComponentData.h b/Common/ComponentData.h
new file mode 100644
index 0000000..75dcdbb
--- /dev/null
+++ b/Common/ComponentData.h
@@ -0,0 +1,111 @@
+//////////////////////////////////////////////////////////////////
+// CComponentData
+// 
+// Exposes the IPropertyBag interface for the components to store
+// their data in.
+//
+// Also supports other host specific settings.
+//
+// Current implementation saves the data in the registry and only
+// saves when requested to by host.
+//
+// Component can pass a Variant NULL to delete the specified 
+// property
+//
+// Only the following types are supported for now: 
+//		VT_UI1 
+//		VT_I2 
+//		VT_I4 
+//		VT_R4 
+//		VT_R8 
+//		VT_CY 
+//		VT_BSTR
+//////////////////////////////////////////////////////////////////
+
+
+#if !defined(COMPONENTDATA_H__2AA70045_1988_11D2_B2D4_0020182B97FC__INCLUDED_)
+#define COMPONENTDATA_H__2AA70045_1988_11D2_B2D4_0020182B97FC__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+// ComponentData.h : header file
+//
+
+#define DATA_KEY _T("Data")
+
+#include "../common/interfaces.h"
+#include <map>
+#include <utility>
+using std::map;
+using std::make_pair;
+
+#include <mystring.h>
+
+typedef map<string, CComVariant> string_variant_map;
+
+/////////////////////////////////////////////////////////////////////////////
+// CComponentData command target
+class ATL_NO_VTABLE CComponentData : 
+	public CComObjectRootEx<CComMultiThreadModel>,
+	public IPropertyBag
+{
+
+// Attributes
+public:
+	CComponentData();
+	virtual ~CComponentData();
+
+
+public:
+	// Host specific functions
+	// Add String support later when needed.
+	bool WriteInt(const string& sKey, int nValue);
+	int GetInt(const string& sKey, int nDefault);
+	bool Delete(const string& sKey);
+
+	// Can be used by Host and also called from the 
+	// IPropertyBag Implementation below
+	HRESULT Write(const string& sValName, const VARIANT& varVal);
+	HRESULT Read(const string& sValName, VARIANT& varVal);
+
+	// Initializes Key
+	HRESULT Initialize(const string& sKey);
+
+
+	// Saves All Setting to Registry Key
+	// If sKey = NULL then saves to key given in Initialize
+	HRESULT Save(string sKey = _T(""));
+
+
+	// Returns an IUnknown to IPropertyBag
+//	IUnknown* GetIUnknown(bool bAddRef = false);
+
+
+protected:
+
+	// Arrays of Settings to be written to Registry
+	// Supports Integers and Strings Only
+	string_variant_map m_mapValues;
+
+	// Registry Key
+	string m_sKey;
+
+public:
+
+DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+BEGIN_COM_MAP(CComponentData)
+	COM_INTERFACE_ENTRY(IPropertyBag)
+END_COM_MAP()
+
+	// IPropertyBag Interface
+	STDMETHOD(Read)(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog);
+	STDMETHOD(Write)(LPCOLESTR pszPropName, VARIANT* pVar);
+
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+#endif // !defined(COMPONENTDATA_H__2AA70045_1988_11D2_B2D4_0020182B97FC__INCLUDED_)
diff --git a/Common/ComponentHolder.cpp b/Common/ComponentHolder.cpp
new file mode 100644
index 0000000..474809b
--- /dev/null
+++ b/Common/ComponentHolder.cpp
@@ -0,0 +1,386 @@
+// ComponentHolder.cpp: implementation of the CComponentHolder class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "ComponentHolder.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#define new DEBUG_NEW
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CComponentHolder::CComponentHolder()
+{
+	// Both pointers are null for an uninited object
+	m_pComponentDOS = NULL;
+	m_pComponentWin = NULL;
+}
+
+CComponentHolder::~CComponentHolder()
+{
+	// Just in case owner forgot
+	Release();
+}
+
+//////////////////////////////////////////////////////////////////
+// Returns the component type (DOS or Windows)
+
+UINT CComponentHolder::GetType()
+{
+	// Needs to be Initialzed
+	ASSERT(!(m_pComponentDOS == NULL && m_pComponentWin == NULL));
+
+
+	// Return Type
+	if(m_pComponentWin != NULL)
+		return COMPONENT_WIN;
+	else
+		return COMPONENT_DOS;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Returns a IUnknown to the current component
+
+IUnknown* CComponentHolder::GetUnknown()
+{
+	// Needs to be Initialzed
+	ASSERT(!(m_pComponentDOS == NULL && m_pComponentWin == NULL));
+
+	// When copying out a Pointer make sure to AddRef
+	if(m_pComponentWin != NULL)
+	{
+		m_pComponentWin->AddRef();
+		return m_pComponentWin;
+	}
+	else
+	{
+		m_pComponentDOS->AddRef();
+		return m_pComponentDOS;
+	}
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Accepts a String ID, converts it and then calls the real 
+// Initialize
+
+HRESULT CComponentHolder::Initialize(const string& sID, const string& sRegKey)
+{
+	ASSERT(!sRegKey.empty());
+
+	USES_CONVERSION;
+	HRESULT hr;
+	CLSID clsid;
+
+	// Get the CLSID
+	hr = CLSIDFromString(T2OLE(sID), &clsid);
+
+	if(FAILED(hr)) 
+		return hr;
+
+	// And then call the real version
+	return Initialize(clsid, sRegKey);
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Loads and Initializes the Component
+
+HRESULT CComponentHolder::Initialize(const CLSID & clsid, const string& sRegKey)
+{
+	ASSERT(!sRegKey.empty());
+	USES_CONVERSION;
+
+	// If we're already Initialized then Release all the 
+	// and start again interfaces
+	if(IsInitialized())
+		Release();
+
+
+	// Intitialize the Data Component
+	m_Data.Initialize(sRegKey);
+
+
+
+	// Get an IUnknown to the Component First
+	// Since we don't know what it supports
+	// (CComPtr) calls Release for this one
+	HRESULT hr;
+	CComPtr<IUnknown> pUnk;
+	hr = CoCreateInstance(clsid, NULL, /*CLSCTX_ALL*/CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER , IID_IUnknown, (void**) &pUnk);
+
+	if(FAILED(hr)) 
+		return hr;
+
+
+	// Check if it Supports IID_ISecureShutdownWin
+	hr = pUnk->QueryInterface(IID_ISecureShutdownWin, (void**) &m_pComponentWin);
+	if(FAILED(hr)) m_pComponentWin = NULL;
+
+
+	// Check if it Supports IID_ISecureShutdownDOS
+	hr = pUnk->QueryInterface(IID_ISecureShutdownDOS, (void**) &m_pComponentDOS);
+	if(FAILED(hr)) m_pComponentDOS = NULL;
+
+
+	// Did we catch something?
+	if(!IsInitialized())
+		return hr;
+
+	switch(GetType())
+	{
+	case COMPONENT_WIN:
+		// Give the Component it's Data Pointer
+		hr = m_pComponentWin->SetData(m_Data.GetUnknown());
+		if(FAILED(hr)) return hr;
+		break;
+	case COMPONENT_DOS:
+		// Give the Component it's Data Pointer
+		hr = m_pComponentDOS->SetData(m_Data.GetUnknown());
+		if(FAILED(hr)) return hr;
+		break;
+	}
+
+	// Get Name
+	m_sName = GetInfoStr(nsName, _T("(No Name)"));
+
+	return S_OK;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Helper Function
+
+bool CComponentHolder::IsInitialized()
+{
+	// Either one has to be initialized
+	return !((m_pComponentDOS == NULL) && (m_pComponentWin == NULL)); 
+}
+
+/*#ifndef NS_NO_PROPPAGE
+//////////////////////////////////////////////////////////////////
+// Returns a pointer to the Property page for current component
+// or error if none
+
+
+HRESULT CComponentHolder::GetPropPage(CPropPageHolder** pPropPage)
+{
+	// If we already have a Prop Page then just get pointer
+	if(m_PropPage.IsInitialized())
+	{
+		*pPropPage = &m_PropPage;
+		return S_OK;
+	}
+
+
+	// Otherwise Create one
+	HRESULT hr;
+	
+
+	// Get a IUnkown to the current Component
+	CComPtr<IUnknown> pUnk; // Releases Pointer
+	GetIUnknown(&pUnk);
+
+
+	// See if it likes us
+	hr = m_PropPage.Initialize(pUnk);
+	if(FAILED(hr)) return hr;
+
+
+	// Return Pointer
+	*pPropPage = &m_PropPage;
+
+
+	return S_OK;
+}
+
+
+bool CComponentHolder::HasPropPage()
+{
+	CPropPageHolder* pPropPage;
+	return SUCCEEDED(GetPropPage(&pPropPage));
+}
+
+#endif // NS_NO_PROPPAGE
+*/
+//////////////////////////////////////////////////////////////////
+// Completely removes the component from Memory
+
+HRESULT CComponentHolder::Release()
+{
+/*
+	// Check if we've got PropPage 
+	// If so then get rid of it
+	if(m_PropPage.IsInitialized())
+		m_PropPage.Destroy();
+*/
+
+	// Save the Data to the DataObject
+	// m_Data.Save();
+
+
+	// Only Update if Initialized
+	if(IsInitialized()){
+
+		switch(GetType()){
+
+			case COMPONENT_WIN:
+
+				// Get Component to Release Data Pointer
+				m_pComponentWin->SetData(NULL);
+
+				// Release Component
+				m_pComponentWin->Release();
+
+				break;
+
+			case COMPONENT_DOS:
+
+				// Get Component to Release Data Pointer
+				m_pComponentDOS->SetData(NULL);
+
+				// Release Component
+				m_pComponentDOS->Release();
+
+				break;
+
+		}
+
+		// Set to NULL as a flag
+		m_pComponentWin = NULL;
+		m_pComponentDOS = NULL;
+
+		m_sName = _T("");
+	}
+
+	return S_OK;
+}
+
+//////////////////////////////////////////////////////////////////
+// Invokes actual shutdown (Windows Components Only)
+
+HRESULT CComponentHolder::DoShutdown(DWORD dwMode, HWND hwndParent)
+{
+	// Needs to be Initialized First
+	ASSERT(!(m_pComponentDOS == NULL && m_pComponentWin == NULL));
+
+
+	switch(GetType()){
+		case COMPONENT_WIN:
+
+			// Call Shutdown. Only Windows
+			return m_pComponentWin->DoShutdown((long)hwndParent, (long)dwMode);
+
+			break;
+
+		case COMPONENT_DOS:
+
+			// Call Shutdown. DOS don't support
+			ASSERT(false);
+			return E_FAIL;
+
+			break;
+	}
+
+	return E_FAIL;
+	
+}
+
+//////////////////////////////////////////////////////////////////
+// Retrieves Text for Batch File (DOS Components Only)
+
+HRESULT CComponentHolder::GetBatchText(string& sBatchText)
+{
+	USES_CONVERSION;
+	BSTR bstrBatchText;
+	HRESULT hr;
+
+	switch(GetType())
+	{
+		case COMPONENT_WIN:
+
+			// Not Supported in Windows
+			return E_FAIL;
+
+			break;
+
+		case COMPONENT_DOS:
+
+			// Get Batch Text. 
+			hr = m_pComponentDOS->GetBatchText(&bstrBatchText);
+
+			// Transfer to CString
+			if(SUCCEEDED(hr))
+				sBatchText = OLE2T(bstrBatchText);
+
+			return hr;
+
+			break;
+
+	}
+
+	return E_FAIL;
+	
+
+}
+
+
+CComVariant CComponentHolder::GetInfo(NightSecInfo nsItem)
+{
+	USES_CONVERSION;
+	CComVariant vInfo;
+	vInfo.vt = VT_EMPTY;
+	HRESULT hr;
+
+	switch(GetType()){
+
+		case COMPONENT_WIN:
+			hr = m_pComponentWin->get_Info(nsItem, &vInfo);
+			break;
+		case COMPONENT_DOS:
+			hr = m_pComponentDOS->get_Info(nsItem, &vInfo);
+			break;
+
+	}
+
+	if(FAILED(hr))
+		vInfo.vt = VT_NULL;
+
+	return vInfo;
+}
+
+string CComponentHolder::GetInfoStr(NightSecInfo nsItem, const string& sDefault)
+{
+	USES_CONVERSION;
+
+	// Get Name
+	CComVariant vInfo = GetInfo(nsItem);
+
+	if(vInfo.vt == VT_BSTR)
+		return OLE2T(vInfo.bstrVal);
+
+	return sDefault;
+
+}
+
+int CComponentHolder::GetInfoInt(NightSecInfo nsItem, int nDefault)
+{
+	// Get Name
+	CComVariant vInfo = GetInfo(nsItem);
+
+	if(vInfo.vt == VT_NULL || vInfo.vt == VT_EMPTY)
+		return nDefault;
+
+	if(SUCCEEDED(vInfo.ChangeType(VT_I4)))
+		return vInfo.lVal;
+
+	return nDefault;
+
+}
diff --git a/Common/ComponentHolder.h b/Common/ComponentHolder.h
new file mode 100644
index 0000000..66b90e2
--- /dev/null
+++ b/Common/ComponentHolder.h
@@ -0,0 +1,104 @@
+//////////////////////////////////////////////////////////////////
+//  
+// ComponentHolder.h: interface for the CComponentHolder class.
+//
+// Holds one componet (either DOS or Windows)
+//
+// Is Initialized when either DOS or Windows pointer is valid
+//
+// virtual functions make it possible to override the funtionality
+// and create host based app specific components.
+// See shutdown.exe program for example of this
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(COMPONENTHOLDER_H__FDBF1422_18AE_11D2_B2D4_0020182B97FC__INCLUDED_)
+#define COMPONENTHOLDER_H__FDBF1422_18AE_11D2_B2D4_0020182B97FC__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include "../common/defines.h"
+#include "../common/interfaces.h"
+#include "../common/ComponentData.h"
+
+#include <mystring.h>
+
+#define CComObjectMember CComObjectGlobal
+
+class CComponentHolder
+{
+
+public:
+	CComponentHolder();
+	virtual ~CComponentHolder();
+
+	// Calls main component function for Windows Components
+	virtual HRESULT DoShutdown(DWORD dwMode, HWND hwndParent = NULL);
+	// Calls main component function for DOS Components
+	virtual HRESULT GetBatchText(string& sBatchText);
+
+
+	// Initialization 
+	// Needs  Registry Key to Initialize and Save the Component Data
+	virtual bool IsInitialized();
+	virtual HRESULT Initialize(const CLSID& clsid, const string& sRegKey);
+	virtual HRESULT Initialize(const string& sID, const string& sRegKey);
+
+
+	virtual HRESULT Release();
+
+	// Returns type (DOS or Windows)
+	virtual UINT GetType();
+
+	// Get's a IUnknown to the Component
+	virtual IUnknown* GetUnknown();
+
+protected:
+	ISecureShutdownDOS* m_pComponentDOS;
+	ISecureShutdownWin* m_pComponentWin;
+
+	// Component ID
+protected:
+	string m_sID;
+public:
+	virtual const string& GetID() const { return m_sID; };
+
+	// Name
+protected:
+	string m_sName;
+public:
+	const string& GetName() const { return m_sName; };
+
+/*
+#ifndef NS_NO_PROPPAGE
+	// Component Property Page
+protected:
+	CComObjectMember<CPropPageHolder> m_PropPage;
+public:
+//	virtual HRESULT GetPropPage(CPropPageHolder** pPropPage);
+//	bool HasPropPage();
+#endif // NS_NO_PROPPAGE
+*/
+
+	// Component's Data
+protected:
+	CComObjectMember<CComponentData> m_Data;
+public:
+	virtual CComponentData* GetData() { return &m_Data; };
+
+
+	// Host specific Funtions for accessing component data
+public:
+	int GetInfoInt(NightSecInfo nsItem, int nDefault);
+	string GetInfoStr(NightSecInfo nsItem, const string& sDefault);
+	CComVariant GetInfo(NightSecInfo nsItem);
+	virtual bool IsEnabled() { return m_Data.GetInt(ENABLED_KEY, false) ? true : false; };
+	virtual bool Enable(bool bEnable) { return m_Data.WriteInt(ENABLED_KEY, bEnable); } ;
+	virtual int GetPos() { return m_Data.GetInt(POSITION_KEY, 1); } ;
+	virtual bool SetPos(int nPos) { return m_Data.WriteInt(POSITION_KEY, nPos); } ;
+
+};
+
+#endif // !defined(COMPONENTHOLDER_H__FDBF1422_18AE_11D2_B2D4_0020182B97FC__INCLUDED_)
diff --git a/Common/Defines.h b/Common/Defines.h
new file mode 100644
index 0000000..b66b229
--- /dev/null
+++ b/Common/Defines.h
@@ -0,0 +1,32 @@
+#ifndef __DEFINES_H__980713
+#define __DEFINES_H__980713
+
+
+#define COMPONENT_WIN		1
+#define COMPONENT_DOS		2
+
+#define WIZPAGE_MIDDLE		0
+#define WIZPAGE_FIRST		1
+#define WIZPAGE_LAST		2
+
+#define NS_GROUP						_T("Heavenly Helpers")
+#define NS_MAIN							_T("Night Security")
+#define NS_COMPONENTS					_T("Components")
+#define NS_INSTALLEDCOMPONENTS			_T("Installed Components")
+
+#define NS_HELP_FILE					_T("nightsec.hlp")
+
+#define NS_REG_MAIN						_T("Software\\Heavenly Helpers\\Night Security")
+#define NS_REG_COMPONENTS				_T("Software\\Heavenly Helpers\\Night Security\\Components")
+#define NS_REG_INSTALLEDCOMPONENTS		_T("Software\\Heavenly Helpers\\Night Security\\Installed Components")
+
+#define NIGHTSEC_CLEARALL		0x00000001
+
+#define ENABLED_KEY						_T("Enabled")
+#define POSITION_KEY					_T("Position")
+
+#define FORCE_SHUTDOWN_KEY				_T("Force MSDOS")
+#define IS_SETUP_KEY					_T("Is Setup")
+#define NO_LOG_KEY						_T("No Log")
+
+#endif //__DEFINES_H__980713
\ No newline at end of file
diff --git a/Common/NightSec.h b/Common/NightSec.h
new file mode 100644
index 0000000..a3f8705
--- /dev/null
+++ b/Common/NightSec.h
@@ -0,0 +1,591 @@
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+/* File created by MIDL compiler version 3.01.75 */
+/* at Wed Apr 21 21:38:00 1999
+ */
+/* Compiler settings for NightSec Worker.idl:
+    Oicf (OptLev=i2), W1, Zp8, env=Win32, ms_ext, c_ext
+    error checks: none
+*/
+//@@MIDL_FILE_HEADING(  )
+#include "rpc.h"
+#include "rpcndr.h"
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __NightSec_Worker_h__
+#define __NightSec_Worker_h__
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+/* Forward Declarations */ 
+
+#ifndef __ISecureShutdownWin_FWD_DEFINED__
+#define __ISecureShutdownWin_FWD_DEFINED__
+typedef interface ISecureShutdownWin ISecureShutdownWin;
+#endif 	/* __ISecureShutdownWin_FWD_DEFINED__ */
+
+
+#ifndef __ISecureShutdownDOS_FWD_DEFINED__
+#define __ISecureShutdownDOS_FWD_DEFINED__
+typedef interface ISecureShutdownDOS ISecureShutdownDOS;
+#endif 	/* __ISecureShutdownDOS_FWD_DEFINED__ */
+
+
+#ifndef __EmptyRecycleBin_FWD_DEFINED__
+#define __EmptyRecycleBin_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class EmptyRecycleBin EmptyRecycleBin;
+#else
+typedef struct EmptyRecycleBin EmptyRecycleBin;
+#endif /* __cplusplus */
+
+#endif 	/* __EmptyRecycleBin_FWD_DEFINED__ */
+
+
+#ifndef __EmptyTempFolder_FWD_DEFINED__
+#define __EmptyTempFolder_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class EmptyTempFolder EmptyTempFolder;
+#else
+typedef struct EmptyTempFolder EmptyTempFolder;
+#endif /* __cplusplus */
+
+#endif 	/* __EmptyTempFolder_FWD_DEFINED__ */
+
+
+#ifndef __DeleteSwapFile_FWD_DEFINED__
+#define __DeleteSwapFile_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DeleteSwapFile DeleteSwapFile;
+#else
+typedef struct DeleteSwapFile DeleteSwapFile;
+#endif /* __cplusplus */
+
+#endif 	/* __DeleteSwapFile_FWD_DEFINED__ */
+
+
+#ifndef __RunScanDisk_FWD_DEFINED__
+#define __RunScanDisk_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class RunScanDisk RunScanDisk;
+#else
+typedef struct RunScanDisk RunScanDisk;
+#endif /* __cplusplus */
+
+#endif 	/* __RunScanDisk_FWD_DEFINED__ */
+
+
+#ifndef __WipefreeSpace_FWD_DEFINED__
+#define __WipefreeSpace_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class WipefreeSpace WipefreeSpace;
+#else
+typedef struct WipefreeSpace WipefreeSpace;
+#endif /* __cplusplus */
+
+#endif 	/* __WipefreeSpace_FWD_DEFINED__ */
+
+
+#ifndef __WXPYShutdown_FWD_DEFINED__
+#define __WXPYShutdown_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class WXPYShutdown WXPYShutdown;
+#else
+typedef struct WXPYShutdown WXPYShutdown;
+#endif /* __cplusplus */
+
+#endif 	/* __WXPYShutdown_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t);
+void __RPC_USER MIDL_user_free( void __RPC_FAR * ); 
+
+/****************************************
+ * Generated header for interface: __MIDL_itf_NightSec_Worker_0000
+ * at Wed Apr 21 21:38:00 1999
+ * using MIDL 3.01.75
+ ****************************************/
+/* [local] */ 
+
+
+typedef /* [helpstring][uuid][v1_enum] */ 
+enum NightSecInfo
+    {	nsName	= 0,
+	nsCmdLine	= nsName + 1,
+	nsHelpText	= nsCmdLine + 1,
+	nsForceShow	= nsHelpText + 1,
+	nsHideNormal	= nsForceShow + 1,
+	nsCopyAble	= nsHideNormal + 1,
+	nsHelpFile	= nsCopyAble + 1,
+	nsHelpTopic	= nsHelpFile + 1
+    }	NightSecInfo;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_NightSec_Worker_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_NightSec_Worker_0000_v0_0_s_ifspec;
+
+#ifndef __ISecureShutdownWin_INTERFACE_DEFINED__
+#define __ISecureShutdownWin_INTERFACE_DEFINED__
+
+/****************************************
+ * Generated header for interface: ISecureShutdownWin
+ * at Wed Apr 21 21:38:00 1999
+ * using MIDL 3.01.75
+ ****************************************/
+/* [unique][helpstring][dual][uuid][object] */ 
+
+
+
+EXTERN_C const IID IID_ISecureShutdownWin;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    interface DECLSPEC_UUID("34F11691-F275-11d2-A589-0020182B97FC")
+    ISecureShutdownWin : public IDispatch
+    {
+    public:
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE DoShutdown( 
+            /* [in] */ long hParent,
+            /* [in] */ long lMode) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE SetData( 
+            /* [in] */ IUnknown __RPC_FAR *pUnk) = 0;
+        
+        virtual /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE get_Info( 
+            /* [in] */ NightSecInfo nsItem,
+            /* [retval][out] */ VARIANT __RPC_FAR *pvVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct ISecureShutdownWinVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( 
+            ISecureShutdownWin __RPC_FAR * This);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( 
+            ISecureShutdownWin __RPC_FAR * This);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [out] */ UINT __RPC_FAR *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
+            /* [in] */ UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ DISPID __RPC_FAR *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
+            /* [out] */ VARIANT __RPC_FAR *pVarResult,
+            /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
+            /* [out] */ UINT __RPC_FAR *puArgErr);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *DoShutdown )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ long hParent,
+            /* [in] */ long lMode);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *SetData )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ IUnknown __RPC_FAR *pUnk);
+        
+        /* [helpstring][id][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Info )( 
+            ISecureShutdownWin __RPC_FAR * This,
+            /* [in] */ NightSecInfo nsItem,
+            /* [retval][out] */ VARIANT __RPC_FAR *pvVal);
+        
+        END_INTERFACE
+    } ISecureShutdownWinVtbl;
+
+    interface ISecureShutdownWin
+    {
+        CONST_VTBL struct ISecureShutdownWinVtbl __RPC_FAR *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ISecureShutdownWin_QueryInterface(This,riid,ppvObject)	\
+    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
+
+#define ISecureShutdownWin_AddRef(This)	\
+    (This)->lpVtbl -> AddRef(This)
+
+#define ISecureShutdownWin_Release(This)	\
+    (This)->lpVtbl -> Release(This)
+
+
+#define ISecureShutdownWin_GetTypeInfoCount(This,pctinfo)	\
+    (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo)
+
+#define ISecureShutdownWin_GetTypeInfo(This,iTInfo,lcid,ppTInfo)	\
+    (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo)
+
+#define ISecureShutdownWin_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)	\
+    (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
+
+#define ISecureShutdownWin_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)	\
+    (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)
+
+
+#define ISecureShutdownWin_DoShutdown(This,hParent,lMode)	\
+    (This)->lpVtbl -> DoShutdown(This,hParent,lMode)
+
+#define ISecureShutdownWin_SetData(This,pUnk)	\
+    (This)->lpVtbl -> SetData(This,pUnk)
+
+#define ISecureShutdownWin_get_Info(This,nsItem,pvVal)	\
+    (This)->lpVtbl -> get_Info(This,nsItem,pvVal)
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISecureShutdownWin_DoShutdown_Proxy( 
+    ISecureShutdownWin __RPC_FAR * This,
+    /* [in] */ long hParent,
+    /* [in] */ long lMode);
+
+
+void __RPC_STUB ISecureShutdownWin_DoShutdown_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISecureShutdownWin_SetData_Proxy( 
+    ISecureShutdownWin __RPC_FAR * This,
+    /* [in] */ IUnknown __RPC_FAR *pUnk);
+
+
+void __RPC_STUB ISecureShutdownWin_SetData_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE ISecureShutdownWin_get_Info_Proxy( 
+    ISecureShutdownWin __RPC_FAR * This,
+    /* [in] */ NightSecInfo nsItem,
+    /* [retval][out] */ VARIANT __RPC_FAR *pvVal);
+
+
+void __RPC_STUB ISecureShutdownWin_get_Info_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+
+#endif 	/* __ISecureShutdownWin_INTERFACE_DEFINED__ */
+
+
+#ifndef __ISecureShutdownDOS_INTERFACE_DEFINED__
+#define __ISecureShutdownDOS_INTERFACE_DEFINED__
+
+/****************************************
+ * Generated header for interface: ISecureShutdownDOS
+ * at Wed Apr 21 21:38:00 1999
+ * using MIDL 3.01.75
+ ****************************************/
+/* [unique][helpstring][dual][uuid][object] */ 
+
+
+
+EXTERN_C const IID IID_ISecureShutdownDOS;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    interface DECLSPEC_UUID("34F11692-F275-11d2-A589-0020182B97FC")
+    ISecureShutdownDOS : public IDispatch
+    {
+    public:
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE GetBatchText( 
+            /* [retval][out] */ BSTR __RPC_FAR *psText) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE SetData( 
+            /* [in] */ IUnknown __RPC_FAR *pUnk) = 0;
+        
+        virtual /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE get_Info( 
+            /* [in] */ NightSecInfo nsItem,
+            /* [retval][out] */ VARIANT __RPC_FAR *pvVal) = 0;
+        
+    };
+    
+#else 	/* C style interface */
+
+    typedef struct ISecureShutdownDOSVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( 
+            ISecureShutdownDOS __RPC_FAR * This);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( 
+            ISecureShutdownDOS __RPC_FAR * This);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [out] */ UINT __RPC_FAR *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
+            /* [in] */ UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ DISPID __RPC_FAR *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
+            /* [out] */ VARIANT __RPC_FAR *pVarResult,
+            /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
+            /* [out] */ UINT __RPC_FAR *puArgErr);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetBatchText )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [retval][out] */ BSTR __RPC_FAR *psText);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *SetData )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ IUnknown __RPC_FAR *pUnk);
+        
+        /* [helpstring][id][propget] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *get_Info )( 
+            ISecureShutdownDOS __RPC_FAR * This,
+            /* [in] */ NightSecInfo nsItem,
+            /* [retval][out] */ VARIANT __RPC_FAR *pvVal);
+        
+        END_INTERFACE
+    } ISecureShutdownDOSVtbl;
+
+    interface ISecureShutdownDOS
+    {
+        CONST_VTBL struct ISecureShutdownDOSVtbl __RPC_FAR *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ISecureShutdownDOS_QueryInterface(This,riid,ppvObject)	\
+    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
+
+#define ISecureShutdownDOS_AddRef(This)	\
+    (This)->lpVtbl -> AddRef(This)
+
+#define ISecureShutdownDOS_Release(This)	\
+    (This)->lpVtbl -> Release(This)
+
+
+#define ISecureShutdownDOS_GetTypeInfoCount(This,pctinfo)	\
+    (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo)
+
+#define ISecureShutdownDOS_GetTypeInfo(This,iTInfo,lcid,ppTInfo)	\
+    (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo)
+
+#define ISecureShutdownDOS_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)	\
+    (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
+
+#define ISecureShutdownDOS_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)	\
+    (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)
+
+
+#define ISecureShutdownDOS_GetBatchText(This,psText)	\
+    (This)->lpVtbl -> GetBatchText(This,psText)
+
+#define ISecureShutdownDOS_SetData(This,pUnk)	\
+    (This)->lpVtbl -> SetData(This,pUnk)
+
+#define ISecureShutdownDOS_get_Info(This,nsItem,pvVal)	\
+    (This)->lpVtbl -> get_Info(This,nsItem,pvVal)
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISecureShutdownDOS_GetBatchText_Proxy( 
+    ISecureShutdownDOS __RPC_FAR * This,
+    /* [retval][out] */ BSTR __RPC_FAR *psText);
+
+
+void __RPC_STUB ISecureShutdownDOS_GetBatchText_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISecureShutdownDOS_SetData_Proxy( 
+    ISecureShutdownDOS __RPC_FAR * This,
+    /* [in] */ IUnknown __RPC_FAR *pUnk);
+
+
+void __RPC_STUB ISecureShutdownDOS_SetData_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE ISecureShutdownDOS_get_Info_Proxy( 
+    ISecureShutdownDOS __RPC_FAR * This,
+    /* [in] */ NightSecInfo nsItem,
+    /* [retval][out] */ VARIANT __RPC_FAR *pvVal);
+
+
+void __RPC_STUB ISecureShutdownDOS_get_Info_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+
+#endif 	/* __ISecureShutdownDOS_INTERFACE_DEFINED__ */
+
+
+
+#ifndef __NightSecComponents_LIBRARY_DEFINED__
+#define __NightSecComponents_LIBRARY_DEFINED__
+
+/****************************************
+ * Generated header for library: NightSecComponents
+ * at Wed Apr 21 21:38:00 1999
+ * using MIDL 3.01.75
+ ****************************************/
+/* [helpstring][version][uuid] */ 
+
+
+
+EXTERN_C const IID LIBID_NightSecComponents;
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_EmptyRecycleBin;
+
+class DECLSPEC_UUID("34F11694-F275-11d2-A589-0020182B97FC")
+EmptyRecycleBin;
+#endif
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_EmptyTempFolder;
+
+class DECLSPEC_UUID("34F11695-F275-11d2-A589-0020182B97FC")
+EmptyTempFolder;
+#endif
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_DeleteSwapFile;
+
+class DECLSPEC_UUID("34F11696-F275-11d2-A589-0020182B97FC")
+DeleteSwapFile;
+#endif
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_RunScanDisk;
+
+class DECLSPEC_UUID("34F11697-F275-11d2-A589-0020182B97FC")
+RunScanDisk;
+#endif
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_WipefreeSpace;
+
+class DECLSPEC_UUID("34F11698-F275-11d2-A589-0020182B97FC")
+WipefreeSpace;
+#endif
+
+#ifdef __cplusplus
+EXTERN_C const CLSID CLSID_WXPYShutdown;
+
+class DECLSPEC_UUID("34F11699-F275-11d2-A589-0020182B97FC")
+WXPYShutdown;
+#endif
+#endif /* __NightSecComponents_LIBRARY_DEFINED__ */
+
+/* Additional Prototypes for ALL interfaces */
+
+unsigned long             __RPC_USER  BSTR_UserSize(     unsigned long __RPC_FAR *, unsigned long            , BSTR __RPC_FAR * ); 
+unsigned char __RPC_FAR * __RPC_USER  BSTR_UserMarshal(  unsigned long __RPC_FAR *, unsigned char __RPC_FAR *, BSTR __RPC_FAR * ); 
+unsigned char __RPC_FAR * __RPC_USER  BSTR_UserUnmarshal(unsigned long __RPC_FAR *, unsigned char __RPC_FAR *, BSTR __RPC_FAR * ); 
+void                      __RPC_USER  BSTR_UserFree(     unsigned long __RPC_FAR *, BSTR __RPC_FAR * ); 
+
+unsigned long             __RPC_USER  VARIANT_UserSize(     unsigned long __RPC_FAR *, unsigned long            , VARIANT __RPC_FAR * ); 
+unsigned char __RPC_FAR * __RPC_USER  VARIANT_UserMarshal(  unsigned long __RPC_FAR *, unsigned char __RPC_FAR *, VARIANT __RPC_FAR * ); 
+unsigned char __RPC_FAR * __RPC_USER  VARIANT_UserUnmarshal(unsigned long __RPC_FAR *, unsigned char __RPC_FAR *, VARIANT __RPC_FAR * ); 
+void                      __RPC_USER  VARIANT_UserFree(     unsigned long __RPC_FAR *, VARIANT __RPC_FAR * ); 
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Common/NightSecApp.cpp b/Common/NightSecApp.cpp
new file mode 100644
index 0000000..0fcec5e
--- /dev/null
+++ b/Common/NightSecApp.cpp
@@ -0,0 +1,138 @@
+// NightSecApp.cpp: implementation of the CNightSecApp class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "NightSecApp.h"
+
+#include <regsvr.h>
+#include <appmisc.h>
+#include <path.h>
+#include "../common/defines.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CComponentArray g_aComponents;
+
+#define NS_REGISTER_FAILED _T("Night Security was unable to register the %s component.\n\n%s\nIf Night Security doesn't seem to be working properly please reinstall.")
+const DWORD dwTimeOut = 5000; // time for EXE to be idle before shutting down
+
+CNightSecApp::CNightSecApp(const string& sAppName, const string& sMtxName)
+	: m_sAppName(sAppName), m_oneInstance(sMtxName), 
+	  m_settings(HKEY_CURRENT_USER, NS_REG_MAIN)
+{
+
+}
+
+CNightSecApp::~CNightSecApp()
+{
+
+}
+
+bool CNightSecApp::InitInstance()
+{
+	LPCTSTR szCmdLine = GetCommandLine();
+
+	// If we've been asked to close then exit here
+	if(_tcsstr(szCmdLine, _T("close")) != NULL)
+		return false;
+
+	// Load up all Components
+	if(!g_aComponents.LoadComponents())
+	{
+		RegisterDlls();
+		g_aComponents.LoadComponents();
+	}
+
+	return true;
+}
+
+bool CNightSecApp::ExitInstance() 
+{
+	g_aComponents.UnloadComponents();
+	return false;
+}
+
+HRESULT CNightSecApp::RegisterDlls(bool bUI /*= true*/)
+{
+	file_iterator iterFiles(GetProgramFolder(_Module.m_hInst), 
+							_T("*.dll"), file_iterator::full_paths);
+
+	file_iterator end;
+
+	HRESULT hRet = S_OK;
+
+	for( ; iterFiles != end; iterFiles++)
+	{
+		HRESULT hr = RegisterDLL(iterFiles->cFileName);
+
+		if(SUCCEEDED(hr) || !bUI)
+			continue;
+
+		string sError;
+		file_path fileDll(iterFiles->cFileName);
+		sError.format(NS_REGISTER_FAILED, (LPCTSTR)fileDll.file(), (LPCTSTR)FormatHR(hr));
+
+		MessageBox(NULL, sError, m_sAppName, MB_OK | MB_ICONEXCLAMATION);
+	}
+
+	return hRet;
+}
+
+// Passed to CreateThread to monitor the shutdown event
+/*static DWORD WINAPI MonitorProc(void* pv)
+{
+    CNightSecApp* p = (CNightSecApp*)pv;
+    p->MonitorShutdown();
+    return 0;
+}*/
+
+/*LONG CNightSecApp::Unlock()
+{
+    LONG l = CComModule::Unlock();
+    if (l == 0)
+    {
+        bActivity = true;
+        SetEvent(hEventShutdown); // tell monitor that we transitioned to zero
+    }
+    return l;
+}
+*/
+//Monitors the shutdown event
+/*void CNightSecApp::MonitorShutdown()
+{
+    while (1)
+    {
+        WaitForSingleObject(hEventShutdown, INFINITE);
+        DWORD dwWait=0;
+        do
+        {
+            bActivity = false;
+            dwWait = WaitForSingleObject(hEventShutdown, dwTimeOut);
+        } while (dwWait == WAIT_OBJECT_0);
+        // timed out
+        if (!bActivity && m_nLockCnt == 0) // if no activity let's really bail
+        {
+#if _WIN32_WINNT >= 0x0400 & defined(_ATL_FREE_THREADED)
+            CoSuspendClassObjects();
+            if (!bActivity && m_nLockCnt == 0)
+#endif
+                break;
+        }
+    }
+    CloseHandle(hEventShutdown);
+    PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
+}
+
+bool CNightSecApp::StartMonitor()
+{
+    hEventShutdown = CreateEvent(NULL, false, false, NULL);
+    if (hEventShutdown == NULL)
+        return false;
+    DWORD dwThreadID;
+    HANDLE h = CreateThread(NULL, 0, MonitorProc, this, 0, &dwThreadID);
+    return (h != NULL);
+}
+*/
\ No newline at end of file
diff --git a/Common/NightSecApp.h b/Common/NightSecApp.h
new file mode 100644
index 0000000..80e9fae
--- /dev/null
+++ b/Common/NightSecApp.h
@@ -0,0 +1,41 @@
+// NightSecApp.h: interface for the CNightSecApp class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_NIGHTSECAPP_H__19178A44_7FDB_11D3_BF9E_0020182B97FC__INCLUDED_)
+#define AFX_NIGHTSECAPP_H__19178A44_7FDB_11D3_BF9E_0020182B97FC__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <mystring.h>
+#include <RegSettings.h>
+#include "../common/oneinstance.h"
+
+class CNightSecApp : public CComModule
+{
+public:
+	CNightSecApp(const string& sAppName, const string& sMtxName = _T(""));
+	~CNightSecApp();
+	virtual bool InitInstance();
+	virtual bool ExitInstance();
+	HRESULT RegisterDlls(bool bUI = true);
+
+	// From ATL
+//	LONG Unlock();
+//	DWORD dwThreadID;
+//	HANDLE hEventShutdown;
+//	void MonitorShutdown();
+//	bool StartMonitor();
+	bool bActivity;
+
+protected:
+	const string m_sAppName;
+	COneInstance m_oneInstance;
+
+public:
+	CRegSettings m_settings;
+};
+
+#endif // !defined(AFX_NIGHTSECAPP_H__19178A44_7FDB_11D3_BF9E_0020182B97FC__INCLUDED_)
diff --git a/Common/OneInstance.h b/Common/OneInstance.h
new file mode 100644
index 0000000..5eec36f
--- /dev/null
+++ b/Common/OneInstance.h
@@ -0,0 +1,63 @@
+// OneInstance.h: interface for the COneInstance class.
+//
+//////////////////////////////////////////////////////////////////////
+
+
+#if !defined(AFX_ONEINSTANCE_H__A3059F66_BFED_11D2_A501_0020182B97FC__INCLUDED_)
+#define AFX_ONEINSTANCE_H__A3059F66_BFED_11D2_A501_0020182B97FC__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <string>
+
+class COneInstance
+{
+public:
+
+	// Constructor
+	COneInstance(LPCSTR szID) 
+		: sMtxName(szID) {};
+
+	// Activates a Window based on the following...
+	// szClass:		Class name of Window (get from SPY)
+	// szTitle:		Title bar of Window
+	bool FindAndActivate(LPCSTR szClass, LPCSTR szTitle) const
+	{
+		// Search for the Window
+		HWND hWnd = ::FindWindow(szClass, szTitle);
+
+		// Check if we have any popups
+		HWND hChild = GetLastActivePopup(hWnd);
+
+		bool bRet = SetForegroundWindow(hWnd) ? true : false; // bring main window to top
+
+		if (hWnd != hChild)
+			SetForegroundWindow(hChild); // a pop-up window is active
+										 // bring it to the top too
+										 // do not run second instance
+		return bRet;
+	}
+
+	// Checks if there is already a program loaded 
+	// with the ID passed when creating COneInstance
+	bool IsAlreadyLoaded() const
+	{
+		if(sMtxName.empty())
+			return false;
+
+		// Use a Mutex and not a FindWindow because process could exist
+		// without a Window (
+		::CreateMutex(NULL, true, sMtxName.c_str()); 
+
+		// mutex will be automatically deleted when process ends
+		return (::GetLastError() == ERROR_ALREADY_EXISTS);
+	}
+
+
+protected:
+	std::string sMtxName;
+};
+
+#endif // !defined(AFX_ONEINSTANCE_H__A3059F66_BFED_11D2_A501_0020182B97FC__INCLUDED_)
diff --git a/Common/PropPageHolder.cpp b/Common/PropPageHolder.cpp
new file mode 100644
index 0000000..cd14ff8
--- /dev/null
+++ b/Common/PropPageHolder.cpp
@@ -0,0 +1,317 @@
+// PropPageHolder.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "PropPageHolder.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CPropPageHolder
+
+CPropPageHolder::CPropPageHolder()
+{
+	m_pSite = NULL;
+	m_pPropPage = NULL;
+	m_bActivated = false;
+	memset(&m_PageInfo, 0, sizeof(PROPPAGEINFO));
+}
+
+/*CPropPageHolder::CPropPageHolder(IPropertyPage* pPage, IUnknown* pSite)
+{
+	m_pSite = NULL;
+	m_pPropPage = NULL;
+	m_bActivated = false;
+	memset(&m_PageInfo, 0, sizeof(PROPPAGEINFO));
+	
+	// We were passed a IUnknown, so Initialize from there
+	Initialize(pPage, pSite);
+}
+*/
+
+CPropPageHolder::~CPropPageHolder()
+{
+	// Just in case
+	if(m_pPropPage != NULL)
+		Destroy();
+
+	if(m_PageInfo.cb != 0)
+	{
+		CoTaskMemFree(m_PageInfo.pszDocString);
+		CoTaskMemFree(m_PageInfo.pszHelpFile);
+		CoTaskMemFree(m_PageInfo.pszTitle);
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CPropPageHolder message handlers
+
+//////////////////////////////////////////////////////////////////
+// Loads Prop Page if it has one
+
+HRESULT CPropPageHolder::Initialize(IPropertyPage* pPage, IUnknown* pSite)
+{
+	// Can't Reinitialize
+	ASSERT(!m_pPropPage);
+	ASSERT(pSite);
+	ASSERT(pPage);
+
+	// This is the Container site 
+	// (Returned from IPropertyPageSite::GetPageContainer)
+	m_pSite = pSite;
+
+	m_pPropPage = pPage;
+	pPage->AddRef();
+
+	// Get a IPropertyPageSite Pointer to ourselves
+	// for the new Proppage
+	IPropertyPageSite* pPageSite = NULL;
+	QueryInterface(IID_IPropertyPageSite, (void**)&pPageSite);
+	ASSERT(pPageSite); 
+
+
+	// Set Page Site
+	HRESULT hr = m_pPropPage->SetPageSite(pPageSite);
+
+	// Make sure to reset to null if failed
+	if(FAILED(hr)) 
+	{
+		m_pPropPage->Release();
+		m_pPropPage = NULL;
+	}
+	else 
+	{
+		// Property page should have AddRef'ed,
+		// So release our pointer
+		Release();
+	}
+
+	return hr;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Creates and shows PropPage
+
+HRESULT CPropPageHolder::Create(HWND hwndParent, const RECT& rect, bool bModalParent /*= true*/)
+{
+	// Need to Initialize First
+	ASSERT(m_pPropPage);
+
+
+	// If we're already activated then just 
+	// move to new coordinates
+	if(m_bActivated) 
+		return Move(rect);
+
+
+	HRESULT hr;
+
+
+	// Activate the Page
+	hr = m_pPropPage->Activate(hwndParent, &rect, true);
+
+
+	if(!FAILED(hr))
+	{
+		m_bActivated = true;
+
+		// Make sure it's visible
+		m_pPropPage->Show(SW_SHOW);
+	}
+
+
+	return hr;
+}
+
+//////////////////////////////////////////////////////////////////
+// Destroys and Releases PropPage
+
+HRESULT CPropPageHolder::Destroy()
+{
+	// Can't destroy NULL object
+	if(m_pPropPage == NULL)
+		return S_OK;
+
+
+	Close();
+
+	// Make it let go of our IPropertyPageSite Pointer
+	HRESULT hr = m_pPropPage->SetPageSite(NULL);
+
+
+	// Then release it
+	m_pPropPage->Release();
+
+
+	m_pPropPage = NULL;
+
+	return hr;
+}
+
+HRESULT CPropPageHolder::Close()
+{
+	// Need to Initialize 
+	// and create first
+	ASSERT(m_pPropPage);
+
+	if(m_bActivated) 
+	{
+	
+		m_bActivated = false;
+
+		// Deactivate page
+		return m_pPropPage->Deactivate();
+
+	}
+
+	// It went okay but didn't do anything so...
+	return S_FALSE;
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Calls IPropPage Show
+
+HRESULT CPropPageHolder::Show(UINT nCmdShow)
+{
+	// Need to Initialize 
+	// and create first
+	ASSERT(m_pPropPage);
+	ASSERT(m_bActivated);
+
+	return m_pPropPage->Show(nCmdShow);
+
+}
+
+//////////////////////////////////////////////////////////////////
+// Calls IPropPage Move
+
+HRESULT CPropPageHolder::Move(const RECT& rect)
+{
+	// Need to Initialize 
+	// and create first
+	ASSERT(m_pPropPage);
+	ASSERT(m_bActivated);
+
+	return m_pPropPage->Move(&rect);
+
+}
+
+//////////////////////////////////////////////////////////////////
+// PropPage is inited properly if pointer not null
+
+bool CPropPageHolder::IsInitialized()
+{
+	return !(m_pPropPage == NULL); 
+}
+
+//////////////////////////////////////////////////////////////////
+// Calls IPropPage Apply (results in a call to OnStatusChanged 
+// in our IPropPageSite)
+
+HRESULT CPropPageHolder::Apply()
+{
+	// Need to Initialize First
+	ASSERT(m_pPropPage);
+
+	return m_pPropPage->Apply();
+}
+
+//////////////////////////////////////////////////////////////////
+// Is it Created?
+
+bool CPropPageHolder::IsActivated()
+	{ return m_bActivated; }
+
+
+
+/////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+// PropertyPageSite
+
+STDMETHODIMP CPropPageHolder::OnStatusChange(DWORD dwFlags)
+{
+    TRACE("CPropPageHolder::XPropertyPageSite::OnStatusChange\n");
+
+	// We don't need to implement any of this
+	// as we use delayed saving
+    return S_OK;
+}
+
+STDMETHODIMP CPropPageHolder::GetLocaleID(LCID* pLocaleID)
+{
+    TRACE("CPropPageHolder::XPropertyPageSite::GetLocaleID\n");
+
+	// Just give'm a default language
+	*pLocaleID = LOCALE_SYSTEM_DEFAULT;
+    return S_OK;
+}
+
+STDMETHODIMP CPropPageHolder::GetPageContainer(IUnknown** ppUnk)
+{
+    TRACE("CPropPageHolder::XPropertyPageSite::GetPageContainer\n");
+
+	// If Error we need to set to NULL
+	// This takes care of that cuz NULL is the only error around
+	*ppUnk = m_pSite;
+
+	if(!m_pSite)
+		return E_UNEXPECTED;
+
+	m_pSite->AddRef();
+
+	// Sorry
+    return S_OK;
+}
+
+STDMETHODIMP CPropPageHolder::TranslateAccelerator(LPMSG pMsg)
+{
+    TRACE("CPropPageHolder::XPropertyPageSite::TranslateAccelerator\n");
+
+	// Sorry
+    return E_NOTIMPL;
+}
+
+string CPropPageHolder::GetTitle()
+{
+	USES_CONVERSION;
+	LoadInfo();
+
+	if(m_PageInfo.pszTitle)
+		return OLE2T(m_PageInfo.pszTitle);
+
+	return _T("");
+}
+
+string CPropPageHolder::GetHelpFile()
+{
+	USES_CONVERSION;
+	LoadInfo();
+
+	if(m_PageInfo.pszHelpFile)
+		return OLE2T(m_PageInfo.pszHelpFile);
+
+	return _T("");
+}
+
+DWORD CPropPageHolder::GetHelpContext()
+{
+	LoadInfo();
+	return m_PageInfo.dwHelpContext;
+}
+
+
+HRESULT CPropPageHolder::LoadInfo()
+{
+	if(m_PageInfo.cb != 0)
+		return S_OK;
+
+	ASSERT(m_pPropPage);
+	m_PageInfo.cb = sizeof(PROPPAGEINFO);
+	return m_pPropPage->GetPageInfo(&m_PageInfo);
+}
diff --git a/Common/PropPageHolder.h b/Common/PropPageHolder.h
new file mode 100644
index 0000000..4fec7ee
--- /dev/null
+++ b/Common/PropPageHolder.h
@@ -0,0 +1,89 @@
+//////////////////////////////////////////////////////////////////
+//  
+// PropPageHolder.h : header file
+//
+// CPropPageHolder manages the components IPropertyPage Interface
+//
+// It also exposes a IPropertyPageSite Interface for the 
+// Component (not used for much though)
+//
+//////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_PROPPAGEHOLDER_H__F0EC0A29_18D4_11D2_B2D4_0020182B97FC__INCLUDED_)
+#define AFX_PROPPAGEHOLDER_H__F0EC0A29_18D4_11D2_B2D4_0020182B97FC__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+/////////////////////////////////////////////////////////////////////////////
+// CPropPageHolder command target
+
+class ATL_NO_VTABLE CPropPageHolder : 
+	public CComObjectRootEx<CComSingleThreadModel>,
+	public IPropertyPageSite
+{
+
+// Attributes
+public:
+	CPropPageHolder();
+//	CPropPageHolder(IPropertyPage* pPage, IUnknown* pSite);
+	virtual ~CPropPageHolder();
+
+// Operations
+public:
+	HRESULT Close();
+
+	bool IsActivated();			// Is Proppage Created?
+	HRESULT Apply();			// Save Changes to Data Object
+	bool IsInitialized();		// Is Initialized?
+
+	// Checks to see if it has a IPropPage
+	HRESULT Initialize(IPropertyPage* pUnk, IUnknown* pSite);
+
+	// Activates and Shows the Page
+	// For best results start with WS_VISIBLE = false in 
+	// dialog template (no flicker)
+	HRESULT Create(HWND hwndParent, const RECT& rect, bool bModalParent = true);
+
+	// DeActivates Page and Releases IPropPage
+	HRESULT Destroy();
+
+	// Window Functions
+	HRESULT Show(UINT nCmdShow);
+	HRESULT Move(const RECT& rect);
+
+// Implementation
+protected:
+	HRESULT LoadInfo();
+
+	// Is Created or not?
+	bool m_bActivated;
+
+	IPropertyPage* m_pPropPage;
+	PROPPAGEINFO m_PageInfo;
+	IUnknown* m_pSite;			// This is a pointer to the Page Container Site
+								// Returned from IPropertyPageSite::GetPageContainer
+
+public:
+	DWORD GetHelpContext();
+	string GetHelpFile();
+	string GetTitle();
+
+DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+BEGIN_COM_MAP(CPropPageHolder)
+	COM_INTERFACE_ENTRY(IPropertyPageSite)
+END_COM_MAP()
+
+	// IPropertyBag
+    STDMETHOD(OnStatusChange)(DWORD dwFlags);
+    STDMETHOD(GetLocaleID)(LCID* pLocaleID);
+    STDMETHOD(GetPageContainer)(IUnknown** ppUnk);
+    STDMETHOD(TranslateAccelerator)(LPMSG pMsg);
+    
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+#endif // !defined(AFX_PROPPAGEHOLDER_H__F0EC0A29_18D4_11D2_B2D4_0020182B97FC__INCLUDED_)
diff --git a/Common/events.h b/Common/events.h
new file mode 100644
index 0000000..f736f9c
--- /dev/null
+++ b/Common/events.h
@@ -0,0 +1,6 @@
+#ifndef __EVENTS_H__991107
+#define __EVENTS_H__991107
+
+#import "../Shutdown/Shutdown.tlb" raw_interfaces_only, raw_native_types, no_namespace, named_guids	//"Import typelib"
+
+#endif //__EVENTS_H__991107
\ No newline at end of file
diff --git a/Common/interfaces.cpp b/Common/interfaces.cpp
new file mode 100644
index 0000000..b43b8b5
--- /dev/null
+++ b/Common/interfaces.cpp
@@ -0,0 +1,4 @@
+
+#include "../interfaces/CmptIFaces_i.c"
+#include "../interfaces/SiteIFaces_i.c"
+
diff --git a/Common/interfaces.h b/Common/interfaces.h
new file mode 100644
index 0000000..9bf5667
--- /dev/null
+++ b/Common/interfaces.h
@@ -0,0 +1,14 @@
+#ifndef __INTERFACES_H__980711
+#define __INTERFACES_H__980711
+
+#include "../interfaces/CmptIFaces.h"
+#include "../interfaces/SiteIFaces.h"
+
+#include <comdef.h>
+
+_COM_SMARTPTR_TYPEDEF(INightSecError, __uuidof(INightSecError));
+_COM_SMARTPTR_TYPEDEF(INightSecErrorFix, __uuidof(INightSecErrorFix));
+_COM_SMARTPTR_TYPEDEF(INightSecErrorLog, __uuidof(INightSecErrorLog));
+_COM_SMARTPTR_TYPEDEF(INightSecSiteInfo, __uuidof(INightSecSiteInfo));
+
+#endif //__INTERFACES_H__980711
\ No newline at end of file
diff --git a/Common/types.h b/Common/types.h
new file mode 100644
index 0000000..fa6a1b2
--- /dev/null
+++ b/Common/types.h
@@ -0,0 +1,10 @@
+// Extra types used in Night Security
+
+#include <mystring.h>
+
+#include <vector>
+typedef std::vector<string> string_array;
+ 
+#include <set>
+typedef std::set<string> string_set;
+