/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/

// Registrar.cpp: Implementierung der Klasse Registrar.
//
//////////////////////////////////////////////////////////////////////

#include "registrar.hxx"

#ifndef _REGISTRYVALUEIMPL_HXX_
#include "RegistryValueImpl.hxx"
#endif
#include "windowsregistry.hxx"
#include "registryexception.hxx"

#include <assert.h>
#ifdef _MSC_VER
#pragma warning(disable: 4350 4482)
#include "strsafe.h"
#endif

//----------------------------------------------------------
#ifdef DEBUG
inline void OutputDebugStringFormat( LPCTSTR pFormat, ... )
{
	TCHAR    buffer[1024];
	va_list  args;

	va_start( args, pFormat );
	StringCchVPrintf( buffer, sizeof(buffer), pFormat, args );
	OutputDebugString( buffer );
}
#else
static inline void OutputDebugStringFormat( LPCTSTR, ... )
{
}
#endif
//----------------------------------------------------------

const int MSWORD                     = 0x1;
const int MSEXCEL                    = 0x2;
const int MSPOWERPOINT               = 0x4;	
const int DEFAULT_HTML_EDITOR_FOR_IE = 0x8;	
const int HTML_EDITOR				 = 0x10;	
const int DEFAULT_SHELL_HTML_EDITOR  = 0x20;

namespace /* private */
{
    const std::wstring HTM_OPENWITHLIST = L".htm\\OpenWithList";
    const std::wstring APPLICATIONS = L"Applications";
    const std::wstring SHELL_EDIT_COMMAND = L"shell\\edit\\command";
    const std::wstring HTML_EDIT = L"HTML Edit";
    const std::wstring HTML_EDIT_DISPLAY_NAME = L"Edit Display Name";
    const std::wstring SHELL_EDIT_COMMAND_BACKUP = L"Shell Edit Cmd";
    const std::wstring DEFAULT_HTML_EDITOR = L"Default HTML Editor";
    const std::wstring MS_IE_DEF_HTML_EDITOR = L"Software\\Microsoft\\Internet Explorer\\Default HTML Editor";
    const std::wstring MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD = L"Software\\Microsoft\\Internet Explorer\\Default HTML Editor\\shell\\edit\\command";
}

Registrar::Registrar(const RegistrationContextInformation& RegContext) : 	
	m_ContextInformation(RegContext),
    FORWARD_KEY_PREFIX(L"Apache OpenOffice"),
    DEFAULT_VALUE_NAME(L""),
    BACKUP_VALUE_NAME(L"Backup"),
    PRIVATE_BACKUP_KEY_NAME(L"Apache OpenOffice.reg4msdocmsi"),//PRIVATE_BACKUP_KEY_NAME(L"soffice6.bak"),
    REGISTRATION_STATE(L"Reg4MsDocState")
{
    m_RootKey = WindowsRegistry().GetClassesRootKey();
}

Registrar::~Registrar()
{
}

void Registrar::RegisterForMsWord() const
{    
    assert(m_RootKey.get());
    
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetWordDocumentFileExtension(),
        m_ContextInformation.GetWordDocumentDisplayName(),
        m_ContextInformation.GetWordDocumentDefaultIconEntry(),
        m_ContextInformation.GetWordDocumentDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Writer);
	
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetWordTemplateFileExtension(),
        m_ContextInformation.GetWordTemplateDisplayName(),
        m_ContextInformation.GetWordTemplateDefaultIconEntry(),
        m_ContextInformation.GetWordTemplateDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Writer);	
        
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetRtfDocumentFileExtension(),
        m_ContextInformation.GetRtfDocumentDisplayName(),
        m_ContextInformation.GetRtfDocumentDefaultIconEntry(),
        m_ContextInformation.GetRtfDocumentDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Writer);
	
    SaveRegisteredFor(MSWORD);
}

void Registrar::UnregisterForMsWord() const
{
	assert(m_RootKey.get());

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetWordDocumentFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetWordTemplateFileExtension());		
	}
	catch(RegistryKeyNotFoundException&)
	{}

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetRtfDocumentFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

	SaveNotRegisteredFor(MSWORD);
}

bool Registrar::QueryPreselectForMsApplication(const std::wstring& file_extension) const
{
    bool preselect = false;

    // We use HKCR else we would not see that a registration for
    // MS Office applications already exist if we are about to
    // register in HKCU\Software\Classes
    RegistryKey root_key = WindowsRegistry().GetClassesRootKey();
                
	if (!root_key->HasSubKey(file_extension))
	{
        preselect = true;
        OutputDebugStringFormat( TEXT("QueryPreselect: No SubKey found for (%s), preselected!\n"), file_extension.c_str() );
    }
    else
    {
        RegistryKey RegKey = root_key->OpenSubKey(file_extension, false);
        
        if (RegKey->HasValue(DEFAULT_VALUE_NAME))
	    {
		    RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);

		    if (REG_SZ == RegVal->GetType() &&
		        IsOpenOfficeRegisteredForMsApplication(RegVal->GetDataAsUniString()))
            {
			    preselect = true;
                OutputDebugStringFormat( TEXT("QueryPreselect: (%s) registered to Office, preselected!\n"), file_extension.c_str() );
            }
            else if ( (REG_SZ == RegVal->GetType()) && ! root_key->HasSubKey( RegVal->GetDataAsUniString() ) )
            {
			    preselect = true;
                OutputDebugStringFormat( TEXT("QueryPreselect: (%s) registered but destination is empty, preselected!\n"), file_extension.c_str() );
            }
	    }
        else
        {
            preselect = true;
            OutputDebugStringFormat( TEXT("QueryPreselect: No default found for SubKey (%s), preselected!\n"), file_extension.c_str() );
        }
    }            	
    return preselect;
}

bool Registrar::QueryPreselectMsWordRegistration() const
{    
    return QueryPreselectForMsApplication(
        m_ContextInformation.GetWordDocumentFileExtension());
}

void Registrar::RegisterForMsExcel() const
{
    assert(m_RootKey.get());
    	
	RegisterForMsOfficeApplication(
		m_ContextInformation.GetExcelSheetFileExtension(),
		m_ContextInformation.GetExcelSheetDisplayName(),
		m_ContextInformation.GetExcelSheetDefaultIconEntry(),
		m_ContextInformation.GetExcelSheetDefaultShellCommand(),
		m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Calc);

	RegisterForMsOfficeApplication(
		m_ContextInformation.GetExcelTemplateFileExtension(),
		m_ContextInformation.GetExcelTemplateDisplayName(),
		m_ContextInformation.GetExcelTemplateDefaultIconEntry(),
		m_ContextInformation.GetExcelTemplateDefaultShellCommand(),
		m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Calc);
	
    SaveRegisteredFor(MSEXCEL);
}

void Registrar::UnregisterForMsExcel() const
{
    assert(m_RootKey.get());
    
	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetExcelSheetFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetExcelTemplateFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

    SaveNotRegisteredFor(MSEXCEL);
}

bool Registrar::QueryPreselectMsExcelRegistration() const
{
    return QueryPreselectForMsApplication(
        m_ContextInformation.GetExcelSheetFileExtension());
}

void Registrar::RegisterForMsPowerPoint() const
{
    assert(m_RootKey.get());
    
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetPowerPointDocumentFileExtension(),
        m_ContextInformation.GetPowerPointDocumentDisplayName(),
        m_ContextInformation.GetPowerPointDocumentDefaultIconEntry(),
        m_ContextInformation.GetPowerPointDocumentDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Impress);
            
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetPowerPointShowFileExtension(),
        m_ContextInformation.GetPowerPointShowDisplayName(),
        m_ContextInformation.GetPowerPointShowDefaultIconEntry(),
        m_ContextInformation.GetPowerPointShowDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Impress);
            
    RegisterForMsOfficeApplication(
        m_ContextInformation.GetPowerPointTemplateFileExtension(),
        m_ContextInformation.GetPowerPointTemplateDisplayName(),
        m_ContextInformation.GetPowerPointTemplateDefaultIconEntry(),
        m_ContextInformation.GetPowerPointTemplateDefaultShellCommand(),
        m_ContextInformation.ShellNewCommandDisplayName(),
        RegistrationContextInformation::Impress);	
        
    SaveRegisteredFor(MSPOWERPOINT);
}

void Registrar::UnregisterForMsPowerPoint() const
{
    assert(m_RootKey.get());
    
	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetPowerPointDocumentFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetPowerPointShowFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

	try
	{
		UnregisterForMsOfficeApplication(
			m_ContextInformation.GetPowerPointTemplateFileExtension());
	}
	catch(RegistryKeyNotFoundException&)
	{}

    SaveNotRegisteredFor(MSPOWERPOINT);
}

//-----------------------------------------
/*
*/
bool Registrar::QueryPreselectMsPowerPointRegistration() const
{
    return QueryPreselectForMsApplication( m_ContextInformation.GetPowerPointDocumentFileExtension()) &&
           QueryPreselectForMsApplication( m_ContextInformation.GetPowerPointShowFileExtension());
}

//-----------------------------------------
/** The documentation says we have to
      make the following entries to register
      a html editor for the Internet Explorer
      HKCR\.htm\OpenWithList\App Friendly Name\shell\edit\command
      But the reality shows that this works only 
      with Internet Explorer 5.x 
      Internet Explorer 6.0 wants the follwoing 
      entries:
      HKCR\.htm\OpenWithList\App.exe
      HKCR\Applications\App.ex\shell\edit\command      
*/
void Registrar::RegisterAsHtmlEditorForInternetExplorer() const
{
    assert(m_RootKey.get());
    
    std::wstring OOFriendlyAppName = m_ContextInformation.GetOpenOfficeFriendlyAppName();
    
    std::wstring RegKeyName = HTM_OPENWITHLIST + std::wstring(L"\\") + OOFriendlyAppName;
    RegistryKey RegKey = m_RootKey->CreateSubKey(RegKeyName);
    
    RegKey = RegKey->CreateSubKey(SHELL_EDIT_COMMAND);
    
    RegistryValue RegVal(
        new RegistryValueImpl(
            DEFAULT_VALUE_NAME, 
            m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
                                                          RegistrationContextInformation::Writer)));
            
    RegKey->SetValue(RegVal);
    
    RegKeyName = APPLICATIONS + std::wstring(L"\\") + OOFriendlyAppName;
    RegKey = m_RootKey->CreateSubKey(RegKeyName);
    
    RegVal->SetName(L"FriendlyAppName");
    RegVal->SetValue(OOFriendlyAppName);
    RegKey->SetValue(RegVal);
    
    RegKey = RegKey->CreateSubKey(SHELL_EDIT_COMMAND);
    RegVal->SetName(DEFAULT_VALUE_NAME);
    RegVal->SetValue(
        m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
                                                      RegistrationContextInformation::Writer));        
    RegKey->SetValue(RegVal);
    
    SaveRegisteredFor(HTML_EDITOR);
}

void Registrar::UnregisterAsHtmlEditorForInternetExplorer() const
{
    assert(m_RootKey.get());

	try
	{
		std::wstring OOFriendlyAppName = m_ContextInformation.GetOpenOfficeFriendlyAppName();

        RegistryKey aRegKey = m_RootKey->OpenSubKey( APPLICATIONS );
        if ( aRegKey->HasSubKey( OOFriendlyAppName ) )
		    aRegKey->DeleteSubKeyTree( OOFriendlyAppName );

        aRegKey = m_RootKey->OpenSubKey( HTM_OPENWITHLIST );
        if ( aRegKey->HasSubKey( OOFriendlyAppName ) )
		    aRegKey->DeleteSubKeyTree( OOFriendlyAppName );
	}
    catch(RegistryKeyNotFoundException&)
	{}

    SaveNotRegisteredFor(HTML_EDITOR);
}

void Registrar::RegisterAsDefaultHtmlEditorForInternetExplorer() const
{
    assert(m_RootKey.get());
    
    RegistryKey RegistrationRootKey = GetRootKeyForDefHtmlEditorForIERegistration();
    
    RegistryKey RegKey = RegistrationRootKey->CreateSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
    
    RegistryValue RegVal = RegistryValue(new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
    
    if (RegKey->HasValue(DEFAULT_VALUE_NAME))
	{
        RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
        
        std::wstring CmdLine = RegVal->GetDataAsUniString();
        
        if (std::wstring::npos == CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
        {            
            RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + DEFAULT_HTML_EDITOR);
            
            if (RegKey->HasValue(DEFAULT_VALUE_NAME))
                BackupRegKey->CopyValue(RegKey, DEFAULT_VALUE_NAME);            
            
            RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
            if (RegKey->HasValue(L"Description"))
                BackupRegKey->CopyValue(RegKey, L"Description");
        }
    }
        
    RegVal->SetValue(
        m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
                                                      RegistrationContextInformation::Writer));
    RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
    RegKey->SetValue(RegVal);
    
    RegVal->SetName(L"Description");
    RegVal->SetValue(m_ContextInformation.GetOpenOfficeFriendlyAppName());
    RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
    RegKey->SetValue(RegVal);
    
    SaveRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE);
}

void Registrar::UnregisterAsDefaultHtmlEditorForInternetExplorer() const
{
    assert(m_RootKey.get());
    
    RegistryKey RegistrationRootKey = GetRootKeyForDefHtmlEditorForIERegistration();
    
    RegistryKey RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR_SHL_EDIT_CMD);
        
    if (RegKey->HasValue(DEFAULT_VALUE_NAME))
    {
        RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
        
        std::wstring CmdLine = RegVal->GetDataAsUniString();
            
        if (std::wstring::npos != CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
        {                
            RegistryKey BackupRegKey = m_RootKey->OpenSubKey(PRIVATE_BACKUP_KEY_NAME);
                    
            if (BackupRegKey->HasSubKey(DEFAULT_HTML_EDITOR))
            {
                BackupRegKey = BackupRegKey->OpenSubKey(DEFAULT_HTML_EDITOR);
                
                if (BackupRegKey->HasValue(DEFAULT_VALUE_NAME))
                    RegKey->CopyValue(BackupRegKey, DEFAULT_VALUE_NAME);
                else
                    RegKey->DeleteValue(DEFAULT_VALUE_NAME);

                RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);                        
                    
                if (BackupRegKey->HasValue(L"Description"))
                    RegKey->CopyValue(BackupRegKey, L"Description");
                else
                    RegKey->DeleteValue(L"Description");
            }
            else
            {
                RegKey->DeleteValue(DEFAULT_VALUE_NAME);                       
                RegKey = RegistrationRootKey->OpenSubKey(MS_IE_DEF_HTML_EDITOR);
                RegKey->DeleteValue(L"Description");
            }        
        }
    }
    
    SaveNotRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE);
}

void Registrar::RegisterAsDefaultShellHtmlEditor() const
{
    assert(m_RootKey.get());
    
    RegistryKey RegKey = m_RootKey->CreateSubKey(L".htm");
    
    RegistryValue RegVal = RegistryValue(
        new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
    
    if (RegKey->HasValue(DEFAULT_VALUE_NAME))
        RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
        
    std::wstring HtmFwdKey = RegVal->GetDataAsUniString();        
    if (0 == HtmFwdKey.length() || !m_RootKey->HasSubKey(HtmFwdKey))
        HtmFwdKey = L".htm";
    
    RegKey = m_RootKey->CreateSubKey(HtmFwdKey + L"\\" + SHELL_EDIT_COMMAND);
    
	if (RegKey->HasValue(DEFAULT_VALUE_NAME))
	{
		RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
    
		std::wstring CmdLine = RegVal->GetDataAsUniString();
        
		// backup old values if we are not in place
		if (std::wstring::npos == CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
		{            
			RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + HTML_EDIT);
			BackupRegKey->CopyValue(RegKey, DEFAULT_VALUE_NAME, SHELL_EDIT_COMMAND_BACKUP);
		}		
	}
    
    RegVal->SetValue(
        m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open,
                                                      RegistrationContextInformation::Writer));
        
    RegKey->SetValue(RegVal);
    
    SaveRegisteredFor(DEFAULT_SHELL_HTML_EDITOR);
}

void Registrar::UnregisterAsDefaultShellHtmlEditor() const
{
    assert(m_RootKey.get());
    
	try
	{
		RegistryKey RegKey = m_RootKey->OpenSubKey(L".htm");
    
		RegistryValue RegVal = RegistryValue(
			new RegistryValueImpl(DEFAULT_VALUE_NAME, L""));
    
		if (RegKey->HasValue(DEFAULT_VALUE_NAME))
			RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
        
		std::wstring HtmFwdKey = RegVal->GetDataAsUniString();
        
		if (0 == HtmFwdKey.length() || !m_RootKey->HasSubKey(HtmFwdKey))
			HtmFwdKey = L".htm";
    
		RegKey = m_RootKey->OpenSubKey(HtmFwdKey + L"\\" + SHELL_EDIT_COMMAND);
    
		RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
        
		std::wstring CmdLine = RegVal->GetDataAsUniString();
        
		if (std::wstring::npos != CmdLine.find(m_ContextInformation.GetOpenOfficeExecutableName()))
		{        
			RegistryKey BackupRegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME + L"\\" + HTML_EDIT);
            
			if (BackupRegKey->HasValue(SHELL_EDIT_COMMAND_BACKUP))
				RegKey->CopyValue(BackupRegKey, SHELL_EDIT_COMMAND_BACKUP, DEFAULT_VALUE_NAME);
			else
				RegKey->DeleteValue(DEFAULT_VALUE_NAME);
		}    
	}
    catch(RegistryKeyNotFoundException&)
	{
	}

    SaveNotRegisteredFor(DEFAULT_SHELL_HTML_EDITOR);
}

void Registrar::SaveRegisteredFor(int State) const
{
    assert(m_RootKey.get());
    
    int NewState = GetRegisterState();
    NewState |= State;
    SetRegisterState(NewState);
}

void Registrar::SaveNotRegisteredFor(int State) const
{
    assert(m_RootKey.get());
        
    int NewState = GetRegisterState();
    NewState &= ~State;
    SetRegisterState(NewState);
}

int Registrar::GetRegisterState() const
{
    int State = 0;
    
    RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
    
    if (RegKey->HasValue(REGISTRATION_STATE))
    {
        RegistryValue RegVal = RegKey->GetValue(REGISTRATION_STATE);
        if (REG_DWORD == RegVal->GetType())
            State = RegVal->GetDataAsInt();
    }
    
    return State;
}

void Registrar::SetRegisterState(int NewState) const
{
    RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
    RegistryValue RegVal = RegistryValue(new RegistryValueImpl(REGISTRATION_STATE, NewState));
    RegKey->SetValue(RegVal);
}
    
bool Registrar::IsRegisteredFor(int State) const
{
    assert(m_RootKey.get());
    
    RegistryKey RegKey = m_RootKey->CreateSubKey(PRIVATE_BACKUP_KEY_NAME);
    
    int SavedState = 0;
    
    if (RegKey->HasValue(REGISTRATION_STATE))
    {
        RegistryValue RegVal = RegKey->GetValue(REGISTRATION_STATE);
        if (REG_DWORD == RegVal->GetType())
            SavedState = RegVal->GetDataAsInt();        
    }
    
	return ((SavedState & State) == State);
}

//--------------------------------------
/** Restore the last registration state (necessary for
	Setup repair) */
void Registrar::RepairRegistrationState() const
{
    assert(m_RootKey.get());

	if (IsRegisteredFor(MSWORD))
		RegisterForMsWord();

	if (IsRegisteredFor(MSEXCEL))
		RegisterForMsExcel();

	if (IsRegisteredFor(MSPOWERPOINT))
		RegisterForMsPowerPoint();

	if (IsRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE))
		RegisterAsDefaultHtmlEditorForInternetExplorer();

	if (IsRegisteredFor(HTML_EDITOR))
		RegisterAsHtmlEditorForInternetExplorer();

	if (IsRegisteredFor(DEFAULT_SHELL_HTML_EDITOR))
		RegisterAsDefaultShellHtmlEditor();
}

/** Unregisters all and delete all Registry keys we have written */
void Registrar::UnregisterAllAndCleanUpRegistry() const
{	
	assert(m_RootKey.get());

	if (IsRegisteredFor(MSWORD))
		UnregisterForMsWord();

	if (IsRegisteredFor(MSEXCEL))
		UnregisterForMsExcel();

	if (IsRegisteredFor(MSPOWERPOINT))
		UnregisterForMsPowerPoint();

	if (IsRegisteredFor(DEFAULT_HTML_EDITOR_FOR_IE))
		UnregisterAsDefaultHtmlEditorForInternetExplorer();

	if (IsRegisteredFor(HTML_EDITOR))
		UnregisterAsHtmlEditorForInternetExplorer();

	if (IsRegisteredFor(DEFAULT_SHELL_HTML_EDITOR))
		UnregisterAsDefaultShellHtmlEditor();
	
	if (m_RootKey->HasSubKey(PRIVATE_BACKUP_KEY_NAME))
	    m_RootKey->DeleteSubKeyTree(PRIVATE_BACKUP_KEY_NAME);
}

void Registrar::RegisterForMsOfficeApplication(
    const std::wstring& FileExtension,
    const std::wstring& DocumentDisplayName,
    const std::wstring& DefaultIconEntry,
    const std::wstring& DefaultShellCommand,
    const std::wstring& ShellNewCommandDisplayName,
    const RegistrationContextInformation::OFFICE_APPLICATION eOfficeApp) const
{
    assert(m_RootKey.get());
    
	std::wstring ForwardKeyName = FORWARD_KEY_PREFIX + FileExtension;

	RegistryKey ForwardKey = m_RootKey->CreateSubKey(ForwardKeyName);
	RegistryValue RegVal(new RegistryValueImpl(std::wstring(DEFAULT_VALUE_NAME), DocumentDisplayName));
	ForwardKey->SetValue(RegVal);

	RegistryKey RegKey = ForwardKey->CreateSubKey(L"DefaultIcon");
	RegVal->SetValue(DefaultIconEntry);
	RegKey->SetValue(RegVal);

	RegistryKey RegKeyShell = ForwardKey->CreateSubKey(L"shell");
	RegVal->SetValue(DefaultShellCommand);
	RegKeyShell->SetValue(RegVal);

	RegKey = RegKeyShell->CreateSubKey(L"new");
	RegVal->SetValue(ShellNewCommandDisplayName);
	RegKey->SetValue(RegVal);

	RegKey = RegKey->CreateSubKey(L"command");
	RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::New, eOfficeApp));
	RegKey->SetValue(RegVal);

	RegKey = RegKeyShell->CreateSubKey(L"open\\command");
	RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Open, eOfficeApp));
	RegKey->SetValue(RegVal);

	RegKey = RegKeyShell->CreateSubKey(L"print\\command");
	RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Print, eOfficeApp));
	RegKey->SetValue(RegVal);

	RegKey = RegKeyShell->CreateSubKey(L"printto\\command");
	RegVal->SetValue(m_ContextInformation.GetOpenOfficeCommandline(RegistrationContextInformation::Printto, eOfficeApp));
	RegKey->SetValue(RegVal);

    // set the new forward key under the appropriate extension
	RegKey = m_RootKey->CreateSubKey(FileExtension);
    
	if (RegKey->HasValue(DEFAULT_VALUE_NAME))
	{
		RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
    
		if (REG_SZ == RegVal->GetType())
		{
			std::wstring str = RegVal->GetDataAsUniString();
			if (!IsOpenOfficeRegisteredForMsApplication(str)) 
				ForwardKey->CopyValue(RegKey, DEFAULT_VALUE_NAME, BACKUP_VALUE_NAME);
		}
	}
    
	RegVal->SetValue(ForwardKeyName);
	RegKey->SetValue(RegVal);	
}

void Registrar::UnregisterForMsOfficeApplication(const std::wstring& FileExtension) const
{
    std::wstring FwdRegKeyName = FORWARD_KEY_PREFIX + FileExtension;
    
    if (m_RootKey->HasSubKey(FileExtension))
    {
        RegistryKey RegKey = m_RootKey->OpenSubKey(FileExtension);
        
        if (RegKey->HasValue(DEFAULT_VALUE_NAME))
        {
            RegistryValue RegVal = RegKey->GetValue(DEFAULT_VALUE_NAME);
            if (REG_SZ == RegVal->GetType() && 
                IsOpenOfficeRegisteredForMsApplication(RegVal->GetDataAsUniString()))
            {                
                RegistryKey FwdRegKey = m_RootKey->CreateSubKey(FwdRegKeyName);
                    
                if (FwdRegKey->HasValue(BACKUP_VALUE_NAME))
                    RegKey->CopyValue(FwdRegKey, BACKUP_VALUE_NAME, DEFAULT_VALUE_NAME);
                else
                    RegKey->DeleteValue(DEFAULT_VALUE_NAME);
            }
        }
    }
    
    if (m_RootKey->HasSubKey(FwdRegKeyName))
        m_RootKey->DeleteSubKeyTree(FwdRegKeyName);
}
   
RegistryKey Registrar::GetRootKeyForDefHtmlEditorForIERegistration() const
{
    return WindowsRegistry().GetLocalMachineKey();
}

bool Registrar::IsOpenOfficeRegisteredForMsApplication(const std::wstring& DocumentExtensionDefValue) const
{
    return (std::wstring::npos != DocumentExtensionDefValue.find(FORWARD_KEY_PREFIX));
}