Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-13 14:20:31 +00:00
Code Issues Projects Releases Packages Wiki Activity

[REGEDIT]

Browse source 
- Adam Kachwalla: Fix inconsistent formatting.
- Me: to anyone who's gonna try syncing the code with Wine's regedit: Have fun!
See issue #5716 for more details.

svn path=/trunk/; revision=49980
This commit is contained in:
Aleksey Bragin 2010-12-07 21:49:25 +00:00
parent 65081666b5
commit ffe49df99a
13 changed files with 2665 additions and 2402 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

736
reactos/base/applications/regedit/childwnd.c
View file

@ -49,12 +49,12 @@ static void draw_splitbar(HWND hWnd, int x)
if(!SizingPattern)
{
const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern);
const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern);
}
if(!SizingBrush)
{
SizingBrush = CreatePatternBrush(SizingPattern);
SizingBrush = CreatePatternBrush(SizingPattern);
}
GetClientRect(hWnd, &rt);
rt.left = x - SPLIT_WIDTH/2;
@ -72,7 +72,8 @@ static void ResizeWnd(ChildWnd* pChildWnd, int cx, int cy)
const int tHeight = 18;
SetRect(&rt, 0, 0, cx, cy);
cy = 0;
if (hStatusBar != NULL) {
if (hStatusBar != NULL)
{
GetWindowRect(hStatusBar, &rs);
cy = rs.bottom - rs.top;
}
@ -132,7 +133,8 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
UNREFERENCED_PARAMETER(message);
switch (wID) {
switch (wID)
{
/* Parse the menu selections: */
case ID_REGISTRY_EXIT:
DestroyWindow(hWnd);
@ -156,15 +158,15 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
if (keyPath == 0 || *keyPath == 0)
{
MessageBeep(MB_ICONHAND);
} else
if (DeleteKey(hWnd, hRootKey, keyPath))
DeleteNode(g_pChildWnd->hTreeWnd, 0);
MessageBeep(MB_ICONHAND);
}
else if (DeleteKey(hWnd, hRootKey, keyPath))
DeleteNode(g_pChildWnd->hTreeWnd, 0);
break;
case ID_TREE_EXPORT:
case ID_TREE_EXPORT:
ExportRegistryFile(pChildWnd->hTreeWnd);
break;
case ID_EDIT_FIND:
case ID_EDIT_FIND:
FindDialog(hWnd);
break;
case ID_EDIT_COPYKEYNAME:
@ -186,13 +188,13 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
break;
default:
if ((wID >= ID_TREE_SUGGESTION_MIN) && (wID <= ID_TREE_SUGGESTION_MAX))
{
{
s = Suggestions;
while(wID > ID_TREE_SUGGESTION_MIN)
{
if (*s)
s += _tcslen(s) + 1;
wID--;
wID--;
}
SelectNode(pChildWnd->hTreeWnd, s);
break;
@ -210,95 +212,95 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
#define MIN(a,b) ((a < b) ? (a) : (b))
static void SuggestKeys(HKEY hRootKey, LPCTSTR pszKeyPath, LPTSTR pszSuggestions,
size_t iSuggestionsLength)
size_t iSuggestionsLength)
{
TCHAR szBuffer[256];
TCHAR szLastFound[256];
size_t i;
HKEY hOtherKey, hSubKey;
BOOL bFound;
TCHAR szBuffer[256];
TCHAR szLastFound[256];
size_t i;
HKEY hOtherKey, hSubKey;
BOOL bFound;
memset(pszSuggestions, 0, iSuggestionsLength * sizeof(*pszSuggestions));
iSuggestionsLength--;
memset(pszSuggestions, 0, iSuggestionsLength * sizeof(*pszSuggestions));
iSuggestionsLength--;
/* Are we a root key in HKEY_CLASSES_ROOT? */
if ((hRootKey == HKEY_CLASSES_ROOT) && pszKeyPath[0] && !_tcschr(pszKeyPath, TEXT('\\')))
{
do
{
bFound = FALSE;
/* Are we a root key in HKEY_CLASSES_ROOT? */
if ((hRootKey == HKEY_CLASSES_ROOT) && pszKeyPath[0] && !_tcschr(pszKeyPath, TEXT('\\')))
{
do
{
bFound = FALSE;
/* Check default key */
if (QueryStringValue(hRootKey, pszKeyPath, NULL,
szBuffer, COUNT_OF(szBuffer)) == ERROR_SUCCESS)
{
/* Sanity check this key; it cannot be empty, nor can it be a
* loop back */
if ((szBuffer[0] != '\0') && _tcsicmp(szBuffer, pszKeyPath))
{
if (RegOpenKey(hRootKey, szBuffer, &hOtherKey) == ERROR_SUCCESS)
{
lstrcpyn(pszSuggestions, TEXT("HKCR\\"), (int) iSuggestionsLength);
i = _tcslen(pszSuggestions);
pszSuggestions += i;
iSuggestionsLength -= i;
/* Check default key */
if (QueryStringValue(hRootKey, pszKeyPath, NULL,
szBuffer, COUNT_OF(szBuffer)) == ERROR_SUCCESS)
{
/* Sanity check this key; it cannot be empty, nor can it be a
* loop back */
if ((szBuffer[0] != '\0') && _tcsicmp(szBuffer, pszKeyPath))
{
if (RegOpenKey(hRootKey, szBuffer, &hOtherKey) == ERROR_SUCCESS)
{
lstrcpyn(pszSuggestions, TEXT("HKCR\\"), (int) iSuggestionsLength);
i = _tcslen(pszSuggestions);
pszSuggestions += i;
iSuggestionsLength -= i;
lstrcpyn(pszSuggestions, szBuffer, (int) iSuggestionsLength);
i = MIN(_tcslen(pszSuggestions) + 1, iSuggestionsLength);
pszSuggestions += i;
iSuggestionsLength -= i;
RegCloseKey(hOtherKey);
lstrcpyn(pszSuggestions, szBuffer, (int) iSuggestionsLength);
i = MIN(_tcslen(pszSuggestions) + 1, iSuggestionsLength);
pszSuggestions += i;
iSuggestionsLength -= i;
RegCloseKey(hOtherKey);
bFound = TRUE;
_tcscpy(szLastFound, szBuffer);
pszKeyPath = szLastFound;
}
}
}
}
while(bFound && (iSuggestionsLength > 0));
bFound = TRUE;
_tcscpy(szLastFound, szBuffer);
pszKeyPath = szLastFound;
}
}
}
}
while(bFound && (iSuggestionsLength > 0));
/* Check CLSID key */
if (RegOpenKey(hRootKey, pszKeyPath, &hSubKey) == ERROR_SUCCESS)
{
if (QueryStringValue(hSubKey, TEXT("CLSID"), NULL, szBuffer,
COUNT_OF(szBuffer)) == ERROR_SUCCESS)
{
lstrcpyn(pszSuggestions, TEXT("HKCR\\CLSID\\"), (int) iSuggestionsLength);
i = _tcslen(pszSuggestions);
pszSuggestions += i;
iSuggestionsLength -= i;
/* Check CLSID key */
if (RegOpenKey(hRootKey, pszKeyPath, &hSubKey) == ERROR_SUCCESS)
{
if (QueryStringValue(hSubKey, TEXT("CLSID"), NULL, szBuffer,
COUNT_OF(szBuffer)) == ERROR_SUCCESS)
{
lstrcpyn(pszSuggestions, TEXT("HKCR\\CLSID\\"), (int) iSuggestionsLength);
i = _tcslen(pszSuggestions);
pszSuggestions += i;
iSuggestionsLength -= i;
lstrcpyn(pszSuggestions, szBuffer, (int) iSuggestionsLength);
i = MIN(_tcslen(pszSuggestions) + 1, iSuggestionsLength);
pszSuggestions += i;
iSuggestionsLength -= i;
}
RegCloseKey(hSubKey);
}
}
lstrcpyn(pszSuggestions, szBuffer, (int) iSuggestionsLength);
i = MIN(_tcslen(pszSuggestions) + 1, iSuggestionsLength);
pszSuggestions += i;
iSuggestionsLength -= i;
}
RegCloseKey(hSubKey);
}
}
}
LRESULT CALLBACK AddressBarProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
WNDPROC oldwndproc;
static TCHAR s_szNode[256];
static TCHAR s_szNode[256];
oldwndproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(hwnd, GWL_USERDATA);
switch (uMsg)
switch (uMsg)
{
case WM_KEYUP:
if (wParam == VK_RETURN)
{
GetWindowText(hwnd, s_szNode, sizeof(s_szNode) / sizeof(s_szNode[0]));
SelectNode(g_pChildWnd->hTreeWnd, s_szNode);
}
break;
default:
break;
}
return CallWindowProc(oldwndproc, hwnd, uMsg, wParam, lParam);
case WM_KEYUP:
if (wParam == VK_RETURN)
{
GetWindowText(hwnd, s_szNode, sizeof(s_szNode) / sizeof(s_szNode[0]));
SelectNode(g_pChildWnd->hTreeWnd, s_szNode);
}
break;
default:
break;
}
return CallWindowProc(oldwndproc, hwnd, uMsg, wParam, lParam);
}
/*******************************************************************************
@ -317,10 +319,11 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
BOOL Result;
ChildWnd* pChildWnd = g_pChildWnd;
switch (message) {
switch (message)
{
case WM_CREATE:
{
WNDPROC oldproc;
WNDPROC oldproc;
HFONT hFont;
TCHAR buffer[MAX_PATH];
/* load "My Computer" string */
@ -333,12 +336,12 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
pChildWnd->nSplitPos = 250;
pChildWnd->hWnd = hWnd;
pChildWnd->hAddressBarWnd = CreateWindowEx(WS_EX_CLIENTEDGE, _T("Edit"), NULL, WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
pChildWnd->hAddressBtnWnd = CreateWindowEx(WS_EX_CLIENTEDGE, _T("Button"), _T("»"), WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP | BS_DEFPUSHBUTTON,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
pChildWnd->hTreeWnd = CreateTreeView(hWnd, pChildWnd->szPath, (HMENU) TREE_WINDOW);
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
pChildWnd->hTreeWnd = CreateTreeView(hWnd, pChildWnd->szPath, (HMENU) TREE_WINDOW);
pChildWnd->hListWnd = CreateListView(hWnd, (HMENU) LIST_WINDOW/*, pChildWnd->szPath*/);
SetFocus(pChildWnd->hTreeWnd);
@ -355,17 +358,19 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
(WPARAM)hFont,
0);
}
/* Subclass the AddressBar */
oldproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(pChildWnd->hAddressBarWnd, GWL_WNDPROC);
/* Subclass the AddressBar */
oldproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(pChildWnd->hAddressBarWnd, GWL_WNDPROC);
SetWindowLongPtr(pChildWnd->hAddressBarWnd, GWL_USERDATA, (DWORD_PTR)oldproc);
SetWindowLongPtr(pChildWnd->hAddressBarWnd, GWL_WNDPROC, (DWORD_PTR)AddressBarProc);
break;
break;
}
case WM_COMMAND:
if(HIWORD(wParam) == BN_CLICKED){
if(HIWORD(wParam) == BN_CLICKED)
{
PostMessage(pChildWnd->hAddressBarWnd, WM_KEYUP, VK_RETURN, 0);
}
else if (!_CmdWndProc(hWnd, message, wParam, lParam)) {
else if (!_CmdWndProc(hWnd, message, wParam, lParam))
{
goto def;
}
break;
@ -373,39 +378,44 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
OnPaint(hWnd);
return 0;
case WM_SETCURSOR:
if (LOWORD(lParam) == HTCLIENT) {
if (LOWORD(lParam) == HTCLIENT)
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(hWnd, &pt);
if (pt.x>=pChildWnd->nSplitPos-SPLIT_WIDTH/2 && pt.x<pChildWnd->nSplitPos+SPLIT_WIDTH/2+1) {
if (pt.x>=pChildWnd->nSplitPos-SPLIT_WIDTH/2 && pt.x<pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
{
SetCursor(LoadCursor(0, IDC_SIZEWE));
return TRUE;
}
}
goto def;
case WM_DESTROY:
DestroyTreeView();
DestroyListView(pChildWnd->hListWnd);
DestroyMainMenu();
DestroyTreeView();
DestroyListView(pChildWnd->hListWnd);
DestroyMainMenu();
HeapFree(GetProcessHeap(), 0, pChildWnd);
pChildWnd = NULL;
PostQuitMessage(0);
break;
case WM_LBUTTONDOWN: {
RECT rt;
int x = (short)LOWORD(lParam);
GetClientRect(hWnd, &rt);
if (x>=pChildWnd->nSplitPos-SPLIT_WIDTH/2 && x<pChildWnd->nSplitPos+SPLIT_WIDTH/2+1) {
last_split = pChildWnd->nSplitPos;
draw_splitbar(hWnd, last_split);
SetCapture(hWnd);
}
break;
case WM_LBUTTONDOWN:
{
RECT rt;
int x = (short)LOWORD(lParam);
GetClientRect(hWnd, &rt);
if (x>=pChildWnd->nSplitPos-SPLIT_WIDTH/2 && x<pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
{
last_split = pChildWnd->nSplitPos;
draw_splitbar(hWnd, last_split);
SetCapture(hWnd);
}
break;
}
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
if (GetCapture() == hWnd) {
if (GetCapture() == hWnd)
{
finish_splitbar(hWnd, LOWORD(lParam));
}
break;
@ -417,7 +427,8 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
case WM_KEYDOWN:
if (wParam == VK_ESCAPE)
if (GetCapture() == hWnd) {
if (GetCapture() == hWnd)
{
RECT rt;
draw_splitbar(hWnd, last_split);
GetClientRect(hWnd, &rt);
@ -429,42 +440,44 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
break;
case WM_MOUSEMOVE:
if (GetCapture() == hWnd) {
if (GetCapture() == hWnd)
{
HDC hdc;
RECT rt;
HGDIOBJ OldObj;
int x = LOWORD(lParam);
if(!SizingPattern)
{
const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern);
const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern);
}
if(!SizingBrush)
{
SizingBrush = CreatePatternBrush(SizingPattern);
SizingBrush = CreatePatternBrush(SizingPattern);
}
GetClientRect(hWnd, &rt);
x = (SHORT) min(max(x, SPLIT_MIN), rt.right - SPLIT_MIN);
if(last_split != x)
{
rt.left = last_split-SPLIT_WIDTH/2;
rt.right = last_split+SPLIT_WIDTH/2+1;
hdc = GetDC(hWnd);
OldObj = SelectObject(hdc, SizingBrush);
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
last_split = x;
rt.left = x-SPLIT_WIDTH/2;
rt.right = x+SPLIT_WIDTH/2+1;
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
SelectObject(hdc, OldObj);
ReleaseDC(hWnd, hdc);
rt.left = last_split-SPLIT_WIDTH/2;
rt.right = last_split+SPLIT_WIDTH/2+1;
hdc = GetDC(hWnd);
OldObj = SelectObject(hdc, SizingBrush);
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
last_split = x;
rt.left = x-SPLIT_WIDTH/2;
rt.right = x+SPLIT_WIDTH/2+1;
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
SelectObject(hdc, OldObj);
ReleaseDC(hWnd, hdc);
}
}
break;
case WM_SETFOCUS:
if (pChildWnd != NULL) {
if (pChildWnd != NULL)
{
SetFocus(pChildWnd->nFocusPanel? pChildWnd->hListWnd: pChildWnd->hTreeWnd);
}
break;
@ -473,283 +486,292 @@ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPa
break;
case WM_NOTIFY:
if ((int)wParam == TREE_WINDOW) {
switch (((LPNMHDR)lParam)->code) {
if ((int)wParam == TREE_WINDOW)
{
switch (((LPNMHDR)lParam)->code)
{
case TVN_ITEMEXPANDING:
return !OnTreeExpanding(pChildWnd->hTreeWnd, (NMTREEVIEW*)lParam);
case TVN_SELCHANGED: {
LPCTSTR keyPath, rootName;
LPTSTR fullPath;
HKEY hRootKey;
case TVN_SELCHANGED:
{
LPCTSTR keyPath, rootName;
LPTSTR fullPath;
HKEY hRootKey;
keyPath = GetItemPath(pChildWnd->hTreeWnd, ((NMTREEVIEW*)lParam)->itemNew.hItem, &hRootKey);
if (keyPath) {
RefreshListView(pChildWnd->hListWnd, hRootKey, keyPath);
rootName = get_root_key_name(hRootKey);
fullPath = HeapAlloc(GetProcessHeap(), 0, (_tcslen(rootName) + 1 + _tcslen(keyPath) + 1) * sizeof(TCHAR));
if (fullPath) {
/* set (correct) the address bar text */
if(keyPath[0] != '\0')
_stprintf(fullPath, _T("%s\\%s"), rootName, keyPath);
else
fullPath = _tcscpy(fullPath, rootName);
SendMessage(hStatusBar, SB_SETTEXT, 0, (LPARAM)fullPath);
SendMessage(pChildWnd->hAddressBarWnd, WM_SETTEXT, 0, (LPARAM)fullPath);
HeapFree(GetProcessHeap(), 0, fullPath);
/* disable hive manipulation items temporarily (enable only if necessary) */
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_GRAYED);
/* compare the strings to see if we should enable/disable the "Load Hive" menus accordingly */
if (!(_tcsicmp(rootName, TEXT("HKEY_LOCAL_MACHINE")) &&
_tcsicmp(rootName, TEXT("HKEY_USERS"))))
keyPath = GetItemPath(pChildWnd->hTreeWnd, ((NMTREEVIEW*)lParam)->itemNew.hItem, &hRootKey);
if (keyPath)
{
// enable the unload menu item if at the root
// otherwise enable the load menu item if there is no slash in keyPath (ie. immediate child selected)
if(keyPath[0] == '\0')
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_ENABLED);
else if(!_tcschr(keyPath, _T('\\')))
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_ENABLED);
}
RefreshListView(pChildWnd->hListWnd, hRootKey, keyPath);
rootName = get_root_key_name(hRootKey);
fullPath = HeapAlloc(GetProcessHeap(), 0, (_tcslen(rootName) + 1 + _tcslen(keyPath) + 1) * sizeof(TCHAR));
if (fullPath)
{
/* set (correct) the address bar text */
if(keyPath[0] != '\0')
_stprintf(fullPath, _T("%s\\%s"), rootName, keyPath);
else
fullPath = _tcscpy(fullPath, rootName);
SendMessage(hStatusBar, SB_SETTEXT, 0, (LPARAM)fullPath);
SendMessage(pChildWnd->hAddressBarWnd, WM_SETTEXT, 0, (LPARAM)fullPath);
HeapFree(GetProcessHeap(), 0, fullPath);
/* disable hive manipulation items temporarily (enable only if necessary) */
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_GRAYED);
/* compare the strings to see if we should enable/disable the "Load Hive" menus accordingly */
if (!(_tcsicmp(rootName, TEXT("HKEY_LOCAL_MACHINE")) &&
_tcsicmp(rootName, TEXT("HKEY_USERS"))))
{
// enable the unload menu item if at the root
// otherwise enable the load menu item if there is no slash in keyPath (ie. immediate child selected)
if(keyPath[0] == '\0')
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_LOADHIVE, MF_BYCOMMAND | MF_ENABLED);
else if(!_tcschr(keyPath, _T('\\')))
EnableMenuItem(GetSubMenu(hMenuFrame,0), ID_REGISTRY_UNLOADHIVE, MF_BYCOMMAND | MF_ENABLED);
}
{
HKEY hKey;
TCHAR szBuffer[MAX_PATH];
_sntprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), _T("My Computer\\%s\\%s"), rootName, keyPath);
{
HKEY hKey;
TCHAR szBuffer[MAX_PATH];
_sntprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), _T("My Computer\\%s\\%s"), rootName, keyPath);
if (RegCreateKey(HKEY_CURRENT_USER,
g_szGeneralRegKey,
&hKey) == ERROR_SUCCESS)
{
RegSetValueEx(hKey, _T("LastKey"), 0, REG_SZ, (LPBYTE) szBuffer, (DWORD) _tcslen(szBuffer) * sizeof(szBuffer[0]));
RegCloseKey(hKey);
}
}
}
}
if (RegCreateKey(HKEY_CURRENT_USER,
g_szGeneralRegKey,
&hKey) == ERROR_SUCCESS)
{
RegSetValueEx(hKey, _T("LastKey"), 0, REG_SZ, (LPBYTE) szBuffer, (DWORD) _tcslen(szBuffer) * sizeof(szBuffer[0]));
RegCloseKey(hKey);
}
}
}
}
}
break;
case NM_SETFOCUS:
pChildWnd->nFocusPanel = 0;
break;
case NM_SETFOCUS:
pChildWnd->nFocusPanel = 0;
break;
case TVN_BEGINLABELEDIT:
{
LPNMTVDISPINFO ptvdi;
/* cancel label edit for rootkeys */
ptvdi = (LPNMTVDISPINFO) lParam;
LPNMTVDISPINFO ptvdi;
/* cancel label edit for rootkeys */
ptvdi = (LPNMTVDISPINFO) lParam;
if (!TreeView_GetParent(pChildWnd->hTreeWnd, ptvdi->item.hItem) ||
!TreeView_GetParent(pChildWnd->hTreeWnd, TreeView_GetParent(pChildWnd->hTreeWnd, ptvdi->item.hItem)))
return TRUE;
break;
}
!TreeView_GetParent(pChildWnd->hTreeWnd, TreeView_GetParent(pChildWnd->hTreeWnd, ptvdi->item.hItem)))
return TRUE;
break;
}
case TVN_ENDLABELEDIT:
{
LPCTSTR keyPath;
HKEY hRootKey;
HKEY hKey = NULL;
LPNMTVDISPINFO ptvdi;
LONG lResult = TRUE;
TCHAR szBuffer[MAX_PATH];
{
LPCTSTR keyPath;
HKEY hRootKey;
HKEY hKey = NULL;
LPNMTVDISPINFO ptvdi;
LONG lResult = TRUE;
TCHAR szBuffer[MAX_PATH];
ptvdi = (LPNMTVDISPINFO) lParam;
if (ptvdi->item.pszText)
{
ptvdi = (LPNMTVDISPINFO) lParam;
if (ptvdi->item.pszText)
{
keyPath = GetItemPath(pChildWnd->hTreeWnd, TreeView_GetParent(pChildWnd->hTreeWnd, ptvdi->item.hItem), &hRootKey);
_sntprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), _T("%s\\%s"), keyPath, ptvdi->item.pszText);
keyPath = GetItemPath(pChildWnd->hTreeWnd, ptvdi->item.hItem, &hRootKey);
if (RegOpenKeyEx(hRootKey, szBuffer, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
lResult = FALSE;
RegCloseKey(hKey);
(void)TreeView_EditLabel(pChildWnd->hTreeWnd, ptvdi->item.hItem);
lResult = FALSE;
RegCloseKey(hKey);
(void)TreeView_EditLabel(pChildWnd->hTreeWnd, ptvdi->item.hItem);
}
else
{
if (RenameKey(hRootKey, keyPath, ptvdi->item.pszText) != ERROR_SUCCESS)
lResult = FALSE;
if (RenameKey(hRootKey, keyPath, ptvdi->item.pszText) != ERROR_SUCCESS)
lResult = FALSE;
}
return lResult;
}
}
}
default:
return 0;
}
} else
}
else
{
if ((int)wParam == LIST_WINDOW)
{
switch (((LPNMHDR)lParam)->code) {
case NM_SETFOCUS:
pChildWnd->nFocusPanel = 1;
break;
default:
if(!ListWndNotifyProc(pChildWnd->hListWnd, wParam, lParam, &Result))
{
goto def;
}
return Result;
break;
}
switch (((LPNMHDR)lParam)->code)
{
case NM_SETFOCUS:
pChildWnd->nFocusPanel = 1;
break;
default:
if(!ListWndNotifyProc(pChildWnd->hListWnd, wParam, lParam, &Result))
{
goto def;
}
return Result;
break;
}
}
}
break;
case WM_CONTEXTMENU:
{
POINT pt;
if((HWND)wParam == pChildWnd->hListWnd)
{
int i, cnt;
BOOL IsDefault;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
cnt = ListView_GetSelectedCount(pChildWnd->hListWnd);
i = ListView_GetNextItem(pChildWnd->hListWnd, -1, LVNI_FOCUSED | LVNI_SELECTED);
if (pt.x == -1 && pt.y == -1)
POINT pt;
if((HWND)wParam == pChildWnd->hListWnd)
{
RECT rc;
if (i != -1)
int i, cnt;
BOOL IsDefault;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
cnt = ListView_GetSelectedCount(pChildWnd->hListWnd);
i = ListView_GetNextItem(pChildWnd->hListWnd, -1, LVNI_FOCUSED | LVNI_SELECTED);
if (pt.x == -1 && pt.y == -1)
{
rc.left = LVIR_BOUNDS;
SendMessage(pChildWnd->hListWnd, LVM_GETITEMRECT, i, (LPARAM) &rc);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
RECT rc;
if (i != -1)
{
rc.left = LVIR_BOUNDS;
SendMessage(pChildWnd->hListWnd, LVM_GETITEMRECT, i, (LPARAM) &rc);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
}
else
pt.x = pt.y = 0;
ClientToScreen(pChildWnd->hListWnd, &pt);
}
if(i == -1)
{
TrackPopupMenu(GetSubMenu(hPopupMenus, PM_NEW), TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
else
pt.x = pt.y = 0;
ClientToScreen(pChildWnd->hListWnd, &pt);
}
if(i == -1)
{
TrackPopupMenu(GetSubMenu(hPopupMenus, PM_NEW), TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
else
{
HMENU mnu = GetSubMenu(hPopupMenus, PM_MODIFYVALUE);
SetMenuDefaultItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND);
IsDefault = IsDefaultValue(pChildWnd->hListWnd, i);
if(cnt == 1)
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | (IsDefault ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
else
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
EnableMenuItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
EnableMenuItem(mnu, ID_EDIT_MODIFY_BIN, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
TrackPopupMenu(mnu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
}
else if ((HWND)wParam == pChildWnd->hTreeWnd)
{
TVHITTESTINFO hti;
HMENU hContextMenu;
TVITEM item;
MENUITEMINFO mii;
TCHAR resource[256];
TCHAR buffer[256];
LPTSTR s;
LPCTSTR keyPath;
HKEY hRootKey;
int iLastPos;
WORD wID;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
if (pt.x == -1 && pt.y == -1)
{
RECT rc;
hti.hItem = TreeView_GetSelection(pChildWnd->hTreeWnd);
if (hti.hItem != NULL)
{
TreeView_GetItemRect(pChildWnd->hTreeWnd, hti.hItem, &rc, TRUE);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
ClientToScreen(pChildWnd->hTreeWnd, &pt);
hti.flags = TVHT_ONITEM;
HMENU mnu = GetSubMenu(hPopupMenus, PM_MODIFYVALUE);
SetMenuDefaultItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND);
IsDefault = IsDefaultValue(pChildWnd->hListWnd, i);
if(cnt == 1)
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | (IsDefault ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
else
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
EnableMenuItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
EnableMenuItem(mnu, ID_EDIT_MODIFY_BIN, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
TrackPopupMenu(mnu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
}
else if ((HWND)wParam == pChildWnd->hTreeWnd)
{
TVHITTESTINFO hti;
HMENU hContextMenu;
TVITEM item;
MENUITEMINFO mii;
TCHAR resource[256];
TCHAR buffer[256];
LPTSTR s;
LPCTSTR keyPath;
HKEY hRootKey;
int iLastPos;
WORD wID;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
if (pt.x == -1 && pt.y == -1)
{
RECT rc;
hti.hItem = TreeView_GetSelection(pChildWnd->hTreeWnd);
if (hti.hItem != NULL)
{
TreeView_GetItemRect(pChildWnd->hTreeWnd, hti.hItem, &rc, TRUE);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
ClientToScreen(pChildWnd->hTreeWnd, &pt);
hti.flags = TVHT_ONITEM;
}
else
hti.flags = 0;
}
else
hti.flags = 0;
{
hti.pt.x = pt.x;
hti.pt.y = pt.y;
ScreenToClient(pChildWnd->hTreeWnd, &hti.pt);
(void)TreeView_HitTest(pChildWnd->hTreeWnd, &hti);
}
if (hti.flags & TVHT_ONITEM)
{
hContextMenu = GetSubMenu(hPopupMenus, PM_TREECONTEXT);
(void)TreeView_SelectItem(pChildWnd->hTreeWnd, hti.hItem);
memset(&item, 0, sizeof(item));
item.mask = TVIF_STATE | TVIF_CHILDREN;
item.hItem = hti.hItem;
(void)TreeView_GetItem(pChildWnd->hTreeWnd, &item);
/* Set the Expand/Collapse menu item appropriately */
LoadString(hInst, (item.state & TVIS_EXPANDED) ? IDS_COLLAPSE : IDS_EXPAND, buffer, sizeof(buffer) / sizeof(buffer[0]));
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_STATE | MIIM_ID;
mii.fState = (item.cChildren > 0) ? MFS_DEFAULT : MFS_GRAYED;
mii.wID = (item.state & TVIS_EXPANDED) ? ID_TREE_COLLAPSEBRANCH : ID_TREE_EXPANDBRANCH;
mii.dwTypeData = (LPTSTR) buffer;
SetMenuItemInfo(hContextMenu, 0, TRUE, &mii);
/* Remove any existing suggestions */
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID;
GetMenuItemInfo(hContextMenu, GetMenuItemCount(hContextMenu) - 1, TRUE, &mii);
if ((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX))
{
do
{
iLastPos = GetMenuItemCount(hContextMenu) - 1;
GetMenuItemInfo(hContextMenu, iLastPos, TRUE, &mii);
RemoveMenu(hContextMenu, iLastPos, MF_BYPOSITION);
}
while((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX));
}
/* Come up with suggestions */
keyPath = GetItemPath(pChildWnd->hTreeWnd, NULL, &hRootKey);
SuggestKeys(hRootKey, keyPath, Suggestions, sizeof(Suggestions) / sizeof(Suggestions[0]));
if (Suggestions[0])
{
AppendMenu(hContextMenu, MF_SEPARATOR, 0, NULL);
LoadString(hInst, IDS_GOTO_SUGGESTED_KEY, resource, sizeof(resource) / sizeof(resource[0]));
s = Suggestions;
wID = ID_TREE_SUGGESTION_MIN;
while(*s && (wID <= ID_TREE_SUGGESTION_MAX))
{
_sntprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), resource, s);
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = wID++;
mii.dwTypeData = buffer;
InsertMenuItem(hContextMenu, GetMenuItemCount(hContextMenu), TRUE, &mii);
s += _tcslen(s) + 1;
}
}
TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, pChildWnd->hWnd, NULL);
}
}
else
{
hti.pt.x = pt.x;
hti.pt.y = pt.y;
ScreenToClient(pChildWnd->hTreeWnd, &hti.pt);
(void)TreeView_HitTest(pChildWnd->hTreeWnd, &hti);
}
if (hti.flags & TVHT_ONITEM)
{
hContextMenu = GetSubMenu(hPopupMenus, PM_TREECONTEXT);
(void)TreeView_SelectItem(pChildWnd->hTreeWnd, hti.hItem);
memset(&item, 0, sizeof(item));
item.mask = TVIF_STATE | TVIF_CHILDREN;
item.hItem = hti.hItem;
(void)TreeView_GetItem(pChildWnd->hTreeWnd, &item);
/* Set the Expand/Collapse menu item appropriately */
LoadString(hInst, (item.state & TVIS_EXPANDED) ? IDS_COLLAPSE : IDS_EXPAND, buffer, sizeof(buffer) / sizeof(buffer[0]));
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_STATE | MIIM_ID;
mii.fState = (item.cChildren > 0) ? MFS_DEFAULT : MFS_GRAYED;
mii.wID = (item.state & TVIS_EXPANDED) ? ID_TREE_COLLAPSEBRANCH : ID_TREE_EXPANDBRANCH;
mii.dwTypeData = (LPTSTR) buffer;
SetMenuItemInfo(hContextMenu, 0, TRUE, &mii);
/* Remove any existing suggestions */
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID;
GetMenuItemInfo(hContextMenu, GetMenuItemCount(hContextMenu) - 1, TRUE, &mii);
if ((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX))
{
do
{
iLastPos = GetMenuItemCount(hContextMenu) - 1;
GetMenuItemInfo(hContextMenu, iLastPos, TRUE, &mii);
RemoveMenu(hContextMenu, iLastPos, MF_BYPOSITION);
}
while((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX));
}
/* Come up with suggestions */
keyPath = GetItemPath(pChildWnd->hTreeWnd, NULL, &hRootKey);
SuggestKeys(hRootKey, keyPath, Suggestions, sizeof(Suggestions) / sizeof(Suggestions[0]));
if (Suggestions[0])
{
AppendMenu(hContextMenu, MF_SEPARATOR, 0, NULL);
LoadString(hInst, IDS_GOTO_SUGGESTED_KEY, resource, sizeof(resource) / sizeof(resource[0]));
s = Suggestions;
wID = ID_TREE_SUGGESTION_MIN;
while(*s && (wID <= ID_TREE_SUGGESTION_MAX))
{
_sntprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), resource, s);
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = wID++;
mii.dwTypeData = buffer;
InsertMenuItem(hContextMenu, GetMenuItemCount(hContextMenu), TRUE, &mii);
s += _tcslen(s) + 1;
}
}
TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, pChildWnd->hWnd, NULL);
}
}
break;
break;
}
case WM_SIZE:
if (wParam != SIZE_MINIMIZED && pChildWnd != NULL) {
if (wParam != SIZE_MINIMIZED && pChildWnd != NULL)
{
ResizeWnd(pChildWnd, LOWORD(lParam), HIWORD(lParam));
}
/* fall through */
default: def:
default:
def:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;

158
reactos/base/applications/regedit/clb/clb.c
View file

@ -123,41 +123,41 @@ ClbWndProc(IN HWND hwnd,
LRESULT Ret = 0;
DPRINT1("ClbWndProc(0x%p, 0x%x, 0x%p, 0x%p)\n", hwnd, uMsg, wParam, lParam);
PrivData = (PCLB_PRIVATEDATA)GetWindowLongPtr(hwnd,
0);
0);
if (PrivData == NULL && uMsg != WM_CREATE)
{
goto HandleDefMsg;
}
switch (uMsg)
{
case WM_CREATE:
PrivData = HeapAlloc(GetProcessHeap(),
0,
sizeof(CLB_PRIVATEDATA));
if (PrivData == NULL)
{
Ret = (LRESULT)-1;
break;
}
PrivData->hwnd = hwnd;
case WM_CREATE:
PrivData = HeapAlloc(GetProcessHeap(),
0,
sizeof(CLB_PRIVATEDATA));
if (PrivData == NULL)
{
Ret = (LRESULT)-1;
break;
}
PrivData->hwnd = hwnd;
break;
case WM_DESTROY:
HeapFree(GetProcessHeap(),
0,
PrivData);
break;
case WM_DESTROY:
HeapFree(GetProcessHeap(),
0,
PrivData);
break;
default:
default:
HandleDefMsg:
Ret = DefWindowProc(hwnd,
uMsg,
wParam,
lParam);
break;
Ret = DefWindowProc(hwnd,
uMsg,
wParam,
lParam);
break;
}
return Ret;
@ -171,32 +171,32 @@ ClbpStyleDlgProc(IN HWND hwndDlg,
IN LPARAM lParam)
{
INT_PTR Ret = FALSE;
DPRINT1("ClbpStyleDlgProc(0x%p, 0x%x, 0x%p, 0x%p)\n", hwndDlg, uMsg, wParam, lParam);
switch (uMsg)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
EndDialog(hwndDlg,
(INT_PTR)LOWORD(wParam));
break;
}
break;
case WM_CLOSE:
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
EndDialog(hwndDlg,
IDCANCEL);
(INT_PTR)LOWORD(wParam));
break;
}
break;
case WM_INITDIALOG:
Ret = TRUE;
break;
case WM_CLOSE:
EndDialog(hwndDlg,
IDCANCEL);
break;
case WM_INITDIALOG:
Ret = TRUE;
break;
}
return Ret;
}
@ -230,7 +230,7 @@ CustomControlInfoW(OUT LPCUSTOM_CONTROL_INFO CustomControlInfo OPTIONAL)
ClbClassName);
CustomControlInfo->Zero1 = 0;
wcscpy(CustomControlInfo->ClassName2,
ClbClassName);
@ -240,15 +240,15 @@ CustomControlInfoW(OUT LPCUSTOM_CONTROL_INFO CustomControlInfo OPTIONAL)
CustomControlInfo->Zero2 = 0;
CustomControlInfo->Zero3 = 0;
CustomControlInfo->StylesCount = sizeof(ClbsSupportedStyles) / sizeof(ClbsSupportedStyles[0]);
CustomControlInfo->SupportedStyles = ClbsSupportedStyles;
wcscpy(CustomControlInfo->Columns,
ClbColumns);
CustomControlInfo->ClbStyleW = ClbStyleW;
CustomControlInfo->Zero4 = 0;
CustomControlInfo->Zero5 = 0;
CustomControlInfo->Zero6 = 0;
@ -267,43 +267,43 @@ DllMain(IN HINSTANCE hinstDLL,
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{
WNDCLASS ClbWndClass;
case DLL_PROCESS_ATTACH:
{
WNDCLASS ClbWndClass;
hDllInstance = hinstDLL;
InitCommonControls();
/* register the control's window class */
ClbWndClass.style = CS_GLOBALCLASS | CS_OWNDC;
ClbWndClass.lpfnWndProc = ClbWndProc;
ClbWndClass.cbClsExtra = 0;
ClbWndClass.cbWndExtra = sizeof(PCLB_PRIVATEDATA);
ClbWndClass.hInstance = hinstDLL,
ClbWndClass.hIcon = NULL;
ClbWndClass.hCursor = LoadCursor(NULL,
(LPWSTR)IDC_ARROW);
ClbWndClass.hbrBackground = NULL;
ClbWndClass.lpszMenuName = NULL;
ClbWndClass.lpszClassName = ClbClassName;
if (!RegisterClass(&ClbWndClass))
{
Ret = FALSE;
break;
}
hDllInstance = hinstDLL;
InitCommonControls();
/* register the control's window class */
ClbWndClass.style = CS_GLOBALCLASS | CS_OWNDC;
ClbWndClass.lpfnWndProc = ClbWndProc;
ClbWndClass.cbClsExtra = 0;
ClbWndClass.cbWndExtra = sizeof(PCLB_PRIVATEDATA);
ClbWndClass.hInstance = hinstDLL,
ClbWndClass.hIcon = NULL;
ClbWndClass.hCursor = LoadCursor(NULL,
(LPWSTR)IDC_ARROW);
ClbWndClass.hbrBackground = NULL;
ClbWndClass.lpszMenuName = NULL;
ClbWndClass.lpszClassName = ClbClassName;
if (!RegisterClass(&ClbWndClass))
{
Ret = FALSE;
break;
}
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
UnregisterClass(ClbClassName,
hinstDLL);
break;
case DLL_PROCESS_DETACH:
UnregisterClass(ClbClassName,
hinstDLL);
break;
}
return Ret;
}

166
reactos/base/applications/regedit/edit.c
View file

@ -22,8 +22,8 @@
typedef enum _EDIT_MODE
{
EDIT_MODE_DEC,
EDIT_MODE_HEX
EDIT_MODE_DEC,
EDIT_MODE_HEX
} EDIT_MODE;
@ -96,17 +96,18 @@ INT_PTR CALLBACK modify_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, L
UNREFERENCED_PARAMETER(lParam);
switch(uMsg) {
switch(uMsg)
{
case WM_INITDIALOG:
if(editValueName && _tcscmp(editValueName, _T("")))
{
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
}
else
{
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
}
SetDlgItemText(hwndDlg, IDC_VALUE_DATA, stringValueData);
SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
@ -140,8 +141,8 @@ INT_PTR CALLBACK modify_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, L
}
else
{
if (stringValueData)
*stringValueData = 0;
if (stringValueData)
*stringValueData = 0;
}
}
EndDialog(hwndDlg, IDOK);
@ -163,17 +164,18 @@ INT_PTR CALLBACK modify_multi_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wPa
UNREFERENCED_PARAMETER(lParam);
switch(uMsg) {
switch(uMsg)
{
case WM_INITDIALOG:
if(editValueName && _tcscmp(editValueName, _T("")))
{
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
}
else
{
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
}
SetDlgItemText(hwndDlg, IDC_VALUE_DATA, stringValueData);
SetFocus(GetDlgItem(hwndDlg, IDC_VALUE_DATA));
@ -207,8 +209,8 @@ INT_PTR CALLBACK modify_multi_string_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wPa
}
else
{
if (stringValueData)
*stringValueData = 0;
if (stringValueData)
*stringValueData = 0;
}
}
EndDialog(hwndDlg, IDOK);
@ -274,7 +276,8 @@ INT_PTR CALLBACK modify_dword_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LP
UNREFERENCED_PARAMETER(lParam);
switch(uMsg) {
switch(uMsg)
{
case WM_INITDIALOG:
dwordEditMode = EDIT_MODE_HEX;
@ -290,9 +293,9 @@ INT_PTR CALLBACK modify_dword_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LP
}
else
{
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
}
CheckRadioButton (hwndDlg, IDC_FORMAT_HEX, IDC_FORMAT_DEC, IDC_FORMAT_HEX);
_stprintf (ValueString, _T("%lx"), dwordValueData);
@ -359,8 +362,8 @@ INT_PTR CALLBACK modify_dword_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LP
}
else
{
EndDialog(hwndDlg, IDCANCEL);
return TRUE;
EndDialog(hwndDlg, IDCANCEL);
return TRUE;
}
}
EndDialog(hwndDlg, IDOK);
@ -382,17 +385,18 @@ INT_PTR CALLBACK modify_binary_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, L
UNREFERENCED_PARAMETER(lParam);
switch(uMsg) {
switch(uMsg)
{
case WM_INITDIALOG:
if(editValueName && _tcscmp(editValueName, _T("")))
{
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, editValueName);
}
else
{
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
TCHAR buffer[255];
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
SetDlgItemText(hwndDlg, IDC_VALUE_NAME, buffer);
}
hwndValue = GetDlgItem(hwndDlg, IDC_VALUE_DATA);
HexEdit_LoadBuffer(hwndValue, binValueData, valueDataLen);
@ -408,9 +412,9 @@ INT_PTR CALLBACK modify_binary_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, L
{
len = (UINT) HexEdit_GetBufferSize(hwndValue);
if (len > 0 && binValueData)
binValueData = HeapReAlloc(GetProcessHeap(), 0, binValueData, len);
binValueData = HeapReAlloc(GetProcessHeap(), 0, binValueData, len);
else
binValueData = HeapAlloc(GetProcessHeap(), 0, len + 1);
binValueData = HeapAlloc(GetProcessHeap(), 0, len + 1);
HexEdit_CopyBuffer(hwndValue, binValueData, len);
valueDataLen = len;
}
@ -439,11 +443,11 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
lRet = RegQueryValueEx(hKey, valueName, 0, &type, 0, &valueDataLen);
if (lRet != ERROR_SUCCESS && (!_tcscmp(valueName, _T("")) || valueName == NULL))
{
lRet = ERROR_SUCCESS; /* Allow editing of (Default) values which don't exist */
type = REG_SZ;
valueDataLen = 0;
stringValueData = NULL;
binValueData = NULL;
lRet = ERROR_SUCCESS; /* Allow editing of (Default) values which don't exist */
type = REG_SZ;
valueDataLen = 0;
stringValueData = NULL;
binValueData = NULL;
}
if (lRet != ERROR_SUCCESS)
@ -494,7 +498,7 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
size_t llen, listlen, nl_len;
LPTSTR src, lines = NULL;
if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
{
error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
goto done;
@ -506,7 +510,7 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
goto done;
}
/* convert \0 to \r\n */
/* convert \0 to \r\n */
src = stringValueData;
nl_len = _tcslen(_T("\r\n")) * sizeof(TCHAR);
listlen = sizeof(TCHAR);
@ -515,12 +519,12 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
{
llen = _tcslen(src);
if(llen == 0)
break;
break;
listlen += (llen * sizeof(TCHAR)) + nl_len;
lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, listlen);
_tcscat(lines, src);
_tcscat(lines, _T("\r\n"));
src += llen + 1;
lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, listlen);
_tcscat(lines, src);
_tcscat(lines, _T("\r\n"));
src += llen + 1;
}
HeapFree(GetProcessHeap(), 0, stringValueData);
stringValueData = lines;
@ -552,7 +556,7 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
if(nl == src)
{
EmptyLines = TRUE;
src = nl + c_nl;
src = nl + c_nl;
continue;
}
}
@ -562,7 +566,7 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
}
if(linechars > 0)
{
buflen += ((linechars + 1) * sizeof(TCHAR));
buflen += ((linechars + 1) * sizeof(TCHAR));
lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, buflen);
memcpy((lines + dest), src, linechars * sizeof(TCHAR));
dest += linechars;
@ -581,8 +585,8 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
warning(hwnd, IDS_MULTI_SZ_EMPTY_STRING);
}
lRet = RegSetValueEx(hKey, valueName, 0, type, (LPBYTE)lines, (DWORD) buflen);
HeapFree(GetProcessHeap(), 0, lines);
lRet = RegSetValueEx(hKey, valueName, 0, type, (LPBYTE)lines, (DWORD) buflen);
HeapFree(GetProcessHeap(), 0, lines);
}
else
{
@ -614,44 +618,44 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
LPWSTR u_valuename;
int len_vname = lstrlen(valueName);
if(len_vname > 0)
if(len_vname > 0)
{
if(!(u_valuename = HeapAlloc(GetProcessHeap(), 0, (len_vname + 1) * sizeof(WCHAR))))
{
error(hwnd, IDS_TOO_BIG_VALUE, len_vname);
goto done;
}
/* convert the ansi value name to an unicode string */
MultiByteToWideChar(CP_ACP, 0, valueName, -1, u_valuename, len_vname + 1);
valueDataLen *= sizeof(WCHAR);
if(!(u_valuename = HeapAlloc(GetProcessHeap(), 0, (len_vname + 1) * sizeof(WCHAR))))
{
error(hwnd, IDS_TOO_BIG_VALUE, len_vname);
goto done;
}
/* convert the ansi value name to an unicode string */
MultiByteToWideChar(CP_ACP, 0, valueName, -1, u_valuename, len_vname + 1);
valueDataLen *= sizeof(WCHAR);
}
else
u_valuename = L"";
u_valuename = L"";
#endif
if(valueDataLen > 0)
if(valueDataLen > 0)
{
if(!(binValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + 1)))
if(!(binValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + 1)))
{
error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
goto done;
error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
goto done;
}
/* force to use the unicode version, so editing strings in binary mode is correct */
lRet = RegQueryValueExW(hKey,
/* force to use the unicode version, so editing strings in binary mode is correct */
lRet = RegQueryValueExW(hKey,
#ifndef UNICODE
u_valuename,
u_valuename,
#else
valueName,
valueName,
#endif
0, 0, (LPBYTE)binValueData, &valueDataLen);
0, 0, (LPBYTE)binValueData, &valueDataLen);
if (lRet != ERROR_SUCCESS)
{
HeapFree(GetProcessHeap(), 0, binValueData);
#ifndef UNICODE
if(len_vname > 0)
HeapFree(GetProcessHeap(), 0, u_valuename);
HeapFree(GetProcessHeap(), 0, u_valuename);
#endif
error(hwnd, IDS_BAD_VALUE, valueName);
error(hwnd, IDS_BAD_VALUE, valueName);
goto done;
}
}
@ -662,22 +666,22 @@ BOOL ModifyValue(HWND hwnd, HKEY hKey, LPCTSTR valueName, BOOL EditBin)
if (DialogBox(0, MAKEINTRESOURCE(IDD_EDIT_BIN_DATA), hwnd, modify_binary_dlgproc) == IDOK)
{
/* force to use the unicode version, so editing strings in binary mode is correct */
lRet = RegSetValueExW(hKey,
/* force to use the unicode version, so editing strings in binary mode is correct */
lRet = RegSetValueExW(hKey,
#ifndef UNICODE
u_valuename,
u_valuename,
#else
valueName,
valueName,
#endif
0, type, (LPBYTE)binValueData, valueDataLen);
0, type, (LPBYTE)binValueData, valueDataLen);
if (lRet == ERROR_SUCCESS)
result = TRUE;
}
if(binValueData != NULL)
HeapFree(GetProcessHeap(), 0, binValueData);
HeapFree(GetProcessHeap(), 0, binValueData);
#ifndef UNICODE
if(len_vname > 0)
HeapFree(GetProcessHeap(), 0, u_valuename);
HeapFree(GetProcessHeap(), 0, u_valuename);
#endif
}
else
@ -717,7 +721,7 @@ static LONG CopyKey(HKEY hDestKey, LPCTSTR lpDestSubKey, HKEY hSrcKey, LPCTSTR l
/* create the destination subkey */
lResult = RegCreateKeyEx(hDestKey, lpDestSubKey, 0, NULL, 0, KEY_WRITE, NULL,
&hDestSubKey, &dwDisposition);
&hDestSubKey, &dwDisposition);
if (lResult)
goto done;
@ -786,9 +790,10 @@ BOOL DeleteKey(HWND hwnd, HKEY hKeyRoot, LPCTSTR keyPath)
HKEY hKey;
lRet = RegOpenKeyEx(hKeyRoot, keyPath, 0, KEY_READ|KEY_SET_VALUE, &hKey);
if (lRet != ERROR_SUCCESS) {
error_code_messagebox(hwnd, lRet);
return FALSE;
if (lRet != ERROR_SUCCESS)
{
error_code_messagebox(hwnd, lRet);
return FALSE;
}
LoadString(hInst, IDS_QUERY_DELETE_KEY_CONFIRM, caption, sizeof(caption)/sizeof(TCHAR));
@ -798,9 +803,10 @@ BOOL DeleteKey(HWND hwnd, HKEY hKeyRoot, LPCTSTR keyPath)
goto done;
lRet = SHDeleteKey(hKeyRoot, keyPath);
if (lRet != ERROR_SUCCESS) {
error(hwnd, IDS_BAD_KEY, keyPath);
goto done;
if (lRet != ERROR_SUCCESS)
{
error(hwnd, IDS_BAD_KEY, keyPath);
goto done;
}
result = TRUE;

278
reactos/base/applications/regedit/find.c
View file

@ -101,10 +101,10 @@ CompareData(
{
if (s_dwFlags & RSF_MATCHCASE)
return 2 == CompareString(LOCALE_SYSTEM_DEFAULT, 0,
psz1, cch1, psz2, cch2);
psz1, cch1, psz2, cch2);
else
return 2 == CompareString(LOCALE_SYSTEM_DEFAULT,
NORM_IGNORECASE, psz1, cch1, psz2, cch2);
return 2 == CompareString(LOCALE_SYSTEM_DEFAULT,
NORM_IGNORECASE, psz1, cch1, psz2, cch2);
}
for(i = 0; i <= cch1 - cch2; i++)
@ -112,13 +112,13 @@ CompareData(
if (s_dwFlags & RSF_MATCHCASE)
{
if (2 == CompareString(LOCALE_SYSTEM_DEFAULT, 0,
psz1 + i, cch2, psz2, cch2))
psz1 + i, cch2, psz2, cch2))
return TRUE;
}
else
{
if (2 == CompareString(LOCALE_SYSTEM_DEFAULT,
NORM_IGNORECASE, psz1 + i, cch2, psz2, cch2))
NORM_IGNORECASE, psz1 + i, cch2, psz2, cch2))
return TRUE;
}
}
@ -134,7 +134,7 @@ int compare(const void *x, const void *y)
}
BOOL RegFindRecurse(
HKEY hKey,
HKEY hKey,
LPCTSTR pszSubKey,
LPCTSTR pszValueName,
LPTSTR *ppszFoundSubKey,
@ -162,7 +162,7 @@ BOOL RegFindRecurse(
pszValueName = s_empty;
lResult = RegQueryInfoKey(hSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
&c, NULL, NULL, NULL, NULL);
&c, NULL, NULL, NULL, NULL);
if (lResult != ERROR_SUCCESS)
goto err;
ppszNames = (LPTSTR *) malloc(c * sizeof(LPTSTR));
@ -176,7 +176,7 @@ BOOL RegFindRecurse(
goto err;
s_cbName = MAX_PATH * sizeof(TCHAR);
lResult = RegEnumValue(hSubKey, i, s_szName, &s_cbName, NULL, NULL,
lResult = RegEnumValue(hSubKey, i, s_szName, &s_cbName, NULL, NULL,
NULL, &cb);
if (lResult == ERROR_NO_MORE_ITEMS)
{
@ -206,8 +206,8 @@ BOOL RegFindRecurse(
if (!fPast)
continue;
if ((s_dwFlags & RSF_LOOKATVALUES) &&
CompareName(ppszNames[i], s_szFindWhat))
if ((s_dwFlags & RSF_LOOKATVALUES) &&
CompareName(ppszNames[i], s_szFindWhat))
{
*ppszFoundSubKey = _tcsdup(szSubKey);
if (ppszNames[i][0] == 0)
@ -218,19 +218,19 @@ BOOL RegFindRecurse(
}
lResult = RegQueryValueEx(hSubKey, ppszNames[i], NULL, &type,
NULL, &cb);
NULL, &cb);
if (lResult != ERROR_SUCCESS)
goto err;
pb = malloc(cb);
if (pb == NULL)
goto err;
lResult = RegQueryValueEx(hSubKey, ppszNames[i], NULL, &type,
pb, &cb);
pb, &cb);
if (lResult != ERROR_SUCCESS)
goto err;
if ((s_dwFlags & RSF_LOOKATDATA) &&
CompareData(type, (LPTSTR) pb, s_szFindWhat))
if ((s_dwFlags & RSF_LOOKATDATA) &&
CompareData(type, (LPTSTR) pb, s_szFindWhat))
{
*ppszFoundSubKey = _tcsdup(szSubKey);
if (ppszNames[i][0] == 0)
@ -252,7 +252,7 @@ BOOL RegFindRecurse(
ppszNames = NULL;
lResult = RegQueryInfoKey(hSubKey, NULL, NULL, NULL, &c, NULL, NULL,
NULL, NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL, NULL);
if (lResult != ERROR_SUCCESS)
goto err;
ppszNames = (LPTSTR *) malloc(c * sizeof(LPTSTR));
@ -266,7 +266,7 @@ BOOL RegFindRecurse(
goto err;
s_cbName = MAX_PATH * sizeof(TCHAR);
lResult = RegEnumKeyEx(hSubKey, i, s_szName, &s_cbName, NULL, NULL,
lResult = RegEnumKeyEx(hSubKey, i, s_szName, &s_cbName, NULL, NULL,
NULL, NULL);
if (lResult == ERROR_NO_MORE_ITEMS)
{
@ -289,11 +289,11 @@ BOOL RegFindRecurse(
goto err;
if ((s_dwFlags & RSF_LOOKATKEYS) &&
CompareName(ppszNames[i], s_szFindWhat))
CompareName(ppszNames[i], s_szFindWhat))
{
*ppszFoundSubKey = malloc(
(lstrlen(szSubKey) + lstrlen(ppszNames[i]) + 2) *
sizeof(TCHAR));
(lstrlen(szSubKey) + lstrlen(ppszNames[i]) + 2) *
sizeof(TCHAR));
if (*ppszFoundSubKey == NULL)
goto err;
if (szSubKey[0])
@ -313,7 +313,7 @@ BOOL RegFindRecurse(
{
LPTSTR psz = *ppszFoundSubKey;
*ppszFoundSubKey = malloc(
(lstrlen(szSubKey) + lstrlen(psz) + 2) * sizeof(TCHAR));
(lstrlen(szSubKey) + lstrlen(psz) + 2) * sizeof(TCHAR));
if (*ppszFoundSubKey == NULL)
goto err;
if (szSubKey[0])
@ -352,7 +352,7 @@ success:
}
BOOL RegFindWalk(
HKEY * phKey,
HKEY * phKey,
LPCTSTR pszSubKey,
LPCTSTR pszValueName,
LPTSTR *ppszFoundSubKey,
@ -393,13 +393,13 @@ BOOL RegFindWalk(
lstrcpyn(szKeyName, pch + 1, MAX_PATH);
*pch = 0;
lResult = RegOpenKeyEx(hBaseKey, szSubKey, 0, KEY_ALL_ACCESS,
&hSubKey);
&hSubKey);
if (lResult != ERROR_SUCCESS)
return FALSE;
}
lResult = RegQueryInfoKey(hSubKey, NULL, NULL, NULL, &c, NULL, NULL,
NULL, NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL, NULL);
if (lResult != ERROR_SUCCESS)
goto err;
@ -415,7 +415,7 @@ BOOL RegFindWalk(
s_cbName = MAX_PATH * sizeof(TCHAR);
lResult = RegEnumKeyExW(hSubKey, i, s_szName, &s_cbName,
NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL);
if (lResult == ERROR_NO_MORE_ITEMS)
{
c = i;
@ -443,11 +443,11 @@ BOOL RegFindWalk(
continue;
if ((s_dwFlags & RSF_LOOKATKEYS) &&
CompareName(ppszNames[i], s_szFindWhat))
CompareName(ppszNames[i], s_szFindWhat))
{
*ppszFoundSubKey = malloc(
(lstrlen(szSubKey) + lstrlen(ppszNames[i]) + 2) *
sizeof(TCHAR));
(lstrlen(szSubKey) + lstrlen(ppszNames[i]) + 2) *
sizeof(TCHAR));
if (*ppszFoundSubKey == NULL)
goto err;
if (szSubKey[0])
@ -462,13 +462,13 @@ BOOL RegFindWalk(
goto success;
}
if (RegFindRecurse(hSubKey, ppszNames[i], NULL,
if (RegFindRecurse(hSubKey, ppszNames[i], NULL,
ppszFoundSubKey, ppszFoundValueName))
{
LPTSTR psz = *ppszFoundSubKey;
*ppszFoundSubKey = malloc(
(lstrlen(szSubKey) + lstrlen(psz) + 2) *
sizeof(TCHAR));
(lstrlen(szSubKey) + lstrlen(psz) + 2) *
sizeof(TCHAR));
if (*ppszFoundSubKey == NULL)
goto err;
if (szSubKey[0])
@ -605,23 +605,23 @@ static INT_PTR CALLBACK AbortFindDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam,
switch(uMsg)
{
case WM_CLOSE:
s_bAbort = TRUE;
break;
case WM_CLOSE:
s_bAbort = TRUE;
break;
case WM_COMMAND:
switch(HIWORD(wParam))
case WM_COMMAND:
switch(HIWORD(wParam))
{
case BN_CLICKED:
switch(LOWORD(wParam))
{
case BN_CLICKED:
switch(LOWORD(wParam))
{
case IDCANCEL:
s_bAbort = TRUE;
break;
}
break;
case IDCANCEL:
s_bAbort = TRUE;
break;
}
break;
}
break;
}
return 0;
}
@ -652,7 +652,7 @@ BOOL FindNext(HWND hWnd)
/* Create abort find dialog */
s_hwndAbortDialog = CreateDialog(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDD_FINDING), hWnd, AbortFindDialogProc);
MAKEINTRESOURCE(IDD_FINDING), hWnd, AbortFindDialogProc);
if (s_hwndAbortDialog)
{
ShowWindow(s_hwndAbortDialog, SW_SHOW);
@ -667,7 +667,7 @@ BOOL FindNext(HWND hWnd)
EnableWindow(g_pChildWnd->hListWnd, FALSE);
EnableWindow(g_pChildWnd->hAddressBarWnd, FALSE);
fSuccess = RegFindWalk(&hKeyRoot, pszKeyPath, pszValueName,
fSuccess = RegFindWalk(&hKeyRoot, pszKeyPath, pszValueName,
&pszFoundSubKey, &pszFoundValueName);
EnableWindow(hFrameWnd, TRUE);
@ -703,107 +703,107 @@ static INT_PTR CALLBACK FindDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPAR
switch(uMsg)
{
case WM_INITDIALOG:
dwFlags = GetFindFlags();
case WM_INITDIALOG:
dwFlags = GetFindFlags();
hControl = GetDlgItem(hDlg, IDC_LOOKAT_KEYS);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATKEYS) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_LOOKAT_KEYS);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATKEYS) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_LOOKAT_VALUES);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATVALUES) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_LOOKAT_VALUES);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATVALUES) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_LOOKAT_DATA);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATDATA) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_LOOKAT_DATA);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_LOOKATDATA) ? TRUE : FALSE, 0);
/* Match whole string */
hControl = GetDlgItem(hDlg, IDC_MATCHSTRING);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_WHOLESTRING) ? TRUE : FALSE, 0);
/* Match whole string */
hControl = GetDlgItem(hDlg, IDC_MATCHSTRING);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_WHOLESTRING) ? TRUE : FALSE, 0);
/* Case sensitivity */
hControl = GetDlgItem(hDlg, IDC_MATCHCASE);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_MATCHCASE) ? TRUE : FALSE, 0);
/* Case sensitivity */
hControl = GetDlgItem(hDlg, IDC_MATCHCASE);
if (hControl)
SendMessage(hControl, BM_SETCHECK, (dwFlags & RSF_MATCHCASE) ? TRUE : FALSE, 0);
hControl = GetDlgItem(hDlg, IDC_FINDWHAT);
if (hControl)
hControl = GetDlgItem(hDlg, IDC_FINDWHAT);
if (hControl)
{
SetWindowText(hControl, s_szSavedFindValue);
SetFocus(hControl);
SendMessage(hControl, EM_SETSEL, 0, -1);
}
break;
case WM_CLOSE:
EndDialog(hDlg, 0);
break;
case WM_COMMAND:
switch(HIWORD(wParam))
{
case BN_CLICKED:
switch(LOWORD(wParam))
{
SetWindowText(hControl, s_szSavedFindValue);
SetFocus(hControl);
SendMessage(hControl, EM_SETSEL, 0, -1);
case IDOK:
dwFlags = 0;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_KEYS);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATKEYS;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_VALUES);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATVALUES;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_DATA);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATDATA;
hControl = GetDlgItem(hDlg, IDC_MATCHSTRING);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_WHOLESTRING;
hControl = GetDlgItem(hDlg, IDC_MATCHCASE);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_MATCHCASE;
SetFindFlags(dwFlags);
hControl = GetDlgItem(hDlg, IDC_FINDWHAT);
if (hControl)
GetWindowText(hControl, s_szFindWhat, sizeof(s_szFindWhat) / sizeof(s_szFindWhat[0]));
EndDialog(hDlg, 1);
break;
case IDCANCEL:
EndDialog(hDlg, 0);
break;
}
break;
case WM_CLOSE:
EndDialog(hDlg, 0);
break;
case WM_COMMAND:
switch(HIWORD(wParam))
case EN_CHANGE:
switch(LOWORD(wParam))
{
case BN_CLICKED:
switch(LOWORD(wParam))
{
case IDOK:
dwFlags = 0;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_KEYS);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATKEYS;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_VALUES);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATVALUES;
hControl = GetDlgItem(hDlg, IDC_LOOKAT_DATA);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_LOOKATDATA;
hControl = GetDlgItem(hDlg, IDC_MATCHSTRING);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_WHOLESTRING;
hControl = GetDlgItem(hDlg, IDC_MATCHCASE);
if (hControl && (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED))
dwFlags |= RSF_MATCHCASE;
SetFindFlags(dwFlags);
hControl = GetDlgItem(hDlg, IDC_FINDWHAT);
if (hControl)
GetWindowText(hControl, s_szFindWhat, sizeof(s_szFindWhat) / sizeof(s_szFindWhat[0]));
EndDialog(hDlg, 1);
break;
case IDCANCEL:
EndDialog(hDlg, 0);
break;
}
break;
case EN_CHANGE:
switch(LOWORD(wParam))
{
case IDC_FINDWHAT:
GetWindowText((HWND) lParam, s_szSavedFindValue, sizeof(s_szSavedFindValue) / sizeof(s_szSavedFindValue[0]));
hControl = GetDlgItem(hDlg, IDOK);
if (hControl)
{
lStyle = GetWindowLongPtr(hControl, GWL_STYLE);
if (s_szSavedFindValue[0])
lStyle &= ~WS_DISABLED;
else
lStyle |= WS_DISABLED;
SetWindowLongPtr(hControl, GWL_STYLE, lStyle);
RedrawWindow(hControl, NULL, NULL, RDW_INVALIDATE);
}
break;
}
case IDC_FINDWHAT:
GetWindowText((HWND) lParam, s_szSavedFindValue, sizeof(s_szSavedFindValue) / sizeof(s_szSavedFindValue[0]));
hControl = GetDlgItem(hDlg, IDOK);
if (hControl)
{
lStyle = GetWindowLongPtr(hControl, GWL_STYLE);
if (s_szSavedFindValue[0])
lStyle &= ~WS_DISABLED;
else
lStyle |= WS_DISABLED;
SetWindowLongPtr(hControl, GWL_STYLE, lStyle);
RedrawWindow(hControl, NULL, NULL, RDW_INVALIDATE);
}
break;
}
break;
}
break;
}
return iResult;
}
@ -811,15 +811,15 @@ static INT_PTR CALLBACK FindDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPAR
void FindDialog(HWND hWnd)
{
if (DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_FIND),
hWnd, FindDialogProc, 0) != 0)
hWnd, FindDialogProc, 0) != 0)
{
if (!FindNext(hWnd))
{
TCHAR msg[128], caption[128];
TCHAR msg[128], caption[128];
LoadString(hInst, IDS_FINISHEDFIND, msg, sizeof(msg)/sizeof(TCHAR));
LoadString(hInst, IDS_APP_TITLE, caption, sizeof(caption)/sizeof(TCHAR));
MessageBox(0, msg, caption, MB_ICONINFORMATION);
LoadString(hInst, IDS_FINISHEDFIND, msg, sizeof(msg)/sizeof(TCHAR));
LoadString(hInst, IDS_APP_TITLE, caption, sizeof(caption)/sizeof(TCHAR));
MessageBox(0, msg, caption, MB_ICONINFORMATION);
}
}
}

230
reactos/base/applications/regedit/framewnd.c
View file

@ -45,7 +45,8 @@ static void resize_frame_rect(HWND hWnd, PRECT prect)
prect->bottom -= rt.bottom+3;
}
*/
if (IsWindowVisible(hStatusBar)) {
if (IsWindowVisible(hStatusBar))
{
SetupStatusBar(hWnd, TRUE);
GetClientRect(hStatusBar, &rt);
prect->bottom -= rt.bottom;
@ -141,12 +142,15 @@ static void OnMenuSelect(HWND hWnd, UINT nItemID, UINT nFlags, HMENU hSysMenu)
TCHAR str[100];
_tcscpy(str, _T(""));
if (nFlags & MF_POPUP) {
if (hSysMenu != GetMenu(hWnd)) {
if (nFlags & MF_POPUP)
{
if (hSysMenu != GetMenu(hWnd))
{
if (nItemID == 2) nItemID = 5;
}
}
if (LoadString(hInst, nItemID, str, 100)) {
if (LoadString(hInst, nItemID, str, 100))
{
/* load appropriate string*/
LPTSTR lpsz = str;
/* first newline terminates actual string*/
@ -171,8 +175,8 @@ void SetupStatusBar(HWND hWnd, BOOL bResize)
void UpdateStatusBar(void)
{
NMHDR nmhdr;
ZeroMemory(&nmhdr, sizeof(NMHDR));
NMHDR nmhdr;
ZeroMemory(&nmhdr, sizeof(NMHDR));
nmhdr.code = TVN_SELCHANGED;
SendMessage(g_pChildWnd->hWnd, WM_NOTIFY, (WPARAM)TREE_WINDOW, (LPARAM)&nmhdr);
}
@ -191,7 +195,8 @@ static BOOL CheckCommDlgError(HWND hWnd)
{
DWORD dwErrorCode = CommDlgExtendedError();
UNREFERENCED_PARAMETER(hWnd);
switch (dwErrorCode) {
switch (dwErrorCode)
{
case CDERR_DIALOGFAILURE:
break;
case CDERR_FINDRESFAILURE:
@ -233,24 +238,24 @@ TCHAR FileTitleBuffer[_MAX_PATH];
typedef struct
{
UINT DisplayID;
UINT FilterID;
UINT DisplayID;
UINT FilterID;
} FILTERPAIR, *PFILTERPAIR;
void
BuildFilterStrings(TCHAR *Filter, PFILTERPAIR Pairs, int PairCount)
{
int i, c;
int i, c;
c = 0;
for(i = 0; i < PairCount; i++)
{
c += LoadString(hInst, Pairs[i].DisplayID, &Filter[c], 255 * sizeof(TCHAR));
c = 0;
for(i = 0; i < PairCount; i++)
{
c += LoadString(hInst, Pairs[i].DisplayID, &Filter[c], 255 * sizeof(TCHAR));
Filter[++c] = '\0';
c += LoadString(hInst, Pairs[i].FilterID, &Filter[c], 255 * sizeof(TCHAR));
Filter[++c] = '\0';
}
Filter[++c] = '\0';
c += LoadString(hInst, Pairs[i].FilterID, &Filter[c], 255 * sizeof(TCHAR));
Filter[++c] = '\0';
}
Filter[++c] = '\0';
}
static BOOL InitOpenFileName(HWND hWnd, OPENFILENAME* pofn)
@ -288,18 +293,18 @@ static INT_PTR CALLBACK LoadHive_KeyNameInHookProc(HWND hWndDlg, UINT uMsg, WPAR
static INT sLength = 0;
switch(uMsg)
{
case WM_INITDIALOG:
case WM_INITDIALOG:
sKey = (LPTSTR)lParam;
sLength = 128; /* FIXME: Ugly hack! */
case WM_COMMAND:
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
case IDOK:
if(GetDlgItemText(hWndDlg, IDC_EDIT_KEY, sKey, sLength))
return EndDialog(hWndDlg, -1);
else
return EndDialog(hWndDlg, 0);
case IDCANCEL:
case IDCANCEL:
return EndDialog(hWndDlg, 0);
}
break;
@ -349,7 +354,9 @@ static BOOL LoadHive(HWND hWnd)
return FALSE;
}
}
} else {
}
else
{
CheckCommDlgError(hWnd);
}
return TRUE;
@ -393,9 +400,11 @@ static BOOL ImportRegistryFile(HWND hWnd)
ofn.lpstrTitle = Caption;
ofn.Flags |= OFN_ENABLESIZING;
/* ofn.lCustData = ;*/
if (GetOpenFileName(&ofn)) {
if (GetOpenFileName(&ofn))
{
FILE *fp = _wfopen(ofn.lpstrFile, L"r");
if (fp == NULL || !import_registry_file(fp)) {
if (fp == NULL || !import_registry_file(fp))
{
LPSTR p = GetMultiByteString(ofn.lpstrFile);
fprintf(stderr, "Can't open file \"%s\"\n", p);
HeapFree(GetProcessHeap(), 0, p);
@ -404,7 +413,9 @@ static BOOL ImportRegistryFile(HWND hWnd)
return FALSE;
}
fclose(fp);
} else {
}
else
{
CheckCommDlgError(hWnd);
}
@ -427,8 +438,9 @@ static UINT_PTR CALLBACK ExportRegistryFile_OFNHookProc(HWND hdlg, UINT uiMsg, W
UNREFERENCED_PARAMETER(wParam);
switch(uiMsg) {
case WM_INITDIALOG:
switch(uiMsg)
{
case WM_INITDIALOG:
pOfn = (OPENFILENAME *) lParam;
pszSelectedKey = (LPTSTR) pOfn->lCustData;
@ -445,7 +457,7 @@ static UINT_PTR CALLBACK ExportRegistryFile_OFNHookProc(HWND hdlg, UINT uiMsg, W
SetWindowText(hwndExportBranchText, pszSelectedKey);
break;
case WM_NOTIFY:
case WM_NOTIFY:
if (((NMHDR *) lParam)->code == CDN_FILEOK)
{
pOfnNotify = (OFNOTIFY *) lParam;
@ -454,15 +466,15 @@ static UINT_PTR CALLBACK ExportRegistryFile_OFNHookProc(HWND hdlg, UINT uiMsg, W
hwndExportBranch = GetDlgItem(hdlg, IDC_EXPORT_BRANCH);
hwndExportBranchText = GetDlgItem(hdlg, IDC_EXPORT_BRANCH_TEXT);
if (hwndExportBranch && hwndExportBranchText
&& (SendMessage(hwndExportBranch, BM_GETCHECK, 0, 0) == BST_CHECKED))
{
GetWindowText(hwndExportBranchText, pszSelectedKey, _MAX_PATH);
}
else
{
pszSelectedKey[0] = '\0';
}
}
&& (SendMessage(hwndExportBranch, BM_GETCHECK, 0, 0) == BST_CHECKED))
{
GetWindowText(hwndExportBranchText, pszSelectedKey, _MAX_PATH);
}
else
{
pszSelectedKey[0] = '\0';
}
}
break;
}
return iResult;
@ -492,7 +504,8 @@ BOOL ExportRegistryFile(HWND hWnd)
ofn.Flags = OFN_ENABLETEMPLATE | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_OVERWRITEPROMPT;
ofn.lpfnHook = ExportRegistryFile_OFNHookProc;
ofn.lpTemplateName = MAKEINTRESOURCE(IDD_EXPORTRANGE);
if (GetSaveFileName(&ofn)) {
if (GetSaveFileName(&ofn))
{
BOOL result;
DWORD format;
@ -501,13 +514,16 @@ BOOL ExportRegistryFile(HWND hWnd)
else
format = REG_FORMAT_4;
result = export_registry_key(ofn.lpstrFile, ExportKeyPath, format);
if (!result) {
if (!result)
{
LPSTR p = GetMultiByteString(ofn.lpstrFile);
fprintf(stderr, "Can't open file \"%s\"\n", p);
HeapFree(GetProcessHeap(), 0, p);
return FALSE;
}
} else {
}
else
{
CheckCommDlgError(hWnd);
}
return TRUE;
@ -530,7 +546,8 @@ BOOL PrintRegistryHive(HWND hWnd, LPTSTR path)
pd.nToPage = 0xFFFF;
pd.nMinPage = 1;
pd.nMaxPage = 0xFFFF;
if (PrintDlg(&pd)) {
if (PrintDlg(&pd))
{
/* GDI calls to render output. */
DeleteDC(pd.hDC); /* Delete DC when done.*/
}
@ -539,8 +556,10 @@ BOOL PrintRegistryHive(HWND hWnd, LPTSTR path)
PRINTDLGEX pd;
hResult = PrintDlgEx(&pd);
if (hResult == S_OK) {
switch (pd.dwResultAction) {
if (hResult == S_OK)
{
switch (pd.dwResultAction)
{
case PD_RESULT_APPLY:
/*The user clicked the Apply button and later clicked the Cancel button. This indicates that the user wants to apply the changes made in the property sheet, but does not yet want to print. The PRINTDLGEX structure contains the information specified by the user at the time the Apply button was clicked. */
break;
@ -553,8 +572,11 @@ BOOL PrintRegistryHive(HWND hWnd, LPTSTR path)
default:
break;
}
} else {
switch (hResult) {
}
else
{
switch (hResult)
{
case E_OUTOFMEMORY:
/*Insufficient memory. */
break;
@ -662,9 +684,11 @@ static BOOL CreateNewValue(HKEY hRootKey, LPCTSTR pszKeyPath, DWORD dwType)
wsprintf(szNewValue, szNewValueFormat, iIndex++);
cbData = sizeof(data);
lResult = RegQueryValueEx(hKey, szNewValue, NULL, &dwExistingType, data, &cbData);
} while(lResult == ERROR_SUCCESS);
}
while(lResult == ERROR_SUCCESS);
switch(dwType) {
switch(dwType)
{
case REG_DWORD:
cbData = sizeof(DWORD);
break;
@ -723,9 +747,9 @@ InitializeRemoteRegistryPicker(OUT IDsObjectPicker **pDsObjectPicker)
{
sizeof(DSOP_SCOPE_INIT_INFO),
DSOP_SCOPE_TYPE_USER_ENTERED_UPLEVEL_SCOPE | DSOP_SCOPE_TYPE_USER_ENTERED_DOWNLEVEL_SCOPE |
DSOP_SCOPE_TYPE_GLOBAL_CATALOG | DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN |
DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN | DSOP_SCOPE_TYPE_WORKGROUP |
DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN | DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN,
DSOP_SCOPE_TYPE_GLOBAL_CATALOG | DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN |
DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN | DSOP_SCOPE_TYPE_WORKGROUP |
DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN | DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN,
0,
{
{
@ -750,7 +774,7 @@ InitializeRemoteRegistryPicker(OUT IDsObjectPicker **pDsObjectPicker)
InitInfo.apwzAttributeNames = NULL;
hRet = (*pDsObjectPicker)->lpVtbl->Initialize(*pDsObjectPicker,
&InitInfo);
&InitInfo);
if (FAILED(hRet))
{
@ -772,8 +796,8 @@ InvokeRemoteRegistryPickerDialog(IN IDsObjectPicker *pDsObjectPicker,
HRESULT hRet;
hRet = pDsObjectPicker->lpVtbl->InvokeDialog(pDsObjectPicker,
hwndParent,
&pdo);
hwndParent,
&pdo);
if (hRet == S_OK)
{
STGMEDIUM stm;
@ -855,7 +879,8 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
UNREFERENCED_PARAMETER(lParam);
UNREFERENCED_PARAMETER(message);
switch (LOWORD(wParam)) {
switch (LOWORD(wParam))
{
case ID_REGISTRY_LOADHIVE:
LoadHive(hWnd);
return TRUE;
@ -924,9 +949,9 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
pts = pt;
if(ClientToScreen(g_pChildWnd->hWnd, &pts))
{
SetCursorPos(pts.x, pts.y);
SetCursor(LoadCursor(0, IDC_SIZEWE));
SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
SetCursorPos(pts.x, pts.y);
SetCursor(LoadCursor(0, IDC_SIZEWE));
SendMessage(g_pChildWnd->hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM(pt.x, pt.y));
}
return TRUE;
}
@ -940,12 +965,14 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
valueName = GetValueName(g_pChildWnd->hListWnd, -1);
if (keyPath) {
if (keyPath)
{
lRet = RegOpenKeyEx(hKeyRoot, keyPath, 0, regsam, &hKey);
if (lRet != ERROR_SUCCESS) hKey = 0;
}
switch (LOWORD(wParam)) {
switch (LOWORD(wParam))
{
case ID_EDIT_MODIFY:
if (valueName && ModifyValue(hWnd, hKey, valueName, FALSE))
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
@ -978,49 +1005,49 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if (GetFocus() == g_pChildWnd->hListWnd)
{
UINT nSelected = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
if(nSelected >= 1)
{
TCHAR msg[128], caption[128];
LoadString(hInst, IDS_QUERY_DELETE_CONFIRM, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, (nSelected == 1 ? IDS_QUERY_DELETE_ONE : IDS_QUERY_DELETE_MORE), msg, sizeof(msg)/sizeof(TCHAR));
if(MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) == IDYES)
UINT nSelected = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
if(nSelected >= 1)
{
int ni, errs;
item = -1;
errs = 0;
while((ni = ListView_GetNextItem(g_pChildWnd->hListWnd, item, LVNI_SELECTED)) > -1)
{
valueName = GetValueName(g_pChildWnd->hListWnd, item);
if(RegDeleteValue(hKey, valueName) != ERROR_SUCCESS)
TCHAR msg[128], caption[128];
LoadString(hInst, IDS_QUERY_DELETE_CONFIRM, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, (nSelected == 1 ? IDS_QUERY_DELETE_ONE : IDS_QUERY_DELETE_MORE), msg, sizeof(msg)/sizeof(TCHAR));
if(MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) == IDYES)
{
errs++;
}
item = ni;
}
int ni, errs;
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
if(errs > 0)
{
LoadString(hInst, IDS_ERR_DELVAL_CAPTION, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, IDS_ERR_DELETEVALUE, msg, sizeof(msg)/sizeof(TCHAR));
MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONSTOP);
}
item = -1;
errs = 0;
while((ni = ListView_GetNextItem(g_pChildWnd->hListWnd, item, LVNI_SELECTED)) > -1)
{
valueName = GetValueName(g_pChildWnd->hListWnd, item);
if(RegDeleteValue(hKey, valueName) != ERROR_SUCCESS)
{
errs++;
}
item = ni;
}
RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath);
if(errs > 0)
{
LoadString(hInst, IDS_ERR_DELVAL_CAPTION, caption, sizeof(caption)/sizeof(TCHAR));
LoadString(hInst, IDS_ERR_DELETEVALUE, msg, sizeof(msg)/sizeof(TCHAR));
MessageBox(g_pChildWnd->hWnd, msg, caption, MB_ICONSTOP);
}
}
}
}
}
else if (GetFocus() == g_pChildWnd->hTreeWnd)
{
if (keyPath == 0 || *keyPath == 0)
{
MessageBeep(MB_ICONHAND);
} else
if (DeleteKey(hWnd, hKeyRoot, keyPath))
{
DeleteNode(g_pChildWnd->hTreeWnd, 0);
RefreshTreeView(g_pChildWnd->hTreeWnd);
}
if (keyPath == 0 || *keyPath == 0)
{
MessageBeep(MB_ICONHAND);
}
else if (DeleteKey(hWnd, hKeyRoot, keyPath))
{
DeleteNode(g_pChildWnd->hTreeWnd, 0);
RefreshTreeView(g_pChildWnd->hTreeWnd);
}
}
break;
}
@ -1064,9 +1091,9 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
RefreshTreeView(g_pChildWnd->hTreeWnd);
/*RefreshListView(g_pChildWnd->hListWnd, hKeyRoot, keyPath, NULL); */
break;
/*case ID_OPTIONS_TOOLBAR:*/
/* toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
/* break;*/
/*case ID_OPTIONS_TOOLBAR:*/
/* toggle_child(hWnd, LOWORD(wParam), hToolBar);*/
/* break;*/
case ID_EDIT_NEW_KEY:
CreateNewKey(g_pChildWnd->hTreeWnd, TreeView_GetSelection(g_pChildWnd->hTreeWnd));
break;
@ -1099,7 +1126,7 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
}
if(hKey)
RegCloseKey(hKey);
RegCloseKey(hKey);
return result;
}
@ -1116,7 +1143,8 @@ static BOOL _CmdWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
switch (message)
{
case WM_CREATE:
CreateWindowEx(0, szChildClass, NULL, WS_CHILD | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

2194
reactos/base/applications/regedit/hexedit.c
View file

File diff suppressed because it is too large Load diff

344
reactos/base/applications/regedit/listview.c
View file

@ -96,23 +96,23 @@ VOID SetValueName(HWND hwndLV, LPCTSTR pszValueName)
i = ListView_FindItem(hwndLV, -1, &fi);
}
ListView_SetItemState(hwndLV, i, LVIS_FOCUSED | LVIS_SELECTED,
LVIS_FOCUSED | LVIS_SELECTED);
LVIS_FOCUSED | LVIS_SELECTED);
iListViewSelect = i;
}
BOOL IsDefaultValue(HWND hwndLV, int i)
{
PLINE_INFO lineinfo;
LVITEM Item;
PLINE_INFO lineinfo;
LVITEM Item;
Item.mask = LVIF_PARAM;
Item.iItem = i;
if(ListView_GetItem(hwndLV, &Item))
{
lineinfo = (PLINE_INFO)Item.lParam;
return lineinfo && (!lineinfo->name || !_tcscmp(lineinfo->name, _T("")));
}
return FALSE;
Item.mask = LVIF_PARAM;
Item.iItem = i;
if(ListView_GetItem(hwndLV, &Item))
{
lineinfo = (PLINE_INFO)Item.lParam;
return lineinfo && (!lineinfo->name || !_tcscmp(lineinfo->name, _T("")));
}
return FALSE;
}
/*******************************************************************************
@ -129,7 +129,7 @@ static void AddEntryToList(HWND hwndLV, LPTSTR Name, DWORD dwValType, void* ValB
linfo->val_len = dwCount;
if(dwCount > 0)
{
memcpy(&linfo[1], ValBuf, dwCount);
memcpy(&linfo[1], ValBuf, dwCount);
}
linfo->name = _tcsdup(Name);
@ -146,12 +146,12 @@ static void AddEntryToList(HWND hwndLV, LPTSTR Name, DWORD dwValType, void* ValB
item.lParam = (LPARAM)linfo;
switch(dwValType)
{
case REG_SZ:
case REG_EXPAND_SZ:
case REG_MULTI_SZ:
case REG_SZ:
case REG_EXPAND_SZ:
case REG_MULTI_SZ:
item.iImage = Image_String;
break;
default:
default:
item.iImage = Image_Bin;
break;
}
@ -162,87 +162,90 @@ static void AddEntryToList(HWND hwndLV, LPTSTR Name, DWORD dwValType, void* ValB
#endif
index = ListView_InsertItem(hwndLV, &item);
if (index != -1) {
switch (dwValType) {
if (index != -1)
{
switch (dwValType)
{
case REG_SZ:
case REG_EXPAND_SZ:
if(dwCount > 0)
{
ListView_SetItemText(hwndLV, index, 2, ValBuf);
ListView_SetItemText(hwndLV, index, 2, ValBuf);
}
else if(!ValExists)
{
TCHAR buffer[255];
/* load (value not set) string */
LoadString(hInst, IDS_VALUE_NOT_SET, buffer, sizeof(buffer)/sizeof(TCHAR));
ListView_SetItemText(hwndLV, index, 2, buffer);
TCHAR buffer[255];
/* load (value not set) string */
LoadString(hInst, IDS_VALUE_NOT_SET, buffer, sizeof(buffer)/sizeof(TCHAR));
ListView_SetItemText(hwndLV, index, 2, buffer);
}
break;
case REG_MULTI_SZ:
{
LPTSTR src, str;
if(dwCount >= 2)
{
LPTSTR src, str;
if(dwCount >= 2)
{
src = (LPTSTR)ValBuf;
str = HeapAlloc(GetProcessHeap(), 0, dwCount);
if(str != NULL)
{
*str = _T('\0');
/* concatenate all srings */
while(*src != _T('\0'))
{
_tcscat(str, src);
_tcscat(str, _T(" "));
src += _tcslen(src) + 1;
}
ListView_SetItemText(hwndLV, index, 2, str);
HeapFree(GetProcessHeap(), 0, str);
}
else
ListView_SetItemText(hwndLV, index, 2, _T(""));
}
else
ListView_SetItemText(hwndLV, index, 2, _T(""));
}
break;
case REG_DWORD: {
TCHAR buf[200];
if(dwCount == sizeof(DWORD))
src = (LPTSTR)ValBuf;
str = HeapAlloc(GetProcessHeap(), 0, dwCount);
if(str != NULL)
{
wsprintf(buf, _T("0x%08x (%u)"), *(DWORD*)ValBuf, *(DWORD*)ValBuf);
}
else
{
LoadString(hInst, IDS_INVALID_DWORD, buf, sizeof(buf)/sizeof(TCHAR));
}
ListView_SetItemText(hwndLV, index, 2, buf);
}
/* lpsRes = convertHexToDWORDStr(lpbData, dwLen); */
break;
default:
{
unsigned int i;
LPBYTE pData = (LPBYTE)ValBuf;
LPTSTR strBinary;
if(dwCount > 0)
{
strBinary = HeapAlloc(GetProcessHeap(), 0, (dwCount * sizeof(TCHAR) * 3) + sizeof(TCHAR));
for (i = 0; i < dwCount; i++)
*str = _T('\0');
/* concatenate all srings */
while(*src != _T('\0'))
{
wsprintf( strBinary + i*3, _T("%02X "), pData[i] );
_tcscat(str, src);
_tcscat(str, _T(" "));
src += _tcslen(src) + 1;
}
strBinary[dwCount * 3] = 0;
ListView_SetItemText(hwndLV, index, 2, strBinary);
HeapFree(GetProcessHeap(), 0, strBinary);
ListView_SetItemText(hwndLV, index, 2, str);
HeapFree(GetProcessHeap(), 0, str);
}
else
{
TCHAR szText[128];
LoadString(hInst, IDS_BINARY_EMPTY, szText, sizeof(szText)/sizeof(TCHAR));
ListView_SetItemText(hwndLV, index, 2, szText);
}
ListView_SetItemText(hwndLV, index, 2, _T(""));
}
break;
else
ListView_SetItemText(hwndLV, index, 2, _T(""));
}
break;
case REG_DWORD:
{
TCHAR buf[200];
if(dwCount == sizeof(DWORD))
{
wsprintf(buf, _T("0x%08x (%u)"), *(DWORD*)ValBuf, *(DWORD*)ValBuf);
}
else
{
LoadString(hInst, IDS_INVALID_DWORD, buf, sizeof(buf)/sizeof(TCHAR));
}
ListView_SetItemText(hwndLV, index, 2, buf);
}
/* lpsRes = convertHexToDWORDStr(lpbData, dwLen); */
break;
default:
{
unsigned int i;
LPBYTE pData = (LPBYTE)ValBuf;
LPTSTR strBinary;
if(dwCount > 0)
{
strBinary = HeapAlloc(GetProcessHeap(), 0, (dwCount * sizeof(TCHAR) * 3) + sizeof(TCHAR));
for (i = 0; i < dwCount; i++)
{
wsprintf( strBinary + i*3, _T("%02X "), pData[i] );
}
strBinary[dwCount * 3] = 0;
ListView_SetItemText(hwndLV, index, 2, strBinary);
HeapFree(GetProcessHeap(), 0, strBinary);
}
else
{
TCHAR szText[128];
LoadString(hInst, IDS_BINARY_EMPTY, szText, sizeof(szText)/sizeof(TCHAR));
ListView_SetItemText(hwndLV, index, 2, szText);
}
}
break;
}
}
}
@ -258,7 +261,8 @@ static BOOL CreateListColumns(HWND hWndListView)
lvC.pszText = szText;
/* Load the column labels from the resource file. */
for (index = 0; index < MAX_LIST_COLUMNS; index++) {
for (index = 0; index < MAX_LIST_COLUMNS; index++)
{
lvC.iSubItem = index;
lvC.cx = default_column_widths[index];
lvC.fmt = column_alignment[index];
@ -288,7 +292,7 @@ static BOOL InitListViewImageLists(HWND hwndLV)
/* Fail if not all of the images were added. */
if (ImageList_GetImageCount(himl) < NUM_ICONS)
{
return FALSE;
return FALSE;
}
/* Associate the image list with the tree view control. */
@ -306,13 +310,15 @@ static void OnGetDispInfo(NMLVDISPINFO* plvdi)
plvdi->item.pszText = NULL;
plvdi->item.cchTextMax = 0;
switch (plvdi->item.iSubItem) {
switch (plvdi->item.iSubItem)
{
case 0:
LoadString(hInst, IDS_DEFAULT_VALUE_NAME, buffer, sizeof(buffer)/sizeof(TCHAR));
plvdi->item.pszText = buffer;
plvdi->item.pszText = buffer;
break;
case 1:
switch (((LINE_INFO*)plvdi->item.lParam)->dwValType) {
switch (((LINE_INFO*)plvdi->item.lParam)->dwValType)
{
case REG_NONE:
plvdi->item.pszText = _T("REG_NONE");
break;
@ -349,13 +355,14 @@ static void OnGetDispInfo(NMLVDISPINFO* plvdi)
case REG_QWORD: /* REG_QWORD_LITTLE_ENDIAN */
plvdi->item.pszText = _T("REG_QWORD");
break;
default: {
default:
{
TCHAR buf2[200];
LoadString(hInst, IDS_UNKNOWN_TYPE, buf2, sizeof(buf2)/sizeof(TCHAR));
wsprintf(buffer, buf2, ((LINE_INFO*)plvdi->item.lParam)->dwValType);
LoadString(hInst, IDS_UNKNOWN_TYPE, buf2, sizeof(buf2)/sizeof(TCHAR));
wsprintf(buffer, buf2, ((LINE_INFO*)plvdi->item.lParam)->dwValType);
plvdi->item.pszText = buffer;
break;
}
}
}
break;
case 3:
@ -377,7 +384,8 @@ static int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSor
if (g_columnToSort == 1 && l->dwValType != r->dwValType)
return g_invertSort ? (int)r->dwValType - (int)l->dwValType : (int)l->dwValType - (int)r->dwValType;
if (g_columnToSort == 2) {
if (g_columnToSort == 2)
{
/* FIXME: Sort on value */
}
return g_invertSort ? _tcsicmp(r->name, l->name) : _tcsicmp(l->name, r->name);
@ -388,87 +396,89 @@ BOOL ListWndNotifyProc(HWND hWnd, WPARAM wParam, LPARAM lParam, BOOL *Result)
NMLVDISPINFO* Info;
UNREFERENCED_PARAMETER(wParam);
*Result = TRUE;
switch (((LPNMHDR)lParam)->code) {
case LVN_GETDISPINFO:
OnGetDispInfo((NMLVDISPINFO*)lParam);
return TRUE;
case LVN_COLUMNCLICK:
if (g_columnToSort == (DWORD)((LPNMLISTVIEW)lParam)->iSubItem)
g_invertSort = !g_invertSort;
else {
g_columnToSort = ((LPNMLISTVIEW)lParam)->iSubItem;
g_invertSort = FALSE;
}
switch (((LPNMHDR)lParam)->code)
{
case LVN_GETDISPINFO:
OnGetDispInfo((NMLVDISPINFO*)lParam);
return TRUE;
case LVN_COLUMNCLICK:
if (g_columnToSort == (DWORD)((LPNMLISTVIEW)lParam)->iSubItem)
g_invertSort = !g_invertSort;
else
{
g_columnToSort = ((LPNMLISTVIEW)lParam)->iSubItem;
g_invertSort = FALSE;
}
(void)ListView_SortItems(hWnd, CompareFunc, (WPARAM)hWnd);
return TRUE;
case NM_DBLCLK:
case NM_RETURN:
(void)ListView_SortItems(hWnd, CompareFunc, (WPARAM)hWnd);
return TRUE;
case NM_DBLCLK:
case NM_RETURN:
{
SendMessage(hFrameWnd, WM_COMMAND, MAKEWPARAM(ID_EDIT_MODIFY, 0), 0);
}
return TRUE;
case NM_SETFOCUS:
g_pChildWnd->nFocusPanel = 0;
break;
case LVN_BEGINLABELEDIT:
Info = (NMLVDISPINFO*)lParam;
if(Info)
{
PLINE_INFO lineinfo = (PLINE_INFO)Info->item.lParam;
if(!lineinfo->name || !_tcscmp(lineinfo->name, _T("")))
{
SendMessage(hFrameWnd, WM_COMMAND, MAKEWPARAM(ID_EDIT_MODIFY, 0), 0);
*Result = TRUE;
}
return TRUE;
case NM_SETFOCUS:
g_pChildWnd->nFocusPanel = 0;
break;
case LVN_BEGINLABELEDIT:
Info = (NMLVDISPINFO*)lParam;
if(Info)
else
{
PLINE_INFO lineinfo = (PLINE_INFO)Info->item.lParam;
if(!lineinfo->name || !_tcscmp(lineinfo->name, _T("")))
*Result = FALSE;
}
}
else
*Result = TRUE;
return TRUE;
case LVN_ENDLABELEDIT:
Info = (NMLVDISPINFO*)lParam;
if(Info && Info->item.pszText)
{
PLINE_INFO lineinfo = (PLINE_INFO)Info->item.lParam;
if(!lineinfo->name || !_tcscmp(lineinfo->name, _T("")))
{
*Result = FALSE;
}
else
{
if(_tcslen(Info->item.pszText) == 0)
{
TCHAR msg[128], caption[128];
LoadString(hInst, IDS_ERR_RENVAL_TOEMPTY, msg, sizeof(msg)/sizeof(TCHAR));
LoadString(hInst, IDS_ERR_RENVAL_CAPTION, caption, sizeof(caption)/sizeof(TCHAR));
MessageBox(0, msg, caption, 0);
*Result = TRUE;
}
else
{
*Result = FALSE;
HKEY hKeyRoot;
LPCTSTR keyPath;
LONG lResult;
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
lResult = RenameValue(hKeyRoot, keyPath, Info->item.pszText, lineinfo->name);
lineinfo->name = realloc(lineinfo->name, (_tcslen(Info->item.pszText)+1)*sizeof(TCHAR));
if (lineinfo->name != NULL)
_tcscpy(lineinfo->name, Info->item.pszText);
*Result = TRUE;
return (lResult == ERROR_SUCCESS);
}
}
else
*Result = TRUE;
return TRUE;
case LVN_ENDLABELEDIT:
Info = (NMLVDISPINFO*)lParam;
if(Info && Info->item.pszText)
{
PLINE_INFO lineinfo = (PLINE_INFO)Info->item.lParam;
if(!lineinfo->name || !_tcscmp(lineinfo->name, _T("")))
{
*Result = FALSE;
}
else
{
if(_tcslen(Info->item.pszText) == 0)
{
TCHAR msg[128], caption[128];
}
else
*Result = TRUE;
LoadString(hInst, IDS_ERR_RENVAL_TOEMPTY, msg, sizeof(msg)/sizeof(TCHAR));
LoadString(hInst, IDS_ERR_RENVAL_CAPTION, caption, sizeof(caption)/sizeof(TCHAR));
MessageBox(0, msg, caption, 0);
*Result = TRUE;
}
else
{
HKEY hKeyRoot;
LPCTSTR keyPath;
LONG lResult;
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
lResult = RenameValue(hKeyRoot, keyPath, Info->item.pszText, lineinfo->name);
lineinfo->name = realloc(lineinfo->name, (_tcslen(Info->item.pszText)+1)*sizeof(TCHAR));
if (lineinfo->name != NULL)
_tcscpy(lineinfo->name, Info->item.pszText);
*Result = TRUE;
return (lResult == ERROR_SUCCESS);
}
}
}
else
*Result = TRUE;
return TRUE;
return TRUE;
}
return FALSE;
}
@ -500,10 +510,11 @@ fail:
void DestroyListView(HWND hwndLV)
{
INT count, i;
LVITEM item;
LVITEM item;
count = ListView_GetItemCount(hwndLV);
for (i = 0; i < count; i++) {
for (i = 0; i < count; i++)
{
item.mask = LVIF_PARAM;
item.iItem = i;
(void)ListView_GetItem(hwndLV, &item);
@ -555,7 +566,8 @@ BOOL RefreshListView(HWND hwndLV, HKEY hKey, LPCTSTR keyPath)
/* AddEntryToList(hwndLV, _T("(Default)"), dwValType, ValBuf, dwValSize); */
/* } */
/* dwValSize = max_val_size; */
while (RegEnumValue(hNewKey, dwIndex, ValName, &dwValNameLen, NULL, &dwValType, ValBuf, &dwValSize) == ERROR_SUCCESS) {
while (RegEnumValue(hNewKey, dwIndex, ValName, &dwValNameLen, NULL, &dwValType, ValBuf, &dwValSize) == ERROR_SUCCESS)
{
/* Add a terminating 0 character. Usually this is only necessary for strings. */
ValBuf[dwValSize] = 0;
#ifdef UNICODE
@ -568,7 +580,7 @@ BOOL RefreshListView(HWND hwndLV, HKEY hKey, LPCTSTR keyPath)
++dwIndex;
if(!_tcscmp(ValName, _T("")))
{
AddedDefault = TRUE;
AddedDefault = TRUE;
}
}
HeapFree(GetProcessHeap(), 0, ValBuf);
@ -576,7 +588,7 @@ BOOL RefreshListView(HWND hwndLV, HKEY hKey, LPCTSTR keyPath)
}
if(!AddedDefault)
{
AddEntryToList(hwndLV, _T(""), REG_SZ, NULL, 0, 0, FALSE);
AddEntryToList(hwndLV, _T(""), REG_SZ, NULL, 0, 0, FALSE);
}
ListView_SortItems(hwndLV, CompareFunc, (WPARAM)hwndLV);
c = ListView_GetItemCount(hwndLV);
@ -585,8 +597,8 @@ BOOL RefreshListView(HWND hwndLV, HKEY hKey, LPCTSTR keyPath)
ListView_SetItemState(hwndLV, i, 0, LVIS_FOCUSED | LVIS_SELECTED);
}
ListView_SetItemState(hwndLV, iListViewSelect,
LVIS_FOCUSED | LVIS_SELECTED,
LVIS_FOCUSED | LVIS_SELECTED);
LVIS_FOCUSED | LVIS_SELECTED,
LVIS_FOCUSED | LVIS_SELECTED);
RegCloseKey(hNewKey);
SendMessage(hwndLV, WM_SETREDRAW, TRUE, 0);

55
reactos/base/applications/regedit/main.c
View file

@ -88,9 +88,9 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
wcChild.hInstance = hInstance;
wcChild.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_REGEDIT));
wcChild.hCursor = LoadCursor(0, IDC_ARROW),
wcChild.lpszClassName = szChildClass,
wcChild.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_REGEDIT), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
wcChild.lpszClassName = szChildClass,
wcChild.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_REGEDIT), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
RegisterClassEx(&wcChild); /* register child windows class */
@ -107,13 +107,13 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
AclUiAvailable = InitializeAclUiDll();
if(!AclUiAvailable)
{
/* hide the Edit/Permissions... menu entry */
if(hEditMenu != NULL)
{
RemoveMenu(hEditMenu, ID_EDIT_PERMISSIONS, MF_BYCOMMAND);
/* remove the separator after the menu item */
RemoveMenu(hEditMenu, 4, MF_BYPOSITION);
}
/* hide the Edit/Permissions... menu entry */
if(hEditMenu != NULL)
{
RemoveMenu(hEditMenu, ID_EDIT_PERMISSIONS, MF_BYCOMMAND);
/* remove the separator after the menu item */
RemoveMenu(hEditMenu, 4, MF_BYPOSITION);
}
}
if(hEditMenu != NULL)
@ -129,14 +129,16 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL, hMenuFrame, hInstance, NULL/*lpParam*/);
if (!hFrameWnd) {
if (!hFrameWnd)
{
return FALSE;
}
/* Create the status bar */
hStatusBar = CreateStatusWindow(WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|SBT_NOBORDERS,
_T(""), hFrameWnd, STATUS_WINDOW);
if (hStatusBar) {
if (hStatusBar)
{
/* Create the status bar panes */
SetupStatusBar(hFrameWnd, FALSE);
CheckMenuItem(GetSubMenu(hMenuFrame, ID_VIEW_MENU), ID_VIEW_STATUSBAR, MF_BYCOMMAND|MF_CHECKED);
@ -144,7 +146,7 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
/* Restore position */
if (QueryStringValue(HKEY_CURRENT_USER, g_szGeneralRegKey, _T("LastKey"),
szBuffer, COUNT_OF(szBuffer)) == ERROR_SUCCESS)
szBuffer, COUNT_OF(szBuffer)) == ERROR_SUCCESS)
{
SelectNode(g_pChildWnd->hTreeWnd, szBuffer);
}
@ -159,8 +161,9 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
/* we need to destroy the main menu before destroying the main window
to avoid a memory leak */
void DestroyMainMenu() {
DestroyMenu(hMenuFrame);
void DestroyMainMenu()
{
DestroyMenu(hMenuFrame);
}
/******************************************************************************/
@ -175,11 +178,11 @@ void ExitInstance(HINSTANCE hInstance)
BOOL TranslateChildTabMessage(MSG *msg)
{
if (msg->message != WM_KEYDOWN) return FALSE;
if (msg->wParam != VK_TAB) return FALSE;
if (GetParent(msg->hwnd) != g_pChildWnd->hWnd) return FALSE;
PostMessage(g_pChildWnd->hWnd, WM_COMMAND, ID_SWITCH_PANELS, 0);
return TRUE;
if (msg->message != WM_KEYDOWN) return FALSE;
if (msg->wParam != VK_TAB) return FALSE;
if (GetParent(msg->hwnd) != g_pChildWnd->hWnd) return FALSE;
PostMessage(g_pChildWnd->hWnd, WM_COMMAND, ID_SWITCH_PANELS, 0);
return TRUE;
}
int APIENTRY wWinMain(HINSTANCE hInstance,
@ -192,7 +195,8 @@ int APIENTRY wWinMain(HINSTANCE hInstance,
UNREFERENCED_PARAMETER(hPrevInstance);
if (ProcessCmdLine(lpCmdLine)) {
if (ProcessCmdLine(lpCmdLine))
{
return 0;
}
@ -205,15 +209,18 @@ int APIENTRY wWinMain(HINSTANCE hInstance,
hInst = hInstance;
/* Perform application initialization */
if (!InitInstance(hInstance, nCmdShow)) {
if (!InitInstance(hInstance, nCmdShow))
{
return FALSE;
}
hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(ID_ACCEL));
/* Main message loop */
while (GetMessage(&msg, (HWND)NULL, 0, 0)) {
while (GetMessage(&msg, (HWND)NULL, 0, 0))
{
if (!TranslateAccelerator(hFrameWnd, hAccel, &msg)
&& !TranslateChildTabMessage(&msg)) {
&& !TranslateChildTabMessage(&msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}

10
reactos/base/applications/regedit/main.h
View file

@ -43,7 +43,8 @@ extern HINSTANCE hInst;
/******************************************************************************/
enum OPTION_FLAGS {
enum OPTION_FLAGS
{
OPTIONS_AUTO_REFRESH = 0x01,
OPTIONS_READ_ONLY_MODE = 0x02,
OPTIONS_CONFIRM_ON_DELETE = 0x04,
@ -53,12 +54,13 @@ enum OPTION_FLAGS {
OPTIONS_VIEW_DATA_ONLY = 0x40,
};
typedef struct {
typedef struct
{
HWND hWnd;
HWND hTreeWnd;
HWND hListWnd;
HWND hAddressBarWnd;
HWND hAddressBtnWnd;
HWND hAddressBarWnd;
HWND hAddressBtnWnd;
int nFocusPanel; /* 0: left 1: right */
int nSplitPos;
WINDOWPLACEMENT pos;

187
reactos/base/applications/regedit/regedit.c
View file

@ -52,7 +52,8 @@ static const char *usage =
"This program is command-line compatible with Microsoft Windows\n"
"regedit.\n";
typedef enum {
typedef enum
{
ACTION_UNDEF, ACTION_ADD, ACTION_EXPORT, ACTION_DELETE
} REGEDIT_ACTION;
@ -79,40 +80,52 @@ void get_file_name(LPWSTR *command_line, LPWSTR file_name)
int pos = 0; /* position of pointer "s" in *command_line */
file_name[0] = 0;
if (!s[0]) {
if (!s[0])
{
return;
}
if (s[0] == L'"') {
if (s[0] == L'"')
{
s++;
(*command_line)++;
while(s[0] != L'"') {
if (!s[0]) {
while(s[0] != L'"')
{
if (!s[0])
{
fprintf(stderr, "%s: Unexpected end of file name!\n", getAppName());
exit(1);
}
s++;
pos++;
}
} else {
while(s[0] && !iswspace(s[0])) {
}
else
{
while(s[0] && !iswspace(s[0]))
{
s++;
pos++;
}
}
memcpy(file_name, *command_line, pos * sizeof((*command_line)[0]));
/* remove the last backslash */
if (file_name[pos - 1] == L'\\') {
if (file_name[pos - 1] == L'\\')
{
file_name[pos - 1] = L'\0';
} else {
}
else
{
file_name[pos] = L'\0';
}
if (s[0]) {
if (s[0])
{
s++;
pos++;
}
while(s[0] && iswspace(s[0])) {
while(s[0] && iswspace(s[0]))
{
s++;
pos++;
}
@ -121,64 +134,75 @@ void get_file_name(LPWSTR *command_line, LPWSTR file_name)
BOOL PerformRegAction(REGEDIT_ACTION action, LPWSTR s)
{
switch (action) {
case ACTION_ADD: {
WCHAR filename[MAX_PATH];
FILE *fp;
switch (action)
{
case ACTION_ADD:
{
WCHAR filename[MAX_PATH];
FILE *fp;
get_file_name(&s, filename);
if (!filename[0]) {
fprintf(stderr, "%s: No file name is specified\n", getAppName());
fprintf(stderr, usage);
exit(4);
}
while(filename[0]) {
fp = _wfopen(filename, L"r");
if (fp == NULL)
{
LPSTR p = GetMultiByteString(filename);
perror("");
fprintf(stderr, "%s: Can't open file \"%s\"\n", getAppName(), p);
HeapFree(GetProcessHeap(), 0, p);
exit(5);
}
import_registry_file(fp);
get_file_name(&s, filename);
}
break;
get_file_name(&s, filename);
if (!filename[0])
{
fprintf(stderr, "%s: No file name is specified\n", getAppName());
fprintf(stderr, usage);
exit(4);
}
case ACTION_DELETE: {
while(filename[0])
{
fp = _wfopen(filename, L"r");
if (fp == NULL)
{
LPSTR p = GetMultiByteString(filename);
perror("");
fprintf(stderr, "%s: Can't open file \"%s\"\n", getAppName(), p);
HeapFree(GetProcessHeap(), 0, p);
exit(5);
}
import_registry_file(fp);
get_file_name(&s, filename);
}
break;
}
case ACTION_DELETE:
{
WCHAR reg_key_name[KEY_MAX_LEN];
get_file_name(&s, reg_key_name);
if (!reg_key_name[0])
{
fprintf(stderr, "%s: No registry key is specified for removal\n", getAppName());
fprintf(stderr, usage);
exit(6);
}
delete_registry_key(reg_key_name);
break;
}
case ACTION_EXPORT:
{
WCHAR filename[MAX_PATH];
filename[0] = _T('\0');
get_file_name(&s, filename);
if (!filename[0])
{
fprintf(stderr, "%s: No file name is specified\n", getAppName());
fprintf(stderr, usage);
exit(7);
}
if (s[0])
{
WCHAR reg_key_name[KEY_MAX_LEN];
get_file_name(&s, reg_key_name);
if (!reg_key_name[0]) {
fprintf(stderr, "%s: No registry key is specified for removal\n", getAppName());
fprintf(stderr, usage);
exit(6);
}
delete_registry_key(reg_key_name);
break;
export_registry_key(filename, reg_key_name, REG_FORMAT_4);
}
case ACTION_EXPORT: {
WCHAR filename[MAX_PATH];
filename[0] = _T('\0');
get_file_name(&s, filename);
if (!filename[0]) {
fprintf(stderr, "%s: No file name is specified\n", getAppName());
fprintf(stderr, usage);
exit(7);
}
if (s[0]) {
WCHAR reg_key_name[KEY_MAX_LEN];
get_file_name(&s, reg_key_name);
export_registry_key(filename, reg_key_name, REG_FORMAT_4);
} else {
export_registry_key(filename, NULL, REG_FORMAT_4);
}
break;
else
{
export_registry_key(filename, NULL, REG_FORMAT_4);
}
break;
}
default:
fprintf(stderr, "%s: Unhandled action!\n", getAppName());
exit(8);
@ -196,9 +220,12 @@ BOOL PerformRegAction(REGEDIT_ACTION action, LPWSTR s)
*/
static void error_unknown_switch(WCHAR chu, LPWSTR s)
{
if (iswalpha(chu)) {
if (iswalpha(chu))
{
fprintf(stderr, "%s: Undefined switch /%c!\n", getAppName(), chu);
} else {
}
else
{
fprintf(stderr, "%s: Alphabetic character is expected after '%c' "
"in swit ch specification\n", getAppName(), *(s - 1));
}
@ -220,12 +247,16 @@ BOOL ProcessCmdLine(LPWSTR lpCmdLine)
ch = *s;
ch2 = *(s + 1);
chu = (WCHAR)towupper(ch);
if (!ch2 || iswspace(ch2)) {
if (!ch2 || iswspace(ch2))
{
if (chu == L'S' || chu == L'V')
{
/* ignore these switches */
} else {
switch (chu) {
}
else
{
switch (chu)
{
case L'D':
action = ACTION_DELETE;
break;
@ -242,14 +273,19 @@ BOOL ProcessCmdLine(LPWSTR lpCmdLine)
}
}
s++;
} else {
if (ch2 == L':') {
switch (chu) {
}
else
{
if (ch2 == L':')
{
switch (chu)
{
case L'L':
/* fall through */
case L'R':
s += 2;
while (*s && !iswspace(*s)) {
while (*s && !iswspace(*s))
{
s++;
}
break;
@ -257,7 +293,9 @@ BOOL ProcessCmdLine(LPWSTR lpCmdLine)
error_unknown_switch(chu, s);
break;
}
} else {
}
else
{
/* this is a file name, starting from '/' */
s--;
break;
@ -265,7 +303,8 @@ BOOL ProcessCmdLine(LPWSTR lpCmdLine)
}
/* skip spaces to the next parameter */
ch = *s;
while (ch && iswspace(ch)) {
while (ch && iswspace(ch))
{
s++;
ch = *s;
}

14
reactos/base/applications/regedit/regedit.rc
View file

@ -31,10 +31,10 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#include "rsrc.rc"
IDI_OPEN_FILE ICON DISCARDABLE res/folderopen.ico
IDI_CLOSED_FILE ICON DISCARDABLE res/folder.ico
IDI_ROOT ICON DISCARDABLE res/computer.ico
IDI_STRING ICON DISCARDABLE res/string.ico
IDI_BIN ICON DISCARDABLE res/bin.ico
IDI_REGEDIT ICON DISCARDABLE res/regedit.ico
IDI_REGFILE ICON DISCARDABLE res/regfile.ico
IDI_OPEN_FILE ICON DISCARDABLE res/folderopen.ico
IDI_CLOSED_FILE ICON DISCARDABLE res/folder.ico
IDI_ROOT ICON DISCARDABLE res/computer.ico
IDI_STRING ICON DISCARDABLE res/string.ico
IDI_BIN ICON DISCARDABLE res/bin.ico
IDI_REGEDIT ICON DISCARDABLE res/regedit.ico
IDI_REGFILE ICON DISCARDABLE res/regfile.ico

439
reactos/base/applications/regedit/regproc.c
View file

@ -30,22 +30,25 @@
*/
#define REG_FILE_HEX_LINE_LEN (2 + 25 * 3)
static const CHAR *reg_class_names[] = {
"HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_CLASSES_ROOT",
"HKEY_CURRENT_CONFIG", "HKEY_CURRENT_USER", "HKEY_DYN_DATA"
};
static const CHAR *reg_class_names[] =
{
"HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_CLASSES_ROOT",
"HKEY_CURRENT_CONFIG", "HKEY_CURRENT_USER", "HKEY_DYN_DATA"
};
#define REG_CLASS_NUMBER (sizeof(reg_class_names) / sizeof(reg_class_names[0]))
const WCHAR* reg_class_namesW[REG_CLASS_NUMBER] = {
const WCHAR* reg_class_namesW[REG_CLASS_NUMBER] =
{
L"HKEY_LOCAL_MACHINE", L"HKEY_USERS", L"HKEY_CLASSES_ROOT",
L"HKEY_CURRENT_CONFIG", L"HKEY_CURRENT_USER", L"HKEY_DYN_DATA"
};
static HKEY reg_class_keys[REG_CLASS_NUMBER] = {
HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
};
static HKEY reg_class_keys[REG_CLASS_NUMBER] =
{
HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
};
/* return values */
#define NOT_ENOUGH_MEMORY 1
@ -149,7 +152,8 @@ static BOOL convertHexToDWord(WCHAR* str, DWORD *dw)
char dummy;
WideCharToMultiByte(CP_ACP, 0, str, -1, buf, 9, NULL, NULL);
if (lstrlenW(str) > 8 || sscanf(buf, "%lx%c", dw, &dummy) != 1) {
if (lstrlenW(str) > 8 || sscanf(buf, "%lx%c", dw, &dummy) != 1)
{
fprintf(stderr,"%s: ERROR, invalid hex value\n", getAppName());
return FALSE;
}
@ -172,12 +176,14 @@ static BYTE* convertHexCSVToHex(WCHAR *str, DWORD *size)
s = str;
d = data;
*size=0;
while (*s != '\0') {
while (*s != '\0')
{
UINT wc;
WCHAR *end;
wc = wcstoul(s,&end, 16);
if (end == s || wc > 0xff || (*end && *end != L',')) {
if (end == s || wc > 0xff || (*end && *end != L','))
{
char* strA = GetMultiByteString(s);
fprintf(stderr,"%s: ERROR converting CSV hex stream. Invalid value at '%s'\n",
getAppName(), strA);
@ -203,7 +209,13 @@ static BYTE* convertHexCSVToHex(WCHAR *str, DWORD *size)
*/
static DWORD getDataType(LPWSTR *lpValue, DWORD* parse_type)
{
struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
struct data_type
{
const WCHAR *tag;
int len;
int type;
int parse_type;
};
static const WCHAR quote[] = {'"'};
static const WCHAR str[] = {'s','t','r',':','"'};
@ -213,19 +225,20 @@ static DWORD getDataType(LPWSTR *lpValue, DWORD* parse_type)
static const WCHAR hexp[] = {'h','e','x','('};
static const struct data_type data_types[] = { /* actual type */ /* type to assume for parsing */
{ quote, 1, REG_SZ, REG_SZ },
{ str, 5, REG_SZ, REG_SZ },
{ str2, 8, REG_EXPAND_SZ, REG_SZ },
{ hex, 4, REG_BINARY, REG_BINARY },
{ dword, 6, REG_DWORD, REG_DWORD },
{ hexp, 4, -1, REG_BINARY },
{ NULL, 0, 0, 0 }
};
{ quote, 1, REG_SZ, REG_SZ },
{ str, 5, REG_SZ, REG_SZ },
{ str2, 8, REG_EXPAND_SZ, REG_SZ },
{ hex, 4, REG_BINARY, REG_BINARY },
{ dword, 6, REG_DWORD, REG_DWORD },
{ hexp, 4, -1, REG_BINARY },
{ NULL, 0, 0, 0 }
};
const struct data_type *ptr;
int type;
for (ptr = data_types; ptr->tag; ptr++) {
for (ptr = data_types; ptr->tag; ptr++)
{
if (wcsncmp(ptr->tag, *lpValue, ptr->len))
continue;
@ -233,14 +246,18 @@ static DWORD getDataType(LPWSTR *lpValue, DWORD* parse_type)
*parse_type = ptr->parse_type;
type=ptr->type;
*lpValue+=ptr->len;
if (type == -1) {
if (type == -1)
{
WCHAR* end;
/* "hex(xx):" is special */
type = (int)wcstoul( *lpValue , &end, 16 );
if (**lpValue=='\0' || *end!=')' || *(end+1)!=':') {
if (**lpValue=='\0' || *end!=')' || *(end+1)!=':')
{
type=REG_NONE;
} else {
}
else
{
*lpValue = end + 2;
}
}
@ -258,10 +275,13 @@ static void REGPROC_unescape_string(WCHAR* str)
int str_idx = 0; /* current character under analysis */
int val_idx = 0; /* the last character of the unescaped string */
int len = lstrlenW(str);
for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
if (str[str_idx] == '\\') {
for (str_idx = 0; str_idx < len; str_idx++, val_idx++)
{
if (str[str_idx] == '\\')
{
str_idx++;
switch (str[str_idx]) {
switch (str[str_idx])
{
case 'n':
str[val_idx] = '\n';
break;
@ -271,11 +291,13 @@ static void REGPROC_unescape_string(WCHAR* str)
break;
default:
fprintf(stderr,"Warning! Unrecognized escape sequence: \\%c'\n",
str[str_idx]);
str[str_idx]);
str[val_idx] = str[str_idx];
break;
}
} else {
}
else
{
str[val_idx] = str[str_idx];
}
}
@ -310,9 +332,11 @@ static BOOL parseKeyName(LPWSTR lpKeyName, HKEY *hKey, LPWSTR *lpKeyPath)
}
*hKey = NULL;
for (i = 0; i < REG_CLASS_NUMBER; i++) {
for (i = 0; i < REG_CLASS_NUMBER; i++)
{
if (CompareStringW(LOCALE_USER_DEFAULT, 0, lpKeyName, len, reg_class_namesW[i], len) == CSTR_EQUAL &&
len == lstrlenW(reg_class_namesW[i])) {
len == lstrlenW(reg_class_namesW[i]))
{
*hKey = reg_class_keys[i];
break;
}
@ -404,12 +428,12 @@ static LONG setValue(WCHAR* val_name, WCHAR* val_data, BOOL is_unicode)
}
res = RegSetValueExW(
currentKeyHandle,
val_name,
0, /* Reserved */
dwDataType,
lpbData,
dwLen);
currentKeyHandle,
val_name,
0, /* Reserved */
dwDataType,
lpbData,
dwLen);
if (dwParseType == REG_BINARY)
HeapFree(GetProcessHeap(), 0, lpbData);
return res;
@ -435,15 +459,15 @@ static LONG openKeyW(WCHAR* stdInput)
return ERROR_INVALID_PARAMETER;
res = RegCreateKeyExW(
keyClass, /* Class */
keyPath, /* Sub Key */
0, /* MUST BE 0 */
NULL, /* object type */
REG_OPTION_NON_VOLATILE, /* option, REG_OPTION_NON_VOLATILE ... */
KEY_ALL_ACCESS, /* access mask, KEY_ALL_ACCESS */
NULL, /* security attribute */
&currentKeyHandle, /* result */
&dwDisp); /* disposition, REG_CREATED_NEW_KEY or
keyClass, /* Class */
keyPath, /* Sub Key */
0, /* MUST BE 0 */
NULL, /* object type */
REG_OPTION_NON_VOLATILE, /* option, REG_OPTION_NON_VOLATILE ... */
KEY_ALL_ACCESS, /* access mask, KEY_ALL_ACCESS */
NULL, /* security attribute */
&currentKeyHandle, /* result */
&dwDisp); /* disposition, REG_CREATED_NEW_KEY or
REG_OPENED_EXISTING_KEY */
if (res == ERROR_SUCCESS)
@ -485,29 +509,39 @@ static void processSetValue(WCHAR* line, BOOL is_unicode)
/* get value name */
while ( iswspace(line[line_idx]) ) line_idx++;
if (line[line_idx] == '@' && line[line_idx + 1] == '=') {
if (line[line_idx] == '@' && line[line_idx + 1] == '=')
{
line[line_idx] = '\0';
val_name = line;
line_idx++;
} else if (line[line_idx] == '\"') {
}
else if (line[line_idx] == '\"')
{
line_idx++;
val_name = line + line_idx;
while (TRUE) {
while (TRUE)
{
if (line[line_idx] == '\\') /* skip escaped character */
{
line_idx += 2;
} else {
if (line[line_idx] == '\"') {
}
else
{
if (line[line_idx] == '\"')
{
line[line_idx] = '\0';
line_idx++;
break;
} else {
}
else
{
line_idx++;
}
}
}
while ( iswspace(line[line_idx]) ) line_idx++;
if (line[line_idx] != '=') {
if (line[line_idx] != '=')
{
char* lineA;
line[line_idx] = '\"';
lineA = GetMultiByteString(line);
@ -516,7 +550,9 @@ static void processSetValue(WCHAR* line, BOOL is_unicode)
return;
}
} else {
}
else
{
char* lineA = GetMultiByteString(line);
fprintf(stderr,"Warning! unrecognized line:\n%s\n", lineA);
HeapFree(GetProcessHeap(), 0, lineA);
@ -538,10 +574,10 @@ static void processSetValue(WCHAR* line, BOOL is_unicode)
char* val_nameA = GetMultiByteString(val_name);
char* val_dataA = GetMultiByteString(val_data);
fprintf(stderr,"%s: ERROR Key %s not created. Value: %s, Data: %s\n",
getAppName(),
currentKeyName,
val_nameA,
val_dataA);
getAppName(),
currentKeyName,
val_nameA,
val_dataA);
HeapFree(GetProcessHeap(), 0, val_nameA);
HeapFree(GetProcessHeap(), 0, val_dataA);
}
@ -558,7 +594,8 @@ static void processRegEntry(WCHAR* stdInput, BOOL isUnicode)
* We encountered the end of the file, make sure we
* close the opened key and exit
*/
if (stdInput == NULL) {
if (stdInput == NULL)
{
closeKey();
return;
}
@ -578,19 +615,22 @@ static void processRegEntry(WCHAR* stdInput, BOOL isUnicode)
if ( stdInput[0] == '-')
{
delete_registry_key(stdInput + 1);
} else if ( openKeyW(stdInput) != ERROR_SUCCESS )
}
else if ( openKeyW(stdInput) != ERROR_SUCCESS )
{
char* stdInputA = GetMultiByteString(stdInput);
fprintf(stderr,"%s: setValue failed to open key %s\n",
getAppName(), stdInputA);
getAppName(), stdInputA);
HeapFree(GetProcessHeap(), 0, stdInputA);
}
} else if( currentKeyHandle &&
(( stdInput[0] == '@') || /* reading a default @=data pair */
( stdInput[0] == '\"'))) /* reading a new value=data pair */
}
else if( currentKeyHandle &&
(( stdInput[0] == '@') || /* reading a default @=data pair */
( stdInput[0] == '\"'))) /* reading a new value=data pair */
{
processSetValue(stdInput, isUnicode);
} else
}
else
{
/* Since we are assuming that the file format is valid we must be
* reading a blank line which indicates the end of this key processing
@ -614,13 +654,15 @@ static void processRegLinesA(FILE *in)
line = HeapAlloc(GetProcessHeap(), 0, lineSize);
CHECK_ENOUGH_MEMORY(line);
while (!feof(in)) {
while (!feof(in))
{
LPSTR s; /* The pointer into line for where the current fgets should read */
LPSTR check;
WCHAR* lineW;
s = line;
for (;;) {
for (;;)
{
size_t size_remaining;
int size_to_get;
char *s_eol; /* various local uses */
@ -650,11 +692,15 @@ static void processRegLinesA(FILE *in)
check = fgets (s, size_to_get, in);
if (check == NULL) {
if (ferror(in)) {
if (check == NULL)
{
if (ferror(in))
{
perror ("While reading input");
exit (IO_ERROR);
} else {
}
else
{
assert (feof(in));
*s = '\0';
/* It is not clear to me from the definition that the
@ -666,40 +712,46 @@ static void processRegLinesA(FILE *in)
/* If we didn't read the eol nor the eof go around for the rest */
s_eol = strchr (s, '\n');
if (!feof (in) && !s_eol) {
if (!feof (in) && !s_eol)
{
s = strchr (s, '\0');
/* It should be s + size_to_get - 1 but this is safer */
continue;
}
/* If it is a comment line then discard it and go around again */
if (line [0] == '#') {
if (line [0] == '#')
{
s = line;
continue;
}
/* Remove any line feed. Leave s_eol on the \0 */
if (s_eol) {
if (s_eol)
{
*s_eol = '\0';
if (s_eol > line && *(s_eol-1) == '\r')
*--s_eol = '\0';
} else
}
else
s_eol = strchr (s, '\0');
/* If there is a concatenating \\ then go around again */
if (s_eol > line && *(s_eol-1) == '\\') {
if (s_eol > line && *(s_eol-1) == '\\')
{
int c;
s = s_eol-1;
do
{
c = fgetc(in);
} while(c == ' ' || c == '\t');
}
while(c == ' ' || c == '\t');
if(c == EOF)
{
fprintf(stderr,"%s: ERROR - invalid continuation.\n",
getAppName());
getAppName());
}
else
{
@ -737,7 +789,8 @@ static void processRegLinesW(FILE *in)
s = buf;
line = buf;
while(!feof(in)) {
while(!feof(in))
{
size_t size_remaining;
int size_to_get;
WCHAR *s_eol = NULL; /* various local uses */
@ -769,11 +822,15 @@ static void processRegLinesW(FILE *in)
CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in);
s[CharsInBuf] = 0;
if (CharsInBuf == 0) {
if (ferror(in)) {
if (CharsInBuf == 0)
{
if (ferror(in))
{
perror ("While reading input");
exit (IO_ERROR);
} else {
}
else
{
assert (feof(in));
*s = '\0';
/* It is not clear to me from the definition that the
@ -788,7 +845,8 @@ static void processRegLinesW(FILE *in)
{
s_eol = wcschr(line, '\n');
if(!s_eol) {
if(!s_eol)
{
/* Move the stub of the line to the start of the buffer so
* we get the maximum space to read into, and so we don't
* have to recalculate 'line' if the buffer expands */
@ -799,14 +857,16 @@ static void processRegLinesW(FILE *in)
}
/* If it is a comment line then discard it and go around again */
if (*line == '#') {
if (*line == '#')
{
line = s_eol + 1;
continue;
}
/* If there is a concatenating \\ then go around again */
if ((*(s_eol-1) == '\\') ||
(*(s_eol-1) == '\r' && *(s_eol-2) == '\\')) {
(*(s_eol-1) == '\r' && *(s_eol-2) == '\\'))
{
WCHAR* NextLine = s_eol;
while(*(NextLine+1) == ' ' || *(NextLine+1) == '\t')
@ -824,7 +884,8 @@ static void processRegLinesW(FILE *in)
}
/* Remove any line feed. Leave s_eol on the \0 */
if (s_eol) {
if (s_eol)
{
*s_eol = '\0';
if (s_eol > buf && *(s_eol-1) == '\r')
*(s_eol-1) = '\0';
@ -859,10 +920,11 @@ static void REGPROC_print_error(void)
error_code = GetLastError ();
status = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
if (!status) {
NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
if (!status)
{
fprintf(stderr,"%s: Cannot display message for error %ld, status %ld\n",
getAppName(), error_code, GetLastError());
getAppName(), error_code, GetLastError());
exit(1);
}
puts(lpMsgBuf);
@ -883,7 +945,8 @@ static void REGPROC_print_error(void)
static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
{
required_len++;
if (required_len > *len) {
if (required_len > *len)
{
*len = required_len;
if (!*buffer)
*buffer = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(**buffer));
@ -903,7 +966,8 @@ static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD require
*/
static void REGPROC_resize_binary_buffer(BYTE **buffer, DWORD *size, DWORD required_size)
{
if (required_size > *size) {
if (required_size > *size)
{
*size = required_size;
if (!*buffer)
*buffer = HeapAlloc(GetProcessHeap(), 0, *size);
@ -925,9 +989,11 @@ static void REGPROC_export_string(WCHAR **line_buf, DWORD *line_buf_size, DWORD
/* escaping characters */
pos = *line_len;
for (i = 0; i < str_len; i++) {
for (i = 0; i < str_len; i++)
{
WCHAR c = str[i];
switch (c) {
switch (c)
{
case '\n':
extra++;
REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
@ -962,9 +1028,12 @@ static void REGPROC_export_binary(WCHAR **line_buf, DWORD *line_buf_size, DWORD
const WCHAR newline[] = {'\n',0};
CHAR* value_multibyte = NULL;
if (type == REG_BINARY) {
if (type == REG_BINARY)
{
hex_prefix = hex;
} else {
}
else
{
const WCHAR hex_format[] = {'h','e','x','(','%','u',')',':',0};
hex_prefix = hex_buf;
wsprintfW(hex_buf, hex_format, type);
@ -1011,7 +1080,8 @@ static void REGPROC_export_binary(WCHAR **line_buf, DWORD *line_buf_size, DWORD
column += 3;
/* wrap the line */
if (column >= REG_FILE_HEX_LINE_LEN) {
if (column >= REG_FILE_HEX_LINE_LEN)
{
lstrcpyW(*line_buf + data_pos, concat);
data_pos += concat_len;
column = concat_prefix;
@ -1062,11 +1132,11 @@ static void REGPROC_write_line(FILE *file, const WCHAR* str, BOOL unicode)
* val_size - size of the buffer for storing values in bytes.
*/
static void export_hkey(FILE *file, HKEY key,
WCHAR **reg_key_name_buf, DWORD *reg_key_name_size,
WCHAR **val_name_buf, DWORD *val_name_size,
BYTE **val_buf, DWORD *val_size,
WCHAR **line_buf, DWORD *line_buf_size,
BOOL unicode)
WCHAR **reg_key_name_buf, DWORD *reg_key_name_size,
WCHAR **val_name_buf, DWORD *val_name_size,
BYTE **val_buf, DWORD *val_size,
WCHAR **line_buf, DWORD *line_buf_size,
BOOL unicode)
{
DWORD max_sub_key_len;
DWORD max_val_name_len;
@ -1079,16 +1149,17 @@ static void export_hkey(FILE *file, HKEY key,
/* get size information and resize the buffers if necessary */
if (RegQueryInfoKeyW(key, NULL, NULL, NULL, NULL,
&max_sub_key_len, NULL,
NULL, &max_val_name_len, &max_val_size, NULL, NULL
) != ERROR_SUCCESS) {
&max_sub_key_len, NULL,
NULL, &max_val_name_len, &max_val_size, NULL, NULL
) != ERROR_SUCCESS)
{
REGPROC_print_error();
}
curr_len = lstrlenW(*reg_key_name_buf);
REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size,
max_sub_key_len + curr_len + 1);
max_sub_key_len + curr_len + 1);
REGPROC_resize_char_buffer(val_name_buf, val_name_size,
max_val_name_len);
max_val_name_len);
REGPROC_resize_binary_buffer(val_buf, val_size, max_val_size);
REGPROC_resize_char_buffer(line_buf, line_buf_size, lstrlenW(*reg_key_name_buf) + 4);
/* output data for the current key */
@ -1098,26 +1169,34 @@ static void export_hkey(FILE *file, HKEY key,
/* print all the values */
i = 0;
more_data = TRUE;
while(more_data) {
while(more_data)
{
DWORD value_type;
DWORD val_name_size1 = *val_name_size;
DWORD val_size1 = *val_size;
ret = RegEnumValueW(key, i, *val_name_buf, &val_name_size1, NULL,
&value_type, *val_buf, &val_size1);
if (ret == ERROR_MORE_DATA) {
&value_type, *val_buf, &val_size1);
if (ret == ERROR_MORE_DATA)
{
/* Increase the size of the buffers and retry */
REGPROC_resize_char_buffer(val_name_buf, val_name_size, val_name_size1);
REGPROC_resize_binary_buffer(val_buf, val_size, val_size1);
} else if (ret != ERROR_SUCCESS) {
}
else if (ret != ERROR_SUCCESS)
{
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
if (ret != ERROR_NO_MORE_ITEMS)
{
REGPROC_print_error();
}
} else {
}
else
{
DWORD line_len;
i++;
if ((*val_name_buf)[0]) {
if ((*val_name_buf)[0])
{
const WCHAR val_start[] = {'"','%','s','"','=',0};
line_len = 0;
@ -1128,22 +1207,28 @@ static void export_hkey(FILE *file, HKEY key,
line_len = 3 + lstrlenW(*val_name_buf);
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
wsprintfW(*line_buf, val_start, *val_name_buf);
} else {
}
else
{
const WCHAR std_val[] = {'@','=',0};
line_len = 2;
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
lstrcpyW(*line_buf, std_val);
}
switch (value_type) {
switch (value_type)
{
case REG_SZ:
{
WCHAR* wstr = (WCHAR*)*val_buf;
if (val_size1 < sizeof(WCHAR) || val_size1 % sizeof(WCHAR) ||
wstr[val_size1 / sizeof(WCHAR) - 1]) {
wstr[val_size1 / sizeof(WCHAR) - 1])
{
REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
} else {
}
else
{
const WCHAR start[] = {'"',0};
const WCHAR end[] = {'"','\n',0};
DWORD len;
@ -1178,14 +1263,14 @@ static void export_hkey(FILE *file, HKEY key,
char* key_nameA = GetMultiByteString(*reg_key_name_buf);
char* value_nameA = GetMultiByteString(*val_name_buf);
fprintf(stderr,"%s: warning - unsupported registry format '%ld', "
"treat as binary\n",
getAppName(), value_type);
"treat as binary\n",
getAppName(), value_type);
fprintf(stderr,"key name: \"%s\"\n", key_nameA);
fprintf(stderr,"value name:\"%s\"\n\n", value_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
HeapFree(GetProcessHeap(), 0, value_nameA);
}
/* falls through */
/* falls through */
case REG_EXPAND_SZ:
case REG_MULTI_SZ:
/* falls through */
@ -1199,30 +1284,40 @@ static void export_hkey(FILE *file, HKEY key,
i = 0;
more_data = TRUE;
(*reg_key_name_buf)[curr_len] = '\\';
while(more_data) {
while(more_data)
{
DWORD buf_size = *reg_key_name_size - curr_len - 1;
ret = RegEnumKeyExW(key, i, *reg_key_name_buf + curr_len + 1, &buf_size,
NULL, NULL, NULL, NULL);
if (ret == ERROR_MORE_DATA) {
NULL, NULL, NULL, NULL);
if (ret == ERROR_MORE_DATA)
{
/* Increase the size of the buffer and retry */
REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size, curr_len + 1 + buf_size);
} else if (ret != ERROR_SUCCESS) {
}
else if (ret != ERROR_SUCCESS)
{
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
if (ret != ERROR_NO_MORE_ITEMS)
{
REGPROC_print_error();
}
} else {
}
else
{
HKEY subkey;
i++;
if (RegOpenKeyW(key, *reg_key_name_buf + curr_len + 1,
&subkey) == ERROR_SUCCESS) {
&subkey) == ERROR_SUCCESS)
{
export_hkey(file, subkey, reg_key_name_buf, reg_key_name_size,
val_name_buf, val_name_size, val_buf, val_size,
line_buf, line_buf_size, unicode);
val_name_buf, val_name_size, val_buf, val_size,
line_buf, line_buf_size, unicode);
RegCloseKey(subkey);
} else {
}
else
{
REGPROC_print_error();
}
}
@ -1246,7 +1341,8 @@ static FILE *REGPROC_open_export_file(WCHAR *file_name, BOOL unicode)
file = _wfopen(file_name, L"wb");
else
file = _wfopen(file_name, L"w");
if (!file) {
if (!file)
{
CHAR* file_nameA = GetMultiByteString(file_name);
perror("");
fprintf(stderr,"%s: Can't open file \"%s\"\n", getAppName(), file_nameA);
@ -1291,75 +1387,87 @@ BOOL export_registry_key(WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
BOOL unicode = (format == REG_FORMAT_5);
reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
reg_key_name_size * sizeof(*reg_key_name_buf));
reg_key_name_size * sizeof(*reg_key_name_buf));
val_name_buf = HeapAlloc(GetProcessHeap(), 0,
val_name_size * sizeof(*val_name_buf));
val_name_size * sizeof(*val_name_buf));
val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
if (reg_key_name && reg_key_name[0]) {
if (reg_key_name && reg_key_name[0])
{
HKEY reg_key_class;
WCHAR *branch_name = NULL;
HKEY key;
REGPROC_resize_char_buffer(&reg_key_name_buf, &reg_key_name_size,
lstrlenW(reg_key_name));
lstrlenW(reg_key_name));
lstrcpyW(reg_key_name_buf, reg_key_name);
/* open the specified key */
if (!parseKeyName(reg_key_name, &reg_key_class, &branch_name)) {
if (!parseKeyName(reg_key_name, &reg_key_class, &branch_name))
{
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
getAppName(), key_nameA);
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
exit(1);
}
if (!branch_name[0]) {
if (!branch_name[0])
{
/* no branch - registry class is specified */
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, reg_key_class,
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
} else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
}
else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS)
{
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, key,
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
RegCloseKey(key);
} else {
}
else
{
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Can't export. Registry key '%s' does not exist!\n",
getAppName(), key_nameA);
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
REGPROC_print_error();
}
} else {
}
else
{
unsigned int i;
/* export all registry classes */
file = REGPROC_open_export_file(file_name, unicode);
for (i = 0; i < REG_CLASS_NUMBER; i++) {
for (i = 0; i < REG_CLASS_NUMBER; i++)
{
/* do not export HKEY_CLASSES_ROOT */
if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
reg_class_keys[i] != HKEY_DYN_DATA) {
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
reg_class_keys[i] != HKEY_DYN_DATA)
{
lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
export_hkey(file, reg_class_keys[i],
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
&reg_key_name_buf, &reg_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
}
}
}
if (file) {
if (file)
{
fclose(file);
}
HeapFree(GetProcessHeap(), 0, reg_key_name);
@ -1382,7 +1490,8 @@ BOOL import_registry_file(FILE* reg_file)
if (s[0] == 0xff && s[1] == 0xfe)
{
processRegLinesW(reg_file);
} else
}
else
{
fseek(reg_file, 0, SEEK_SET);
processRegLinesA(reg_file);
@ -1408,17 +1517,19 @@ void delete_registry_key(WCHAR *reg_key_name)
if (!reg_key_name || !reg_key_name[0])
return;
if (!parseKeyName(reg_key_name, &key_class, &key_name)) {
if (!parseKeyName(reg_key_name, &key_class, &key_name))
{
char* reg_key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
getAppName(), reg_key_nameA);
getAppName(), reg_key_nameA);
HeapFree(GetProcessHeap(), 0, reg_key_nameA);
exit(1);
}
if (!*key_name) {
if (!*key_name)
{
char* reg_key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Can't delete registry class '%s'\n",
getAppName(), reg_key_nameA);
getAppName(), reg_key_nameA);
HeapFree(GetProcessHeap(), 0, reg_key_nameA);
exit(1);
}

256
reactos/base/applications/regedit/treeview.c
View file

@ -42,19 +42,22 @@ static BOOL get_item_path(HWND hwndTV, HTREEITEM hItem, HKEY* phKey, LPTSTR* pKe
item.hItem = hItem;
if (!TreeView_GetItem(hwndTV, &item)) return FALSE;
if (item.lParam) {
/* found root key with valid key value */
*phKey = (HKEY)item.lParam;
return TRUE;
if (item.lParam)
{
/* found root key with valid key value */
*phKey = (HKEY)item.lParam;
return TRUE;
}
if(!get_item_path(hwndTV, TreeView_GetParent(hwndTV, hItem), phKey, pKeyPath, pPathLen, pMaxLen)) return FALSE;
if (*pPathLen) {
if (*pPathLen)
{
(*pKeyPath)[*pPathLen] = _T('\\');
++(*pPathLen);
}
do {
do
{
item.mask = TVIF_TEXT;
item.hItem = hItem;
item.pszText = *pKeyPath + *pPathLen;
@ -62,15 +65,17 @@ static BOOL get_item_path(HWND hwndTV, HTREEITEM hItem, HKEY* phKey, LPTSTR* pKe
item.cchTextMax = (int) maxLen;
if (!TreeView_GetItem(hwndTV, &item)) return FALSE;
len = _tcslen(item.pszText);
if (len < maxLen - 1) {
if (len < maxLen - 1)
{
*pPathLen += (int) len;
break;
}
newStr = HeapReAlloc(GetProcessHeap(), 0, *pKeyPath, *pMaxLen * 2);
if (!newStr) return FALSE;
*pKeyPath = newStr;
*pMaxLen *= 2;
} while(TRUE);
}
newStr = HeapReAlloc(GetProcessHeap(), 0, *pKeyPath, *pMaxLen * 2);
if (!newStr) return FALSE;
*pKeyPath = newStr;
*pMaxLen *= 2;
}
while(TRUE);
return TRUE;
}
@ -87,9 +92,10 @@ LPCTSTR GetItemPath(HWND hwndTV, HTREEITEM hItem, HKEY* phRootKey)
if (maxLen == -1) return NULL;
if (!hItem) hItem = TreeView_GetSelection(hwndTV);
if (!hItem) return NULL;
if (!get_item_path(hwndTV, hItem, phRootKey, &pathBuffer, &pathLen, &maxLen)) {
return NULL;
}
if (!get_item_path(hwndTV, hItem, phRootKey, &pathBuffer, &pathLen, &maxLen))
{
return NULL;
}
return pathBuffer;
}
@ -106,8 +112,10 @@ static HTREEITEM AddEntryToTree(HWND hwndTV, HTREEITEM hParent, LPTSTR label, HK
TVITEM tvi;
TVINSERTSTRUCT tvins;
if (hKey) {
if (RegQueryInfoKey(hKey, 0, 0, 0, &dwChildren, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS) {
if (hKey)
{
if (RegQueryInfoKey(hKey, 0, 0, 0, &dwChildren, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS)
{
dwChildren = 0;
}
}
@ -140,15 +148,20 @@ BOOL RefreshTreeItem(HWND hwndTV, HTREEITEM hItem)
KeyPath = GetItemPath(hwndTV, hItem, &hRoot);
if (*KeyPath) {
if (RegOpenKeyEx(hRoot, KeyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS) {
if (*KeyPath)
{
if (RegOpenKeyEx(hRoot, KeyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
goto done;
}
} else {
}
else
{
hKey = hRoot;
}
if (RegQueryInfoKey(hKey, 0, 0, 0, &dwCount, &dwMaxSubKeyLen, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS) {
if (RegQueryInfoKey(hKey, 0, 0, 0, &dwCount, &dwMaxSubKeyLen, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS)
{
goto done;
}
@ -156,19 +169,22 @@ BOOL RefreshTreeItem(HWND hwndTV, HTREEITEM hItem)
tvItem.mask = TVIF_CHILDREN;
tvItem.hItem = hItem;
tvItem.cChildren = dwCount;
if (!TreeView_SetItem(hwndTV, &tvItem)) {
if (!TreeView_SetItem(hwndTV, &tvItem))
{
goto done;
}
/* We don't have to bother with the rest if it's not expanded. */
if (TreeView_GetItemState(hwndTV, hItem, TVIS_EXPANDED) == 0) {
if (TreeView_GetItemState(hwndTV, hItem, TVIS_EXPANDED) == 0)
{
RegCloseKey(hKey);
bSuccess = TRUE;
goto done;
}
dwMaxSubKeyLen++; /* account for the \0 terminator */
if (!(Name = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(TCHAR)))) {
if (!(Name = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(TCHAR))))
{
goto done;
}
tvItem.cchTextMax = dwMaxSubKeyLen;
@ -185,7 +201,8 @@ BOOL RefreshTreeItem(HWND hwndTV, HTREEITEM hItem)
DWORD dwStep = 10000;
for (childItem = TreeView_GetChild(hwndTV, hItem); childItem;
childItem = TreeView_GetNextSibling(hwndTV, childItem)) {
childItem = TreeView_GetNextSibling(hwndTV, childItem))
{
if (dwActualSize + dwMaxSubKeyLen + 1 > dwPhysicalSize)
{
@ -218,40 +235,50 @@ BOOL RefreshTreeItem(HWND hwndTV, HTREEITEM hItem)
/* Now go through all the children in the tree, and check if any have to be removed. */
childItem = TreeView_GetChild(hwndTV, hItem);
while (childItem) {
while (childItem)
{
HTREEITEM nextItem = TreeView_GetNextSibling(hwndTV, childItem);
if (RefreshTreeItem(hwndTV, childItem) == FALSE) {
if (RefreshTreeItem(hwndTV, childItem) == FALSE)
{
(void)TreeView_DeleteItem(hwndTV, childItem);
}
childItem = nextItem;
}
/* Now go through all the children in the registry, and check if any have to be added. */
/* Now go through all the children in the registry, and check if any have to be added. */
bAddedAny = FALSE;
for (dwIndex = 0; dwIndex < dwCount; dwIndex++) {
for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
{
DWORD cName = dwMaxSubKeyLen, dwSubCount;
BOOL found;
found = FALSE;
if (RegEnumKeyEx(hKey, dwIndex, Name, &cName, 0, 0, 0, NULL) != ERROR_SUCCESS) {
if (RegEnumKeyEx(hKey, dwIndex, Name, &cName, 0, 0, 0, NULL) != ERROR_SUCCESS)
{
continue;
}
/* Check if the node is already in there. */
if (pszNodes) {
for (s = pszNodes; *s; s += _tcslen(s) + 1) {
if (!_tcscmp(s, Name)) {
if (pszNodes)
{
for (s = pszNodes; *s; s += _tcslen(s) + 1)
{
if (!_tcscmp(s, Name))
{
found = TRUE;
break;
}
}
}
if (found == FALSE) {
if (found == FALSE)
{
/* Find the number of children of the node. */
dwSubCount = 0;
if (RegOpenKeyEx(hKey, Name, 0, KEY_QUERY_VALUE, &hSubKey) == ERROR_SUCCESS) {
if (RegQueryInfoKey(hSubKey, 0, 0, 0, &dwSubCount, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS) {
if (RegOpenKeyEx(hKey, Name, 0, KEY_QUERY_VALUE, &hSubKey) == ERROR_SUCCESS)
{
if (RegQueryInfoKey(hSubKey, 0, 0, 0, &dwSubCount, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS)
{
dwSubCount = 0;
}
RegCloseKey(hSubKey);
@ -287,7 +314,8 @@ BOOL RefreshTreeView(HWND hwndTV)
SendMessage(hwndTV, WM_SETREDRAW, FALSE, 0);
hItem = TreeView_GetChild(hwndTV, TreeView_GetRoot(hwndTV));
while (hItem) {
while (hItem)
{
RefreshTreeItem(hwndTV, hItem);
hItem = TreeView_GetNextSibling(hwndTV, hItem);
}
@ -325,7 +353,7 @@ HTREEITEM InsertNode(HWND hwndTV, HTREEITEM hItem, LPTSTR name)
hNewItem = AddEntryToTree(hwndTV, hItem, name, 0, 0);
SendMessage(hwndTV, TVM_SORTCHILDREN, 0, (LPARAM) hItem);
}
else
else
{
item.mask = TVIF_CHILDREN | TVIF_HANDLE;
item.hItem = hItem;
@ -388,11 +416,11 @@ static BOOL InitTreeViewItems(HWND hwndTV, LPTSTR pHostName)
if (!AddEntryToTree(hwndTV, hRoot, _T("HKEY_USERS"), HKEY_USERS, 1)) return FALSE;
if (!AddEntryToTree(hwndTV, hRoot, _T("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG, 1)) return FALSE;
if (GetVersion() & 0x80000000)
if (GetVersion() & 0x80000000)
{
/* Win9x specific key */
if (!AddEntryToTree(hwndTV, hRoot, _T("HKEY_DYN_DATA"), HKEY_DYN_DATA, 1)) return FALSE;
}
}
/* expand and select host name */
(void)TreeView_Expand(hwndTV, hRoot, TVE_EXPAND);
@ -431,8 +459,8 @@ static BOOL InitTreeViewImageLists(HWND hwndTV)
0);
if (hico)
{
Image_Open = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
Image_Open = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
}
hico = LoadImage(hInst,
@ -443,8 +471,8 @@ static BOOL InitTreeViewImageLists(HWND hwndTV)
0);
if (hico)
{
Image_Closed = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
Image_Closed = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
}
hico = LoadImage(hInst,
@ -455,8 +483,8 @@ static BOOL InitTreeViewImageLists(HWND hwndTV)
0);
if (hico)
{
Image_Root = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
Image_Root = ImageList_AddIcon(himl, hico);
DestroyIcon(hico);
}
/* Fail if not all of the images were added. */
@ -483,7 +511,8 @@ BOOL OnTreeExpanding(HWND hwndTV, NMTREEVIEW* pnmtv)
static int expanding;
if (expanding) return FALSE;
if (pnmtv->itemNew.state & TVIS_EXPANDEDONCE ) {
if (pnmtv->itemNew.state & TVIS_EXPANDEDONCE )
{
return TRUE;
}
expanding = TRUE;
@ -493,11 +522,14 @@ BOOL OnTreeExpanding(HWND hwndTV, NMTREEVIEW* pnmtv)
keyPath = GetItemPath(hwndTV, pnmtv->itemNew.hItem, &hRoot);
if (!keyPath) goto done;
if (*keyPath) {
if (*keyPath)
{
errCode = RegOpenKeyEx(hRoot, keyPath, 0, KEY_READ, &hNewKey);
if (errCode != ERROR_SUCCESS) goto done;
} else {
hNewKey = hRoot;
}
else
{
hNewKey = hRoot;
}
errCode = RegQueryInfoKey(hNewKey, 0, 0, 0, &dwCount, &dwMaxSubKeyLen, 0, 0, 0, 0, 0, 0);
@ -506,13 +538,15 @@ BOOL OnTreeExpanding(HWND hwndTV, NMTREEVIEW* pnmtv)
Name = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(TCHAR));
if (!Name) goto done;
for (dwIndex = 0; dwIndex < dwCount; dwIndex++) {
for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
{
DWORD cName = dwMaxSubKeyLen, dwSubCount;
errCode = RegEnumKeyEx(hNewKey, dwIndex, Name, &cName, 0, 0, 0, 0);
if (errCode != ERROR_SUCCESS) continue;
errCode = RegOpenKeyEx(hNewKey, Name, 0, KEY_QUERY_VALUE, &hKey);
if (errCode == ERROR_SUCCESS) {
if (errCode == ERROR_SUCCESS)
{
errCode = RegQueryInfoKey(hKey, 0, 0, 0, &dwSubCount, 0, 0, 0, 0, 0, 0, 0);
RegCloseKey(hKey);
}
@ -611,88 +645,90 @@ HWND CreateTreeView(HWND hwndParent, LPTSTR pHostName, HMENU id)
0, 0, rcClient.right, rcClient.bottom,
hwndParent, id, hInst, NULL);
/* Initialize the image list, and add items to the control. */
if (!InitTreeViewImageLists(hwndTV) || !InitTreeViewItems(hwndTV, pHostName)) {
if (!InitTreeViewImageLists(hwndTV) || !InitTreeViewItems(hwndTV, pHostName))
{
DestroyWindow(hwndTV);
return NULL;
}
return hwndTV;
}
void DestroyTreeView() {
if (pathBuffer)
HeapFree(GetProcessHeap(), 0, pathBuffer);
void DestroyTreeView()
{
if (pathBuffer)
HeapFree(GetProcessHeap(), 0, pathBuffer);
}
BOOL SelectNode(HWND hwndTV, LPCTSTR keyPath)
{
HTREEITEM hRoot, hItem;
HTREEITEM hChildItem;
TCHAR szPathPart[128];
TCHAR szBuffer[128];
LPCTSTR s;
TVITEM tvi;
HTREEITEM hRoot, hItem;
HTREEITEM hChildItem;
TCHAR szPathPart[128];
TCHAR szBuffer[128];
LPCTSTR s;
TVITEM tvi;
/* Total no-good hack */
if (!_tcsnicmp(keyPath, _T("My Computer\\"), 12))
keyPath += 12;
hRoot = TreeView_GetRoot(hwndTV);
hItem = hRoot;
hRoot = TreeView_GetRoot(hwndTV);
hItem = hRoot;
while(keyPath[0])
{
s = _tcschr(keyPath, TEXT('\\'));
lstrcpyn(szPathPart, keyPath, s ? s - keyPath + 1 : _tcslen(keyPath) + 1);
while(keyPath[0])
{
s = _tcschr(keyPath, TEXT('\\'));
lstrcpyn(szPathPart, keyPath, s ? s - keyPath + 1 : _tcslen(keyPath) + 1);
/* Special case for root to expand root key abbreviations */
if (hItem == hRoot)
{
if (!_tcsicmp(szPathPart, TEXT("HKCR")))
_tcscpy(szPathPart, TEXT("HKEY_CLASSES_ROOT"));
else if (!_tcsicmp(szPathPart, TEXT("HKCU")))
_tcscpy(szPathPart, TEXT("HKEY_CURRENT_USER"));
else if (!_tcsicmp(szPathPart, TEXT("HKLM")))
_tcscpy(szPathPart, TEXT("HKEY_LOCAL_MACHINE"));
else if (!_tcsicmp(szPathPart, TEXT("HKU")))
_tcscpy(szPathPart, TEXT("HKEY_USERS"));
else if (!_tcsicmp(szPathPart, TEXT("HKCC")))
_tcscpy(szPathPart, TEXT("HKEY_CURRENT_CONFIG"));
else if (!_tcsicmp(szPathPart, TEXT("HKDD")))
_tcscpy(szPathPart, TEXT("HKEY_DYN_DATA"));
}
/* Special case for root to expand root key abbreviations */
if (hItem == hRoot)
{
if (!_tcsicmp(szPathPart, TEXT("HKCR")))
_tcscpy(szPathPart, TEXT("HKEY_CLASSES_ROOT"));
else if (!_tcsicmp(szPathPart, TEXT("HKCU")))
_tcscpy(szPathPart, TEXT("HKEY_CURRENT_USER"));
else if (!_tcsicmp(szPathPart, TEXT("HKLM")))
_tcscpy(szPathPart, TEXT("HKEY_LOCAL_MACHINE"));
else if (!_tcsicmp(szPathPart, TEXT("HKU")))
_tcscpy(szPathPart, TEXT("HKEY_USERS"));
else if (!_tcsicmp(szPathPart, TEXT("HKCC")))
_tcscpy(szPathPart, TEXT("HKEY_CURRENT_CONFIG"));
else if (!_tcsicmp(szPathPart, TEXT("HKDD")))
_tcscpy(szPathPart, TEXT("HKEY_DYN_DATA"));
}
for (hChildItem = TreeView_GetChild(hwndTV, hItem); hChildItem;
hChildItem = TreeView_GetNextSibling(hwndTV, hChildItem))
{
memset(&tvi, 0, sizeof(tvi));
tvi.hItem = hChildItem;
tvi.mask = TVIF_TEXT | TVIF_CHILDREN;
tvi.pszText = szBuffer;
tvi.cchTextMax = sizeof(szBuffer) / sizeof(szBuffer[0]);
for (hChildItem = TreeView_GetChild(hwndTV, hItem); hChildItem;
hChildItem = TreeView_GetNextSibling(hwndTV, hChildItem))
{
memset(&tvi, 0, sizeof(tvi));
tvi.hItem = hChildItem;
tvi.mask = TVIF_TEXT | TVIF_CHILDREN;
tvi.pszText = szBuffer;
tvi.cchTextMax = sizeof(szBuffer) / sizeof(szBuffer[0]);
(void)TreeView_GetItem(hwndTV, &tvi);
(void)TreeView_GetItem(hwndTV, &tvi);
if (!_tcsicmp(szBuffer, szPathPart))
break;
}
if (!_tcsicmp(szBuffer, szPathPart))
break;
}
if (!hChildItem)
return FALSE;
if (!hChildItem)
return FALSE;
if (tvi.cChildren > 0)
{
if (!TreeView_Expand(hwndTV, hChildItem, TVE_EXPAND))
return FALSE;
}
if (tvi.cChildren > 0)
{
if (!TreeView_Expand(hwndTV, hChildItem, TVE_EXPAND))
return FALSE;
}
keyPath = s ? s + 1 : _T("");
hItem = hChildItem;
}
keyPath = s ? s + 1 : _T("");
hItem = hChildItem;
}
(void)TreeView_SelectItem(hwndTV, hItem);
(void)TreeView_EnsureVisible(hwndTV, hItem);
(void)TreeView_SelectItem(hwndTV, hItem);
(void)TreeView_EnsureVisible(hwndTV, hItem);
return TRUE;
return TRUE;
}