/*

 *  LAME MP3 encoder for DirectShow

 *  Registry calls handling class

 *

 *  Copyright (c) 2000-2005 Marie Orlova, Peter Gubanov, Vitaly Ivanov, 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"

namespace Lame

{

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;

}

} // namespace Lame