/*
 *	MPEG Audio Encoder for DirectShow
 *	Registry wrapper
 *
 *	Copyright (c) 2000 Marie Orlova, Peter Gubanov, Elecard Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <Windows.h>

#include "reg.h"


CRegKey::CRegKey(void)
{
	m_hRootKey = NULL;
	m_name[0] = 0;
	m_hKey = NULL;
}


CRegKey::CRegKey(HKEY rt, PTSTR pName)
{
	m_hRootKey = rt;
	m_hKey = NULL;
	if(pName)
	{
		lstrcpy(m_name, pName);
		Open(m_hRootKey, m_name);
	}
	else
		m_name[0] = 0;
}


CRegKey::~CRegKey(void)
{
	Close();
}



BOOL	CRegKey::Open(HKEY rootKey, PTSTR pName)
{
	if(m_hKey)
		Close();

	m_hRootKey = rootKey;
	if(pName) 
	{
		lstrcpy(m_name, pName);
		if(RegOpenKeyEx(m_hRootKey, m_name, 0, KEY_ALL_ACCESS, &m_hKey) != ERROR_SUCCESS) 
		{
			m_hKey = NULL;
			return FALSE;
		}
	}
	else 
	{
		m_name[0] = 0;
		m_hKey = m_hRootKey;
	}

	return TRUE;
}


BOOL	CRegKey::Create(HKEY rootKey, PTSTR pName)
{
	if(m_hKey)
		Close();

	m_hRootKey = rootKey;
	if(pName) 
	{
		lstrcpy(m_name, pName);
		if(RegCreateKeyEx(m_hRootKey, pName, NULL,
				TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
				&m_hKey, NULL) != ERROR_SUCCESS) 
		{

			m_hKey = NULL;
			return FALSE;
		}
	}
	else 
	{
		m_name[0] = 0;
	}
	m_hRootKey = m_hKey;

	return TRUE;
}


BOOL	CRegKey::Open(PTSTR an)
{
	TCHAR achName[MAX_PATH];

	if(m_hKey)
		Close();

	lstrcpy(achName, m_name);
	if(an)
		lstrcat(achName, an);

	if(RegOpenKeyEx(m_hRootKey, achName, 0, KEY_ALL_ACCESS, &m_hKey) != ERROR_SUCCESS) 
	{
		m_hKey = NULL;
		return FALSE;
	}

	return TRUE;
}


BOOL	CRegKey::Create(PTSTR an)
{
	TCHAR achName[MAX_PATH];

	if(m_hKey)
		Close();

	lstrcpy(achName, m_name);
	if(an)
		lstrcat(achName, an);

	if(RegCreateKeyEx(m_hRootKey, achName, NULL,
			TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
			&m_hKey, NULL) != ERROR_SUCCESS) 
	{

		m_hKey = NULL;
		return FALSE;
	}

	return TRUE;
}


BOOL	CRegKey::Close(void)
{
	if(m_hKey && m_hKey != m_hRootKey)
		RegCloseKey(m_hKey);

	m_hKey = 0;
	return TRUE;
}

BOOL	CRegKey::getFlag(PTSTR valuename, BOOL bDefault)
{
	if(!m_hKey)
		return bDefault;

	DWORD cbData;
	DWORD	dwData;
	DWORD	dwType;

	cbData = sizeof(dwData);
	if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (PBYTE)&dwData, &cbData) == ERROR_SUCCESS) 
	{
		if(dwType == REG_DWORD)
			return (dwData) ? TRUE : FALSE;
	}
	return bDefault;
}


void	CRegKey::setFlag(PTSTR valuename, BOOL bValue, BOOL bDefault)
{
	if(getFlag(valuename, bDefault) == bValue )
		return;

	RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&bValue, sizeof(bValue));
}


void	CRegKey::setFlag(PTSTR valuename, BOOL bValue)
{
	RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&bValue, sizeof(bValue));
}


DWORD	CRegKey::getDWORD(PTSTR valuename, DWORD bDefault)
{
	DWORD dwData;
	DWORD cbData;
	DWORD	dwType;

	if(!m_hKey)
		return bDefault;

	cbData = sizeof(dwData);
	if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (PBYTE)&dwData, &cbData) == ERROR_SUCCESS) {
		if(dwType == REG_DWORD) 
		{
			return (UINT)dwData;
		}
	}

	return bDefault;
}


void	CRegKey::setDWORD(PTSTR valuename, DWORD dwValue, DWORD dwDefault)
{
	DWORD dwData = dwValue;

	if(getDWORD(valuename, dwDefault) == dwValue)
		return;

	RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&dwData, sizeof(dwData));
}


void	CRegKey::setDWORD(PTSTR valuename, DWORD dwValue)
{
	DWORD dwData = dwValue;
	RegSetValueEx(m_hKey, valuename, 0, REG_DWORD, (PBYTE)&dwData, sizeof(dwData));
}


DWORD CRegKey::getString(PTSTR valuename, PTSTR pDefault, PTSTR pResult, int cbSize)
{
	DWORD dwType;

	cbSize *= sizeof(TCHAR);	// for unicode strings

	if(m_hKey) 
	{
		if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (LPBYTE)pResult, (LPDWORD)&cbSize) == ERROR_SUCCESS) 
		{
			if(dwType == REG_SZ) 
			{
				return(cbSize - 1);
			}
		}
	}
	lstrcpy(pResult, pDefault);
	return lstrlen(pDefault);
}


void	CRegKey::setString(PTSTR valuename, PTSTR pData)
{
	RegSetValueEx(m_hKey, valuename, 0, REG_SZ, (LPBYTE)pData, (lstrlen(pData) + 1)*sizeof(TCHAR));
}


DWORD CRegKey::getBinary(PTSTR valuename, PVOID pDefault, PVOID pResult, int cbSize)
{
	DWORD dwType;

	if(RegQueryValueEx(m_hKey, valuename, NULL, &dwType, (LPBYTE)pResult, (LPDWORD)&cbSize) == ERROR_SUCCESS) 
	{
		if(dwType == REG_BINARY) 
		{
			return cbSize;
		}
	}

	memmove(pResult, pDefault, cbSize);
	return cbSize;
}


DWORD CRegKey::setBinary(PTSTR valuename, PVOID pData, int cbSize)
{
	RegSetValueEx(m_hKey, valuename, 0, REG_BINARY, (LPBYTE)pData, cbSize);
	return cbSize;
}

