xref: /reactos/dll/cpl/sysdm/virtmem.c (revision 41805926) 
1 /*
2  * PROJECT:     ReactOS system properties, control panel applet
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        dll/cpl/sysdm/virtmem.c
5  * PURPOSE:     Virtual memory control dialog
6  * COPYRIGHT:   Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
7  *
8  */
9 
10 #include "precomp.h"
11 
12 #define NDEBUG
13 #include <debug.h>
14 
15 static BOOL OnSelChange(HWND hwndDlg, PVIRTMEM pVirtMem);
16 static LPCTSTR lpKey = _T("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management");
17 
18 static BOOL
19 ReadPageFileSettings(PVIRTMEM pVirtMem)
20 {
21     HKEY hkey = NULL;
22     DWORD dwType;
23     DWORD dwDataSize;
24     BOOL bRet = FALSE;
25 
26     if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
27                        lpKey,
28                        0,
29                        NULL,
30                        REG_OPTION_NON_VOLATILE,
31                        KEY_QUERY_VALUE,
32                        NULL,
33                        &hkey,
34                        NULL) == ERROR_SUCCESS)
35     {
36         if (RegQueryValueEx(hkey,
37                             _T("PagingFiles"),
38                             NULL,
39                             &dwType,
40                             NULL,
41                             &dwDataSize) == ERROR_SUCCESS)
42         {
43             pVirtMem->szPagingFiles = (LPTSTR)HeapAlloc(GetProcessHeap(),
44                                                         0,
45                                                         dwDataSize);
46             if (pVirtMem->szPagingFiles != NULL)
47             {
48                 ZeroMemory(pVirtMem->szPagingFiles,
49                            dwDataSize);
50                 if (RegQueryValueEx(hkey,
51                                     _T("PagingFiles"),
52                                     NULL,
53                                     &dwType,
54                                     (PBYTE)pVirtMem->szPagingFiles,
55                                     &dwDataSize) == ERROR_SUCCESS)
56                 {
57                     bRet = TRUE;
58                 }
59             }
60         }
61     }
62 
63     if (!bRet)
64         ShowLastWin32Error(pVirtMem->hSelf);
65 
66     if (hkey != NULL)
67         RegCloseKey(hkey);
68 
69     return bRet;
70 }
71 
72 
73 static VOID
74 GetPageFileSizes(LPTSTR lpPageFiles,
75                  LPINT lpInitialSize,
76                  LPINT lpMaximumSize)
77 {
78     INT i = 0;
79 
80     *lpInitialSize = -1;
81     *lpMaximumSize = -1;
82 
83     while (*lpPageFiles != _T('\0'))
84     {
85         if (*lpPageFiles == _T(' '))
86         {
87             lpPageFiles++;
88 
89             switch (i)
90             {
91                 case 0:
92                     *lpInitialSize = (INT)_ttoi(lpPageFiles);
93                     i = 1;
94                     break;
95 
96                 case 1:
97                     *lpMaximumSize = (INT)_ttoi(lpPageFiles);
98                     return;
99             }
100         }
101 
102         lpPageFiles++;
103     }
104 }
105 
106 
107 static VOID
108 ParseMemSettings(PVIRTMEM pVirtMem)
109 {
110     TCHAR szDrives[1024];    // All drives
111     LPTSTR DrivePtr = szDrives;
112     TCHAR szDrive[3];        // Single drive
113     TCHAR szVolume[MAX_PATH + 1];
114     INT MinSize;
115     INT MaxSize;
116     INT DriveLen;
117     INT PgCnt = 0;
118     INT Len;
119 
120     DriveLen = GetLogicalDriveStrings(1023,
121                                       szDrives);
122 
123     while (DriveLen != 0)
124     {
125         Len = lstrlen(DrivePtr) + 1;
126         DriveLen -= Len;
127 
128         DrivePtr = _tcsupr(DrivePtr);
129 
130         /* Copy the 'X:' portion */
131         lstrcpyn(szDrive, DrivePtr, sizeof(szDrive) / sizeof(TCHAR));
132 
133         if (GetDriveType(DrivePtr) == DRIVE_FIXED)
134         {
135             MinSize = -1;
136             MaxSize = -1;
137 
138             /* Does drive match the one in the registry ? */
139             if (!_tcsncmp(pVirtMem->szPagingFiles, szDrive, 2))
140             {
141                 GetPageFileSizes(pVirtMem->szPagingFiles,
142                                  &MinSize,
143                                  &MaxSize);
144             }
145 
146             pVirtMem->Pagefile[PgCnt].OldMinSize = MinSize;
147             pVirtMem->Pagefile[PgCnt].OldMaxSize = MaxSize;
148             pVirtMem->Pagefile[PgCnt].NewMinSize = MinSize;
149             pVirtMem->Pagefile[PgCnt].NewMaxSize = MaxSize;
150             pVirtMem->Pagefile[PgCnt].bUsed = TRUE;
151             lstrcpy(pVirtMem->Pagefile[PgCnt].szDrive, szDrive);
152 
153 
154             /* Get the volume label if there is one */
155             if (GetVolumeInformation(DrivePtr,
156                                      szVolume,
157                                      MAX_PATH + 1,
158                                      NULL,
159                                      NULL,
160                                      NULL,
161                                      NULL,
162                                      0))
163             {
164                 pVirtMem->Pagefile[PgCnt].pszVolume = HeapAlloc(GetProcessHeap(),
165                                                                 0,
166                                                                 (_tcslen(szVolume) + 1) * sizeof(TCHAR));
167                 if (pVirtMem->Pagefile[PgCnt].pszVolume != NULL)
168                     _tcscpy(pVirtMem->Pagefile[PgCnt].pszVolume, szVolume);
169             }
170 
171             PgCnt++;
172         }
173 
174         DrivePtr += Len;
175     }
176 
177     pVirtMem->Count = PgCnt;
178 }
179 
180 
181 static VOID
182 WritePageFileSettings(PVIRTMEM pVirtMem)
183 {
184     HKEY hk = NULL;
185     TCHAR szPagingFiles[2048];
186     TCHAR szText[256];
187     INT i, nPos = 0;
188     BOOL bErr = TRUE;
189 
190     for (i = 0; i < pVirtMem->Count; ++i)
191     {
192         if (pVirtMem->Pagefile[i].bUsed &&
193             pVirtMem->Pagefile[i].NewMinSize != -1 &&
194             pVirtMem->Pagefile[i].NewMaxSize != -1)
195         {
196             _stprintf(szText,
197                       _T("%s\\pagefile.sys %i %i"),
198                       pVirtMem->Pagefile[i].szDrive,
199                       pVirtMem->Pagefile[i].NewMinSize,
200                       pVirtMem->Pagefile[i].NewMaxSize);
201 
202             /* Add it to our overall registry string */
203             lstrcpy(szPagingFiles + nPos, szText);
204 
205             /* Record the position where the next string will start */
206             nPos += (INT)lstrlen(szText) + 1;
207 
208             /* Add another NULL for REG_MULTI_SZ */
209             szPagingFiles[nPos] = _T('\0');
210             nPos++;
211         }
212     }
213 
214     if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
215                        lpKey,
216                        0,
217                        NULL,
218                        REG_OPTION_NON_VOLATILE,
219                        KEY_WRITE,
220                        NULL,
221                        &hk,
222                        NULL) == ERROR_SUCCESS)
223     {
224         if (RegSetValueEx(hk,
225                           _T("PagingFiles"),
226                           0,
227                           REG_MULTI_SZ,
228                           (LPBYTE) szPagingFiles,
229                           (DWORD) nPos * sizeof(TCHAR)) == ERROR_SUCCESS)
230         {
231             bErr = FALSE;
232         }
233 
234         RegCloseKey(hk);
235     }
236 
237     if (bErr == FALSE)
238     {
239         /* Delete obsolete paging files on the next boot */
240         for (i = 0; i < 26; i++)
241         {
242             if (pVirtMem->Pagefile[i].OldMinSize != -1 &&
243                 pVirtMem->Pagefile[i].NewMinSize == -1)
244             {
245                 _stprintf(szText,
246                           _T("%s\\pagefile.sys"),
247                           pVirtMem->Pagefile[i].szDrive);
248 
249                 MoveFileEx(szText, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
250             }
251         }
252     }
253 
254     if (bErr)
255         ShowLastWin32Error(pVirtMem->hSelf);
256 
257 }
258 
259 
260 static VOID
261 SetListBoxColumns(HWND hwndListBox)
262 {
263     RECT rect = {0, 0, 103, 0};
264     MapDialogRect(hwndListBox, &rect);
265 
266     SendMessage(hwndListBox, LB_SETTABSTOPS, (WPARAM)1, (LPARAM)&rect.right);
267 }
268 
269 
270 static VOID
271 OnNoPagingFile(PVIRTMEM pVirtMem)
272 {
273     /* Disable the page file custom size boxes */
274     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);
275     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
276 }
277 
278 
279 static VOID
280 OnSysManSize(PVIRTMEM pVirtMem)
281 {
282     /* Disable the page file custom size boxes */
283     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);
284     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
285 }
286 
287 
288 static VOID
289 OnCustom(PVIRTMEM pVirtMem)
290 {
291     /* Enable the page file custom size boxes */
292     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), TRUE);
293     EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), TRUE);
294 }
295 
296 
297 static VOID
298 InitPagefileList(PVIRTMEM pVirtMem)
299 {
300     TCHAR szDisplayString[256];
301     TCHAR szSize[64];
302     INT Index;
303     INT i;
304 
305     for (i = 0; i < 26; i++)
306     {
307         if (pVirtMem->Pagefile[i].bUsed)
308         {
309             if ((pVirtMem->Pagefile[i].NewMinSize == -1) &&
310                 (pVirtMem->Pagefile[i].NewMaxSize == -1))
311             {
312                 LoadString(hApplet,
313                            IDS_PAGEFILE_NONE,
314                            szSize,
315                            sizeof(szSize) / sizeof(szSize[0]));
316             }
317             else if ((pVirtMem->Pagefile[i].NewMinSize == 0) &&
318                      (pVirtMem->Pagefile[i].NewMaxSize == 0))
319             {
320                 LoadString(hApplet,
321                            IDS_PAGEFILE_SYSTEM,
322                            szSize,
323                            sizeof(szSize) / sizeof(szSize[0]));
324             }
325             else
326             {
327                 _stprintf(szSize, _T("%d - %d"),
328                           pVirtMem->Pagefile[i].NewMinSize,
329                           pVirtMem->Pagefile[i].NewMaxSize);
330             }
331 
332             _stprintf(szDisplayString,
333                       _T("%s  [%s]\t%s"),
334                       pVirtMem->Pagefile[i].szDrive,
335                       pVirtMem->Pagefile[i].pszVolume ? pVirtMem->Pagefile[i].pszVolume : _T(""),
336                       szSize);
337 
338             Index = SendMessage(pVirtMem->hListBox, LB_ADDSTRING, (WPARAM)0, (LPARAM)szDisplayString);
339             SendMessage(pVirtMem->hListBox, LB_SETITEMDATA, Index, i);
340         }
341     }
342 
343     SendMessage(pVirtMem->hListBox, LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
344 
345     OnSelChange(pVirtMem->hSelf, pVirtMem);
346 }
347 
348 
349 static VOID
350 UpdatePagefileEntry(PVIRTMEM pVirtMem,
351                     INT ListIndex,
352                     INT DriveIndex)
353 {
354     TCHAR szDisplayString[256];
355     TCHAR szSize[64];
356 
357     if ((pVirtMem->Pagefile[DriveIndex].NewMinSize == -1) &&
358         (pVirtMem->Pagefile[DriveIndex].NewMaxSize == -1))
359     {
360         LoadString(hApplet,
361                    IDS_PAGEFILE_NONE,
362                    szSize,
363                    sizeof(szSize) / sizeof(szSize[0]));
364     }
365     else if ((pVirtMem->Pagefile[DriveIndex].NewMinSize == 0) &&
366              (pVirtMem->Pagefile[DriveIndex].NewMaxSize == 0))
367     {
368         LoadString(hApplet,
369                    IDS_PAGEFILE_SYSTEM,
370                    szSize,
371                    sizeof(szSize) / sizeof(szSize[0]));
372     }
373     else
374     {
375         _stprintf(szSize,
376                   _T("%d - %d"),
377                   pVirtMem->Pagefile[DriveIndex].NewMinSize,
378                   pVirtMem->Pagefile[DriveIndex].NewMaxSize);
379     }
380 
381     _stprintf(szDisplayString,
382               _T("%s  [%s]\t%s"),
383               pVirtMem->Pagefile[DriveIndex].szDrive,
384               pVirtMem->Pagefile[DriveIndex].pszVolume ? pVirtMem->Pagefile[DriveIndex].pszVolume : L"",
385               szSize);
386 
387     SendMessage(pVirtMem->hListBox, LB_DELETESTRING, (WPARAM)ListIndex, 0);
388     SendMessage(pVirtMem->hListBox, LB_INSERTSTRING, (WPARAM)ListIndex, (LPARAM)szDisplayString);
389     SendMessage(pVirtMem->hListBox, LB_SETCURSEL, (WPARAM)ListIndex, 0);
390 }
391 
392 
393 static VOID
394 OnSet(PVIRTMEM pVirtMem)
395 {
396     INT Index;
397     UINT MinSize = -1;
398     UINT MaxSize = -1;
399     BOOL bTranslated;
400     INT DriveIndex = 0;
401 
402     Index  = (INT)SendDlgItemMessage(pVirtMem->hSelf,
403                                      IDC_PAGEFILELIST,
404                                      LB_GETCURSEL,
405                                      0,
406                                      0);
407     if (Index >= 0 && Index < pVirtMem->Count)
408     {
409         DriveIndex = SendDlgItemMessage(pVirtMem->hSelf,
410                                         IDC_PAGEFILELIST,
411                                         LB_GETITEMDATA,
412                                         (WPARAM)Index,
413                                         0);
414 
415         /* Check if custom settings are checked */
416         if (IsDlgButtonChecked(pVirtMem->hSelf,
417                                IDC_CUSTOM) == BST_CHECKED)
418         {
419             MinSize = GetDlgItemInt(pVirtMem->hSelf,
420                                     IDC_INITIALSIZE,
421                                     &bTranslated,
422                                     FALSE);
423             if (!bTranslated)
424             {
425                 ResourceMessageBox(hApplet,
426                                    NULL,
427                                    MB_ICONWARNING | MB_OK,
428                                    IDS_MESSAGEBOXTITLE,
429                                    IDS_WARNINITIALSIZE);
430                 return;
431             }
432 
433             MaxSize = GetDlgItemInt(pVirtMem->hSelf,
434                                     IDC_MAXSIZE,
435                                     &bTranslated,
436                                     FALSE);
437             if (!bTranslated)
438             {
439                 ResourceMessageBox(hApplet,
440                                    NULL,
441                                    MB_ICONWARNING | MB_OK,
442                                    IDS_MESSAGEBOXTITLE,
443                                    IDS_WARNMAXIMUMSIZE);
444                 return;
445             }
446 
447             /* Check the valid range of the minimum size */
448             if (MinSize < 2 ||
449                 MinSize > pVirtMem->Pagefile[DriveIndex].FreeSize ||
450                 MinSize > 4096)
451             {
452                 ResourceMessageBox(hApplet,
453                                    NULL,
454                                    MB_ICONWARNING | MB_OK,
455                                    IDS_MESSAGEBOXTITLE,
456                                    IDS_WARNINITIALRANGE);
457                 return;
458             }
459 
460             /* Check the valid range of the maximum size */
461             if (MaxSize < MinSize ||
462                 MaxSize > pVirtMem->Pagefile[DriveIndex].FreeSize ||
463                 MaxSize > 4096)
464             {
465                 ResourceMessageBox(hApplet,
466                                    NULL,
467                                    MB_ICONWARNING | MB_OK,
468                                    IDS_MESSAGEBOXTITLE,
469                                    IDS_WARNMAXIMUMRANGE);
470                 return;
471             }
472 
473             pVirtMem->Pagefile[DriveIndex].NewMinSize = MinSize;
474             pVirtMem->Pagefile[DriveIndex].NewMaxSize = MaxSize;
475             pVirtMem->Pagefile[DriveIndex].bUsed = TRUE;
476         }
477         else if (IsDlgButtonChecked(pVirtMem->hSelf,
478                                     IDC_NOPAGEFILE) == BST_CHECKED)
479         {
480             /* No pagefile */
481             pVirtMem->Pagefile[DriveIndex].NewMinSize = -1;
482             pVirtMem->Pagefile[DriveIndex].NewMaxSize = -1;
483             pVirtMem->Pagefile[DriveIndex].bUsed = TRUE;
484         }
485         else
486         {
487             /* System managed size*/
488             pVirtMem->Pagefile[DriveIndex].NewMinSize = 0;
489             pVirtMem->Pagefile[DriveIndex].NewMaxSize = 0;
490             pVirtMem->Pagefile[DriveIndex].bUsed = TRUE;
491         }
492 
493         /* Set the modified flag if min or max size has changed */
494         if ((pVirtMem->Pagefile[DriveIndex].OldMinSize != pVirtMem->Pagefile[DriveIndex].NewMinSize) ||
495             (pVirtMem->Pagefile[DriveIndex].OldMaxSize != pVirtMem->Pagefile[DriveIndex].NewMaxSize))
496             pVirtMem->bModified = TRUE;
497 
498         UpdatePagefileEntry(pVirtMem, Index, DriveIndex);
499     }
500 }
501 
502 
503 static BOOL
504 OnSelChange(HWND hwndDlg, PVIRTMEM pVirtMem)
505 {
506     TCHAR szBuffer[64];
507     MEMORYSTATUSEX MemoryStatus;
508     ULARGE_INTEGER FreeDiskSpace;
509     UINT i, FreeMemMb, RecoMemMb, PageFileSizeMb;
510     INT Index;
511     TCHAR szText[MAX_PATH], szMegabytes[8];
512     WIN32_FIND_DATAW fdata = {0};
513     HANDLE hFind;
514     ULARGE_INTEGER pfSize;
515 
516     Index = (INT)SendDlgItemMessage(hwndDlg,
517                                     IDC_PAGEFILELIST,
518                                     LB_GETCURSEL,
519                                     0,
520                                     0);
521     if (Index >= 0 && Index < pVirtMem->Count)
522     {
523         LoadString(hApplet,
524                    IDS_PAGEFILE_MB,
525                    szMegabytes,
526                    ARRAYSIZE(szMegabytes));
527 
528         /* Set drive letter */
529         SetDlgItemText(hwndDlg, IDC_DRIVE,
530                        pVirtMem->Pagefile[Index].szDrive);
531 
532         /* Set available disk space */
533         if (GetDiskFreeSpaceEx(pVirtMem->Pagefile[Index].szDrive,
534                                NULL, NULL, &FreeDiskSpace))
535         {
536             pVirtMem->Pagefile[Index].FreeSize = (UINT)(FreeDiskSpace.QuadPart / (1024 * 1024));
537             _stprintf(szBuffer, szMegabytes, pVirtMem->Pagefile[Index].FreeSize);
538             SetDlgItemText(hwndDlg, IDC_SPACEAVAIL, szBuffer);
539         }
540 
541         if (pVirtMem->Pagefile[Index].NewMinSize == -1 &&
542             pVirtMem->Pagefile[Index].NewMaxSize == -1)
543         {
544             /* No pagefile */
545 
546             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
547             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);
548 
549             CheckDlgButton(pVirtMem->hSelf, IDC_NOPAGEFILE, BST_CHECKED);
550         }
551         else if (pVirtMem->Pagefile[Index].NewMinSize == 0 &&
552                  pVirtMem->Pagefile[Index].NewMaxSize == 0)
553         {
554             /* System managed size*/
555 
556             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
557             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);
558 
559             CheckDlgButton(pVirtMem->hSelf, IDC_SYSMANSIZE, BST_CHECKED);
560         }
561         else
562         {
563             /* Custom size */
564 
565             /* Enable and fill the custom values */
566             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), TRUE);
567             EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), TRUE);
568 
569             SetDlgItemInt(pVirtMem->hSelf,
570                           IDC_INITIALSIZE,
571                           pVirtMem->Pagefile[Index].NewMinSize,
572                           FALSE);
573 
574             SetDlgItemInt(pVirtMem->hSelf,
575                           IDC_MAXSIZE,
576                           pVirtMem->Pagefile[Index].NewMaxSize,
577                           FALSE);
578 
579             CheckDlgButton(pVirtMem->hSelf,
580                            IDC_CUSTOM,
581                            BST_CHECKED);
582         }
583 
584         /* Set minimum pagefile size (2 MB) */
585         _stprintf(szBuffer, szMegabytes, 2);
586         SetDlgItemText(hwndDlg, IDC_MINIMUM, szBuffer);
587 
588         /* Set recommended pagefile size */
589         MemoryStatus.dwLength = sizeof(MEMORYSTATUSEX);
590         if (GlobalMemoryStatusEx(&MemoryStatus))
591         {
592             FreeMemMb = (UINT)(MemoryStatus.ullTotalPhys / (1024 * 1024));
593             RecoMemMb = FreeMemMb + (FreeMemMb / 2); /* The recommended VM size is 150% of free memory. */
594             if (RecoMemMb > 4096)
595                 RecoMemMb = 4096;
596             _stprintf(szBuffer, szMegabytes, RecoMemMb);
597             SetDlgItemText(hwndDlg, IDC_RECOMMENDED, szBuffer);
598         }
599 
600         /* Set current pagefile size */
601         PageFileSizeMb = 0;
602 
603         for (i = 0; i < pVirtMem->Count; i++)
604         {
605             _stprintf(szText,
606                       _T("%c:\\pagefile.sys"),
607                       pVirtMem->Pagefile[i].szDrive[0]);
608 
609             hFind = FindFirstFileW(szText, &fdata);
610             if (hFind == INVALID_HANDLE_VALUE)
611             {
612                 DPRINT1("Unable to read PageFile size : %ls due to error %d\n", szText,GetLastError());
613             }
614             else
615             {
616                 pfSize.LowPart = fdata.nFileSizeLow;
617                 pfSize.HighPart = fdata.nFileSizeHigh;
618                 PageFileSizeMb += pfSize.QuadPart / (1024*1024);
619                 FindClose(hFind);
620             }
621         }
622 
623         _stprintf(szBuffer, szMegabytes, PageFileSizeMb);
624         SetDlgItemText(hwndDlg, IDC_CURRENT, szBuffer);
625     }
626 
627     return TRUE;
628 }
629 
630 
631 static VOID
632 OnVirtMemDialogOk(PVIRTMEM pVirtMem)
633 {
634     if (pVirtMem->bModified != FALSE)
635     {
636         ResourceMessageBox(hApplet,
637                            NULL,
638                            MB_ICONINFORMATION | MB_OK,
639                            IDS_MESSAGEBOXTITLE,
640                            IDS_INFOREBOOT);
641 
642         WritePageFileSettings(pVirtMem);
643     }
644 }
645 
646 
647 static VOID
648 OnInitVirtMemDialog(HWND hwnd, PVIRTMEM pVirtMem)
649 {
650     INT i;
651 
652     pVirtMem->hSelf = hwnd;
653     pVirtMem->hListBox = GetDlgItem(hwnd, IDC_PAGEFILELIST);
654     pVirtMem->bModified = FALSE;
655 
656     SetListBoxColumns(pVirtMem->hListBox);
657 
658     for (i = 0; i < 26; i++)
659     {
660         pVirtMem->Pagefile[i].bUsed = FALSE;
661         pVirtMem->Pagefile[i].OldMinSize = -1;
662         pVirtMem->Pagefile[i].OldMaxSize = -1;
663         pVirtMem->Pagefile[i].NewMinSize = -1;
664         pVirtMem->Pagefile[i].NewMaxSize = -1;
665     }
666 
667     /* Load the pagefile systems from the reg */
668     ReadPageFileSettings(pVirtMem);
669 
670     /* Parse our settings and set up dialog */
671     ParseMemSettings(pVirtMem);
672 
673     InitPagefileList(pVirtMem);
674 }
675 
676 
677 static VOID
678 OnDestroy(PVIRTMEM pVirtMem)
679 {
680     INT i;
681 
682     for (i = 0; i < 26; i++)
683     {
684         if (pVirtMem->Pagefile[i].pszVolume != NULL)
685             HeapFree(GetProcessHeap(), 0, pVirtMem->Pagefile[i].pszVolume);
686     }
687 
688     if (pVirtMem->szPagingFiles)
689         HeapFree(GetProcessHeap(), 0, pVirtMem->szPagingFiles);
690 
691     HeapFree(GetProcessHeap(), 0, pVirtMem);
692 }
693 
694 
695 INT_PTR CALLBACK
696 VirtMemDlgProc(HWND hwndDlg,
697                UINT uMsg,
698                WPARAM wParam,
699                LPARAM lParam)
700 {
701     PVIRTMEM pVirtMem;
702 
703     UNREFERENCED_PARAMETER(lParam);
704 
705     pVirtMem = (PVIRTMEM)GetWindowLongPtr(hwndDlg, DWLP_USER);
706 
707     switch (uMsg)
708     {
709         case WM_INITDIALOG:
710             pVirtMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VIRTMEM));
711             if (pVirtMem == NULL)
712             {
713                 EndDialog(hwndDlg, 0);
714                 return FALSE;
715             }
716 
717             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pVirtMem);
718 
719             OnInitVirtMemDialog(hwndDlg, pVirtMem);
720             break;
721 
722         case WM_DESTROY:
723             OnDestroy(pVirtMem);
724             break;
725 
726         case WM_COMMAND:
727             switch (LOWORD(wParam))
728             {
729                 case IDCANCEL:
730                     EndDialog(hwndDlg, 0);
731                     return TRUE;
732 
733                 case IDOK:
734                     OnVirtMemDialogOk(pVirtMem);
735                     EndDialog(hwndDlg, pVirtMem->bModified);
736                     return TRUE;
737 
738                 case IDC_NOPAGEFILE:
739                     OnNoPagingFile(pVirtMem);
740                     return TRUE;
741 
742                 case IDC_SYSMANSIZE:
743                     OnSysManSize(pVirtMem);
744                     return TRUE;
745 
746                 case IDC_CUSTOM:
747                     OnCustom(pVirtMem);
748                     return TRUE;
749 
750                 case IDC_SET:
751                     OnSet(pVirtMem);
752                     return TRUE;
753 
754                 case IDC_PAGEFILELIST:
755                     switch (HIWORD(wParam))
756                     {
757                         case LBN_SELCHANGE:
758                             OnSelChange(hwndDlg, pVirtMem);
759                             return TRUE;
760                     }
761                     break;
762             }
763             break;
764     }
765 
766     return FALSE;
767 }
768