environment.c File Reference

#include "precomp.h"
#include <commctrl.h>
#include <commdlg.h>
#include <string.h>

Include dependency graph for environment.c:

Go to the source code of this file.

Classes
struct	_VARIABLE_DATA
struct	_ENVIRONMENT_DIALOG_DATA
struct	_ENVIRONMENT_EDIT_DIALOG_DATA

Typedefs
typedef struct _VARIABLE_DATA	VARIABLE_DATA
typedef struct _VARIABLE_DATA *	PVARIABLE_DATA
typedef struct _ENVIRONMENT_DIALOG_DATA	ENVIRONMENT_DIALOG_DATA
typedef struct _ENVIRONMENT_DIALOG_DATA *	PENVIRONMENT_DIALOG_DATA
typedef struct _ENVIRONMENT_EDIT_DIALOG_DATA	EDIT_DIALOG_DATA
typedef struct _ENVIRONMENT_EDIT_DIALOG_DATA *	PEDIT_DIALOG_DATA

Functions
static BOOL	DetermineDialogBoxType (LPTSTR lpRawValue)
static DWORD	GatherDataFromEditBox (HWND hwndDlg, PVARIABLE_DATA VarData)
static DWORD	GatherDataFromListView (HWND hwndListView, PVARIABLE_DATA VarData)
static INT	GetSelectedListViewItem (HWND hwndListView)
static LRESULT CALLBACK	ListViewSubclassProc (HWND hListBox, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
static VOID	AddEmptyItem (HWND hwndListView, DWORD dwSelectedValueIndex)
static VOID	AddValuesToList (HWND hwndDlg, PEDIT_DIALOG_DATA DlgData)
static VOID	BrowseRequiredFile (HWND hwndDlg)
static VOID	BrowseRequiredFolder (HWND hwndDlg, PEDIT_DIALOG_DATA DlgData)
static VOID	MoveListItem (HWND hwndDlg, PEDIT_DIALOG_DATA DlgData, BOOL bMoveUp)
static VOID	OnEnvironmentEditDlgResize (HWND hwndDlg, PEDIT_DIALOG_DATA DlgData, DWORD cx, DWORD cy)
static BOOL	OnBeginLabelEdit (NMLVDISPINFO *pnmv)
static BOOL	OnEndLabelEdit (NMLVDISPINFO *pnmv)
static BOOL	OnNotifyEditVariableDlg (HWND hwndDlg, PEDIT_DIALOG_DATA DlgData, NMHDR *phdr)
static INT_PTR CALLBACK	EditVariableDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	GetEnvironmentVariables (HWND hwndListView, HKEY hRootKey, LPTSTR lpSubKeyName)
static VOID	SetEnvironmentDialogListViewColumns (HWND hwndListView)
static VOID	OnInitEnvironmentDialog (HWND hwndDlg)
static VOID	OnNewVariable (HWND hwndDlg, INT iDlgItem)
static VOID	OnEditVariable (HWND hwndDlg, INT iDlgItem)
static VOID	OnDeleteVariable (HWND hwndDlg, INT iDlgItem)
static VOID	OnEnvironmentDlgResize (HWND hwndDlg, PENVIRONMENT_DIALOG_DATA DlgData, DWORD cx, DWORD cy)
static VOID	ReleaseListViewItems (HWND hwndDlg, INT iDlgItem)
static VOID	SetAllVars (HWND hwndDlg, INT iDlgItem)
static BOOL	OnNotify (HWND hwndDlg, NMHDR *phdr)
INT_PTR CALLBACK	EnvironmentDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

Typedef Documentation

EDIT_DIALOG_DATA

typedef struct _ENVIRONMENT_EDIT_DIALOG_DATA EDIT_DIALOG_DATA

ENVIRONMENT_DIALOG_DATA

typedef struct _ENVIRONMENT_DIALOG_DATA ENVIRONMENT_DIALOG_DATA

PEDIT_DIALOG_DATA

typedef struct _ENVIRONMENT_EDIT_DIALOG_DATA * PEDIT_DIALOG_DATA

PENVIRONMENT_DIALOG_DATA

typedef struct _ENVIRONMENT_DIALOG_DATA * PENVIRONMENT_DIALOG_DATA

PVARIABLE_DATA

typedef struct _VARIABLE_DATA * PVARIABLE_DATA

VARIABLE_DATA

typedef struct _VARIABLE_DATA VARIABLE_DATA

Function Documentation

AddEmptyItem()

static VOID AddEmptyItem ( HWND  hwndListView, DWORD  dwSelectedValueIndex  )

static

Definition at line 229 of file environment.c.

{
    LV_ITEM lvi;
 
    ZeroMemory(&lvi, sizeof(lvi));
    lvi.mask = LVIF_TEXT | LVIF_STATE;
    lvi.cchTextMax = MAX_PATH;
    lvi.pszText = _T("");
    lvi.iItem = dwSelectedValueIndex;
    lvi.iSubItem = 0;
    ListView_InsertItem(hwndListView, &lvi);
}

Referenced by BrowseRequiredFolder(), and EditVariableDlgProc().

AddValuesToList()

static VOID AddValuesToList ( HWND  hwndDlg, PEDIT_DIALOG_DATA  DlgData  )

static

Definition at line 244 of file environment.c.

{
    LV_COLUMN column;
    LV_ITEM lvi;
    RECT rItem;
 
    DWORD dwValueLength;
    DWORD i;
    HWND hwndListView;
    LPTSTR lpTemp;
    LPTSTR lpToken;
 
    ZeroMemory(&column, sizeof(column));
    ZeroMemory(&lvi, sizeof(lvi));
 
    hwndListView = GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE);
 
    GetClientRect(hwndListView, &rItem);
 
    column.mask = LVCF_WIDTH;
    column.cx = rItem.right;
    ListView_InsertColumn(hwndListView, 0, &column);
    ShowScrollBar(hwndListView, SB_HORZ, FALSE);
 
    lvi.mask = LVIF_TEXT | LVIF_STATE;
    lvi.cchTextMax = MAX_PATH;
    lvi.iSubItem = 0;
 
    dwValueLength = _tcslen(DlgData->VarData->lpRawValue) + 1;
    lpTemp = GlobalAlloc(GPTR, dwValueLength * sizeof(TCHAR));
    if (!lpTemp)
        return;
 
    StringCchCopy(lpTemp, dwValueLength, DlgData->VarData->lpRawValue);
 
    for (lpToken = _tcstok(lpTemp, _T(";")), i = 0;
         lpToken != NULL;
         lpToken = _tcstok(NULL, _T(";")), i++)
    {
        lvi.iItem = i;
        lvi.pszText = lpToken;
        lvi.state = (i == 0) ? LVIS_SELECTED : 0;
        ListView_InsertItem(hwndListView, &lvi);
    }
 
    DlgData->dwSelectedValueIndex = 0;
    ListView_SetExtendedListViewStyle(hwndListView, LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT);
    ListView_SetItemState(hwndListView, DlgData->dwSelectedValueIndex,
                          LVIS_FOCUSED | LVIS_SELECTED,
                          LVIS_FOCUSED | LVIS_SELECTED);
 
    ListView_Update(hwndListView, DlgData->dwSelectedValueIndex);
    GlobalFree(lpTemp);
}

Referenced by EditVariableDlgProc().

BrowseRequiredFile()

static VOID BrowseRequiredFile ( HWND  hwndDlg )

static

Definition at line 301 of file environment.c.

{
    OPENFILENAME ofn;
    TCHAR szFilter[MAX_STR_LENGTH] = _T("");
    TCHAR szFile[MAX_PATH] = _T("");
 
    LoadString(hApplet, IDS_FILE_BROWSE_FILTER, szFilter, _countof(szFilter));
 
    ZeroMemory(&ofn, sizeof(ofn));
 
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwndDlg;
    ofn.lpstrFilter = szFilter;
    ofn.lpstrFile = szFile;
    ofn.nMaxFile = _countof(szFile);
    ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
 
    if (GetOpenFileName(&ofn))
    {
        SetDlgItemText(hwndDlg, IDC_VARIABLE_VALUE, szFile);
    }
}

Referenced by EditVariableDlgProc().

BrowseRequiredFolder()

static VOID BrowseRequiredFolder ( HWND  hwndDlg, PEDIT_DIALOG_DATA  DlgData  )

static

Definition at line 325 of file environment.c.

{
    HWND hwndListView;
    TCHAR szDir[MAX_PATH];
 
    BROWSEINFO bi;
    LPITEMIDLIST pidllist;
 
    ZeroMemory(&bi, sizeof(bi));
    bi.hwndOwner = hwndDlg;
    bi.ulFlags = BIF_NEWDIALOGSTYLE;
 
    hwndListView = GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE);
 
    pidllist = SHBrowseForFolder(&bi);
    if (!pidllist)
    {
        return;
    }
 
    if (SHGetPathFromIDList(pidllist, szDir))
    {
        if (DlgData->dwDlgID == IDD_EDIT_VARIABLE_FANCY)
        {
            /* If no item is selected then create a new empty item and add the required location to it */
            if (!DlgData->bIsItemSelected)
            {
                DlgData->dwSelectedValueIndex = ListView_GetItemCount(hwndListView);
                AddEmptyItem(hwndListView, DlgData->dwSelectedValueIndex);
            }
            ListView_SetItemText(hwndListView,
                                 DlgData->dwSelectedValueIndex,
                                 0,
                                 szDir);
            ListView_SetItemState(hwndListView, DlgData->dwSelectedValueIndex,
                                  LVIS_FOCUSED | LVIS_SELECTED,
                                  LVIS_FOCUSED | LVIS_SELECTED);
        }
        else
        {
            SetDlgItemText(hwndDlg, IDC_VARIABLE_VALUE, szDir);
        }
    }
 
    CoTaskMemFree(pidllist);
}

Referenced by EditVariableDlgProc().

DetermineDialogBoxType()

static BOOL DetermineDialogBoxType ( LPTSTR  lpRawValue )

static

Definition at line 45 of file environment.c.

{
    DWORD dwValueLength;
    LPTSTR lpTemp;
    LPTSTR lpToken;
 
    dwValueLength = _tcslen(lpRawValue) + 1;
    lpTemp = GlobalAlloc(GPTR, dwValueLength * sizeof(TCHAR));
    if (!lpTemp)
        return FALSE;
 
    StringCchCopy(lpTemp, dwValueLength, lpRawValue);
 
    for (lpToken = _tcstok(lpTemp, _T(";"));
         lpToken != NULL;
         lpToken = _tcstok(NULL, _T(";")))
    {
        /* If the string has environment variable then expand it */
        ExpandEnvironmentStrings(lpToken, lpToken, dwValueLength);
 
        if (!PathIsDirectoryW(lpToken))
            return FALSE;
    }
    GlobalFree(lpTemp);
 
    return TRUE;
}

Referenced by OnEditVariable().

EditVariableDlgProc()

static INT_PTR CALLBACK EditVariableDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 766 of file environment.c.

{
    PEDIT_DIALOG_DATA DlgData;
    HWND hwndListView;
 
    DlgData = (PEDIT_DIALOG_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
    hwndListView = GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            RECT rect;
 
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)lParam);
            DlgData = (PEDIT_DIALOG_DATA)lParam;
 
            GetClientRect(hwndDlg, &rect);
            DlgData->cxOld = rect.right - rect.left;
            DlgData->cyOld = rect.bottom - rect.top;
 
            GetWindowRect(hwndDlg, &rect);
            DlgData->cxMin = rect.right - rect.left;
            DlgData->cyMin = rect.bottom - rect.top;
 
            /* Either get the values from list box or from edit box */
            if (DlgData->dwDlgID == IDD_EDIT_VARIABLE_FANCY)
            {
                /* Subclass the listview control first */
                SetWindowSubclass(hwndListView, ListViewSubclassProc, 1, 0);
 
                if (DlgData->VarData->lpRawValue != NULL)
                {
                    AddValuesToList(hwndDlg, DlgData);
                }
            }
            else
            {
                if (DlgData->VarData->lpName != NULL)
                {
                    SendDlgItemMessage(hwndDlg, IDC_VARIABLE_NAME, WM_SETTEXT, 0, (LPARAM)DlgData->VarData->lpName);
                }
 
                if (DlgData->VarData->lpRawValue != NULL)
                {
                    SendDlgItemMessage(hwndDlg, IDC_VARIABLE_VALUE, WM_SETTEXT, 0, (LPARAM)DlgData->VarData->lpRawValue);
                }
            }
            break;
        }
 
        case WM_SIZE:
        {
            OnEnvironmentEditDlgResize(hwndDlg, DlgData, LOWORD(lParam), HIWORD(lParam));
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, 0);
            return TRUE;
        }
 
        case WM_SIZING:
        {
            /* Forbid resizing the dialog smaller than its minimal size */
            PRECT pRect = (PRECT)lParam;
 
            if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->left = pRect->right - DlgData->cxMin;
            }
            else
            if ((wParam == WMSZ_RIGHT) || (wParam == WMSZ_TOPRIGHT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->right = pRect->left + DlgData->cxMin;
            }
 
            if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->top = pRect->bottom - DlgData->cyMin;
            }
            else
            if ((wParam == WMSZ_BOTTOM) || (wParam == WMSZ_BOTTOMLEFT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->bottom = pRect->top + DlgData->cyMin;
            }
 
            /* Make sure the normal variable edit dialog doesn't change its height */
            if (DlgData->dwDlgID == IDD_EDIT_VARIABLE)
            {
                if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT))
                {
                    if (pRect->bottom - pRect->top > DlgData->cyMin)
                        pRect->top = pRect->bottom - DlgData->cyMin;
                }
                else
                if ((wParam == WMSZ_BOTTOM) || (wParam == WMSZ_BOTTOMLEFT) || (wParam == WMSZ_BOTTOMRIGHT))
                {
                    if (pRect->bottom - pRect->top > DlgData->cyMin)
                        pRect->bottom = pRect->top + DlgData->cyMin;
                }
            }
 
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
            return TRUE;
        }
 
        case WM_NOTIFY:
        {
            return OnNotifyEditVariableDlg(hwndDlg, DlgData, (NMHDR*)lParam);
        }
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    LPTSTR p;
                    DWORD dwValueLength;
 
                    /* Either set the values to the list box or to the edit box */
                    if (DlgData->dwDlgID == IDD_EDIT_VARIABLE_FANCY)
                    {
                        dwValueLength = GatherDataFromListView(hwndListView, DlgData->VarData);
                    }
                    else
                    {
                        dwValueLength = GatherDataFromEditBox(hwndDlg, DlgData->VarData);
                    }
 
                    if (dwValueLength == 0)
                    {
                        break;
                    }
 
                    if (DlgData->VarData->lpCookedValue != NULL)
                    {
                        GlobalFree(DlgData->VarData->lpCookedValue);
                        DlgData->VarData->lpCookedValue = NULL;
                    }
 
                    p = _tcschr(DlgData->VarData->lpRawValue, _T('%'));
                    if (p && _tcschr(++p, _T('%')))
                    {
                        DlgData->VarData->dwType = REG_EXPAND_SZ;
 
                        DlgData->VarData->lpCookedValue = GlobalAlloc(GPTR, 2 * MAX_PATH * sizeof(TCHAR));
                        if (!DlgData->VarData->lpCookedValue)
                            return FALSE;
 
                        ExpandEnvironmentStrings(DlgData->VarData->lpRawValue,
                                                 DlgData->VarData->lpCookedValue,
                                                 2 * MAX_PATH);
                    }
                    else
                    {
                        DlgData->VarData->dwType = REG_SZ;
 
                        DlgData->VarData->lpCookedValue = GlobalAlloc(GPTR, (dwValueLength + 1) * sizeof(TCHAR));
                        if (!DlgData->VarData->lpCookedValue)
                            return FALSE;
 
                        _tcscpy(DlgData->VarData->lpCookedValue, DlgData->VarData->lpRawValue);
                    }
 
                    EndDialog(hwndDlg, 1);
                    return TRUE;
                }
 
                case IDCANCEL:
                    EndDialog(hwndDlg, 0);
                    return TRUE;
 
                case IDC_BUTTON_BROWSE_FILE:
                {
                    BrowseRequiredFile(hwndDlg);
                    break;
                }
 
                case IDC_BUTTON_BROWSE_FOLDER:
                {
                    BrowseRequiredFolder(hwndDlg, DlgData);
                    break;
                }
 
                case IDC_BUTTON_DELETE:
                {
                    DWORD dwLastIndex;
 
                    dwLastIndex = ListView_GetItemCount(hwndListView) - 1;
                    ListView_DeleteItem(hwndListView, DlgData->dwSelectedValueIndex);
 
                    if (dwLastIndex == DlgData->dwSelectedValueIndex)
                    {
                        DlgData->dwSelectedValueIndex--;
                    }
 
                    ListView_SetItemState(hwndListView, DlgData->dwSelectedValueIndex,
                                          LVIS_FOCUSED | LVIS_SELECTED,
                                          LVIS_FOCUSED | LVIS_SELECTED);
                    break;
                }
 
                case IDC_BUTTON_MOVE_UP:
                {
                    MoveListItem(hwndDlg, DlgData, TRUE);
                    break;
                }
 
                case IDC_BUTTON_MOVE_DOWN:
                {
                    MoveListItem(hwndDlg, DlgData, FALSE);
                    break;
                }
 
                case IDC_BUTTON_EDIT_TEXT:
                {
                    if (ResourceMessageBox(hApplet,
                                           hwndDlg,
                                           MB_OKCANCEL | MB_ICONWARNING | MB_DEFBUTTON1,
                                           IDS_ENVIRONMENT_WARNING_TITLE,
                                           IDS_ENVIRONMENT_WARNING) == IDOK)
                    {
                        EndDialog(hwndDlg, -1);
                    }
                    break;
                }
 
                case IDC_BUTTON_NEW:
                {
                    DlgData->dwSelectedValueIndex = ListView_GetItemCount(hwndListView);
                    AddEmptyItem(hwndListView, DlgData->dwSelectedValueIndex);
                    ListView_EditLabel(hwndListView, DlgData->dwSelectedValueIndex);
                    break;
                }
 
                case IDC_BUTTON_EDIT:
                {
                    ListView_EditLabel(hwndListView, DlgData->dwSelectedValueIndex);
                    break;
                }
            }
            break;
    }
 
    return FALSE;
}

Referenced by OnEditVariable(), and OnNewVariable().

EnvironmentDlgProc()

INT_PTR CALLBACK EnvironmentDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1823 of file environment.c.

{
    PENVIRONMENT_DIALOG_DATA DlgData;
    DlgData = (PENVIRONMENT_DIALOG_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            RECT rect;
 
            DlgData = GlobalAlloc(GPTR, sizeof(ENVIRONMENT_DIALOG_DATA));
            if (!DlgData)
            {
                EndDialog(hwndDlg, 0);
                return (INT_PTR)TRUE;
            }
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)DlgData);
 
            GetClientRect(hwndDlg, &rect);
            DlgData->cxOld = rect.right - rect.left;
            DlgData->cyOld = rect.bottom - rect.top;
 
            GetWindowRect(hwndDlg, &rect);
            DlgData->cxMin = rect.right - rect.left;
            DlgData->cyMin = rect.bottom - rect.top;
 
            OnInitEnvironmentDialog(hwndDlg);
            break;
        }
 
        case WM_SIZE:
        {
            OnEnvironmentDlgResize(hwndDlg, DlgData, LOWORD(lParam), HIWORD(lParam));
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, 0);
            return TRUE;
        }
 
        case WM_SIZING:
        {
            /* Forbid resizing the dialog smaller than its minimal size */
            PRECT pRect = (PRECT)lParam;
 
            if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->left = pRect->right - DlgData->cxMin;
            }
            else
            if ((wParam == WMSZ_RIGHT) || (wParam == WMSZ_TOPRIGHT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->right = pRect->left + DlgData->cxMin;
            }
 
            if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->top = pRect->bottom - DlgData->cyMin;
            }
            else
            if ((wParam == WMSZ_BOTTOM) || (wParam == WMSZ_BOTTOMLEFT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->bottom = pRect->top + DlgData->cyMin;
            }
 
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
            return TRUE;
        }
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_USER_VARIABLE_NEW:
                    OnNewVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_USER_VARIABLE_EDIT:
                    OnEditVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_USER_VARIABLE_DELETE:
                    OnDeleteVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_NEW:
                    OnNewVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_EDIT:
                    OnEditVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_DELETE:
                    OnDeleteVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDOK:
                    SetAllVars(hwndDlg, IDC_USER_VARIABLE_LIST);
                    SetAllVars(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    SendMessage(HWND_BROADCAST, WM_WININICHANGE,
                                0, (LPARAM)_T("Environment"));
                    EndDialog(hwndDlg, 0);
                    return TRUE;
 
                case IDCANCEL:
                    EndDialog(hwndDlg, 0);
                    return TRUE;
            }
            break;
 
        case WM_DESTROY:
            ReleaseListViewItems(hwndDlg, IDC_USER_VARIABLE_LIST);
            ReleaseListViewItems(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
            GlobalFree(DlgData);
            break;
 
        case WM_NOTIFY:
            return OnNotify(hwndDlg, (NMHDR*)lParam);
    }
 
    return FALSE;
}

Referenced by AdvancedPageProc().

GatherDataFromEditBox()

static DWORD GatherDataFromEditBox ( HWND  hwndDlg, PVARIABLE_DATA  VarData  )

static

Definition at line 74 of file environment.c.

{
    DWORD dwNameLength;
    DWORD dwValueLength;
 
    dwNameLength = SendDlgItemMessage(hwndDlg, IDC_VARIABLE_NAME, WM_GETTEXTLENGTH, 0, 0);
    dwValueLength = SendDlgItemMessage(hwndDlg, IDC_VARIABLE_VALUE, WM_GETTEXTLENGTH, 0, 0);
 
    if (dwNameLength == 0 || dwValueLength == 0)
    {
        return 0;
    }
 
    /* Reallocate the name buffer, regrowing it if necessary */
    if (!VarData->lpName || (_tcslen(VarData->lpName) < dwNameLength))
    {
        if (VarData->lpName)
            GlobalFree(VarData->lpName);
 
        VarData->lpName = GlobalAlloc(GPTR, (dwNameLength + 1) * sizeof(TCHAR));
        if (!VarData->lpName)
            return 0;
    }
    SendDlgItemMessage(hwndDlg, IDC_VARIABLE_NAME, WM_GETTEXT, dwNameLength + 1, (LPARAM)VarData->lpName);
 
    /* Reallocate the value buffer, regrowing it if necessary */
    if (!VarData->lpRawValue || (_tcslen(VarData->lpRawValue) < dwValueLength))
    {
        if (VarData->lpRawValue)
            GlobalFree(VarData->lpRawValue);
 
        VarData->lpRawValue = GlobalAlloc(GPTR, (dwValueLength + 1) * sizeof(TCHAR));
        if (!VarData->lpRawValue)
            return 0;
    }
    SendDlgItemMessage(hwndDlg, IDC_VARIABLE_VALUE, WM_GETTEXT, dwValueLength + 1, (LPARAM)VarData->lpRawValue);
 
    return dwValueLength;
}

Referenced by EditVariableDlgProc().

GatherDataFromListView()

static DWORD GatherDataFromListView ( HWND  hwndListView, PVARIABLE_DATA  VarData  )

static

Definition at line 116 of file environment.c.

{
    DWORD dwValueLength;
    DWORD NumberOfItems;
    DWORD i;
    TCHAR szData[MAX_PATH];
 
    /* Gather the number of items for the semi-colon */
    NumberOfItems = ListView_GetItemCount(hwndListView);
    if (NumberOfItems == 0)
    {
        return 0;
    }
 
    /* Since the last item doesn't need the semi-colon subtract 1 */
    dwValueLength = NumberOfItems - 1;
 
    for (i = 0; i < NumberOfItems; i++)
    {
        ListView_GetItemText(hwndListView,
                             i,
                             0,
                             szData,
                             _countof(szData));
        dwValueLength += _tcslen(szData);
    }
 
    /* Reallocate the value buffer, regrowing it if necessary */
    if (!VarData->lpRawValue || (_tcslen(VarData->lpRawValue) < dwValueLength))
    {
        if (VarData->lpRawValue)
            GlobalFree(VarData->lpRawValue);
 
        VarData->lpRawValue = GlobalAlloc(GPTR, (dwValueLength + 1) * sizeof(TCHAR));
        if (!VarData->lpRawValue)
            return 0;
    }
 
    /* First reinitialize the value buffer, then copy the variable values while
     * separating them with a semi-colon, except for the last value. */
    VarData->lpRawValue[0] = _T('\0');
    for (i = 0; i < NumberOfItems; i++)
    {
        if (i > 0)
        {
            StringCchCat(VarData->lpRawValue, dwValueLength + 1, _T(";"));
        }
        ListView_GetItemText(hwndListView,
                             i,
                             0,
                             szData,
                             _countof(szData));
        StringCchCat(VarData->lpRawValue, dwValueLength + 1, szData);
    }
    return dwValueLength;
}

Referenced by EditVariableDlgProc().

GetEnvironmentVariables()

static VOID GetEnvironmentVariables ( HWND  hwndListView, HKEY  hRootKey, LPTSTR  lpSubKeyName  )

static

Definition at line 1019 of file environment.c.

{
    HKEY hKey;
    DWORD dwValues;
    DWORD dwMaxValueNameLength;
    DWORD dwMaxValueDataLength;
    DWORD i;
    LPTSTR lpName;
    LPTSTR lpData;
    LPTSTR lpExpandData;
    DWORD dwNameLength;
    DWORD dwDataLength;
    DWORD dwType;
    PVARIABLE_DATA VarData;
 
    LV_ITEM lvi;
    int iItem;
 
    if (RegOpenKeyEx(hRootKey,
                     lpSubKeyName,
                     0,
                     KEY_READ,
                     &hKey))
        return;
 
    if (RegQueryInfoKey(hKey,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        &dwValues,
                        &dwMaxValueNameLength,
                        &dwMaxValueDataLength,
                        NULL,
                        NULL))
    {
        RegCloseKey(hKey);
        return;
    }
 
    lpName = GlobalAlloc(GPTR, (dwMaxValueNameLength + 1) * sizeof(TCHAR));
    if (lpName == NULL)
    {
        RegCloseKey(hKey);
        return;
    }
 
    lpData = GlobalAlloc(GPTR, (dwMaxValueDataLength + 1) * sizeof(TCHAR));
    if (lpData == NULL)
    {
        GlobalFree(lpName);
        RegCloseKey(hKey);
        return;
    }
 
    lpExpandData = GlobalAlloc(GPTR, 2048 * sizeof(TCHAR));
    if (lpExpandData == NULL)
    {
        GlobalFree(lpName);
        GlobalFree(lpData);
        RegCloseKey(hKey);
        return;
    }
 
    for (i = 0; i < dwValues; i++)
    {
        dwNameLength = dwMaxValueNameLength + 1;
        dwDataLength = dwMaxValueDataLength + 1;
 
        if (RegEnumValue(hKey,
                         i,
                         lpName,
                         &dwNameLength,
                         NULL,
                         &dwType,
                         (LPBYTE)lpData,
                         &dwDataLength))
        {
            GlobalFree(lpExpandData);
            GlobalFree(lpName);
            GlobalFree(lpData);
            RegCloseKey(hKey);
            return;
        }
 
        if (dwType != REG_SZ && dwType != REG_EXPAND_SZ)
            continue;
 
        VarData = GlobalAlloc(GPTR, sizeof(VARIABLE_DATA));
 
        VarData->dwType = dwType;
 
        VarData->lpName = GlobalAlloc(GPTR, (dwNameLength + 1) * sizeof(TCHAR));
        _tcscpy(VarData->lpName, lpName);
 
        VarData->lpRawValue = GlobalAlloc(GPTR, (dwDataLength + 1) * sizeof(TCHAR));
        _tcscpy(VarData->lpRawValue, lpData);
 
        ExpandEnvironmentStrings(lpData, lpExpandData, 2048);
 
        VarData->lpCookedValue = GlobalAlloc(GPTR, (_tcslen(lpExpandData) + 1) * sizeof(TCHAR));
        _tcscpy(VarData->lpCookedValue, lpExpandData);
 
        memset(&lvi, 0x00, sizeof(lvi));
        lvi.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
        lvi.lParam = (LPARAM)VarData;
        lvi.pszText = VarData->lpName;
        lvi.state = (i == 0) ? LVIS_SELECTED : 0;
        iItem = ListView_InsertItem(hwndListView, &lvi);
 
        ListView_SetItemText(hwndListView, iItem, 1, VarData->lpCookedValue);
    }
 
    GlobalFree(lpExpandData);
    GlobalFree(lpName);
    GlobalFree(lpData);
    RegCloseKey(hKey);
}

Referenced by OnInitEnvironmentDialog().

GetSelectedListViewItem()

static INT GetSelectedListViewItem ( HWND  hwndListView )

static

Definition at line 175 of file environment.c.

{
    INT iCount;
    INT iItem;
 
    iCount = SendMessage(hwndListView,
                         LVM_GETITEMCOUNT,
                         0,
                         0);
    if (iCount != LB_ERR)
    {
        for (iItem = 0; iItem < iCount; iItem++)
        {
            if (SendMessage(hwndListView,
                            LVM_GETITEMSTATE,
                            iItem,
                            (LPARAM) LVIS_SELECTED) == LVIS_SELECTED)
            {
                return iItem;
            }
        }
    }
 
    return -1;
}

Referenced by OnDeleteVariable(), and OnEditVariable().

ListViewSubclassProc()

static LRESULT CALLBACK ListViewSubclassProc ( HWND  hListBox, UINT  uMsg, WPARAM  wParam, LPARAM  lParam, UINT_PTR  uIdSubclass, DWORD_PTR  dwRefData  )

static

Definition at line 202 of file environment.c.

{
    switch (uMsg)
    {
        case WM_DESTROY:
        {
            RemoveWindowSubclass(hListBox, ListViewSubclassProc, uIdSubclass);
            break;
        }
 
        /* Whenever the control is resized make sure it doesn't spawn the horizontal scrollbar */
        case WM_SIZE:
        {
            ShowScrollBar(hListBox, SB_HORZ, FALSE);
            break;
        }
    }
 
    return DefSubclassProc(hListBox, uMsg, wParam, lParam);
}

Referenced by EditVariableDlgProc(), and ListViewSubclassProc().

MoveListItem()

static VOID MoveListItem ( HWND  hwndDlg, PEDIT_DIALOG_DATA  DlgData, BOOL  bMoveUp  )

static

Definition at line 374 of file environment.c.

{
    TCHAR szDest[MAX_PATH];
    TCHAR szSource[MAX_PATH];
    HWND hwndListView;
    DWORD dwSrcIndex, dwDestIndex, dwLastIndex;
 
    hwndListView = GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE);
 
    dwLastIndex = ListView_GetItemCount(hwndListView) - 1;
    dwSrcIndex = DlgData->dwSelectedValueIndex;
    dwDestIndex = bMoveUp ? (dwSrcIndex - 1) : (dwSrcIndex + 1);
 
    if ((bMoveUp && dwSrcIndex > 0) || (!bMoveUp && dwSrcIndex < dwLastIndex))
    {
        ListView_GetItemText(hwndListView,
                             dwSrcIndex,
                             0,
                             szDest,
                             _countof(szDest));
        ListView_GetItemText(hwndListView,
                             dwDestIndex,
                             0,
                             szSource,
                             _countof(szSource));
 
        ListView_SetItemText(hwndListView,
                             dwDestIndex,
                             0,
                             szDest);
        ListView_SetItemText(hwndListView,
                             dwSrcIndex,
                             0,
                             szSource);
 
        DlgData->dwSelectedValueIndex = dwDestIndex;
        ListView_SetItemState(hwndListView, DlgData->dwSelectedValueIndex,
                              LVIS_FOCUSED | LVIS_SELECTED,
                              LVIS_FOCUSED | LVIS_SELECTED);
    }
}

Referenced by EditVariableDlgProc().

OnBeginLabelEdit()

static BOOL OnBeginLabelEdit ( NMLVDISPINFO *  pnmv )

static

Definition at line 650 of file environment.c.

{
    HWND hwndEdit;
 
    hwndEdit = ListView_GetEditControl(pnmv->hdr.hwndFrom);
    if (hwndEdit == NULL)
    {
        return TRUE;
    }
 
    SendMessage(hwndEdit, EM_SETLIMITTEXT, MAX_PATH - 1, 0);
 
    return FALSE;
}

Referenced by OnNotifyEditVariableDlg().

OnDeleteVariable()

static VOID OnDeleteVariable ( HWND  hwndDlg, INT  iDlgItem  )

static

Definition at line 1333 of file environment.c.

{
    HWND hwndListView;
    PVARIABLE_DATA VarData;
    LV_ITEM lvi;
    INT iItem;
 
    hwndListView = GetDlgItem(hwndDlg, iDlgItem);
 
    iItem = GetSelectedListViewItem(hwndListView);
    if (iItem != -1)
    {
        memset(&lvi, 0x00, sizeof(lvi));
        lvi.mask = LVIF_PARAM;
        lvi.iItem = iItem;
 
        if (ListView_GetItem(hwndListView, &lvi))
        {
            VarData = (PVARIABLE_DATA)lvi.lParam;
            if (VarData != NULL)
            {
                if (VarData->lpName != NULL)
                    GlobalFree(VarData->lpName);
 
                if (VarData->lpRawValue != NULL)
                    GlobalFree(VarData->lpRawValue);
 
                if (VarData->lpCookedValue != NULL)
                    GlobalFree(VarData->lpCookedValue);
 
                GlobalFree(VarData);
                lvi.lParam = 0;
            }
        }
 
        (void)ListView_DeleteItem(hwndListView, iItem);
 
        /* Select the previous item */
        if (iItem > 0)
            iItem--;
 
        ListView_SetItemState(hwndListView, iItem,
                              LVIS_FOCUSED | LVIS_SELECTED,
                              LVIS_FOCUSED | LVIS_SELECTED);
    }
}

Referenced by EnvironmentDlgProc(), and OnNotify().

OnEditVariable()

static VOID OnEditVariable ( HWND  hwndDlg, INT  iDlgItem  )

static

Definition at line 1270 of file environment.c.

{
    HWND hwndListView;
    PEDIT_DIALOG_DATA DlgData;
    LV_ITEM lvi;
    INT iItem;
    INT iRet;
 
    DlgData = GlobalAlloc(GPTR, sizeof(EDIT_DIALOG_DATA));
    if (!DlgData)
        return;
 
    DlgData->dwDlgID = IDD_EDIT_VARIABLE;
    DlgData->dwSelectedValueIndex = -1;
 
    hwndListView = GetDlgItem(hwndDlg, iDlgItem);
 
    iItem = GetSelectedListViewItem(hwndListView);
    if (iItem != -1)
    {
        ZeroMemory(&lvi, sizeof(lvi));
        lvi.mask = LVIF_PARAM;
        lvi.iItem = iItem;
 
        if (ListView_GetItem(hwndListView, &lvi))
        {
            DlgData->VarData = (PVARIABLE_DATA)lvi.lParam;
 
            /* If the value has multiple values and directories then edit value with fancy dialog box */
            if (DetermineDialogBoxType(DlgData->VarData->lpRawValue))
                DlgData->dwDlgID = IDD_EDIT_VARIABLE_FANCY;
 
            iRet = DialogBoxParam(hApplet,
                                  MAKEINTRESOURCE(DlgData->dwDlgID),
                                  hwndDlg,
                                  EditVariableDlgProc,
                                  (LPARAM)DlgData);
 
            /* If iRet is less than 0 edit the value and name normally */
            if (iRet < 0)
            {
                DlgData->dwDlgID = IDD_EDIT_VARIABLE;
                iRet = DialogBoxParam(hApplet,
                                      MAKEINTRESOURCE(DlgData->dwDlgID),
                                      hwndDlg,
                                      EditVariableDlgProc,
                                      (LPARAM)DlgData);
            }
 
            if (iRet > 0)
            {
                ListView_SetItemText(hwndListView, iItem, 0, DlgData->VarData->lpName);
                ListView_SetItemText(hwndListView, iItem, 1, DlgData->VarData->lpCookedValue);
            }
        }
 
        GlobalFree(DlgData);
    }
}

Referenced by EnvironmentDlgProc(), and OnNotify().

OnEndLabelEdit()

static BOOL OnEndLabelEdit ( NMLVDISPINFO *  pnmv )

static

Definition at line 666 of file environment.c.

{
    HWND hwndEdit;
    TCHAR szOldDir[MAX_PATH];
    TCHAR szNewDir[MAX_PATH];
 
    hwndEdit = ListView_GetEditControl(pnmv->hdr.hwndFrom);
    if (hwndEdit == NULL)
    {
        return TRUE;
    }
 
    /* Leave, if there is no valid listview item */
    if (pnmv->item.iItem == -1)
    {
        return FALSE;
    }
 
    ListView_GetItemText(pnmv->hdr.hwndFrom,
                         pnmv->item.iItem, 0,
                         szOldDir,
                         _countof(szOldDir));
 
    SendMessage(hwndEdit, WM_GETTEXT, _countof(szNewDir), (LPARAM)szNewDir);
 
    /* If there is nothing in the text box then remove the item */
    if (_tcslen(szNewDir) == 0)
    {
        ListView_DeleteItem(pnmv->hdr.hwndFrom, pnmv->item.iItem);
        ListView_SetItemState(pnmv->hdr.hwndFrom, pnmv->item.iItem - 1,
                              LVIS_FOCUSED | LVIS_SELECTED,
                              LVIS_FOCUSED | LVIS_SELECTED);
        return FALSE;
    }
 
    /* If nothing has been changed then just bail out */
    if (_tcscmp(szOldDir, szNewDir) == 0)
    {
        return FALSE;
    }
 
    ListView_SetItemText(pnmv->hdr.hwndFrom,
                         pnmv->item.iItem, 0,
                         szNewDir);
 
    return TRUE;
}

Referenced by OnNotifyEditVariableDlg().

OnEnvironmentDlgResize()

static VOID OnEnvironmentDlgResize ( HWND  hwndDlg, PENVIRONMENT_DIALOG_DATA  DlgData, DWORD  cx, DWORD  cy  )

static

Definition at line 1382 of file environment.c.

{
    RECT rect;
    INT Colx, y = 0;
    HDWP hdwp = NULL;
    HWND hItemWnd;
 
    if ((cx == DlgData->cxOld) && (cy == DlgData->cyOld))
        return;
 
    hdwp = BeginDeferWindowPos(13);
 
    if (cy >= DlgData->cyOld)
        y += (cy - DlgData->cyOld + 1) / 2;
    else
        y -= (DlgData->cyOld - cy + 1) / 2;
 
    /* For the group box controls */
    hItemWnd = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_GROUP);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              0, 0,
                              (rect.right - rect.left) + (cx - DlgData->cxOld),
                              (rect.bottom - rect.top) + y,
                              SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_GROUP);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left, rect.top + y,
                              (rect.right - rect.left) + (cx - DlgData->cxOld),
                              (rect.bottom - rect.top) + y,
                              SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    /* For the list view controls */
    hItemWnd = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_LIST);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              0, 0,
                              (rect.right - rect.left) + (cx - DlgData->cxOld),
                              (rect.bottom - rect.top) + y,
                              SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
        Colx = ListView_GetColumnWidth(hItemWnd, 1);
        ListView_SetColumnWidth(hItemWnd, 1, Colx + (cx - DlgData->cxOld));
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left, rect.top + y,
                              (rect.right - rect.left) + (cx - DlgData->cxOld),
                              (rect.bottom - rect.top) + y,
                              SWP_NOZORDER | SWP_NOACTIVATE);
        Colx = ListView_GetColumnWidth(hItemWnd, 1);
        ListView_SetColumnWidth(hItemWnd, 1, Colx + (cx - DlgData->cxOld));
    }
 
    /* For the buttons */
    hItemWnd = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_NEW);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_EDIT);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_DELETE);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_NEW);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y * 2,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_EDIT);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y * 2,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_DELETE);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + y * 2,
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDOK);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDCANCEL);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    /* For the size grip */
    hItemWnd = GetDlgItem(hwndDlg, IDC_DIALOG_GRIP);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    if (hdwp)
    {
        EndDeferWindowPos(hdwp);
    }
 
    DlgData->cxOld = cx;
    DlgData->cyOld = cy;
}

Referenced by EnvironmentDlgProc().

OnEnvironmentEditDlgResize()

static VOID OnEnvironmentEditDlgResize ( HWND  hwndDlg, PEDIT_DIALOG_DATA  DlgData, DWORD  cx, DWORD  cy  )

static

Definition at line 419 of file environment.c.

{
    RECT rect;
    HDWP hdwp = NULL;
    HWND hItemWnd;
 
    if ((cx == DlgData->cxOld) && (cy == DlgData->cyOld))
        return;
 
    if (DlgData->dwDlgID == IDD_EDIT_VARIABLE)
    {
        hdwp = BeginDeferWindowPos(5);
 
        /* For the edit control */
        hItemWnd = GetDlgItem(hwndDlg, IDC_VARIABLE_NAME);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  0, 0,
                                  (rect.right - rect.left) + (cx - DlgData->cxOld),
                                  rect.bottom - rect.top,
                                  SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_VARIABLE_VALUE);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  0, 0,
                                  (rect.right - rect.left) + (cx - DlgData->cxOld),
                                  rect.bottom - rect.top,
                                  SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
    }
    else if (DlgData->dwDlgID == IDD_EDIT_VARIABLE_FANCY)
    {
        hdwp = BeginDeferWindowPos(11);
 
        /* For the list view control */
        hItemWnd = GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  0, 0,
                                  (rect.right - rect.left) + (cx - DlgData->cxOld),
                                  (rect.bottom - rect.top) + (cy - DlgData->cyOld),
                                  SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
            ListView_SetColumnWidth(hItemWnd, 0, (rect.right - rect.left) + (cx - DlgData->cxOld));
        }
 
        /* For the buttons */
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_BROWSE_FOLDER);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_NEW);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_EDIT);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_DELETE);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_MOVE_UP);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_MOVE_DOWN);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        hItemWnd = GetDlgItem(hwndDlg, IDC_BUTTON_EDIT_TEXT);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
        {
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  NULL,
                                  rect.left + (cx - DlgData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDOK);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    hItemWnd = GetDlgItem(hwndDlg, IDCANCEL);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    /* For the size grip */
    hItemWnd = GetDlgItem(hwndDlg, IDC_DIALOG_GRIP);
    GetWindowRect(hItemWnd, &rect);
    MapWindowPoints(HWND_DESKTOP, hwndDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
    if (hdwp)
    {
        hdwp = DeferWindowPos(hdwp,
                              hItemWnd,
                              NULL,
                              rect.left + (cx - DlgData->cxOld),
                              rect.top + (cy - DlgData->cyOld),
                              0, 0,
                              SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    if (hdwp)
    {
        EndDeferWindowPos(hdwp);
    }
 
    DlgData->cxOld = cx;
    DlgData->cyOld = cy;
}

Referenced by EditVariableDlgProc().

OnInitEnvironmentDialog()

static VOID OnInitEnvironmentDialog ( HWND  hwndDlg )

static

Definition at line 1170 of file environment.c.

{
    HWND hwndListView;
 
    /* Set user environment variables */
    hwndListView = GetDlgItem(hwndDlg, IDC_USER_VARIABLE_LIST);
 
    (void)ListView_SetExtendedListViewStyle(hwndListView, LVS_EX_FULLROWSELECT);
 
    SetEnvironmentDialogListViewColumns(hwndListView);
 
    GetEnvironmentVariables(hwndListView,
                            HKEY_CURRENT_USER,
                            _T("Environment"));
 
    (void)ListView_SetColumnWidth(hwndListView, 2, LVSCW_AUTOSIZE_USEHEADER);
 
    ListView_SetItemState(hwndListView, 0,
                          LVIS_FOCUSED | LVIS_SELECTED,
                          LVIS_FOCUSED | LVIS_SELECTED);
 
    (void)ListView_Update(hwndListView,0);
 
    /* Set system environment variables */
    hwndListView = GetDlgItem(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
 
    (void)ListView_SetExtendedListViewStyle(hwndListView, LVS_EX_FULLROWSELECT);
 
    SetEnvironmentDialogListViewColumns(hwndListView);
 
    GetEnvironmentVariables(hwndListView,
                            HKEY_LOCAL_MACHINE,
                            _T("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"));
 
    (void)ListView_SetColumnWidth(hwndListView, 2, LVSCW_AUTOSIZE_USEHEADER);
 
    ListView_SetItemState(hwndListView, 0,
                          LVIS_FOCUSED | LVIS_SELECTED,
                          LVIS_FOCUSED | LVIS_SELECTED);
 
    (void)ListView_Update(hwndListView, 0);
}

Referenced by EnvironmentDlgProc().

OnNewVariable()

static VOID OnNewVariable ( HWND  hwndDlg, INT  iDlgItem  )

static

Definition at line 1215 of file environment.c.

{
    HWND hwndListView;
    PEDIT_DIALOG_DATA DlgData;
    LV_ITEM lvi;
    INT iItem;
 
    DlgData = GlobalAlloc(GPTR, sizeof(EDIT_DIALOG_DATA));
    if (!DlgData)
        return;
 
    hwndListView = GetDlgItem(hwndDlg, iDlgItem);
    DlgData->dwDlgID = IDD_EDIT_VARIABLE;
    DlgData->dwSelectedValueIndex = -1;
 
    DlgData->VarData = GlobalAlloc(GPTR, sizeof(VARIABLE_DATA));
    if (!DlgData->VarData)
        return;
 
    if (DialogBoxParam(hApplet,
                       MAKEINTRESOURCE(DlgData->dwDlgID),
                       hwndDlg,
                       EditVariableDlgProc,
                       (LPARAM)DlgData) <= 0)
    {
        if (DlgData->VarData->lpName != NULL)
            GlobalFree(DlgData->VarData->lpName);
 
        if (DlgData->VarData->lpRawValue != NULL)
            GlobalFree(DlgData->VarData->lpRawValue);
 
        if (DlgData->VarData->lpCookedValue != NULL)
            GlobalFree(DlgData->VarData->lpCookedValue);
 
        GlobalFree(DlgData);
    }
    else
    {
        if (DlgData->VarData->lpName != NULL && (DlgData->VarData->lpCookedValue || DlgData->VarData->lpRawValue))
        {
            ZeroMemory(&lvi, sizeof(lvi));
            lvi.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
            lvi.lParam = (LPARAM)DlgData->VarData;
            lvi.pszText = DlgData->VarData->lpName;
            lvi.state = 0;
            iItem = ListView_InsertItem(hwndListView, &lvi);
 
            ListView_SetItemText(hwndListView, iItem, 1, DlgData->VarData->lpCookedValue);
        }
    }
}

Referenced by EnvironmentDlgProc().

OnNotify()

static BOOL OnNotify ( HWND  hwndDlg, NMHDR *  phdr  )

static

Definition at line 1793 of file environment.c.

{
    switch (phdr->code)
    {
        case NM_DBLCLK:
            if (phdr->idFrom == IDC_USER_VARIABLE_LIST ||
                phdr->idFrom == IDC_SYSTEM_VARIABLE_LIST)
            {
                OnEditVariable(hwndDlg, (INT)phdr->idFrom);
                return TRUE;
            }
            break;
 
        case LVN_KEYDOWN:
            if (((LPNMLVKEYDOWN)phdr)->wVKey == VK_DELETE &&
                (phdr->idFrom == IDC_USER_VARIABLE_LIST ||
                 phdr->idFrom == IDC_SYSTEM_VARIABLE_LIST))
            {
                OnDeleteVariable(hwndDlg, (INT)phdr->idFrom);
                return TRUE;
            }
            break;
    }
 
    return FALSE;
}

Referenced by EnvironmentDlgProc().

OnNotifyEditVariableDlg()

static BOOL OnNotifyEditVariableDlg ( HWND  hwndDlg, PEDIT_DIALOG_DATA  DlgData, NMHDR *  phdr  )

static

Definition at line 715 of file environment.c.

{
    LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)phdr;
 
    switch (phdr->idFrom)
    {
        case IDC_LIST_VARIABLE_VALUE:
            switch (phdr->code)
            {
                case NM_CLICK:
                {
                    /* Detect if an item is selected */
                    DlgData->bIsItemSelected = (lpnmlv->iItem != -1);
                    if (lpnmlv->iItem != -1)
                    {
                        DlgData->dwSelectedValueIndex = lpnmlv->iItem;
                    }
                    break;
                }
 
                case NM_DBLCLK:
                {
                    /* Either simulate IDC_BUTTON_NEW or edit an item depending upon the condition */
                    if (lpnmlv->iItem == -1)
                    {
                        SendMessage(GetDlgItem(hwndDlg, IDC_BUTTON_NEW), BM_CLICK, 0, 0);
                    }
                    else
                    {
                        ListView_EditLabel(GetDlgItem(hwndDlg, IDC_LIST_VARIABLE_VALUE), DlgData->dwSelectedValueIndex);
                    }
                    break;
                }
 
                case LVN_BEGINLABELEDIT:
                {
                    return OnBeginLabelEdit((NMLVDISPINFO*)phdr);
                }
 
                case LVN_ENDLABELEDIT:
                {
                    return OnEndLabelEdit((NMLVDISPINFO*)phdr);
                }
            }
            break;
    }
 
    return FALSE;
}

Referenced by EditVariableDlgProc().

ReleaseListViewItems()

static VOID ReleaseListViewItems ( HWND  hwndDlg, INT  iDlgItem  )

static

Definition at line 1615 of file environment.c.

{
    HWND hwndListView;
    PVARIABLE_DATA VarData;
    LV_ITEM lvi;
    INT nItemCount;
    INT i;
 
    hwndListView = GetDlgItem(hwndDlg, iDlgItem);
 
    memset(&lvi, 0x00, sizeof(lvi));
 
    nItemCount = ListView_GetItemCount(hwndListView);
    for (i = 0; i < nItemCount; i++)
    {
        lvi.mask = LVIF_PARAM;
        lvi.iItem = i;
 
        if (ListView_GetItem(hwndListView, &lvi))
        {
            VarData = (PVARIABLE_DATA)lvi.lParam;
            if (VarData != NULL)
            {
                if (VarData->lpName != NULL)
                    GlobalFree(VarData->lpName);
 
                if (VarData->lpRawValue != NULL)
                    GlobalFree(VarData->lpRawValue);
 
                if (VarData->lpCookedValue != NULL)
                    GlobalFree(VarData->lpCookedValue);
 
                GlobalFree(VarData);
                lvi.lParam = 0;
            }
        }
    }
}

Referenced by EnvironmentDlgProc().

SetAllVars()

static VOID SetAllVars ( HWND  hwndDlg, INT  iDlgItem  )

static

Definition at line 1657 of file environment.c.

{
    HWND hwndListView;
    PVARIABLE_DATA VarData;
    LV_ITEM lvi;
    INT iItem;
    HKEY hKey;
    DWORD dwValueCount;
    DWORD dwMaxValueNameLength;
    LPTSTR *aValueArray;
    DWORD dwNameLength;
    DWORD i;
    TCHAR szBuffer[256];
    LPTSTR lpBuffer;
 
    memset(&lvi, 0x00, sizeof(lvi));
 
    /* Get the handle to the list box with all system vars in it */
    hwndListView = GetDlgItem(hwndDlg, iDlgItem);
    /* First item is 0 */
    iItem = 0;
    /* Set up struct to retrieve item */
    lvi.mask = LVIF_PARAM;
    lvi.iItem = iItem;
 
    /* Open or create the key */
    if (RegCreateKeyEx((iDlgItem == IDC_SYSTEM_VARIABLE_LIST ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER),
                       (iDlgItem == IDC_SYSTEM_VARIABLE_LIST ? _T("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment") : _T("Environment")),
                       0,
                       NULL,
                       REG_OPTION_NON_VOLATILE,
                       KEY_WRITE | KEY_READ,
                       NULL,
                       &hKey,
                       NULL))
    {
        return;
    }
 
    /* Get the number of values and the maximum value name length */
    if (RegQueryInfoKey(hKey,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        &dwValueCount,
                        &dwMaxValueNameLength,
                        NULL,
                        NULL,
                        NULL))
    {
        RegCloseKey(hKey);
        return;
    }
 
    if (dwValueCount > 0)
    {
        /* Allocate the value array */
        aValueArray = GlobalAlloc(GPTR, dwValueCount * sizeof(LPTSTR));
        if (aValueArray != NULL)
        {
            /* Get all value names */
            for (i = 0; i < dwValueCount; i++)
            {
                dwNameLength = 256;
                if (!RegEnumValue(hKey,
                                  i,
                                  szBuffer,
                                  &dwNameLength,
                                  NULL,
                                  NULL,
                                  NULL,
                                  NULL))
                {
                    /* Allocate a value name buffer, fill it and attach it to the array */
                    lpBuffer = (LPTSTR)GlobalAlloc(GPTR, (dwNameLength + 1) * sizeof(TCHAR));
                    if (lpBuffer != NULL)
                    {
                        _tcscpy(lpBuffer, szBuffer);
                        aValueArray[i] = lpBuffer;
                    }
                }
            }
 
            /* Delete all values */
            for (i = 0; i < dwValueCount; i++)
            {
                if (aValueArray[i] != NULL)
                {
                    /* Delete the value */
                    RegDeleteValue(hKey,
                                   aValueArray[i]);
 
                    /* Free the value name */
                    GlobalFree(aValueArray[i]);
                }
            }
 
            /* Free the value array */
            GlobalFree(aValueArray);
        }
    }
 
    /* Loop through all variables */
    while (ListView_GetItem(hwndListView, &lvi))
    {
        /* Get the data in each item */
        VarData = (PVARIABLE_DATA)lvi.lParam;
        if (VarData != NULL)
        {
            /* Set the new value */
            if (RegSetValueEx(hKey,
                              VarData->lpName,
                              0,
                              VarData->dwType,
                              (LPBYTE)VarData->lpRawValue,
                              (DWORD)(_tcslen(VarData->lpRawValue) + 1) * sizeof(TCHAR)))
            {
                RegCloseKey(hKey);
                return;
            }
        }
 
        /* Fill struct for next item */
        lvi.mask = LVIF_PARAM;
        lvi.iItem = ++iItem;
    }
 
    RegCloseKey(hKey);
}

Referenced by EnvironmentDlgProc().

SetEnvironmentDialogListViewColumns()

static VOID SetEnvironmentDialogListViewColumns ( HWND  hwndListView )

static

Definition at line 1144 of file environment.c.

{
    RECT rect;
    LV_COLUMN column;
    TCHAR szStr[32];
 
    GetClientRect(hwndListView, &rect);
 
    memset(&column, 0x00, sizeof(column));
    column.mask=LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM | LVCF_TEXT;
    column.fmt=LVCFMT_LEFT;
    column.cx = (INT)((rect.right - rect.left) * 0.32);
    column.iSubItem = 0;
    LoadString(hApplet, IDS_VARIABLE, szStr, sizeof(szStr) / sizeof(szStr[0]));
    column.pszText = szStr;
    (void)ListView_InsertColumn(hwndListView, 0, &column);
 
    column.cx = (INT)((rect.right - rect.left) * 0.63);
    column.iSubItem = 1;
    LoadString(hApplet, IDS_VALUE, szStr, sizeof(szStr) / sizeof(szStr[0]));
    column.pszText = szStr;
    (void)ListView_InsertColumn(hwndListView, 1, &column);
}

Referenced by OnInitEnvironmentDialog().