From 7c027cfcf629e4414c08d94355e14647620539c3 Mon Sep 17 00:00:00 2001 From: Chris Danford Date: Tue, 11 Feb 2003 09:20:58 +0000 Subject: [PATCH] Added support for multiple installation dirs to smpackage. --- stepmania/src/smpackage/EditInsallations.cpp | 129 +++ stepmania/src/smpackage/EditInsallations.h | 53 ++ stepmania/src/smpackage/Registry.cpp | 798 ++++++++++++++++++ stepmania/src/smpackage/Registry.h | 74 ++ .../src/smpackage/SMPackageInstallDlg.cpp | 64 +- stepmania/src/smpackage/SMPackageInstallDlg.h | 6 +- stepmania/src/smpackage/resource.h | 10 +- stepmania/src/smpackage/smpackage.clw | 42 +- stepmania/src/smpackage/smpackage.dsp | 20 + stepmania/src/smpackage/smpackage.rc | 33 +- stepmania/src/smpackage/smpackageUtil.h | 71 ++ 11 files changed, 1276 insertions(+), 24 deletions(-) create mode 100644 stepmania/src/smpackage/EditInsallations.cpp create mode 100644 stepmania/src/smpackage/EditInsallations.h create mode 100644 stepmania/src/smpackage/Registry.cpp create mode 100644 stepmania/src/smpackage/Registry.h create mode 100644 stepmania/src/smpackage/smpackageUtil.h diff --git a/stepmania/src/smpackage/EditInsallations.cpp b/stepmania/src/smpackage/EditInsallations.cpp new file mode 100644 index 0000000000..fc16059998 --- /dev/null +++ b/stepmania/src/smpackage/EditInsallations.cpp @@ -0,0 +1,129 @@ +// EditInsallations.cpp : implementation file +// + +#include "stdafx.h" +#include "smpackage.h" +#include "EditInsallations.h" +#include "smpackageUtil.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// EditInsallations dialog + + +EditInsallations::EditInsallations(CWnd* pParent /*=NULL*/) + : CDialog(EditInsallations::IDD, pParent) +{ + //{{AFX_DATA_INIT(EditInsallations) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT +} + + +void EditInsallations::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(EditInsallations) + DDX_Control(pDX, IDC_LIST, m_list); + DDX_Control(pDX, IDC_EDIT, m_edit); + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(EditInsallations, CDialog) + //{{AFX_MSG_MAP(EditInsallations) + ON_BN_CLICKED(IDC_BUTTON_REMOVE, OnButtonRemove) + ON_BN_CLICKED(IDC_BUTTON_MAKE_DEFAULT, OnButtonMakeDefault) + ON_BN_CLICKED(IDC_BUTTON_ADD, OnButtonAdd) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// EditInsallations message handlers + +BOOL EditInsallations::OnInitDialog() +{ + CDialog::OnInitDialog(); + + // TODO: Add extra initialization here + + + CStringArray asInstallDirs; + GetStepManiaInstallDirs( asInstallDirs ); + for( int i=0; i 1000 +#pragma once +#endif // _MSC_VER > 1000 +// EditInsallations.h : header file +// + +///////////////////////////////////////////////////////////////////////////// +// EditInsallations dialog + +class EditInsallations : public CDialog +{ +// Construction +public: + EditInsallations(CWnd* pParent = NULL); // standard constructor + + CStringArray m_asReturnedInstallDirs; + +// Dialog Data + //{{AFX_DATA(EditInsallations) + enum { IDD = IDD_EDIT_INSTALLATIONS }; + CListBox m_list; + CEdit m_edit; + //}}AFX_DATA + + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(EditInsallations) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + + // Generated message map functions + //{{AFX_MSG(EditInsallations) + virtual BOOL OnInitDialog(); + afx_msg void OnButtonRemove(); + afx_msg void OnButtonMakeDefault(); + afx_msg void OnButtonAdd(); + virtual void OnOK(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_EDITINSALLATIONS_H__CD328CB4_8E35_4B12_BCD1_ADF5CE7EABC7__INCLUDED_) diff --git a/stepmania/src/smpackage/Registry.cpp b/stepmania/src/smpackage/Registry.cpp new file mode 100644 index 0000000000..25b6189eb6 --- /dev/null +++ b/stepmania/src/smpackage/Registry.cpp @@ -0,0 +1,798 @@ + + +#include "stdafx.h" +#include +#include "Registry.h" + +#define CLASS_NAME_LENGTH 255 + +/* IMPORTANT NOTES ABOUT CREGISTRY: + + CRegistry never keeps a key open past the end of a function call. + This is incase the application crashes before the next call to close + the registry + + INCLUDE FILES + "winreg.h" and "afxdisp.h" must be included in "stdafx.h" + + KEY NAMES: + Key names must not begin with a \ and only absolute strings are accepted + +*/ + + + +CRegistry::CRegistry() +{ + m_hRootKey = HKEY_CURRENT_USER; + m_bLazyWrite = TRUE; + m_nLastError = ERROR_SUCCESS; +} + +CRegistry::~CRegistry() +{ + ClearKey(); +} + + +BOOL CRegistry::ClearKey() +{ + /* Call CloseKey to write the current key to the registry and close the + key. An application should not keep keys open any longer than necessary. + Calling CloseKey when there is no current key has no effect.*/ + + m_strCurrentPath.Empty(); + m_hRootKey = HKEY_CURRENT_USER; + m_bLazyWrite = TRUE; + return TRUE; +} + + + +BOOL CRegistry::SetRootKey(HKEY hRootKey) +{ + // sets the root key + // make sure to set it to a valid key + if (hRootKey != HKEY_CLASSES_ROOT && + hRootKey != HKEY_CURRENT_USER && + hRootKey != HKEY_LOCAL_MACHINE && + hRootKey != HKEY_USERS) return FALSE; + + m_hRootKey = hRootKey; + return TRUE; +} + + +BOOL CRegistry::CreateKey(CString strKey) +{ + /* Use CreateKey to add a new key to the registry. + Key is the name of the key to create. Key must be + an absolute name. An absolute key + begins with a backslash (\) and is a subkey of + the root key. */ + + ASSERT(strKey[0] != '\\'); + HKEY hKey; + + DWORD dwDisposition = 0; + + if (::RegCreateKeyEx(m_hRootKey, LPCTSTR(strKey), 0, NULL, + REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, + &dwDisposition) != ERROR_SUCCESS) return FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + m_strCurrentPath = strKey; + return TRUE; +} + + +BOOL CRegistry::DeleteKey(CString strKey) +{ + /* Call DeleteKey to remove a specified key and its associated data, + if any, from the registry. Returns FALSE is there are subkeys + Subkeys must be explicitly deleted by separate calls to DeleteKey. + DeleteKey returns True if key deletion is successful. On error, + DeleteKey returns False. */ + + // need to open the key first with RegOpenKeyEx +// ASSERT(FALSE); // not yet implemented +// ASSERT(strKey[0] != '\\'); + + if (!KeyExists(strKey)) return TRUE; + if (::RegDeleteKey(m_hRootKey, strKey) != ERROR_SUCCESS) return FALSE; + return TRUE; +} + + + +BOOL CRegistry::DeleteValue(CString strName) +{ + /* Call DeleteValue to remove a specific data value + associated with the current key. Name is string + containing the name of the value to delete. Keys can contain + multiple data values, and every value associated with a key + has a unique name. */ + + ASSERT(m_strCurrentPath.GetLength() > 0); + HKEY hKey; + LONG lResult; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_SET_VALUE, &hKey) != ERROR_SUCCESS) return FALSE; + + lResult = ::RegDeleteValue(hKey, LPCTSTR(strName)); + ::RegCloseKey(hKey); + + if (lResult == ERROR_SUCCESS) return TRUE; + return FALSE; +} + + +int CRegistry::GetDataSize(CString strValueName) +{ + /* Call GetDataSize to determine the size, in bytes, of + a data value associated with the current key. ValueName + is a string containing the name of the data value to query. + On success, GetDataSize returns the size of the data value. + On failure, GetDataSize returns -1. */ + + HKEY hKey; + ASSERT(m_strCurrentPath.GetLength() > 0); + LONG lResult; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS) return -1; + + DWORD dwSize = 1; + lResult = ::RegQueryValueEx(hKey, LPCTSTR(strValueName), + NULL, NULL, NULL, &dwSize); + ::RegCloseKey(hKey); + + if (lResult != ERROR_SUCCESS) return -1; + return (int)dwSize; +} + +DWORD CRegistry::GetDataType(CString strValueName) +{ + HKEY hKey; + ASSERT(m_strCurrentPath.GetLength() > 0); + + m_nLastError = ::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_QUERY_VALUE, &hKey); + + if (m_nLastError != ERROR_SUCCESS) return 0; + + DWORD dwType = 1; + m_nLastError = ::RegQueryValueEx(hKey, LPCTSTR(strValueName), + NULL, &dwType, NULL, NULL); + ::RegCloseKey(hKey); + + if (m_nLastError == ERROR_SUCCESS) return dwType; + + return 0; +} + + + +int CRegistry::GetSubKeyCount() +{ + /* Call this function to determine the number of subkeys. + the function returns -1 on error */ + HKEY hKey; + ASSERT(m_strCurrentPath.GetLength() > 0); + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS) return -1; + + LONG lResult; + DWORD dwSubKeyCount, dwValueCount, dwClassNameLength, + dwMaxSubKeyName, dwMaxValueName, dwMaxValueLength; + FILETIME ftLastWritten; + + _TCHAR szClassBuffer[CLASS_NAME_LENGTH]; + + dwClassNameLength = CLASS_NAME_LENGTH; + lResult = ::RegQueryInfoKey(hKey, szClassBuffer, &dwClassNameLength, + NULL, &dwSubKeyCount, &dwMaxSubKeyName, NULL, &dwValueCount, + &dwMaxValueName, &dwMaxValueLength, NULL, &ftLastWritten); + + ::RegCloseKey(hKey); + if (lResult != ERROR_SUCCESS) return -1; + + return (int)dwSubKeyCount; +} + + +int CRegistry::GetValueCount() +{ + /* Call this function to determine the number of subkeys. + the function returns -1 on error */ + HKEY hKey; + ASSERT(m_strCurrentPath.GetLength() > 0); + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS) return -1; + + LONG lResult; + DWORD dwSubKeyCount, dwValueCount, dwClassNameLength, + dwMaxSubKeyName, dwMaxValueName, dwMaxValueLength; + FILETIME ftLastWritten; + + _TCHAR szClassBuffer[CLASS_NAME_LENGTH]; + + dwClassNameLength = CLASS_NAME_LENGTH; + lResult = ::RegQueryInfoKey(hKey, szClassBuffer, &dwClassNameLength, + NULL, &dwSubKeyCount, &dwMaxSubKeyName, NULL, &dwValueCount, + &dwMaxValueName, &dwMaxValueLength, NULL, &ftLastWritten); + + ::RegCloseKey(hKey); + if (lResult != ERROR_SUCCESS) return -1; + + return (int)dwValueCount; +} + + +BOOL CRegistry::KeyExists(CString strKey, HKEY hRootKey) +{ + /* Call KeyExists to determine if a key of a specified name exists. + Key is the name of the key for which to search. */ + + ASSERT(strKey[0] != '\\'); + HKEY hKey; + + if (hRootKey == NULL) hRootKey = m_hRootKey; + + LONG lResult = ::RegOpenKeyEx(hRootKey, LPCTSTR(strKey), 0, + KEY_ALL_ACCESS, &hKey); + ::RegCloseKey(hKey); + if (lResult == ERROR_SUCCESS) return TRUE; + return FALSE; +} + +BOOL CRegistry::SetKey(CString strKey, BOOL bCanCreate) +{ + /* Call SetKey to make a specified key the current key. Key is the + name of the key to open. If Key is null, the CurrentKey property + is set to the key specified by the RootKey property. + + CanCreate specifies whether to create the specified key if it does + not exist. If CanCreate is True, the key is created if necessary. + + Key is opened or created with the security access value KEY_ALL_ACCESS. + OpenKey only creates non-volatile keys, A non-volatile key is stored in + the registry and is preserved when the system is restarted. + + OpenKey returns True if the key is successfully opened or created */ + + ASSERT(strKey[0] != '\\'); + HKEY hKey; + + + // close the current key if it is open + if (strKey.GetLength() == 0) + { + m_strCurrentPath.Empty(); + return TRUE; + } + + DWORD dwDisposition; + if (bCanCreate) // open the key with RegCreateKeyEx + { + if (::RegCreateKeyEx(m_hRootKey, LPCTSTR(strKey), 0, NULL, + REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, + &dwDisposition) != ERROR_SUCCESS) return FALSE; + m_strCurrentPath = strKey; + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return TRUE; + } + + // otherwise, open the key without creating + // open key requires no initial slash + m_nLastError = ::RegOpenKeyEx(m_hRootKey, LPCTSTR(strKey), 0, + KEY_ALL_ACCESS, &hKey); + if (m_nLastError != ERROR_SUCCESS) return FALSE; + m_strCurrentPath = strKey; + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return TRUE; +} + + +BOOL CRegistry::ValueExists(CString strName) +{ + /* Call ValueExists to determine if a particular key exists in + the registry. Calling Value Exists is especially useful before + calling other TRegistry methods that operate only on existing keys. + + Name is the name of the data value for which to check. + ValueExists returns True if a match if found, False otherwise. */ + + HKEY hKey; + LONG lResult; + ASSERT(m_strCurrentPath.GetLength() > 0); + + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS) return FALSE; + + lResult = ::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + NULL, NULL, NULL); + ::RegCloseKey(hKey); + + if (lResult == ERROR_SUCCESS) return TRUE; + return FALSE; +} + + +void CRegistry::RenameValue(CString strOldName, CString strNewName) +{ + /* Call RenameValue to change the name of a data value associated + with the current key. OldName is a string containing the current + name of the data value. NewName is a string containing the replacement + name for the data value. + + If OldName is the name of an existing data value for the current key, + and NewName is not the name of an existing data value for the current + key, RenameValue changes the data value name as specified. Otherwise + the current name remains unchanged. + */ + ASSERT(FALSE); // functionality not yet implemented +} + + + + +COleDateTime CRegistry::ReadDateTime(CString strName, COleDateTime dtDefault) +{ + /* Call ReadDate to read a date value from a specified data value + associated with the current key. Name is the name of the data value to read. + If successful, ReadDate returns a Delphi TDateTime value. The integral part + of a TDateTime value is the number of days that have passed since 12/30/1899. + The fractional part of a TDateTime value is the time of day. + On error, an exception is raised, and the value returned by this function + should be discarded. */ + + DWORD dwType = REG_BINARY; + COleDateTime dt; + DWORD dwSize = sizeof(dt); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return dtDefault; + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&dt, &dwSize) != ERROR_SUCCESS) dt = dtDefault; + ::RegCloseKey(hKey); + return dt; +} + + +double CRegistry::ReadFloat(CString strName, double fDefault) +{ + /* Call ReadFloat to read a float value from a specified + data value associated with the current key. Name is the name + of the data value to read. + + If successful, ReadFloat returns a double value. + On error, an exception is raised, and the value returned by + this function should be discarded. */ + + DWORD dwType = REG_BINARY; + double d; + DWORD dwSize = sizeof(d); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return fDefault; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&d, &dwSize) != ERROR_SUCCESS) d = fDefault; + ::RegCloseKey(hKey); + return d; +} + +CString CRegistry::ReadString(CString strName, CString strDefault) +{ + DWORD dwType = REG_SZ; + DWORD dwSize = 255; + BOOL bSuccess = TRUE; + _TCHAR sz[255]; + HKEY hKey; + + + ASSERT(m_strCurrentPath.GetLength() > 0); + + // make sure it is the proper type + dwType = GetDataType(strName); + + if (dwType != REG_SZ && dwType != REG_EXPAND_SZ) + { + return strDefault; + } + + m_nLastError = ::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey); + if (m_nLastError != ERROR_SUCCESS) return strDefault; + + m_nLastError = ::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)sz, &dwSize); + if (m_nLastError != ERROR_SUCCESS) bSuccess = FALSE; + ::RegCloseKey(hKey); + + if (!bSuccess) return strDefault; + return CString((LPCTSTR)sz); +} + +DWORD CRegistry::ReadDword(CString strName, DWORD dwDefault) +{ + DWORD dwType = REG_DWORD; + DWORD dw; + DWORD dwSize = sizeof(dw); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return dwDefault; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&dw, &dwSize) != ERROR_SUCCESS) dw = dwDefault; + ::RegCloseKey(hKey); + return dw; +} + + + +int CRegistry::ReadInt(CString strName, int nDefault) +{ + DWORD dwType = REG_BINARY; + int n; + DWORD dwSize = sizeof(n); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return nDefault; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&n, &dwSize) != ERROR_SUCCESS) n = nDefault; + ::RegCloseKey(hKey); + return n; +} + +BOOL CRegistry::ReadBool(CString strName, BOOL bDefault) +{ + DWORD dwType = REG_BINARY; + BOOL b; + DWORD dwSize = sizeof(b); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return bDefault; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&b, &dwSize) != ERROR_SUCCESS) b = bDefault; + ::RegCloseKey(hKey); + return b; +} + + +COLORREF CRegistry::ReadColor(CString strName, COLORREF rgbDefault) +{ + DWORD dwType = REG_BINARY; + COLORREF rgb; + DWORD dwSize = sizeof(rgb); + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return rgbDefault; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&rgb, &dwSize) != ERROR_SUCCESS) rgb = rgbDefault; + ::RegCloseKey(hKey); + return rgb; +} + +BOOL CRegistry::ReadFont(CString strName, CFont* pFont) +{ + DWORD dwType = REG_BINARY; + DWORD dwSize = sizeof(LOGFONT); + BOOL bSuccess = TRUE; + HKEY hKey; + LOGFONT lf; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)&lf, &dwSize) != ERROR_SUCCESS) bSuccess = FALSE; + ::RegCloseKey(hKey); + if (bSuccess) + { + pFont->Detach(); + pFont->CreateFontIndirect(&lf); + } + return bSuccess; +} + + +BOOL CRegistry::ReadPoint(CString strName, CPoint* pPoint) +{ + DWORD dwType = REG_BINARY; + DWORD dwSize = sizeof(CPoint); + BOOL bSuccess = TRUE; + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)pPoint, &dwSize) != ERROR_SUCCESS) bSuccess = FALSE; + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::ReadSize(CString strName, CSize* pSize) +{ + DWORD dwType = REG_BINARY; + DWORD dwSize = sizeof(CSize); + BOOL bSuccess = TRUE; + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)pSize, &dwSize) != ERROR_SUCCESS) bSuccess = FALSE; + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::ReadRect(CString strName, CRect* pRect) +{ + DWORD dwType = REG_BINARY; + DWORD dwSize = sizeof(CRect); + BOOL bSuccess = TRUE; + HKEY hKey; + + ASSERT(m_strCurrentPath.GetLength() > 0); + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_READ, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegQueryValueEx(hKey, LPCTSTR(strName), NULL, + &dwType, (LPBYTE)pRect, &dwSize) != ERROR_SUCCESS) bSuccess = FALSE; + ::RegCloseKey(hKey); + return bSuccess; +} + + + + +BOOL CRegistry::WriteBool(CString strName, BOOL bValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&bValue, sizeof(bValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::WriteDateTime(CString strName, COleDateTime dtValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&dtValue, sizeof(dtValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + + +BOOL CRegistry::WriteString(CString strName, CString strValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + _TCHAR sz[255]; + + if (strValue.GetLength() > 254) return FALSE; + +#ifdef _UNICODE + wstrcpy(sz, LPCTSTR(strValue)); +#else + strcpy(sz, LPCTSTR(strValue)); +#endif + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + +#ifdef _UNICODE + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_SZ, (LPBYTE)sz, wstrlen(sz) + 1) + != ERROR_SUCCESS) bSuccess = FALSE; +#else + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_SZ, (LPBYTE)sz, strlen(sz) + 1) + != ERROR_SUCCESS) bSuccess = FALSE; +#endif + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + + +BOOL CRegistry::WriteFloat(CString strName, double fValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&fValue, sizeof(fValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::WriteInt(CString strName, int nValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&nValue, sizeof(nValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::WriteDword(CString strName, DWORD dwValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&dwValue, sizeof(dwValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::WriteColor(CString strName, COLORREF rgbValue) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&rgbValue, sizeof(rgbValue)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + + +BOOL CRegistry::WriteFont(CString strName, CFont* pFont) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + LOGFONT lf; + pFont->GetLogFont(&lf); + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)&lf, sizeof(lf)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + + +BOOL CRegistry::WritePoint(CString strName, CPoint* pPoint) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)pPoint, sizeof(CPoint)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + + +BOOL CRegistry::WriteSize(CString strName, CSize* pSize) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)pSize, sizeof(CSize)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + +BOOL CRegistry::WriteRect(CString strName, CRect* pRect) +{ + ASSERT(m_strCurrentPath.GetLength() > 0); + BOOL bSuccess = TRUE; + HKEY hKey; + + if (::RegOpenKeyEx(m_hRootKey, LPCTSTR(m_strCurrentPath), 0, + KEY_WRITE, &hKey) != ERROR_SUCCESS) return FALSE; + + if (::RegSetValueEx(hKey, LPCTSTR(strName), 0, + REG_BINARY, (LPBYTE)pRect, sizeof(CRect)) + != ERROR_SUCCESS) bSuccess = FALSE; + + if (!m_bLazyWrite) ::RegFlushKey(hKey); + ::RegCloseKey(hKey); + return bSuccess; +} + diff --git a/stepmania/src/smpackage/Registry.h b/stepmania/src/smpackage/Registry.h new file mode 100644 index 0000000000..481711478b --- /dev/null +++ b/stepmania/src/smpackage/Registry.h @@ -0,0 +1,74 @@ + + +#ifndef __REGISTRY_H__ +#define __REGISTRY_H__ + +class CRegistry +{ +public: + CRegistry(); + ~CRegistry(); + +int m_nLastError; + +// CRegistry properties +protected: + HKEY m_hRootKey; + BOOL m_bLazyWrite; + CString m_strCurrentPath; + +public: + inline BOOL PathIsValid() { + return (m_strCurrentPath.GetLength() > 0); } + inline CString GetCurrentPath() { + return m_strCurrentPath; } + inline HKEY GetRootKey() { + return m_hRootKey; } + + +//CRegistry methods +public: + BOOL ClearKey(); + BOOL SetRootKey(HKEY hRootKey); + BOOL CreateKey(CString strKey); + BOOL DeleteKey(CString strKey); + BOOL DeleteValue(CString strName); + int GetDataSize(CString strValueName); + DWORD GetDataType(CString strValueName); + int GetSubKeyCount(); + int GetValueCount(); + BOOL KeyExists(CString strKey, HKEY hRootKey = NULL); + BOOL SetKey(CString strKey, BOOL bCanCreate); + BOOL ValueExists(CString strName); + void RenameValue(CString strOldName, CString strNewName); + + // data reading functions + COleDateTime ReadDateTime(CString strName, COleDateTime dtDefault); + double ReadFloat(CString strName, double fDefault); + CString ReadString(CString strName, CString strDefault); + int ReadInt(CString strName, int nDefault); + BOOL ReadBool(CString strName, BOOL bDefault); + COLORREF ReadColor(CString strName, COLORREF rgbDefault); + BOOL ReadFont(CString strName, CFont* pFont); + BOOL ReadPoint(CString strName, CPoint* pPoint); + BOOL ReadSize(CString strName, CSize* pSize); + BOOL ReadRect(CString strName, CRect* pRect); + DWORD ReadDword(CString strName, DWORD dwDefault); + + // data writing functions + BOOL WriteBool(CString strName, BOOL bValue); + BOOL WriteDateTime(CString strName, COleDateTime dtValue); + BOOL WriteString(CString strName, CString strValue); + BOOL WriteFloat(CString strName, double fValue); + BOOL WriteInt(CString strName, int nValue); + BOOL WriteColor(CString strName, COLORREF rgbValue); + BOOL WriteFont(CString strName, CFont* pFont); + BOOL WritePoint(CString strName, CPoint* pPoint); + BOOL WriteSize(CString strName, CSize* pSize); + BOOL WriteRect(CString strName, CRect* pRect); + BOOL WriteDword(CString strName, DWORD dwValue); + +};// end of CRegistry class definition + + +#endif \ No newline at end of file diff --git a/stepmania/src/smpackage/SMPackageInstallDlg.cpp b/stepmania/src/smpackage/SMPackageInstallDlg.cpp index a9435ca010..0a46fee599 100644 --- a/stepmania/src/smpackage/SMPackageInstallDlg.cpp +++ b/stepmania/src/smpackage/SMPackageInstallDlg.cpp @@ -5,6 +5,8 @@ #include "smpackage.h" #include "SMPackageInstallDlg.h" #include "RageUtil.h" +#include "smpackageUtil.h" +#include "EditInsallations.h" #ifdef _DEBUG #define new DEBUG_NEW @@ -33,7 +35,8 @@ void CSMPackageInstallDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CSMPackageInstallDlg) - // NOTE: the ClassWizard will add DDX and DDV calls here + DDX_Control(pDX, IDC_BUTTON_EDIT, m_buttonEdit); + DDX_Control(pDX, IDC_COMBO_DIR, m_comboDir); //}}AFX_DATA_MAP } @@ -41,9 +44,11 @@ void CSMPackageInstallDlg::DoDataExchange(CDataExchange* pDX) BEGIN_MESSAGE_MAP(CSMPackageInstallDlg, CDialog) //{{AFX_MSG_MAP(CSMPackageInstallDlg) ON_WM_PAINT() + ON_BN_CLICKED(IDC_BUTTON_EDIT, OnButtonEdit) //}}AFX_MSG_MAP END_MESSAGE_MAP() + ///////////////////////////////////////////////////////////////////////////// // CSMPackageInstallDlg message handlers @@ -58,6 +63,7 @@ BOOL CSMPackageInstallDlg::OnInitDialog() // TODO: Add extra initialization here + int i; // // Set the text of the first Edit box @@ -89,7 +95,7 @@ BOOL CSMPackageInstallDlg::OnInitDialog() exit( 1 ); } - for( int i=0; iSetWindowText( sMessage3 ); + + TCHAR szCurrentDirectory[MAX_PATH]; + GetCurrentDirectory( MAX_PATH, szCurrentDirectory ); + AddStepManiaInstallDir( szCurrentDirectory ); + + + RefreshInstallationList(); + return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE @@ -160,9 +167,12 @@ void CSMPackageInstallDlg::OnOK() { // TODO: Add extra validation here - TCHAR szCurrentDirectory[MAX_PATH]; - GetCurrentDirectory( MAX_PATH, szCurrentDirectory ); + m_comboDir.EnableWindow( FALSE ); + m_buttonEdit.EnableWindow( FALSE ); + CString sInstallDir; + m_comboDir.GetWindowText( sInstallDir ); + // Unzip the SMzip package into the Stepmania installation folder for( int i=0; i