#include "resource.h"

Include dependency graph for main.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	ChildWnd

Macros
#define	STATUS_WINDOW 2001

#define	TREE_WINDOW 2002

#define	LIST_WINDOW 2003

#define	SPLIT_WIDTH 5

#define	SPLIT_MIN 30

#define	ARRAY_SIZE(A) (sizeof(A)/sizeof(*A))

#define	PM_MODIFYVALUE 0

#define	PM_NEW 1

#define	PM_TREECONTEXT 2

#define	PM_ROOTITEM 3

#define	PM_HEXEDIT 4

#define	MAX_NEW_KEY_LEN 128

#define	KEY_MAX_LEN 1024

#define	REG_FORMAT_5 1

#define	REG_FORMAT_4 2

Enumerations
enum	OPTION_FLAGS { OPTIONS_AUTO_REFRESH = 0x01, OPTIONS_READ_ONLY_MODE = 0x02, OPTIONS_CONFIRM_ON_DELETE = 0x04, OPTIONS_SAVE_ON_EXIT = 0x08, OPTIONS_DISPLAY_BINARY_DATA = 0x10, OPTIONS_VIEW_TREE_ONLY = 0x20, OPTIONS_VIEW_DATA_ONLY = 0x40 }

Functions
void	ShowAboutBox (HWND hWnd)

LRESULT CALLBACK	ChildWndProc (HWND, UINT, WPARAM, LPARAM)

void	ResizeWnd (int cx, int cy)

LPCWSTR	get_root_key_name (HKEY hRootKey)

VOID	UpdateAddress (HTREEITEM hItem, HKEY hRootKey, LPCWSTR pszPath)

BOOL	ModifyValue (HWND hwnd, HKEY hKey, LPCWSTR valueName, BOOL EditBin)

BOOL	DeleteKey (HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath)

LONG	RenameKey (HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpNewName)

LONG	RenameValue (HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpDestValue, LPCWSTR lpSrcValue)

LONG	QueryStringValue (HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpValueName, LPWSTR pszBuffer, DWORD dwBufferLen)

BOOL	GetKeyName (LPWSTR pszDest, size_t iDestLength, HKEY hRootKey, LPCWSTR lpSubKey)

int	ErrorMessageBox (HWND hWnd, LPCWSTR lpTitle, DWORD dwErrorCode,...)

int	InfoMessageBox (HWND hWnd, UINT uType, LPCWSTR lpTitle, LPCWSTR lpMessage,...)

void	FindDialog (HWND hWnd)

BOOL	FindNext (HWND hWnd)

void	FindNextMessageBox (HWND hWnd)

LRESULT CALLBACK	FrameWndProc (HWND, UINT, WPARAM, LPARAM)

void	SetupStatusBar (HWND hWnd, BOOL bResize)

void	UpdateStatusBar (void)

BOOL	CopyKeyName (HWND hWnd, HKEY hRootKey, LPCWSTR keyName)

BOOL	ExportRegistryFile (HWND hWnd)

HWND	CreateListView (HWND hwndParent, HMENU id, INT cx)

BOOL	RefreshListView (HWND hwndLV, HKEY hKey, LPCWSTR keyPath)

WCHAR *	GetValueName (HWND hwndLV, int iStartAt)

BOOL	ListWndNotifyProc (HWND hWnd, WPARAM wParam, LPARAM lParam, BOOL *Result)

BOOL	TreeWndNotifyProc (HWND hWnd, WPARAM wParam, LPARAM lParam, BOOL *Result)

BOOL	IsDefaultValue (HWND hwndLV, int i)

void WINAPIV	output_message (unsigned int id,...)

void WINAPIV	error_exit (unsigned int id,...)

char *	GetMultiByteString (const WCHAR *strW)

BOOL	import_registry_file (FILE *reg_file)

void	delete_registry_key (WCHAR *reg_key_name)

BOOL	export_registry_key (WCHAR file_name, WCHAR path, DWORD format)

BOOL	RegKeyEditPermissions (HWND hWndOwner, HKEY hKey, LPCWSTR lpMachine, LPCWSTR lpKeyName)

void	LoadSettings (void)

void	SaveSettings (void)

HWND	CreateTreeView (HWND hwndParent, LPWSTR pHostName, HMENU id)

BOOL	RefreshTreeView (HWND hWndTV)

BOOL	RefreshTreeItem (HWND hwndTV, HTREEITEM hItem)

BOOL	OnTreeExpanding (HWND hWnd, NMTREEVIEW *pnmtv)

LPCWSTR	GetItemPath (HWND hwndTV, HTREEITEM hItem, HKEY *phRootKey)

BOOL	DeleteNode (HWND hwndTV, HTREEITEM hItem)

HTREEITEM	InsertNode (HWND hwndTV, HTREEITEM hItem, LPWSTR name)

HWND	StartKeyRename (HWND hwndTV)

BOOL	CreateNewKey (HWND hwndTV, HTREEITEM hItem)

BOOL	SelectNode (HWND hwndTV, LPCWSTR keyPath)

void	DestroyTreeView (HWND hwndTV)

void	DestroyListView (HWND hwndLV)

void	DestroyMainMenu (void)

Variables
ChildWnd *	g_pChildWnd

HINSTANCE	hInst

HWND	hFrameWnd

HMENU	hMenuFrame

HWND	hStatusBar

HMENU	hPopupMenus

HFONT	hFont

enum OPTION_FLAGS	Options

WCHAR	szTitle []

WCHAR	szFrameClass []

WCHAR	szChildClass []

const WCHAR	g_szGeneralRegKey []

const WCHAR *	reg_class_namesW []

Macro Definition Documentation

◆ ARRAY_SIZE

#define ARRAY_SIZE ( A ) (sizeof(A)/sizeof(*A))

Definition at line 33 of file main.h.

◆ KEY_MAX_LEN

#define KEY_MAX_LEN 1024

Definition at line 42 of file main.h.

◆ LIST_WINDOW

#define LIST_WINDOW 2003

Definition at line 28 of file main.h.

◆ MAX_NEW_KEY_LEN

#define MAX_NEW_KEY_LEN 128

Definition at line 41 of file main.h.

◆ PM_HEXEDIT

#define PM_HEXEDIT 4

Definition at line 39 of file main.h.

◆ PM_MODIFYVALUE

#define PM_MODIFYVALUE 0

Definition at line 35 of file main.h.

◆ PM_NEW

#define PM_NEW 1

Definition at line 36 of file main.h.

◆ PM_ROOTITEM

#define PM_ROOTITEM 3

Definition at line 38 of file main.h.

◆ PM_TREECONTEXT

#define PM_TREECONTEXT 2

Definition at line 37 of file main.h.

◆ REG_FORMAT_4

#define REG_FORMAT_4 2

Definition at line 45 of file main.h.

◆ REG_FORMAT_5

#define REG_FORMAT_5 1

Definition at line 44 of file main.h.

◆ SPLIT_MIN

#define SPLIT_MIN 30

Definition at line 31 of file main.h.

◆ SPLIT_WIDTH

#define SPLIT_WIDTH 5

Definition at line 30 of file main.h.

◆ STATUS_WINDOW

#define STATUS_WINDOW 2001

Definition at line 26 of file main.h.

◆ TREE_WINDOW

#define TREE_WINDOW 2002

Definition at line 27 of file main.h.

Enumeration Type Documentation

◆ OPTION_FLAGS

enum OPTION_FLAGS

Enumerator
OPTIONS_AUTO_REFRESH
OPTIONS_READ_ONLY_MODE
OPTIONS_CONFIRM_ON_DELETE
OPTIONS_SAVE_ON_EXIT
OPTIONS_DISPLAY_BINARY_DATA
OPTIONS_VIEW_TREE_ONLY
OPTIONS_VIEW_DATA_ONLY

Definition at line 49 of file main.h.

 {
     OPTIONS_AUTO_REFRESH        = 0x01,
     OPTIONS_READ_ONLY_MODE      = 0x02,
     OPTIONS_CONFIRM_ON_DELETE   = 0x04,
     OPTIONS_SAVE_ON_EXIT        = 0x08,
     OPTIONS_DISPLAY_BINARY_DATA = 0x10,
     OPTIONS_VIEW_TREE_ONLY      = 0x20,
     OPTIONS_VIEW_DATA_ONLY      = 0x40,
 };

Function Documentation

◆ ChildWndProc()

LRESULT CALLBACK ChildWndProc	(	HWND	,
		UINT	,
		WPARAM	,
		LPARAM
	)

Definition at line 301 of file childwnd.c.

 {
     BOOL Result;
     RECT rc;
 
     switch (message)
     {
     case WM_CREATE:
     {
         WNDPROC oldproc;
         HFONT hFont;
         WCHAR buffer[MAX_PATH];
         DWORD style;
 
         /* Load "My Computer" string */
         LoadStringW(hInst, IDS_MY_COMPUTER, buffer, ARRAY_SIZE(buffer));
 
         g_pChildWnd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ChildWnd));
         if (!g_pChildWnd) return 0;
 
         wcsncpy(g_pChildWnd->szPath, buffer, MAX_PATH);
         g_pChildWnd->nSplitPos = 190;
         g_pChildWnd->hWnd = hWnd;
 
         style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
         g_pChildWnd->hAddressBarWnd = CreateWindowExW(WS_EX_CLIENTEDGE, L"Edit", NULL, style,
                                                       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                                                       hWnd, (HMENU)0, hInst, 0);
 
         style = WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_ICON | BS_CENTER |
                 BS_VCENTER | BS_FLAT | BS_DEFPUSHBUTTON;
         g_pChildWnd->hAddressBtnWnd = CreateWindowExW(0, L"Button", L"\x00BB", style,
                                                       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                                                       hWnd, (HMENU)0, hInst, 0);
         g_pChildWnd->hArrowIcon = (HICON)LoadImageW(hInst, MAKEINTRESOURCEW(IDI_ARROW),
                                                     IMAGE_ICON, 12, 12, 0);
         SendMessageW(g_pChildWnd->hAddressBtnWnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM)g_pChildWnd->hArrowIcon);
 
         GetClientRect(hWnd, &rc);
         g_pChildWnd->hTreeWnd = CreateTreeView(hWnd, g_pChildWnd->szPath, (HMENU) TREE_WINDOW);
         g_pChildWnd->hListWnd = CreateListView(hWnd, (HMENU) LIST_WINDOW, rc.right - g_pChildWnd->nSplitPos);
         SetFocus(g_pChildWnd->hTreeWnd);
 
         /* set the address bar and button font */
         if ((g_pChildWnd->hAddressBarWnd) && (g_pChildWnd->hAddressBtnWnd))
         {
             hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
             SendMessageW(g_pChildWnd->hAddressBarWnd,
                          WM_SETFONT,
                          (WPARAM)hFont,
                          0);
             SendMessageW(g_pChildWnd->hAddressBtnWnd,
                          WM_SETFONT,
                          (WPARAM)hFont,
                          0);
         }
         /* Subclass the AddressBar */
         oldproc = (WNDPROC)GetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC);
         SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_USERDATA, (DWORD_PTR)oldproc);
         SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC, (DWORD_PTR)AddressBarProc);
         break;
     }
     case WM_COMMAND:
         if(HIWORD(wParam) == BN_CLICKED)
         {
             PostMessageW(g_pChildWnd->hAddressBarWnd, WM_KEYUP, VK_RETURN, 0);
         }
         break; //goto def;
     case WM_SETCURSOR:
         if (LOWORD(lParam) == HTCLIENT)
         {
             POINT pt;
             GetCursorPos(&pt);
             ScreenToClient(hWnd, &pt);
             if (pt.x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && pt.x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
             {
                 SetCursor(LoadCursorW(0, IDC_SIZEWE));
                 return TRUE;
             }
         }
         goto def;
     case WM_DESTROY:
         DestroyListView(g_pChildWnd->hListWnd);
         DestroyTreeView(g_pChildWnd->hTreeWnd);
         DestroyMainMenu();
         DestroyIcon(g_pChildWnd->hArrowIcon);
         free(g_pChildWnd);
         g_pChildWnd = NULL;
         PostQuitMessage(0);
         break;
     case WM_LBUTTONDOWN:
     {
         RECT rt;
         int x = (short)LOWORD(lParam);
         GetClientRect(hWnd, &rt);
         if (x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
         {
             last_split = g_pChildWnd->nSplitPos;
             draw_splitbar(hWnd, last_split);
             SetCapture(hWnd);
         }
         break;
     }
 
     case WM_LBUTTONUP:
     case WM_RBUTTONDOWN:
         if (GetCapture() == hWnd)
         {
             finish_splitbar(hWnd, LOWORD(lParam));
         }
         break;
 
     case WM_CAPTURECHANGED:
         if (GetCapture()==hWnd && last_split>=0)
             draw_splitbar(hWnd, last_split);
         break;
 
     case WM_KEYDOWN:
         if (wParam == VK_ESCAPE)
             if (GetCapture() == hWnd)
             {
                 RECT rt;
                 draw_splitbar(hWnd, last_split);
                 GetClientRect(hWnd, &rt);
                 ResizeWnd(rt.right, rt.bottom);
                 last_split = -1;
                 ReleaseCapture();
                 SetCursor(LoadCursorW(0, IDC_ARROW));
             }
         break;
 
     case WM_MOUSEMOVE:
         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);
             }
             if(!SizingBrush)
             {
                 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);
             }
         }
         break;
 
     case WM_SETFOCUS:
         if (g_pChildWnd != NULL)
         {
             SetFocus(g_pChildWnd->nFocusPanel? g_pChildWnd->hListWnd: g_pChildWnd->hTreeWnd);
         }
         break;
 
     case WM_TIMER:
         break;
 
     case WM_NOTIFY:
         if (g_pChildWnd == NULL) break;
 
         if (((LPNMHDR)lParam)->idFrom == TREE_WINDOW)
         {
             if (!TreeWndNotifyProc(g_pChildWnd->hListWnd, wParam, lParam, &Result))
             {
                 goto def;
             }
 
             return Result;
         }
         else
         {
             if (((LPNMHDR)lParam)->idFrom == LIST_WINDOW)
             {
                 if (!ListWndNotifyProc(g_pChildWnd->hListWnd, wParam, lParam, &Result))
                 {
                     goto def;
                 }
 
                 return Result;
             }
             else
             {
                 goto def;
             }
         }
         break;
 
     case WM_CONTEXTMENU:
     {
         POINT pt;
         if((HWND)wParam == g_pChildWnd->hListWnd)
         {
             int i, cnt;
             BOOL IsDefault;
             pt.x = (short) LOWORD(lParam);
             pt.y = (short) HIWORD(lParam);
             cnt = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
             i = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_FOCUSED | LVNI_SELECTED);
             if (pt.x == -1 && pt.y == -1)
             {
                 RECT rc;
                 if (i != -1)
                 {
                     rc.left = LVIR_BOUNDS;
                     SendMessageW(g_pChildWnd->hListWnd, LVM_GETITEMRECT, i, (LPARAM) &rc);
                     pt.x = rc.left + 8;
                     pt.y = rc.top + 8;
                 }
                 else
                     pt.x = pt.y = 0;
                 ClientToScreen(g_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(g_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 == g_pChildWnd->hTreeWnd)
         {
             TVHITTESTINFO hti;
             HMENU hContextMenu;
             TVITEMW item;
             MENUITEMINFOW mii;
             WCHAR resource[256];
             WCHAR buffer[256];
             LPWSTR s;
             LPCWSTR keyPath;
             HKEY hRootKey;
             int iLastPos;
             WORD wID;
             BOOL isRoot;
 
             pt.x = (short) LOWORD(lParam);
             pt.y = (short) HIWORD(lParam);
 
             if (pt.x == -1 && pt.y == -1)
             {
                 RECT rc;
                 hti.hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
                 if (hti.hItem != NULL)
                 {
                     TreeView_GetItemRect(g_pChildWnd->hTreeWnd, hti.hItem, &rc, TRUE);
                     pt.x = rc.left + 8;
                     pt.y = rc.top + 8;
                     ClientToScreen(g_pChildWnd->hTreeWnd, &pt);
                     hti.flags = TVHT_ONITEM;
                 }
                 else
                     hti.flags = 0;
             }
             else
             {
                 hti.pt.x = pt.x;
                 hti.pt.y = pt.y;
                 ScreenToClient(g_pChildWnd->hTreeWnd, &hti.pt);
                 TreeView_HitTest(g_pChildWnd->hTreeWnd, &hti);
             }
 
             if (hti.flags & TVHT_ONITEM)
             {
                 TreeView_SelectItem(g_pChildWnd->hTreeWnd, hti.hItem);
 
                 isRoot = (TreeView_GetParent(g_pChildWnd->hTreeWnd, hti.hItem) == NULL);
                 hContextMenu = GetSubMenu(hPopupMenus, isRoot ?  PM_ROOTITEM : PM_TREECONTEXT);
 
                 memset(&item, 0, sizeof(item));
                 item.mask = TVIF_STATE | TVIF_CHILDREN;
                 item.hItem = hti.hItem;
                 TreeView_GetItem(g_pChildWnd->hTreeWnd, &item);
 
                 /* Set the Expand/Collapse menu item appropriately */
                 LoadStringW(hInst, (item.state & TVIS_EXPANDED) ? IDS_COLLAPSE : IDS_EXPAND, buffer, ARRAY_SIZE(buffer));
                 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 = (LPWSTR) buffer;
                 SetMenuItemInfo(hContextMenu, 0, TRUE, &mii);
 
                 if (isRoot == FALSE)
                 {
                     /* 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(g_pChildWnd->hTreeWnd, NULL, &hRootKey);
                     SuggestKeys(hRootKey, keyPath, Suggestions, ARRAY_SIZE(Suggestions));
                     if (Suggestions[0])
                     {
                         AppendMenu(hContextMenu, MF_SEPARATOR, 0, NULL);
 
                         LoadStringW(hInst, IDS_GOTO_SUGGESTED_KEY, resource, ARRAY_SIZE(resource));
 
                         s = Suggestions;
                         wID = ID_TREE_SUGGESTION_MIN;
                         while(*s && (wID <= ID_TREE_SUGGESTION_MAX))
                         {
                             _snwprintf(buffer, ARRAY_SIZE(buffer), 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 += wcslen(s) + 1;
                         }
                     }
                 }
                 TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd/*g_pChildWnd->hWnd*/, NULL);
             }
         }
         break;
     }
 
     case WM_SIZE:
         if (wParam != SIZE_MINIMIZED && g_pChildWnd != NULL)
         {
             ResizeWnd(LOWORD(lParam), HIWORD(lParam));
         }
         /* fall through */
     default:
 def:
         return DefWindowProcW(hWnd, message, wParam, lParam);
     }
     return 0;
 }

◆ CopyKeyName()

BOOL CopyKeyName	(	HWND	hWnd,
		HKEY	hRootKey,
		LPCWSTR	keyName
	)

Definition at line 784 of file framewnd.c.

 {
     BOOL bClipboardOpened = FALSE;
     BOOL bSuccess = FALSE;
     WCHAR szBuffer[512];
     HGLOBAL hGlobal;
     LPWSTR s;
 
     if (!OpenClipboard(hWnd))
         goto done;
     bClipboardOpened = TRUE;
 
     if (!EmptyClipboard())
         goto done;
 
     if (!GetKeyName(szBuffer, ARRAY_SIZE(szBuffer), hRootKey, keyName))
         goto done;
 
     hGlobal = GlobalAlloc(GMEM_MOVEABLE, (wcslen(szBuffer) + 1) * sizeof(WCHAR));
     if (!hGlobal)
         goto done;
 
     s = GlobalLock(hGlobal);
     wcscpy(s, szBuffer);
     GlobalUnlock(hGlobal);
 
     SetClipboardData(CF_UNICODETEXT, hGlobal);
     bSuccess = TRUE;
 
 done:
     if (bClipboardOpened)
         CloseClipboard();
     return bSuccess;
 }

Referenced by _CmdWndProc().

◆ CreateListView()

HWND CreateListView	(	HWND	hwndParent,
		HMENU	id,
		INT	cx
	)

Definition at line 631 of file listview.c.

 {
     RECT rcClient;
     HWND hwndLV;
 
     /* Get the dimensions of the parent window's client area, and create the list view control. */
     GetClientRect(hwndParent, &rcClient);
     hwndLV = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEW, L"List View",
                              WS_VISIBLE | WS_CHILD | WS_TABSTOP | LVS_REPORT | LVS_EDITLABELS | LVS_SHOWSELALWAYS,
                              0, 0, rcClient.right, rcClient.bottom,
                              hwndParent, id, hInst, NULL);
     if (!hwndLV) return NULL;
 
     /* Initialize the image list, and add items to the control. */
     if (!CreateListColumns(hwndLV, cx)) goto fail;
     if (!InitListViewImageLists(hwndLV)) goto fail;
 
     return hwndLV;
 fail:
     DestroyWindow(hwndLV);
     return NULL;
 }

◆ CreateNewKey()

BOOL CreateNewKey	(	HWND	hwndTV,
		HTREEITEM	hItem
	)

Definition at line 573 of file treeview.c.

 {
     WCHAR szNewKeyFormat[128];
     WCHAR szNewKey[128];
     LPCWSTR pszKeyPath;
     int iIndex = 1;
     LONG nResult;
     HKEY hRootKey = NULL, hKey = NULL, hNewKey = NULL;
     BOOL bSuccess = FALSE;
     DWORD dwDisposition;
     HTREEITEM hNewItem;
 
     pszKeyPath = GetItemPath(hwndTV, hItem, &hRootKey);
     if (pszKeyPath[0] == L'\0')
         hKey = hRootKey;
     else if (RegOpenKeyW(hRootKey, pszKeyPath, &hKey) != ERROR_SUCCESS)
         goto done;
 
     if (LoadStringW(hInst, IDS_NEW_KEY, szNewKeyFormat, ARRAY_SIZE(szNewKeyFormat)) <= 0)
         goto done;
 
     /* Need to create a new key with a unique name */
     do
     {
         wsprintf(szNewKey, szNewKeyFormat, iIndex++);
         nResult = RegCreateKeyExW(hKey, szNewKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hNewKey, &dwDisposition);
         if (hNewKey && dwDisposition == REG_OPENED_EXISTING_KEY)
         {
             RegCloseKey(hNewKey);
             hNewKey = NULL;
         }
         else if (!hNewKey)
         {
             InfoMessageBox(hFrameWnd, MB_OK | MB_ICONERROR, NULL, L"Cannot create new key!\n\nError Code: %d", nResult);
             goto done;
         }
     }
     while(!hNewKey);
 
     /* Insert the new key */
     hNewItem = InsertNode(hwndTV, hItem, szNewKey);
     if (!hNewItem)
         goto done;
 
     /* The new key's name is probably not appropriate yet */
     (void)TreeView_EditLabel(hwndTV, hNewItem);
 
     bSuccess = TRUE;
 
 done:
     if (hKey != hRootKey && hKey)
         RegCloseKey(hKey);
     if (hNewKey)
         RegCloseKey(hNewKey);
     return bSuccess;
 }

Referenced by _CmdWndProc().

◆ CreateTreeView()

HWND CreateTreeView	(	HWND	hwndParent,
		LPWSTR	pHostName,
		HMENU	id
	)

Definition at line 740 of file treeview.c.

 {
     RECT rcClient;
     HWND hwndTV;
 
     /* Get the dimensions of the parent window's client area, and create the tree view control.  */
     GetClientRect(hwndParent, &rcClient);
     hwndTV = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEW, NULL,
                             WS_VISIBLE | WS_CHILD | WS_TABSTOP | TVS_HASLINES | TVS_HASBUTTONS | TVS_LINESATROOT | TVS_EDITLABELS | TVS_SHOWSELALWAYS,
                             0, 0, rcClient.right, rcClient.bottom,
                             hwndParent, id, hInst, NULL);
     if (!hwndTV) return NULL;
 
     /* Initialize the image list, and add items to the control.  */
     if (!InitTreeViewImageLists(hwndTV) || !InitTreeViewItems(hwndTV, pHostName))
     {
         DestroyWindow(hwndTV);
         return NULL;
     }
     return hwndTV;
 }

Referenced by ChildWndProc().

◆ delete_registry_key()

void delete_registry_key ( WCHAR * reg_key_name )

Definition at line 1097 of file regproc.c.

 {
     WCHAR *key_name = NULL;
     HKEY key_class;
 
     if (!reg_key_name || !reg_key_name[0])
         return;
 
     if (!(key_class = parse_key_name(reg_key_name, &key_name)))
     {
         if (key_name) *(key_name - 1) = 0;
         error_exit(STRING_INVALID_SYSTEM_KEY, reg_key_name);
     }
 
     if (!key_name || !*key_name)
         error_exit(STRING_DELETE_FAILED, reg_key_name);
 
 #ifdef __REACTOS__
     SHDeleteKey(key_class, key_name);
 #else
     RegDeleteTreeW(key_class, key_name);
 #endif
 }

Referenced by delete_key_state(), and PerformRegAction().

◆ DeleteKey()

BOOL DeleteKey	(	HWND	hwnd,
		HKEY	hKeyRoot,
		LPCWSTR	keyPath
	)

Definition at line 1456 of file edit.c.

 {
     WCHAR msg[128], caption[128];
     BOOL result = FALSE;
     LONG lRet;
     HKEY hKey;
 
     lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ|KEY_SET_VALUE, &hKey);
     if (lRet != ERROR_SUCCESS)
     {
         error_code_messagebox(hwnd, lRet);
         return FALSE;
     }
 
     LoadStringW(hInst, IDS_QUERY_DELETE_KEY_CONFIRM, caption, ARRAY_SIZE(caption));
     LoadStringW(hInst, IDS_QUERY_DELETE_KEY_ONE, msg, ARRAY_SIZE(msg));
 
     if (MessageBoxW(g_pChildWnd->hWnd, msg, caption, MB_ICONQUESTION | MB_YESNO) != IDYES)
         goto done;
 
     lRet = SHDeleteKey(hKeyRoot, keyPath);
     if (lRet != ERROR_SUCCESS)
     {
         error(hwnd, IDS_BAD_KEY, keyPath);
         goto done;
     }
     result = TRUE;
 
 done:
     RegCloseKey(hKey);
     return result;
 }

Referenced by _CmdWndProc(), and DECLARE_INTERFACE_().

◆ DeleteNode()

BOOL DeleteNode	(	HWND	hwndTV,
		HTREEITEM	hItem
	)

Definition at line 107 of file treeview.c.

 {
     if (!hItem) hItem = TreeView_GetSelection(hwndTV);
     if (!hItem) return FALSE;
     return TreeView_DeleteItem(hwndTV, hItem);
 }

◆ DestroyListView()

void DestroyListView ( HWND hwndLV )

Definition at line 654 of file listview.c.

 {
     INT count, i;
     LVITEMW item;
 
     count = ListView_GetItemCount(hwndLV);
     for (i = 0; i < count; i++)
     {
         item.mask = LVIF_PARAM;
         item.iItem = i;
         (void)ListView_GetItem(hwndLV, &item);
         free(((LINE_INFO*)item.lParam)->name);
         HeapFree(GetProcessHeap(), 0, (void*)item.lParam);
     }
 
 }

Referenced by ChildWndProc(), and RefreshListView().

◆ DestroyMainMenu()

void DestroyMainMenu ( void )

Definition at line 164 of file main.c.

 {
     DestroyMenu(hMenuFrame);
 }

Referenced by ChildWndProc().

◆ DestroyTreeView()

void DestroyTreeView ( HWND hwndTV )

Definition at line 762 of file treeview.c.

 {
     HIMAGELIST himl;
 
     if (pathBuffer) HeapFree(GetProcessHeap(), 0, pathBuffer);
 
     /* Destroy the image list associated with the tree view control */
     himl = TreeView_GetImageList(hwndTV, TVSIL_NORMAL);
     if (himl) ImageList_Destroy(himl);
 }

◆ error_exit()

void WINAPIV error_exit	(	unsigned int	id,
			...
	)

Definition at line 103 of file regedit.c.

 {
     WCHAR fmt[1536];
     va_list va_args;
 
     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
     {
 #ifndef __REACTOS__
         WINE_FIXME("LoadString failed with %lu\n", GetLastError());
 #endif
         return;
     }
     va_start(va_args, id);
     output_formatstring(fmt, va_args);
     va_end(va_args);
 
     exit(0); /* regedit.exe always terminates with error code zero */
 }

Referenced by delete_registry_key(), PerformRegAction(), ProcessCmdLine(), and REGPROC_open_export_file().

◆ ErrorMessageBox()

int ErrorMessageBox	(	HWND	hWnd,
		LPCWSTR	lpTitle,
		DWORD	dwErrorCode,
			...
	)

Definition at line 24 of file error.c.

 {
     int iRet = 0;
     LPWSTR lpMsgBuf = NULL;
     DWORD Status = 0;
     va_list args;
 
     va_start(args, dwErrorCode);
 
     Status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                             NULL,
                             dwErrorCode,
                             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                             (LPWSTR)&lpMsgBuf,
                             0,
                             &args);
 
     va_end(args);
 
     iRet = MessageBoxW(hWnd, (Status && lpMsgBuf ? lpMsgBuf : L"Error displaying error message."), lpTitle, MB_OK | MB_ICONERROR);
 
     if (lpMsgBuf) LocalFree(lpMsgBuf);
 
     /* Return the MessageBoxW information */
     return iRet;
 }

Referenced by error_code_messagebox(), ExportRegistryFile(), ImportRegistryFile(), LoadHive(), TreeWndNotifyProc(), and UnloadHive().

◆ export_registry_key()

BOOL export_registry_key	(	WCHAR *	file_name,
		WCHAR *	path,
		DWORD	format
	)

Definition at line 1548 of file regproc.c.

 {
     BOOL unicode = (format == REG_FORMAT_5);
 
     if (path && *path)
         return export_key(file_name, path, unicode);
     else
         return export_all(file_name, path, unicode);
 }

Referenced by ExportRegistryFile(), and PerformRegAction().

◆ ExportRegistryFile()

BOOL ExportRegistryFile ( HWND hWnd )

Definition at line 580 of file framewnd.c.

 {
     BOOL bRet = FALSE;
     OPENFILENAME ofn;
     WCHAR ExportKeyPath[_MAX_PATH] = {0};
     WCHAR Caption[128], szTitle[512], szText[512];
     HKEY hKeyRoot;
     LPCWSTR pszKeyPath;
 
     /* Figure out which key path we are exporting */
     pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
     GetKeyName(ExportKeyPath, ARRAY_SIZE(ExportKeyPath), hKeyRoot, pszKeyPath);
 
     InitOpenFileName(hWnd, &ofn);
     LoadStringW(hInst, IDS_EXPORT_REG_FILE, Caption, ARRAY_SIZE(Caption));
     ofn.lpstrTitle = Caption;
 
     /* Only set the path if a key (not the root node) is selected */
     if (hKeyRoot != 0)
     {
         ofn.lCustData = (LPARAM) ExportKeyPath;
     }
     ofn.Flags = OFN_ENABLETEMPLATE | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_OVERWRITEPROMPT;
     ofn.lpfnHook = ExportRegistryFile_OFNHookProc;
     ofn.lpTemplateName = MAKEINTRESOURCEW(IDD_EXPORTRANGE);
     if (GetSaveFileName(&ofn))
     {
         switch (ofn.nFilterIndex)
         {
             case 2: /* Registry Hive Files */
             {
                 LONG lResult;
                 HKEY hSubKey;
 
                 /* Open the subkey */
                 lResult = RegOpenKeyExW(hKeyRoot, pszKeyPath, 0, KEY_READ, &hSubKey);
                 if (lResult == ERROR_SUCCESS)
                 {
                     /* Enable the 'backup' privilege, save the hive then disable the privilege */
                     EnablePrivilege(SE_BACKUP_NAME, NULL, TRUE);
                     lResult = RegSaveKeyW(hSubKey, ofn.lpstrFile, NULL);
                     if (lResult == ERROR_ALREADY_EXISTS)
                     {
                         /*
                          * We are here, that means that we already said "yes" to the confirmation dialog.
                          * So we absolutely want to replace the hive file.
                          */
                         if (DeleteFileW(ofn.lpstrFile))
                         {
                             /* Try again */
                             lResult = RegSaveKeyW(hSubKey, ofn.lpstrFile, NULL);
                         }
                     }
                     EnablePrivilege(SE_BACKUP_NAME, NULL, FALSE);
 
                     if (lResult != ERROR_SUCCESS)
                     {
                         /*
                          * If we are here, it's because RegSaveKeyW has failed for any reason.
                          * The problem is that even if it has failed, it has created or
                          * replaced the exported hive file with a new empty file. We don't
                          * want to keep this file, so we delete it.
                          */
                         DeleteFileW(ofn.lpstrFile);
                     }
 
                     /* Close the subkey */
                     RegCloseKey(hSubKey);
                 }
 
                 /* Set the return value */
                 bRet = (lResult == ERROR_SUCCESS);
 
                 /* Display error, if any */
                 if (!bRet) ErrorMessageBox(hWnd, Caption, lResult);
 
                 break;
             }
 
             case 1:  /* Windows Registry Editor Version 5.00 */
             case 3:  /* REGEDIT4 */
             default: /* All files ==> use Windows Registry Editor Version 5.00 */
             {
                 if (!export_registry_key(ofn.lpstrFile, ExportKeyPath,
                                          (ofn.nFilterIndex == 3 ? REG_FORMAT_4
                                                                 : REG_FORMAT_5)))
                 {
                     /* Error creating the file */
                     LoadStringW(hInst, IDS_APP_TITLE, szTitle, ARRAY_SIZE(szTitle));
                     LoadStringW(hInst, IDS_EXPORT_ERROR, szText, ARRAY_SIZE(szText));
                     InfoMessageBox(hWnd, MB_OK | MB_ICONERROR, szTitle, szText, ofn.lpstrFile);
                     bRet = FALSE;
                 }
                 else
                 {
                     bRet = TRUE;
                 }
 
                 break;
             }
         }
     }
     else
     {
         CheckCommDlgError(hWnd);
     }
 
     return bRet;
 }

Referenced by _CmdWndProc().

◆ FindDialog()

void FindDialog ( HWND hWnd )

Definition at line 834 of file find.c.

 {
     if (DialogBoxParamW(GetModuleHandle(NULL), MAKEINTRESOURCEW(IDD_FIND),
                        hWnd, FindDialogProc, 0) != 0)
     {
         FindNextMessageBox(hWnd);
     }
 }

Referenced by _CmdWndProc(), and FindNext().

◆ FindNext()

BOOL FindNext ( HWND hWnd )

Definition at line 632 of file find.c.

 {
     HKEY hKeyRoot;
     LPCWSTR pszKeyPath;
     BOOL fSuccess;
     WCHAR szFullKey[512];
     LPCWSTR pszValueName;
     LPWSTR pszFoundSubKey, pszFoundValueName;
 
     if (wcslen(s_szFindWhat) == 0)
     {
         FindDialog(hWnd);
         return TRUE;
     }
 
     s_dwFlags = GetFindFlags();
 
     pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
     if (pszKeyPath == NULL)
     {
         hKeyRoot = HKEY_CLASSES_ROOT;
         pszKeyPath = s_empty;
     }
 
     /* Create abort find dialog */
     s_hwndAbortDialog = CreateDialogW(GetModuleHandle(NULL),
                                      MAKEINTRESOURCEW(IDD_FINDING), hWnd, AbortFindDialogProc);
     if (s_hwndAbortDialog)
     {
         ShowWindow(s_hwndAbortDialog, SW_SHOW);
         UpdateWindow(s_hwndAbortDialog);
     }
     s_bAbort = FALSE;
 
     pszValueName = GetValueName(g_pChildWnd->hListWnd, -1);
 
     EnableWindow(hFrameWnd, FALSE);
     EnableWindow(g_pChildWnd->hTreeWnd, FALSE);
     EnableWindow(g_pChildWnd->hListWnd, FALSE);
     EnableWindow(g_pChildWnd->hAddressBarWnd, FALSE);
 
     fSuccess = RegFindWalk(&hKeyRoot, pszKeyPath, pszValueName,
                            &pszFoundSubKey, &pszFoundValueName);
 
     EnableWindow(hFrameWnd, TRUE);
     EnableWindow(g_pChildWnd->hTreeWnd, TRUE);
     EnableWindow(g_pChildWnd->hListWnd, TRUE);
     EnableWindow(g_pChildWnd->hAddressBarWnd, TRUE);
 
     if (s_hwndAbortDialog)
     {
         DestroyWindow(s_hwndAbortDialog);
         s_hwndAbortDialog = NULL;
     }
 
     if (fSuccess)
     {
         GetKeyName(szFullKey, ARRAY_SIZE(szFullKey), hKeyRoot, pszFoundSubKey);
         SelectNode(g_pChildWnd->hTreeWnd, szFullKey);
         free(pszFoundSubKey);
 
         if (pszFoundValueName != NULL)
         {
             SetValueName(g_pChildWnd->hListWnd, pszFoundValueName);
             free(pszFoundValueName);
             SetFocus(g_pChildWnd->hListWnd);
         }
         else
         {
             SetFocus(g_pChildWnd->hTreeWnd);
         }
     }
     return fSuccess || s_bAbort;
 }

Referenced by FindNextMessageBox().

◆ FindNextMessageBox()

void FindNextMessageBox ( HWND hWnd )

Definition at line 822 of file find.c.

 {
     if (!FindNext(hWnd))
     {
         WCHAR msg[128], caption[128];
 
         LoadStringW(hInst, IDS_FINISHEDFIND, msg, ARRAY_SIZE(msg));
         LoadStringW(hInst, IDS_APP_TITLE, caption, ARRAY_SIZE(caption));
         MessageBoxW(hWnd, msg, caption, MB_ICONINFORMATION);
     }
 }

Referenced by _CmdWndProc(), and FindDialog().

◆ FrameWndProc()

LRESULT CALLBACK FrameWndProc	(	HWND	,
		UINT	,
		WPARAM	,
		LPARAM
	)

Definition at line 1352 of file framewnd.c.

 {
     RECT rc;
     switch (message)
     {
     case WM_CREATE:
         // For now, the Help dialog item is disabled because of lacking of HTML Help support
         EnableMenuItem(GetMenu(hWnd), ID_HELP_HELPTOPICS, MF_BYCOMMAND | MF_GRAYED);
         GetClientRect(hWnd, &rc);
         CreateWindowExW(0, szChildClass, NULL, WS_CHILD | WS_VISIBLE,
                         rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
                         hWnd, (HMENU)0, hInst, 0);
         break;
     case WM_COMMAND:
         if (!_CmdWndProc(hWnd, message, wParam, lParam))
             return DefWindowProcW(hWnd, message, wParam, lParam);
         break;
     case WM_ACTIVATE:
         if (LOWORD(hWnd) && g_pChildWnd)
             SetFocus(g_pChildWnd->hWnd);
         break;
     case WM_SIZE:
         resize_frame_client(hWnd);
         break;
     case WM_TIMER:
         break;
     case WM_INITMENU:
         OnInitMenu(hWnd);
         break;
     case WM_ENTERMENULOOP:
         OnEnterMenuLoop(hWnd);
         break;
     case WM_EXITMENULOOP:
         OnExitMenuLoop(hWnd);
         break;
     case WM_MENUSELECT:
         OnMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam);
         break;
     case WM_SYSCOLORCHANGE:
         /* Forward WM_SYSCOLORCHANGE to common controls */
         SendMessageW(g_pChildWnd->hListWnd, WM_SYSCOLORCHANGE, 0, 0);
         SendMessageW(g_pChildWnd->hTreeWnd, WM_SYSCOLORCHANGE, 0, 0);
         break;
     case WM_DESTROY:
         WinHelpW(hWnd, L"regedit", HELP_QUIT, 0);
         SaveSettings();
         PostQuitMessage(0);
     default:
         return DefWindowProcW(hWnd, message, wParam, lParam);
     }
     return 0;
 }

◆ get_root_key_name()

LPCWSTR get_root_key_name ( HKEY hRootKey )

Definition at line 29 of file childwnd.c.

 {
     if (hRootKey == HKEY_CLASSES_ROOT) return L"HKEY_CLASSES_ROOT";
     if (hRootKey == HKEY_CURRENT_USER) return L"HKEY_CURRENT_USER";
     if (hRootKey == HKEY_LOCAL_MACHINE) return L"HKEY_LOCAL_MACHINE";
     if (hRootKey == HKEY_USERS) return L"HKEY_USERS";
     if (hRootKey == HKEY_CURRENT_CONFIG) return L"HKEY_CURRENT_CONFIG";
     if (hRootKey == HKEY_DYN_DATA) return L"HKEY_DYN_DATA";
 
     return L"UNKNOWN HKEY, PLEASE REPORT";
 }

Referenced by SaveSettings(), and UpdateAddress().

◆ GetItemPath()

LPCWSTR GetItemPath	(	HWND	hwndTV,
		HTREEITEM	hItem,
		HKEY *	phRootKey
	)

Definition at line 88 of file treeview.c.

 {
     int pathLen = 0, maxLen;
 
     *phRootKey = NULL;
     if (!pathBuffer) pathBuffer = HeapAlloc(GetProcessHeap(), 0, 1024);
     if (!pathBuffer) return NULL;
     *pathBuffer = 0;
     maxLen = (int) HeapSize(GetProcessHeap(), 0, pathBuffer);
     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;
     }
     return pathBuffer;
 }

Referenced by _CmdWndProc(), ChildWndProc(), CreateNewKey(), ExportRegistryFile(), FindNext(), ImportRegistryFile(), ListWndNotifyProc(), LoadHive(), OnTreeExpanding(), RefreshTreeItem(), SaveSettings(), TreeWndNotifyProc(), UnloadHive(), UpdateAddress(), and UpdateStatusBar().

◆ GetKeyName()

BOOL GetKeyName	(	LPWSTR	pszDest,
		size_t	iDestLength,
		HKEY	hRootKey,
		LPCWSTR	lpSubKey
	)

Definition at line 1588 of file edit.c.

 {
     LPCWSTR pszRootKey;
 
     if (hRootKey == HKEY_CLASSES_ROOT)
         pszRootKey = L"HKEY_CLASSES_ROOT";
     else if (hRootKey == HKEY_CURRENT_USER)
         pszRootKey = L"HKEY_CURRENT_USER";
     else if (hRootKey == HKEY_LOCAL_MACHINE)
         pszRootKey = L"HKEY_LOCAL_MACHINE";
     else if (hRootKey == HKEY_USERS)
         pszRootKey = L"HKEY_USERS";
     else if (hRootKey == HKEY_CURRENT_CONFIG)
         pszRootKey = L"HKEY_CURRENT_CONFIG";
     else if (hRootKey == HKEY_DYN_DATA)
         pszRootKey = L"HKEY_DYN_DATA";
     else
         return FALSE;
 
     if (lpSubKey[0])
         _snwprintf(pszDest, iDestLength, L"%s\\%s", pszRootKey, lpSubKey);
     else
         _snwprintf(pszDest, iDestLength, L"%s", pszRootKey);
     return TRUE;
 }

Referenced by CopyKeyName(), ExportRegistryFile(), FindNext(), and ScControl().

◆ GetMultiByteString()

char* GetMultiByteString ( const WCHAR * strW )

Definition at line 86 of file regproc.c.

 {
     if(strW)
     {
         char* strA;
         int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
 
         strA = malloc(len);
         WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
         return strA;
     }
     return NULL;
 }

Referenced by REGPROC_write_line().

◆ GetValueName()

WCHAR* GetValueName	(	HWND	hwndLV,
		int	iStartAt
	)

Definition at line 55 of file listview.c.

 {
     int item;
     LVITEMW LVItem;
     PLINE_INFO lineinfo;
 
     /*
        if a new item is inserted, then no allocation,
        otherwise the heap block will be lost!
     */
     item = ListView_GetNextItem(hwndLV, iStartAt, LVNI_SELECTED);
     if (item == -1) return NULL;
 
     /*
         Should be always TRUE anyways
     */
     LVItem.iItem = item;
     LVItem.iSubItem = 0;
     LVItem.mask = LVIF_PARAM;
     if (ListView_GetItem(hwndLV, &LVItem) == FALSE)
         return NULL;
 
     lineinfo = (PLINE_INFO)LVItem.lParam;
     if (lineinfo == NULL)
         return NULL;
 
     return lineinfo->name;
 }

Referenced by _CmdWndProc(), and FindNext().

◆ import_registry_file()

BOOL import_registry_file ( FILE * reg_file )

Definition at line 1049 of file regproc.c.

 {
     BYTE s[2];
     struct parser parser;
     WCHAR *pos;
 
     if (!reg_file || (fread(s, 2, 1, reg_file) != 1))
         return FALSE;
 
     parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
     get_line = parser.is_unicode ? get_lineW : get_lineA;
 
     parser.file          = reg_file;
     parser.two_wchars[0] = s[0];
     parser.two_wchars[1] = s[1];
     parser.reg_version   = -1;
     parser.hkey          = NULL;
     parser.key_name      = NULL;
     parser.value_name    = NULL;
     parser.parse_type    = 0;
     parser.data_type     = 0;
     parser.data          = NULL;
     parser.data_size     = 0;
     parser.backslash     = FALSE;
     parser.state         = HEADER;
 
     pos = parser.two_wchars;
 
     /* parser main loop */
     while (pos)
         pos = (parser_funcs[parser.state])(&parser, pos);
 
     if (parser.reg_version == REG_VERSION_FUZZY || parser.reg_version == REG_VERSION_INVALID)
         return parser.reg_version == REG_VERSION_FUZZY;
 
     free(parser.value_name);
     close_key(&parser);
 
     return TRUE;
 }

Referenced by ImportRegistryFile(), and PerformRegAction().

◆ InfoMessageBox()

int InfoMessageBox	(	HWND	hWnd,
		UINT	uType,
		LPCWSTR	lpTitle,
		LPCWSTR	lpMessage,
			...
	)

Definition at line 51 of file error.c.

 {
     int iRet = 0;
     LPWSTR lpMsgBuf = NULL;
     va_list args;
 
     va_start(args, lpMessage);
 
     if (lpMessage)
     {
         SIZE_T strLen = _vscwprintf(lpMessage, args);
 
         /* Create a buffer on the heap and zero it out (LPTR) */
         lpMsgBuf = (LPWSTR)LocalAlloc(LPTR, (strLen + 1) * sizeof(WCHAR));
         if (lpMsgBuf)
         {
             _vsnwprintf(lpMsgBuf, strLen, lpMessage, args);
         }
     }
 
     va_end(args);
 
     iRet = MessageBoxW(hWnd, (lpMessage && lpMsgBuf ? lpMsgBuf : L"Error displaying info message."), lpTitle, uType);
 
     if (lpMsgBuf) LocalFree(lpMsgBuf);
 
     /* Return the MessageBoxW information */
     return iRet;
 }

Referenced by CreateNewKey(), ExportRegistryFile(), and ImportRegistryFile().

◆ InsertNode()

HTREEITEM InsertNode	(	HWND	hwndTV,
		HTREEITEM	hItem,
		LPWSTR	name
	)

Definition at line 336 of file treeview.c.

 {
     WCHAR buf[MAX_NEW_KEY_LEN];
     HTREEITEM hNewItem = 0;
     TVITEMEXW item;
 
     /* Default to the current selection */
     if (!hItem)
     {
         hItem = TreeView_GetSelection(hwndTV);
         if (!hItem)
             return FALSE;
     }
 
     memset(&item, 0, sizeof(item));
     item.hItem = hItem;
     item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_STATE;
     if (!TreeView_GetItem(hwndTV, &item))
         return FALSE;
 
     if ((item.state & TVIS_EXPANDEDONCE) && (item.cChildren > 0))
     {
         hNewItem = AddEntryToTree(hwndTV, hItem, name, 0, 0);
         SendMessageW(hwndTV, TVM_SORTCHILDREN, 0, (LPARAM) hItem);
     }
     else
     {
         item.mask = TVIF_CHILDREN | TVIF_HANDLE;
         item.hItem = hItem;
         item.cChildren = 1;
         if (!TreeView_SetItem(hwndTV, &item))
             return FALSE;
     }
 
     (void)TreeView_Expand(hwndTV, hItem, TVE_EXPAND);
     if (!hNewItem)
     {
         for(hNewItem = TreeView_GetChild(hwndTV, hItem); hNewItem; hNewItem = TreeView_GetNextSibling(hwndTV, hNewItem))
         {
             item.mask = TVIF_HANDLE | TVIF_TEXT;
             item.hItem = hNewItem;
             item.pszText = buf;
             item.cchTextMax = ARRAY_SIZE(buf);
             if (!TreeView_GetItem(hwndTV, &item)) continue;
             if (wcscmp(name, item.pszText) == 0) break;
         }
     }
     if (hNewItem) (void)TreeView_SelectItem(hwndTV, hNewItem);
 
     return hNewItem;
 }

Referenced by CreateNewKey().

◆ IsDefaultValue()

BOOL IsDefaultValue	(	HWND	hwndLV,
		int	i
	)

Definition at line 107 of file listview.c.

 {
     PLINE_INFO lineinfo;
     LVITEMW Item;
 
     Item.mask = LVIF_PARAM;
     Item.iItem = i;
     if(ListView_GetItem(hwndLV, &Item))
     {
         lineinfo = (PLINE_INFO)Item.lParam;
         return lineinfo && (!lineinfo->name || !wcscmp(lineinfo->name, L""));
     }
     return FALSE;
 }

Referenced by ChildWndProc().

◆ ListWndNotifyProc()

BOOL ListWndNotifyProc	(	HWND	hWnd,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL *	Result
	)

Definition at line 544 of file listview.c.

 {
     NMLVDISPINFO* Info;
     int iSortingColumn;
     UNREFERENCED_PARAMETER(wParam);
     *Result = TRUE;
     switch (((LPNMHDR)lParam)->code)
     {
     case LVN_GETDISPINFO:
         OnGetDispInfo((NMLVDISPINFO*)lParam);
         return TRUE;
     case LVN_COLUMNCLICK:
         iSortingColumn = ((LPNMLISTVIEW)lParam)->iSubItem;
         (void)ListView_Sort(hWnd, iSortingColumn, g_iSortedColumn);
         g_iSortedColumn = iSortingColumn;
         return TRUE;
     case NM_DBLCLK:
     case NM_RETURN:
     {
         SendMessageW(hFrameWnd, WM_COMMAND, MAKEWPARAM(ID_EDIT_MODIFY, 0), 0);
     }
     return TRUE;
     case NM_SETFOCUS:
         g_pChildWnd->nFocusPanel = 1;
         break;
     case LVN_BEGINLABELEDIT:
         Info = (NMLVDISPINFO*)lParam;
         if(Info)
         {
             PLINE_INFO lineinfo = (PLINE_INFO)Info->item.lParam;
             if(!lineinfo->name || !wcscmp(lineinfo->name, L""))
             {
                 *Result = TRUE;
             }
             else
             {
                 *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 || !wcscmp(lineinfo->name, L""))
             {
                 *Result = FALSE;
             }
             else
             {
                 if(wcslen(Info->item.pszText) == 0)
                 {
                     WCHAR msg[128], caption[128];
 
                     LoadStringW(hInst, IDS_ERR_RENVAL_TOEMPTY, msg, ARRAY_SIZE(msg));
                     LoadStringW(hInst, IDS_ERR_RENVAL_CAPTION, caption, ARRAY_SIZE(caption));
                     MessageBoxW(0, msg, caption, 0);
                     *Result = TRUE;
                 }
                 else
                 {
                     HKEY hKeyRoot;
                     LPCWSTR keyPath;
                     LONG lResult;
 
                     keyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hKeyRoot);
                     lResult = RenameValue(hKeyRoot, keyPath, Info->item.pszText, lineinfo->name);
                     lineinfo->name = realloc(lineinfo->name, (wcslen(Info->item.pszText)+1)*sizeof(WCHAR));
                     if (lineinfo->name != NULL)
                         wcscpy(lineinfo->name, Info->item.pszText);
 
                     *Result = TRUE;
                     return (lResult == ERROR_SUCCESS);
                 }
             }
         }
         else
             *Result = TRUE;
 
         return TRUE;
     }
     return FALSE;
 }

Referenced by ChildWndProc().

◆ LoadSettings()

void LoadSettings ( void )

Definition at line 53 of file settings.c.

 {
     HKEY hKey = NULL;
     int iItemIndex = -1;
 
     if (RegOpenKeyEx(HKEY_CURRENT_USER, g_szGeneralRegKey, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
     {
         TCHAR szBuffer[MAX_PATH];
         DWORD dwAdvancedChecked;
         DWORD type, size = sizeof(dwAdvancedChecked);
         LSTATUS lstatus;
 
         /* Restore last selected font */
         if (QueryStringValue(HKEY_CURRENT_USER, g_szGeneralRegKey, _T("Font"), szBuffer, (sizeof(szBuffer)/sizeof(szBuffer[0]))) == ERROR_SUCCESS)
         {
             //Get combobox handle
             hWnd = GetDlgItem(hCharmapDlg, IDC_FONTCOMBO);
 
             //Search for match and return index if match found
             iItemIndex = ComboBox_FindStringExact(hWnd, -1, szBuffer);
             if(iItemIndex != CB_ERR)
             {
                 ComboBox_SetCurSel(hWnd, iItemIndex);
                 ChangeMapFont(hCharmapDlg);
             }
         }
 
         /* Restore last selected character set */
         if (QueryStringValue(HKEY_CURRENT_USER, g_szGeneralRegKey, _T("CodePage"), szBuffer, (sizeof(szBuffer)/sizeof(szBuffer[0]))) == ERROR_SUCCESS)
         {
             //Get combobox handle
             hWnd = GetDlgItem(hCharmapDlg, IDC_COMBO_CHARSET);
 
             iItemIndex = ComboBox_FindStringExact(hWnd, -1, szBuffer);
             if(iItemIndex != CB_ERR)
             {
                 ComboBox_SetCurSel(hWnd, iItemIndex);
             }
         }
 
         lstatus = RegQueryValueEx(hKey, _T("Advanced"), NULL, &type, (LPBYTE)&dwAdvancedChecked, &size);
         if (lstatus == ERROR_SUCCESS && type == REG_DWORD && dwAdvancedChecked != FALSE)
         {
             SendDlgItemMessage(hCharmapDlg, IDC_CHECK_ADVANCED, BM_CLICK, MF_CHECKED, 0);
         }
 
     RegCloseKey(hKey);
     }
     else
     {
         /* Default font seems to be Arial */
         hWnd = GetDlgItem(hCharmapDlg, IDC_FONTCOMBO);
 
         iItemIndex = ComboBox_FindStringExact(hWnd, -1, _T("Arial"));
         if(iItemIndex != CB_ERR)
         {
             ComboBox_SetCurSel(hWnd, iItemIndex);
             ChangeMapFont(hCharmapDlg);
         }
     }
 }

◆ ModifyValue()

BOOL ModifyValue	(	HWND	hwnd,
		HKEY	hKey,
		LPCWSTR	valueName,
		BOOL	EditBin
	)

Definition at line 1072 of file edit.c.

 {
     DWORD type;
     LONG lRet;
     BOOL result = FALSE;
 
     if (!hKey)
         return FALSE;
 
     editValueName = valueName;
 
     lRet = RegQueryValueExW(hKey, valueName, 0, &type, 0, &valueDataLen);
     if (lRet != ERROR_SUCCESS && (valueName == NULL || !valueName[0]))
     {
         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)
     {
         error(hwnd, IDS_BAD_VALUE, valueName);
         goto done;
     }
 
     if (EditBin == FALSE && ((type == REG_SZ) || (type == REG_EXPAND_SZ)))
     {
         if (valueDataLen > 0)
         {
             if (!(stringValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen)))
             {
                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
                 goto done;
             }
             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
             if (lRet != ERROR_SUCCESS)
             {
                 error(hwnd, IDS_BAD_VALUE, valueName);
                 goto done;
             }
         }
         else
         {
             stringValueData = NULL;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_STRING), hwnd, modify_string_dlgproc) == IDOK)
         {
             if (stringValueData)
             {
                 lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)stringValueData, (DWORD) (wcslen(stringValueData) + 1) * sizeof(WCHAR));
             }
             else
             {
                 lRet = RegSetValueExW(hKey, valueName, 0, type, NULL, 0);
             }
             if (lRet == ERROR_SUCCESS)
                 result = TRUE;
         }
     }
     else if (EditBin == FALSE && type == REG_MULTI_SZ)
     {
         if (valueDataLen > 0)
         {
             size_t llen, listlen, nl_len;
             LPWSTR src, lines = NULL;
 
             if (!(stringValueData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, valueDataLen + sizeof(WCHAR))))
             {
                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
                 goto done;
             }
             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)stringValueData, &valueDataLen);
             if (lRet != ERROR_SUCCESS)
             {
                 error(hwnd, IDS_BAD_VALUE, valueName);
                 goto done;
             }
 
             /* convert \0 to \r\n */
             src = stringValueData;
             nl_len = wcslen(L"\r\n") * sizeof(WCHAR);
             listlen = sizeof(WCHAR);
             lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, listlen + sizeof(WCHAR));
             while(*src != L'\0')
             {
                 llen = wcslen(src);
                 if(llen == 0)
                     break;
                 listlen += (llen * sizeof(WCHAR)) + nl_len;
                 lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, listlen);
                 wcscat(lines, src);
                 wcscat(lines, L"\r\n");
                 src += llen + 1;
             }
             HeapFree(GetProcessHeap(), 0, stringValueData);
             stringValueData = lines;
         }
         else
         {
             stringValueData = NULL;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_MULTI_STRING), hwnd, modify_multi_string_dlgproc) == IDOK)
         {
             if (stringValueData)
             {
                 /* convert \r\n to \0 */
                 BOOL EmptyLines = FALSE;
                 LPWSTR src, lines, nl;
                 size_t linechars, buflen, c_nl, dest;
 
                 src = stringValueData;
                 buflen = sizeof(WCHAR);
                 lines = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen + sizeof(WCHAR));
                 c_nl = wcslen(L"\r\n");
                 dest = 0;
                 while(*src != L'\0')
                 {
                     if((nl = wcsstr(src, L"\r\n")))
                     {
                         linechars = nl - src;
                         if(nl == src)
                         {
                             EmptyLines = TRUE;
                             src = nl + c_nl;
                             continue;
                         }
                     }
                     else
                     {
                         linechars = wcslen(src);
                     }
                     if(linechars > 0)
                     {
                         buflen += ((linechars + 1) * sizeof(WCHAR));
                         lines = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lines, buflen);
                         memcpy((lines + dest), src, linechars * sizeof(WCHAR));
                         dest += linechars;
                         lines[dest++] = L'\0';
                     }
                     else
                     {
                         EmptyLines = TRUE;
                     }
                     src += linechars + (nl != NULL ? c_nl : 0);
                 }
                 lines[++dest] = L'\0';
 
                 if(EmptyLines)
                 {
                     warning(hwnd, IDS_MULTI_SZ_EMPTY_STRING);
                 }
 
                 lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)lines, (DWORD) buflen);
                 HeapFree(GetProcessHeap(), 0, lines);
             }
             else
             {
                 lRet = RegSetValueExW(hKey, valueName, 0, type, NULL, 0);
             }
             if (lRet == ERROR_SUCCESS)
                 result = TRUE;
         }
     }
     else if (EditBin == FALSE && type == REG_DWORD)
     {
         lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)&dwordValueData, &valueDataLen);
         if (lRet != ERROR_SUCCESS)
         {
             error(hwnd, IDS_BAD_VALUE, valueName);
             goto done;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_DWORD), hwnd, modify_dword_dlgproc) == IDOK)
         {
             lRet = RegSetValueExW(hKey, valueName, 0, type, (LPBYTE)&dwordValueData, sizeof(DWORD));
             if (lRet == ERROR_SUCCESS)
                 result = TRUE;
         }
     }
     else if (EditBin == FALSE && type == REG_RESOURCE_LIST)
     {
         if (valueDataLen > 0)
         {
             resourceValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen);
             if (resourceValueData == NULL)
             {
                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
                 goto done;
             }
 
             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)resourceValueData, &valueDataLen);
             if (lRet != ERROR_SUCCESS)
             {
                 error(hwnd, IDS_BAD_VALUE, valueName);
                 goto done;
             }
         }
         else
         {
             resourceValueData = NULL;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE_LIST), hwnd, modify_resource_list_dlgproc) == IDOK)
         {
         }
     }
     else if (EditBin == FALSE && type == REG_FULL_RESOURCE_DESCRIPTOR)
     {
         if (valueDataLen > 0)
         {
             resourceValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + sizeof(ULONG));
             if (resourceValueData == NULL)
             {
                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
                 goto done;
             }
 
             lRet = RegQueryValueExW(hKey, valueName, 0, 0, (LPBYTE)&resourceValueData->List[0], &valueDataLen);
             if (lRet != ERROR_SUCCESS)
             {
                 error(hwnd, IDS_BAD_VALUE, valueName);
                 goto done;
             }
 
             resourceValueData->Count = 1;
             fullResourceIndex = 0;
         }
         else
         {
             resourceValueData = NULL;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_RESOURCE), hwnd, modify_resource_dlgproc) == IDOK)
         {
         }
     }
     else if ((EditBin != FALSE) || (type == REG_NONE) || (type == REG_BINARY))
     {
         if(valueDataLen > 0)
         {
             if(!(binValueData = HeapAlloc(GetProcessHeap(), 0, valueDataLen + 1)))
             {
                 error(hwnd, IDS_TOO_BIG_VALUE, valueDataLen);
                 goto done;
             }
 
             /* Use the unicode version, so editing strings in binary mode is correct */
             lRet = RegQueryValueExW(hKey, valueName,
                                     0, 0, (LPBYTE)binValueData, &valueDataLen);
             if (lRet != ERROR_SUCCESS)
             {
                 HeapFree(GetProcessHeap(), 0, binValueData);
                 error(hwnd, IDS_BAD_VALUE, valueName);
                 goto done;
             }
         }
         else
         {
             binValueData = NULL;
         }
 
         if (DialogBoxW(0, MAKEINTRESOURCEW(IDD_EDIT_BIN_DATA), hwnd, modify_binary_dlgproc) == IDOK)
         {
             /* Use the unicode version, so editing strings in binary mode is correct */
             lRet = RegSetValueExW(hKey, valueName,
                                   0, type, (LPBYTE)binValueData, valueDataLen);
             if (lRet == ERROR_SUCCESS)
                 result = TRUE;
         }
         if(binValueData != NULL)
             HeapFree(GetProcessHeap(), 0, binValueData);
     }
     else
     {
         error(hwnd, IDS_UNSUPPORTED_TYPE, type);
     }
 
 done:
     if (resourceValueData)
         HeapFree(GetProcessHeap(), 0, resourceValueData);
     resourceValueData = NULL;
 
     if (stringValueData)
         HeapFree(GetProcessHeap(), 0, stringValueData);
     stringValueData = NULL;
 
     return result;
 }

Referenced by _CmdWndProc().

◆ OnTreeExpanding()

BOOL OnTreeExpanding	(	HWND	hWnd,
		NMTREEVIEW *	pnmtv
	)

Definition at line 505 of file treeview.c.

 {
     DWORD dwCount, dwIndex, dwMaxSubKeyLen;
     HKEY hRoot, hNewKey, hKey;
     LPCWSTR keyPath;
     LPWSTR Name;
     LONG errCode;
     HCURSOR hcursorOld;
 
     static int expanding;
     if (expanding) return FALSE;
     if (pnmtv->itemNew.state & TVIS_EXPANDEDONCE )
     {
         return TRUE;
     }
     expanding = TRUE;
     hcursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
     SendMessageW(hwndTV, WM_SETREDRAW, FALSE, 0);
 
     keyPath = GetItemPath(hwndTV, pnmtv->itemNew.hItem, &hRoot);
     if (!keyPath) goto done;
 
     if (*keyPath)
     {
         errCode = RegOpenKeyExW(hRoot, keyPath, 0, KEY_READ, &hNewKey);
         if (errCode != ERROR_SUCCESS) goto done;
     }
     else
     {
         hNewKey = hRoot;
     }
 
     errCode = RegQueryInfoKeyW(hNewKey, 0, 0, 0, &dwCount, &dwMaxSubKeyLen, 0, 0, 0, 0, 0, 0);
     if (errCode != ERROR_SUCCESS) goto done;
     dwMaxSubKeyLen++; /* account for the \0 terminator */
     Name = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(WCHAR));
     if (!Name) goto done;
 
     for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
     {
         DWORD cName = dwMaxSubKeyLen, dwSubCount;
 
         errCode = RegEnumKeyExW(hNewKey, dwIndex, Name, &cName, 0, 0, 0, 0);
         if (errCode != ERROR_SUCCESS) continue;
         errCode = RegOpenKeyExW(hNewKey, Name, 0, KEY_QUERY_VALUE, &hKey);
         if (errCode == ERROR_SUCCESS)
         {
             errCode = RegQueryInfoKeyW(hKey, 0, 0, 0, &dwSubCount, 0, 0, 0, 0, 0, 0, 0);
             RegCloseKey(hKey);
         }
         if (errCode != ERROR_SUCCESS) dwSubCount = 0;
         AddEntryToTree(hwndTV, pnmtv->itemNew.hItem, Name, NULL, dwSubCount);
     }
 
     SendMessageW(hwndTV, TVM_SORTCHILDREN, 0, (LPARAM)pnmtv->itemNew.hItem);
 
     RegCloseKey(hNewKey);
     HeapFree(GetProcessHeap(), 0, Name);
 
 done:
     SendMessageW(hwndTV, WM_SETREDRAW, TRUE, 0);
     SetCursor(hcursorOld);
     expanding = FALSE;
 
     return TRUE;
 }

Referenced by TreeWndNotifyProc().

◆ output_message()

void WINAPIV output_message	(	unsigned int	id,
			...
	)

Definition at line 92 of file reg.c.

 {
     WCHAR *fmt = NULL;
     int len;
     va_list va_args;
 
     if (!(len = LoadStringW(GetModuleHandleW(NULL), id, (WCHAR *)&fmt, 0)))
     {
         WINE_FIXME("LoadString failed with %d\n", GetLastError());
         return;
     }
 
     len++;
     fmt = malloc(len * sizeof(WCHAR));
     if (!fmt) return;
 
     LoadStringW(GetModuleHandleW(NULL), id, fmt, len);
 
     va_start(va_args, id);
     output_formatstring(fmt, va_args);
     va_end(va_args);
 
     free(fmt);
 }

Referenced by ask_confirm(), ask_overwrite_value(), export_key(), get_file_handle(), get_regdata(), key_name_state(), open_export_key(), output_error(), parse_registry_key(), parse_win31_line_state(), PerformRegAction(), ProcessCmdLine(), query_value(), reg_add(), reg_copy(), reg_delete(), reg_export(), reg_import(), reg_query(), REGPROC_unescape_string(), run_add(), run_delete(), run_query(), sane_path(), unescape_string(), unknown_data_state(), and wmain().

◆ QueryStringValue()

LONG QueryStringValue	(	HKEY	hKey,
		LPCWSTR	lpSubKey,
		LPCWSTR	lpValueName,
		LPWSTR	pszBuffer,
		DWORD	dwBufferLen
	)

Definition at line 1554 of file edit.c.

 {
     LONG lResult;
     HKEY hSubKey = NULL;
     DWORD cbData, dwType;
 
     if (lpSubKey)
     {
         lResult = RegOpenKeyW(hKey, lpSubKey, &hSubKey);
         if (lResult != ERROR_SUCCESS)
             goto done;
         hKey = hSubKey;
     }
 
     cbData = (dwBufferLen - 1) * sizeof(*pszBuffer);
     lResult = RegQueryValueExW(hKey, lpValueName, NULL, &dwType, (LPBYTE) pszBuffer, &cbData);
     if (lResult != ERROR_SUCCESS)
         goto done;
     if (dwType != REG_SZ)
     {
         lResult = -1;
         goto done;
     }
 
     pszBuffer[cbData / sizeof(*pszBuffer)] = L'\0';
 
 done:
     if (lResult != ERROR_SUCCESS)
         pszBuffer[0] = L'\0';
     if (hSubKey)
         RegCloseKey(hSubKey);
     return lResult;
 }

◆ RefreshListView()

BOOL RefreshListView	(	HWND	hwndLV,
		HKEY	hKey,
		LPCWSTR	keyPath
	)

Definition at line 671 of file listview.c.

 {
     DWORD max_sub_key_len;
     DWORD max_val_name_len;
     DWORD max_val_size;
     DWORD val_count;
     HKEY hNewKey;
     LONG errCode;
     INT i, c;
     BOOL AddedDefault = FALSE;
 
     if (!hwndLV) return FALSE;
 
     (void)ListView_EditLabel(hwndLV, -1);
 
     SendMessageW(hwndLV, WM_SETREDRAW, FALSE, 0);
     DestroyListView(hwndLV);
 
     (void)ListView_DeleteAllItems(hwndLV);
 
     if(!hKey) return FALSE;
 
     errCode = RegOpenKeyExW(hKey, keyPath, 0, KEY_READ, &hNewKey);
     if (errCode != ERROR_SUCCESS) return FALSE;
 
     /* get size information and resize the buffers if necessary */
     errCode = RegQueryInfoKeyW(hNewKey, NULL, NULL, NULL, NULL, &max_sub_key_len, NULL,
                                &val_count, &max_val_name_len, &max_val_size, NULL, NULL);
 
     if (errCode == ERROR_SUCCESS)
     {
         WCHAR* ValName = HeapAlloc(GetProcessHeap(), 0, ++max_val_name_len * sizeof(WCHAR));
         DWORD dwValNameLen = max_val_name_len;
         BYTE* ValBuf = HeapAlloc(GetProcessHeap(), 0, max_val_size + sizeof(WCHAR));
         DWORD dwValSize = max_val_size;
         DWORD dwIndex = 0L;
         DWORD dwValType;
         /*                if (RegQueryValueExW(hNewKey, NULL, NULL, &dwValType, ValBuf, &dwValSize) == ERROR_SUCCESS) { */
         /*                    AddEntryToList(hwndLV, L"(Default)", dwValType, ValBuf, dwValSize); */
         /*                } */
         /*                dwValSize = max_val_size; */
         while (RegEnumValueW(hNewKey, dwIndex, ValName, &dwValNameLen, NULL, &dwValType, ValBuf, &dwValSize) == ERROR_SUCCESS)
         {
             /* Add a terminating 0 character. Usually this is only necessary for strings. */
             ValBuf[dwValSize] = ValBuf[dwValSize + 1] = 0;
 
             AddEntryToList(hwndLV, ValName, dwValType, ValBuf, dwValSize, -1, TRUE);
             dwValNameLen = max_val_name_len;
             dwValSize = max_val_size;
             dwValType = 0L;
             ++dwIndex;
             if(!wcscmp(ValName, L""))
             {
                 AddedDefault = TRUE;
             }
         }
         HeapFree(GetProcessHeap(), 0, ValBuf);
         HeapFree(GetProcessHeap(), 0, ValName);
     }
     RegCloseKey(hNewKey);
 
     if(!AddedDefault)
     {
         AddEntryToList(hwndLV, L"", REG_SZ, NULL, 0, 0, FALSE);
     }
     c = ListView_GetItemCount(hwndLV);
     for(i = 0; i < c; i++)
     {
         ListView_SetItemState(hwndLV, i, 0, LVIS_FOCUSED | LVIS_SELECTED);
     }
     ListView_SetItemState(hwndLV, iListViewSelect,
                           LVIS_FOCUSED | LVIS_SELECTED,
                           LVIS_FOCUSED | LVIS_SELECTED);
     (void)ListView_Sort(hwndLV, g_iSortedColumn, -1);
     SendMessageW(hwndLV, WM_SETREDRAW, TRUE, 0);
 
     return TRUE;
 }

Referenced by _CmdWndProc(), CreateNewValue(), ImportRegistryFile(), LoadHive(), UnloadHive(), and UpdateAddress().

◆ RefreshTreeItem()

BOOL RefreshTreeItem	(	HWND	hwndTV,
		HTREEITEM	hItem
	)

Definition at line 141 of file treeview.c.

 {
     HKEY hRoot, hKey, hSubKey;
     HTREEITEM childItem;
     LPCWSTR KeyPath;
     DWORD dwCount, dwIndex, dwMaxSubKeyLen;
     LPWSTR Name = NULL;
     TVITEMW tvItem;
     LPWSTR pszNodes = NULL;
     BOOL bSuccess = FALSE;
     LPWSTR s;
     BOOL bAddedAny;
 
     KeyPath = GetItemPath(hwndTV, hItem, &hRoot);
 
     if (*KeyPath)
     {
         if (RegOpenKeyExW(hRoot, KeyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
         {
             goto done;
         }
     }
     else
     {
         hKey = hRoot;
     }
 
     if (RegQueryInfoKeyW(hKey, 0, 0, 0, &dwCount, &dwMaxSubKeyLen, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS)
     {
         goto done;
     }
 
     /* Set the number of children again */
     tvItem.mask = TVIF_CHILDREN;
     tvItem.hItem = hItem;
     tvItem.cChildren = dwCount;
     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)
     {
         RegCloseKey(hKey);
         bSuccess = TRUE;
         goto done;
     }
 
     dwMaxSubKeyLen++; /* account for the \0 terminator */
     if (!(Name = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(WCHAR))))
     {
         goto done;
     }
     tvItem.cchTextMax = dwMaxSubKeyLen;
     /*if (!(tvItem.pszText = HeapAlloc(GetProcessHeap(), 0, dwMaxSubKeyLen * sizeof(WCHAR)))) {
         goto done;
     }*/
 
     /* Get all of the tree node siblings in one contiguous block of memory */
     {
         DWORD dwPhysicalSize = 0;
         DWORD dwActualSize = 0;
         DWORD dwNewPhysicalSize;
         LPWSTR pszNewNodes;
         DWORD dwStep = 10000;
 
         for (childItem = TreeView_GetChild(hwndTV, hItem); childItem;
                 childItem = TreeView_GetNextSibling(hwndTV, childItem))
         {
 
             if (dwActualSize + dwMaxSubKeyLen + 1 > dwPhysicalSize)
             {
                 dwNewPhysicalSize = dwActualSize + dwMaxSubKeyLen + 1 + dwStep;
 
                 if (pszNodes)
                     pszNewNodes = (LPWSTR) HeapReAlloc(GetProcessHeap(), 0, pszNodes, dwNewPhysicalSize * sizeof(WCHAR));
                 else
                     pszNewNodes = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, dwNewPhysicalSize * sizeof(WCHAR));
                 if (!pszNewNodes)
                     goto done;
 
                 dwPhysicalSize = dwNewPhysicalSize;
                 pszNodes = pszNewNodes;
             }
 
             tvItem.mask = TVIF_TEXT;
             tvItem.hItem = childItem;
             tvItem.pszText = &pszNodes[dwActualSize];
             tvItem.cchTextMax = dwPhysicalSize - dwActualSize;
             if (!TreeView_GetItem(hwndTV, &tvItem))
                 goto done;
 
             dwActualSize += (DWORD) wcslen(&pszNodes[dwActualSize]) + 1;
         }
 
         if (pszNodes)
             pszNodes[dwActualSize] = L'\0';
     }
 
     /* Now go through all the children in the tree, and check if any have to be removed. */
     childItem = TreeView_GetChild(hwndTV, hItem);
     while (childItem)
     {
         HTREEITEM nextItem = TreeView_GetNextSibling(hwndTV, childItem);
         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. */
     bAddedAny = FALSE;
     for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
     {
         DWORD cName = dwMaxSubKeyLen, dwSubCount;
         BOOL found;
 
         found = FALSE;
         if (RegEnumKeyExW(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 += wcslen(s) + 1)
             {
                 if (!wcscmp(s, Name))
                 {
                     found = TRUE;
                     break;
                 }
             }
         }
 
         if (found == FALSE)
         {
             /* Find the number of children of the node. */
             dwSubCount = 0;
             if (RegOpenKeyExW(hKey, Name, 0, KEY_QUERY_VALUE, &hSubKey) == ERROR_SUCCESS)
             {
                 if (RegQueryInfoKeyW(hSubKey, 0, 0, 0, &dwSubCount, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS)
                 {
                     dwSubCount = 0;
                 }
                 RegCloseKey(hSubKey);
             }
 
             AddEntryToTree(hwndTV, hItem, Name, NULL, dwSubCount);
             bAddedAny = TRUE;
         }
     }
     RegCloseKey(hKey);
 
     if (bAddedAny)
         SendMessageW(hwndTV, TVM_SORTCHILDREN, 0, (LPARAM) hItem);
 
     bSuccess = TRUE;
 
 done:
     if (pszNodes)
         HeapFree(GetProcessHeap(), 0, pszNodes);
     if (Name)
         HeapFree(GetProcessHeap(), 0, Name);
     return bSuccess;
 }

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ARRAY_SIZE

◆ KEY_MAX_LEN

◆ LIST_WINDOW

◆ MAX_NEW_KEY_LEN

◆ PM_HEXEDIT

◆ PM_MODIFYVALUE

◆ PM_NEW

◆ PM_ROOTITEM

◆ PM_TREECONTEXT

◆ REG_FORMAT_4

◆ REG_FORMAT_5

◆ SPLIT_MIN

◆ SPLIT_WIDTH

◆ STATUS_WINDOW

◆ TREE_WINDOW

Enumeration Type Documentation

◆ OPTION_FLAGS

Function Documentation

◆ ChildWndProc()

◆ CopyKeyName()

◆ CreateListView()

◆ CreateNewKey()

◆ CreateTreeView()

◆ delete_registry_key()

◆ DeleteKey()

◆ DeleteNode()

◆ DestroyListView()

◆ DestroyMainMenu()

◆ DestroyTreeView()

◆ error_exit()

◆ ErrorMessageBox()

◆ export_registry_key()

◆ ExportRegistryFile()

◆ FindDialog()

◆ FindNext()

◆ FindNextMessageBox()

◆ FrameWndProc()

◆ get_root_key_name()

◆ GetItemPath()

◆ GetKeyName()

◆ GetMultiByteString()

◆ GetValueName()

◆ import_registry_file()

◆ InfoMessageBox()

◆ InsertNode()

◆ IsDefaultValue()

◆ ListWndNotifyProc()

◆ LoadSettings()

◆ ModifyValue()

◆ OnTreeExpanding()

◆ output_message()

◆ QueryStringValue()

◆ RefreshListView()

◆ RefreshTreeItem()