![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uconvert.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / uconvert|
Return to uconvert.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / uconvert |
1.1 root 1: /**************************************************************************\
2: * uconvert.c -- convert to/from unicode using
3: * MulitByteToWideChar & WideCharToMulitByte
4: *
5: * Steve Firebaugh
6: * Microsoft Developer Support
7: * Copyright (c) 1992, 1993 Microsoft Corporation
8: *
9: \**************************************************************************/
10: #define UNICODE
11:
12:
13: #include <windows.h>
14: #include <commdlg.h>
15: #include "uconvert.h"
16: #include "install.h"
17:
18:
19:
20:
21:
22:
23: /**************************************************************************\
24: * Global variables.
25: \**************************************************************************/
26:
27: HANDLE hInst;
28:
29: /* declare global HWNDs for the child windows.
30: * They are created at WM_CREATE of the main window.
31: * Also used in the "View" dialogs.
32: */
33: HWND hwndLabel0, hwndLabel1;
34: HWND hwndName0, hwndName1;
35: HWND hwndSize0, hwndSize1;
36: HWND hwndCodePage0, hwndCodePage1;
37: HWND hwndByteOrder0, hwndByteOrder1;
38: HWND hwndButton0, hwndButton1;
39:
40: /* Global variables storing the source and destination "type" information.
41: *
42: * used to communicate between main wnd proc, and *OptionsProc.
43: *
44: * gTypeSource - stores the type interpretation of the source data
45: * (and implicitly the destination data.)
46: * TYPEUNKNOWN: indeterminant... not set. Can not do conversion.
47: * TYPEUNICODE: source unicode & destination giDestinationCodePage.
48: * TYPECODEPAGE: source giSourceCodePage & destination unicode.
49: *
50: * giSourceCodePage stores valid source code page iff gTypeSource == TRUE
51: * giDestinationCodePage stores valid destination code page iff gTypeSource == FALSE
52: *
53: */
54: int gTypeSource;
55: UINT giSourceCodePage;
56: UINT giDestinationCodePage;
57:
58: /* Pointers to the source and destination data, and the
59: * count of bytes in each of the buffers.
60: */
61: #define NODATA 0
62: PBYTE pSourceData = NULL;
63: PBYTE pDestinationData = NULL;
64: int nBytesSource = NODATA;
65: int nBytesDestination = NODATA;
66:
67: /* Conversion Options variables. */
68: DWORD gMBFlags = MB_PRECOMPOSED;
69: DWORD gWCFlags = 0;
70: char glpDefaultChar[4] = ""; // what is max size of multibyte character?
71: BOOL gUsedDefaultChar = FALSE;
72:
73: /* Handling the Byte Order Mark (BOM).
74: *
75: * If the input file begins with a BOM, then we know it is unicode,
76: * we skip over the BOM and decrement the size of data by SIZEOFBOM.
77: *
78: *
79: * Before writing data that we know is unicode, write the szBOM string
80: * to the file.
81: *
82: * Notice that this means that the file sizes we show in the window
83: * do NOT include the BOM.
84: */
85:
86: char szBOM[] = "\377\376"; // 0xFF, 0xFE // leave off TEXT() macro.
87: char szRBOM[] = "\376\377"; // 0xFF, 0xFE // leave off TEXT() macro.
88: #define SIZEOFBOM 2
89:
90: /* Title of main window */
91: TCHAR TitleMBToWC[]= TEXT("UConvert -- MultiByteToWideChar()");
92: TCHAR TitleWCToMB[]= TEXT("UConvert -- WideCharToMultiByte()");
93: TCHAR TitleUnknown[]= TEXT("UConvert.");
94:
95: /* file name of the online help file */
96: TCHAR szHelpPathName[] = TEXT("uconvert.HLP");
97:
98: /* Strings used to fill onscreen windows. */
99: TCHAR szBlank[] = TEXT("");
100: TCHAR szNBytes[] = TEXT("bytes: %d");
101: TCHAR szByteOrderReversed[]=TEXT("Byte Order Reversed.");
102:
103: /* MessageBox() strings and flags. */
104: TCHAR MBTitle[]= TEXT("Application Warning");
105: UINT MBFlags = MB_OK | MB_ICONEXCLAMATION;
106:
107:
108: /* misc. defines affecting size and placement of child windows */
109: #define BORDER GetSystemMetrics (SM_CXFRAME)*4
110: #define WHEIGHT GetSystemMetrics (SM_CYMENU)
111:
112:
113:
114: /**************************************************************************\
115: *
116: * function: WinMain()
117: *
118: *
119: \**************************************************************************/
120: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
121: LPSTR lpCmdLine, int nCmdShow)
122: {
123: MSG msg;
124: WNDCLASS wc;
125: HWND hwndMain;
126: HACCEL haccel;
127:
128:
129: UNREFERENCED_PARAMETER( lpCmdLine );
130: UNREFERENCED_PARAMETER( nCmdShow );
131: hInst = hInstance;
132:
133:
134: /* Check for previous instance. If none, then register class. */
135: if (!hPrevInstance) {
136:
137: wc.style = 0;
138: wc.lpfnWndProc = (WNDPROC)MainWndProc;
139:
140: wc.cbClsExtra = 0;
141: wc.cbWndExtra = 0;
142: wc.hInstance = hInstance;
143: wc.hIcon = LoadIcon(hInstance, TEXT("uconvertIcon"));
144: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
145: wc.hbrBackground = GetStockObject (LTGRAY_BRUSH);
146: wc.lpszMenuName = TEXT("uconvertMenu");
147: wc.lpszClassName = TEXT("uconvert");
148:
149: if (!RegisterClass(&wc)) return (FALSE);
150:
151: } /* class registered o.k. */
152:
153:
154: /* Create the main window. Return false if CreateWindow() fails */
155: hwndMain = CreateWindow(
156: TEXT("uconvert"),
157: TitleUnknown,
158: (WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME | WS_MAXIMIZEBOX)) | WS_VISIBLE,
159: CW_USEDEFAULT,
160: CW_USEDEFAULT,
161: 512, // Big enough for most of the text.
162: 16*WHEIGHT,
163: NULL, NULL, hInst, NULL);
164:
165: if (!hwndMain) return (FALSE);
166:
167:
168: /* Load the accelerator table that provides clipboard support. */
169: haccel = LoadAccelerators (hInst, TEXT("uconvertAccel"));
170:
171:
172:
173: /* Loop getting messages and dispatching them. */
174: while (GetMessage(&msg, NULL, 0,0)) {
175: if (!TranslateAccelerator(hwndMain, haccel, &msg)) {
176: TranslateMessage(&msg);
177: DispatchMessage(&msg);
178: }
179: }
180:
181: return (msg.wParam);
182: }
183:
184:
185:
186:
187: /**************************************************************************\
188: *
189: * function: MainWndProc()
190: *
191: *
192: * On WM_CREATE create all of the child windows.
193: * On WM_DESTROY make sure that all dynamically allocated memory is freed.
194: * On WM_PAINT, outline many of the child windows.
195: * On WM_COMMAND, respond to the command messages properly.
196: *
197: \**************************************************************************/
198: LRESULT CALLBACK MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
199: {
200:
201:
202: /* misc. variables used in multiple messages cases. */
203: RECT clientrect;
204: RECT rect;
205: TCHAR buffer[50];
206: static TCHAR szFilter[MAX_PATH];
207:
208: switch (message) {
209:
210: /**********************************************************************\
211: * WM_CREATE
212: *
213: * Create all of the child windows used on this main window.
214: * Assign the HWNDs to the correct static variables.
215: *
216: \**********************************************************************/
217: case WM_CREATE: {
218: GetClientRect (hwnd, &clientrect);
219:
220: /* Create Source Windows. */
221: CopyRect (&rect, &clientrect);
222: rect.right = (clientrect.right - clientrect.left) /2;
223: InflateRect (&rect, -2*BORDER, -BORDER);
224: createwindows(&rect,
225: hwnd,
226: &hwndLabel0,
227: &hwndName0,
228: &hwndSize0,
229: &hwndCodePage0,
230: &hwndByteOrder0,
231: &hwndButton0);
232:
233: /* Create Destination Windows. */
234: CopyRect (&rect, &clientrect);
235: rect.left = (clientrect.right - clientrect.left) /2;
236: InflateRect (&rect, -2*BORDER, -BORDER);
237: createwindows(&rect,
238: hwnd,
239: &hwndLabel1,
240: &hwndName1,
241: &hwndSize1,
242: &hwndCodePage1,
243: &hwndByteOrder1,
244: &hwndButton1);
245:
246: /* fill in window information that is different for source/destination */
247: SetWindowText (hwndLabel0, TEXT("Source:" ));
248: SetWindowText (hwndLabel1, TEXT("Destination:"));
249:
250: SetWindowText (hwndButton0, TEXT("View &Source..." ));
251: SetWindowText (hwndButton1, TEXT("View &Destination..."));
252: SetWindowLong (hwndButton0, GWL_ID, BID_VIEWSOURCE );
253: SetWindowLong (hwndButton1, GWL_ID, BID_VIEWDESTINATION );
254:
255: gTypeSource = TYPEUNKNOWN;
256: giSourceCodePage = GetACP(); // Just some reasonable initializer.
257: giDestinationCodePage = GetACP(); // Just some reasonable initializer.
258:
259: /* initialize source & destination data correctly */
260: SendMessage (hwnd, WM_COMMAND, MID_CLEARSOURCE, 0);
261: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
262:
263: /* Build up the correct filter strings for OPENFILENAME structure
264: * Do it here so that we only have to do it once.
265: */
266: {
267: TCHAR *p;
268:
269: p = szFilter;
270: lstrcpy (buffer,TEXT("All Files (*.*)"));
271: lstrcpy (p,buffer);
272: p += lstrlen (buffer) +1;
273: lstrcpy (buffer,TEXT("*.*"));
274: lstrcpy (p,buffer);
275: p += lstrlen (buffer) +1;
276:
277: lstrcpy (buffer,TEXT("Text Files (*.txt)"));
278: lstrcpy (p,buffer);
279: p += lstrlen (buffer) +1;
280: lstrcpy (buffer,TEXT("*.txt"));
281: lstrcpy (p,buffer);
282: p += lstrlen (buffer) +1;
283:
284: lstrcpy (buffer,TEXT("Unicode Files (*.utf)"));
285: lstrcpy (p,buffer);
286: p += lstrlen (buffer) +1;
287: lstrcpy (buffer,TEXT("*.utf"));
288: lstrcpy (p,buffer);
289: p += lstrlen (buffer) +1;
290:
291: lstrcpy (p,TEXT("\0"));
292: }
293: } break; /* end WM_CREATE */
294:
295:
296:
297: /**********************************************************************\
298: * WM_DESTROY
299: *
300: * Release the Online help, and free allocated memory if any.
301: \**********************************************************************/
302: case WM_DESTROY:
303: WinHelp( hwnd, szHelpPathName, (UINT) HELP_QUIT, (DWORD) NULL );
304: ManageMemory (MMFREE, MMSOURCE, 0, pSourceData);
305: ManageMemory (MMFREE, MMDESTINATION, 0, pDestinationData);
306: PostQuitMessage(0);
307: break;
308:
309:
310: /**********************************************************************\
311: * WM_CTLCOLOR*
312: *
313: * Set the background of the child controls to be gray here.
314: \**********************************************************************/
315: case WM_CTLCOLORBTN:
316: case WM_CTLCOLORSTATIC: {
317: HDC hdc;
318:
319: hdc = (HDC) wParam;
320: SetBkMode (hdc, TRANSPARENT);
321: return (LRESULT)GetStockObject (LTGRAY_BRUSH);
322: } break;
323:
324:
325:
326:
327: /**********************************************************************\
328: * WM_PAINT
329: *
330: * Simply draw the two vertical divider lines, and 3D frame the children.
331: *
332: \**********************************************************************/
333: case WM_PAINT: {
334: HDC hdc;
335: PAINTSTRUCT ps;
336:
337: hdc = BeginPaint(hwnd, &ps);
338: GetClientRect (hwnd, &clientrect);
339:
340: /* draw vertical separator line in the center */
341: rect.left = (clientrect.right - clientrect.left ) /2 -1;
342: rect.top = clientrect.top;
343: rect.right = rect.left +1;;
344: rect.bottom = clientrect.bottom;
345: FrameRect (hdc, &rect, GetStockObject (GRAY_BRUSH));
346: SelectObject (hdc, GetStockObject (WHITE_PEN));
347: MoveToEx (hdc, rect.right, rect.top, NULL);
348: LineTo (hdc,rect.right, rect.bottom);
349:
350: /* draw 3D outlines of child windows. */
351: framechildwindow (hdc, hwnd, hwndName0);
352: framechildwindow (hdc, hwnd, hwndSize0);
353: framechildwindow (hdc, hwnd, hwndCodePage0);
354: framechildwindow (hdc, hwnd, hwndByteOrder0);
355:
356: framechildwindow (hdc, hwnd, hwndName1);
357: framechildwindow (hdc, hwnd, hwndSize1);
358: framechildwindow (hdc, hwnd, hwndCodePage1);
359: framechildwindow (hdc, hwnd, hwndByteOrder1);
360:
361: /* underline the labels */
362: underlinechildwindow (hdc, hwnd, hwndLabel0);
363: underlinechildwindow (hdc, hwnd, hwndLabel1);
364:
365: EndPaint (hwnd, &ps);
366: } break; /* end WM_PAINT */
367:
368:
369:
370:
371: /**********************************************************************\
372: * WMU_ADJUSTFORNEWSOURCE
373: *
374: * lParam - szName of source (file, clipboard, ...)
375: *
376: * global - nBytesSource
377: *
378: * "user message." Set the text of the Source windows
379: \**********************************************************************/
380: case WMU_ADJUSTFORNEWSOURCE: {
381: LPVOID szName;
382:
383: szName = (LPVOID) lParam;
384:
385: /* Set Window text appropriately */
386: wsprintf (buffer, szNBytes, nBytesSource);
387: SetWindowText (hwndSize0, buffer);
388: SetWindowText (hwndName0, szName);
389: SetWindowText (hwndByteOrder0, szBlank);
390:
391: /* Clear the destination data if any to avoid user confusion. */
392: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
393:
394: /* Reset the "type strings" based on new gTypeSource. */
395: SendMessage (hwnd, WMU_SETTYPESTRINGS, 0,0);
396: } break;
397:
398:
399:
400:
401: /**********************************************************************\
402: * WMU_SETTYPESTRINGS
403: *
404: * "user message." Set the text of the "type" windows to reflect
405: * the state stored in gTypeSource and gi*CodePage.
406: *
407: \**********************************************************************/
408: case WMU_SETTYPESTRINGS:
409: switch (gTypeSource) {
410: case TYPEUNICODE:
411: SetWindowText (hwndCodePage0, TEXT("Unicode"));
412: wsprintf (buffer, TEXT("CodePage: %d"), giDestinationCodePage);
413: SetWindowText (hwndCodePage1, buffer);
414: SetWindowText (hwnd, TitleWCToMB);
415: break;
416: case TYPECODEPAGE:
417: wsprintf (buffer, TEXT("CodePage: %d"), giSourceCodePage);
418: SetWindowText (hwndCodePage0, buffer);
419: SetWindowText (hwndCodePage1, TEXT("Unicode"));
420: SetWindowText (hwnd, TitleMBToWC);
421: break;
422: case TYPEUNKNOWN:
423: SetWindowText (hwndCodePage0, szBlank);
424: SetWindowText (hwndCodePage1, szBlank);
425: SetWindowText (hwnd, TitleUnknown);
426: break;
427: } /* end switch gTypeSource */
428: break;
429:
430:
431: /**********************************************************************\
432: * WM_INITMENU
433: *
434: * Manage the enabled state of all of the menus.
435: * Notice that the button enabled state is taken care of in ManageMemory().
436: *
437: * In general, this is dependent upon pSourceData & pDestinationData.
438: * They are either NULL or non-NULL, and menu items are dependent upon
439: * this state.
440: *
441: * One exception is the "Paste from Clipboard menu" which is enabled
442: * conditional upon there being text data in the clipboard.
443: *
444: \**********************************************************************/
445: case WM_INITMENU:
446:
447: /* Adjust the "Paste from Clipboard menu" */
448: OpenClipboard (hwnd);
449: if (IsClipboardFormatAvailable (CF_UNICODETEXT) ||
450: IsClipboardFormatAvailable (CF_OEMTEXT) ||
451: IsClipboardFormatAvailable (CF_TEXT))
452: EnableMenuItem (GetMenu (hwnd),MID_PASTESOURCE, MF_ENABLED);
453: else
454: EnableMenuItem (GetMenu (hwnd),MID_PASTESOURCE, MF_GRAYED);
455: CloseClipboard ();
456:
457:
458: /* Adjust the source data dependent menus. */
459: if (pSourceData != NULL) {
460: EnableMenuItem (GetMenu (hwnd),MID_SOURCEOPT, MF_ENABLED);
461: EnableMenuItem (GetMenu (hwnd),MID_SWAPSOURCE, MF_ENABLED);
462: EnableMenuItem (GetMenu (hwnd),MID_CLEARSOURCE, MF_ENABLED);
463: EnableMenuItem (GetMenu (hwnd),MID_CONVERTNOW, MF_ENABLED);
464: EnableMenuItem (GetMenu (hwnd),MID_CONVERSIONOPT, MF_ENABLED);
465: EnableMenuItem (GetMenu (hwnd),MID_DESTINATIONOPT, MF_ENABLED);
466: } else {
467: EnableMenuItem (GetMenu (hwnd),MID_SOURCEOPT, MF_GRAYED);
468: EnableMenuItem (GetMenu (hwnd),MID_SWAPSOURCE, MF_GRAYED);
469: EnableMenuItem (GetMenu (hwnd),MID_CLEARSOURCE, MF_GRAYED);
470: EnableMenuItem (GetMenu (hwnd),MID_CONVERTNOW, MF_GRAYED);
471: EnableMenuItem (GetMenu (hwnd),MID_CONVERSIONOPT, MF_GRAYED);
472: EnableMenuItem (GetMenu (hwnd),MID_DESTINATIONOPT, MF_GRAYED);
473: }
474:
475:
476: /* Adjust the destination data dependent menus. */
477: if (pDestinationData != NULL) {
478: EnableMenuItem (GetMenu (hwnd),MID_SAVEAS, MF_ENABLED);
479: EnableMenuItem (GetMenu (hwnd),MID_SWAPDESTINATION, MF_ENABLED);
480: EnableMenuItem (GetMenu (hwnd),MID_COPYDESTINATION, MF_ENABLED);
481: EnableMenuItem (GetMenu (hwnd),MID_CLEARDESTINATION, MF_ENABLED);
482: } else {
483: EnableMenuItem (GetMenu (hwnd),MID_SAVEAS, MF_GRAYED);
484: EnableMenuItem (GetMenu (hwnd),MID_SWAPDESTINATION, MF_GRAYED);
485: EnableMenuItem (GetMenu (hwnd),MID_COPYDESTINATION, MF_GRAYED);
486: EnableMenuItem (GetMenu (hwnd),MID_CLEARDESTINATION, MF_GRAYED);
487: }
488:
489: break;
490:
491:
492:
493:
494:
495: /**********************************************************************\
496: * WM_COMMAND
497: *
498: * Just switch() on the command ID. Notice that menu and button
499: * command messages are treated the same.
500: *
501: \**********************************************************************/
502: case WM_COMMAND:
503: switch (LOWORD(wParam)) {
504:
505:
506: /******************************************************************\
507: * WM_COMMAND, MID_OPEN
508: *
509: * Put up common dialog, try to open & read file.
510: * Fill windows with correct text & fill pSourceData.
511: \******************************************************************/
512: case MID_OPEN : {
513: HANDLE hFile;
514: DWORD nBytesRead;
515: TCHAR szFile[MAX_PATH],szFileTitle[MAX_PATH];
516:
517: /* First set up the structure for the GetOpenFileName
518: * common dialog.
519: */
520: {
521: OPENFILENAME OpenFileName;
522: /* buffers for the file names. */
523:
524: wsprintf (szFile, szBlank);
525: wsprintf (szFileTitle, szBlank);
526:
527:
528: OpenFileName.lStructSize = sizeof(OPENFILENAME);
529: OpenFileName.hwndOwner = hwnd;
530: OpenFileName.hInstance = (HANDLE) hInst;
531: OpenFileName.lpstrFilter = szFilter; // built in WM_CREATE
532: OpenFileName.lpstrCustomFilter = NULL;
533: OpenFileName.nMaxCustFilter = 0L;
534: OpenFileName.nFilterIndex = 1L;
535: OpenFileName.lpstrFile = szFile;
536: OpenFileName.nMaxFile = MAX_PATH;
537: OpenFileName.lpstrFileTitle = szFileTitle;
538: OpenFileName.nMaxFileTitle = MAX_PATH;
539: OpenFileName.lpstrInitialDir = NULL;
540: OpenFileName.lpstrTitle = TEXT("Open File");
541:
542: OpenFileName.nFileOffset = 0;
543: OpenFileName.nFileExtension = 0;
544: OpenFileName.lpstrDefExt = NULL;
545:
546: OpenFileName.lCustData = 0;
547: OpenFileName.lpfnHook = NULL;
548: OpenFileName.lpTemplateName = NULL;
549:
550: OpenFileName.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
551:
552: if (!GetOpenFileName(&OpenFileName)) return 0;
553: }
554:
555:
556: /* User has filled in the file information.
557: * Try to open that file for reading.
558: */
559: hFile = CreateFile(szFile,
560: GENERIC_READ,
561: 0,
562: NULL,
563: OPEN_EXISTING,
564: FILE_ATTRIBUTE_NORMAL,
565: NULL);
566: if (hFile == INVALID_HANDLE_VALUE) {
567: MessageBox (hwnd, TEXT("open file failed."),MBTitle, MBFlags);
568: return 0;
569: }
570:
571:
572: /* make sure file is not too big... i.e. > 2^32
573: * If it is OK, write the file size in hwndSize0
574: */
575: {
576: BY_HANDLE_FILE_INFORMATION bhfi;
577:
578: GetFileInformationByHandle (hFile, &bhfi);
579: if (bhfi.nFileSizeHigh != 0) {
580: MessageBox (hwnd, TEXT("File too big, > 2^32."),MBTitle, MBFlags);
581: CloseHandle (hFile);
582: return 0;
583: }
584:
585: nBytesSource= bhfi.nFileSizeLow;
586:
587: }
588:
589: pSourceData = ManageMemory (MMALLOC, MMSOURCE, nBytesSource, pSourceData);
590: if (pSourceData == NULL) {
591: CloseHandle (hFile);
592: return 0;
593: }
594:
595: /* first read two bytes and look for BOM */
596: if (!ReadFile (hFile, pSourceData,SIZEOFBOM, &nBytesRead, NULL)) {
597: MessageBox (hwnd, TEXT("ReadFile() failed."),MBTitle, MBFlags);
598: CloseHandle (hFile);
599: pSourceData = ManageMemory (MMFREE, MMSOURCE, 0, pSourceData);
600: return 0;
601: }
602:
603:
604:
605: /* If file begins with BOM, then we know the type,
606: * we'll decrement the number of bytes by two,
607: * and read the rest of the data.
608: */
609: if (IsBOM (pSourceData)) {
610: gTypeSource = TYPEUNICODE;
611: nBytesSource -=SIZEOFBOM;
612:
613: /* If file begins with Reverse BOM, then we know the type,
614: * we'll decrement the number of bytes by two,
615: * and read the rest of the data, and post a message so
616: * that we know to swap the order later.
617: */
618: } else if (IsRBOM (pSourceData)) {
619: gTypeSource = TYPEUNICODE;
620: nBytesSource -=SIZEOFBOM;
621: MessageBox (hwnd, TEXT("Reverse byte order mark detected.\n Automatically swapping byte order."),MBTitle, MBFlags);
622: PostMessage (hwnd, WM_COMMAND, MID_SWAPSOURCE, 0);
623:
624: /* Oops, does not begin with BOM.
625: * Reset file pointer, and read data.
626: */
627: } else {
628: gTypeSource = TYPEUNKNOWN;
629: SetFilePointer (hFile, -SIZEOFBOM, NULL, FILE_CURRENT);
630: }
631:
632:
633:
634: /* try to read all of it into memory */
635: if (!ReadFile (hFile, pSourceData,nBytesSource, &nBytesRead, NULL)) {
636: MessageBox (hwnd, TEXT("ReadFile() failed."),MBTitle, MBFlags);
637: CloseHandle (hFile);
638: pSourceData = ManageMemory (MMFREE, MMSOURCE, 0, pSourceData);
639: return 0;
640: }
641:
642: CloseHandle (hFile);
643:
644: /* If we don't know the file type at this point,
645: * try to determine if it is unicode.
646: */
647: if (gTypeSource == TYPEUNKNOWN) {
648: if (IsUnicode (pSourceData))
649: gTypeSource = TYPEUNICODE;
650: else
651: gTypeSource = TYPECODEPAGE;
652: }
653:
654: SendMessage (hwnd, WMU_ADJUSTFORNEWSOURCE, 0, (LPARAM)szFile);
655:
656:
657:
658: } break; /* end case MID_OPEN */
659:
660:
661:
662: /******************************************************************\
663: * WM_COMMAND, MID_SAVEAS
664: *
665: * Put up common dialog, try to open file, and write data to it.
666: \******************************************************************/
667: case MID_SAVEAS: {
668: HANDLE hFile;
669: DWORD nBytesRead;
670: TCHAR szFile[MAX_PATH],szFileTitle[MAX_PATH];
671:
672: if (nBytesDestination == NODATA ) {
673: MessageBox (hwnd, TEXT("No text to save"),MBTitle, MBFlags);
674: return 0;
675: }
676:
677:
678: /* Set up the structure for the GetSaveFileName
679: * common dialog.
680: */
681: {
682: OPENFILENAME OpenFileName;
683: /* buffers for the file names. */
684:
685: wsprintf (szFile, szBlank);
686: wsprintf (szFileTitle, szBlank);
687:
688: OpenFileName.lStructSize = sizeof(OPENFILENAME);
689: OpenFileName.hwndOwner = hwnd;
690: OpenFileName.hInstance = (HANDLE) hInst;
691: OpenFileName.lpstrFilter = szFilter;
692: OpenFileName.lpstrCustomFilter = NULL;
693: OpenFileName.nMaxCustFilter = 0L;
694: OpenFileName.nFilterIndex = 1L;
695: OpenFileName.lpstrFile = szFile;
696: OpenFileName.nMaxFile = MAX_PATH;
697: OpenFileName.lpstrFileTitle = szFileTitle;
698: OpenFileName.nMaxFileTitle = MAX_PATH;
699: OpenFileName.lpstrInitialDir = NULL;
700: OpenFileName.lpstrTitle = TEXT("Save As");
701:
702: OpenFileName.nFileOffset = 0;
703: OpenFileName.nFileExtension = 0;
704: OpenFileName.lpstrDefExt = NULL;
705:
706: OpenFileName.lCustData = 0;
707: OpenFileName.lpfnHook = NULL;
708: OpenFileName.lpTemplateName = NULL;
709:
710: OpenFileName.Flags = OFN_HIDEREADONLY;
711:
712: if (!GetSaveFileName(&OpenFileName)) return 0;
713: }
714:
715:
716: /* User has filled in the file information.
717: * Try to open that file for writing.
718: */
719: hFile = CreateFile(szFile,
720: GENERIC_WRITE,
721: 0,
722: NULL,
723: CREATE_ALWAYS,
724: FILE_ATTRIBUTE_NORMAL,
725: NULL);
726:
727: if (hFile == INVALID_HANDLE_VALUE) {
728: MessageBox (hwnd, TEXT("CreateFile() failed."),MBTitle, MBFlags);
729: return 0;
730: }
731:
732:
733: /* if destination is unicode, try to write BOM first.
734: * unless the bytes have been swapped
735: * (criterion: hwndByteOrder contains text)
736: * in which case, write a Reverse Byte Order Mark.
737: */
738: if (gTypeSource == TYPECODEPAGE) {
739: if (GetWindowTextLength (hwndByteOrder1) == 0) {
740:
741: if (!WriteFile (hFile, szBOM, SIZEOFBOM, &nBytesRead, NULL)) {
742: MessageBox (hwnd, TEXT("WriteFile() failed."),MBTitle, MBFlags);
743: CloseHandle (hFile);
744: return 0;
745: }
746:
747: }else {
748: if (!WriteFile (hFile, szRBOM, SIZEOFBOM, &nBytesRead, NULL)) {
749: MessageBox (hwnd, TEXT("WriteFile() failed."),MBTitle, MBFlags);
750: CloseHandle (hFile);
751: return 0;
752: }
753:
754: }
755: }
756:
757:
758: /* try to write all of it into memory */
759: if (!WriteFile (hFile, pDestinationData,nBytesDestination, &nBytesRead, NULL)) {
760: MessageBox (hwnd, TEXT("WriteFile() failed."),MBTitle, MBFlags);
761: CloseHandle (hFile);
762: return 0;
763: }
764:
765: SetWindowText (hwndName1, szFile);
766: CloseHandle (hFile);
767:
768: } break;
769:
770:
771: /**********************************************************************\
772: * WM_COMMAND, MID_PASTESOURCE
773: *
774: * Paste the clipboard's prefered data format into the source.
775: * Fills pSourceData.
776: \**********************************************************************/
777: case MID_PASTESOURCE: {
778: UINT iFormat;
779: PVOID pData;
780:
781: OpenClipboard (hwnd);
782:
783: iFormat = 0;
784: while (iFormat = EnumClipboardFormats(iFormat))
785: if ((iFormat == CF_UNICODETEXT) || (iFormat == CF_OEMTEXT) || (iFormat == CF_TEXT)) {
786:
787: pData = GetClipboardData (iFormat);
788:
789: switch (iFormat) {
790: case CF_UNICODETEXT:
791: nBytesSource = lstrlenW (pData) *2;
792: pSourceData= ManageMemory (MMALLOC, MMSOURCE, nBytesSource+2, pSourceData);
793: lstrcpyW ((LPVOID)pSourceData, pData);
794: gTypeSource = TYPEUNICODE;
795: break;
796:
797: case CF_OEMTEXT:
798: nBytesSource = lstrlenA (pData);
799: pSourceData= ManageMemory (MMALLOC, MMSOURCE, nBytesSource+1, pSourceData);
800: lstrcpyA (pSourceData, pData);
801: gTypeSource = TYPECODEPAGE;
802: giSourceCodePage = GetOEMCP();
803: break;
804:
805: case CF_TEXT:
806: nBytesSource = lstrlenA (pData);
807: pSourceData= ManageMemory (MMALLOC, MMSOURCE, nBytesSource+1, pSourceData);
808: lstrcpyA (pSourceData, pData);
809: gTypeSource = TYPECODEPAGE;
810: giSourceCodePage = GetACP();
811: break;
812:
813: default: break; // shouldn't get here
814: } /* end switch (iFormat) */
815:
816: SendMessage (hwnd, WMU_ADJUSTFORNEWSOURCE, 0,
817: (LPARAM)TEXT("<from Clipboard>"));
818:
819: break; /* break out of while loop. */
820: } /* end if iFormat */
821:
822:
823: CloseClipboard ();
824:
825: } break;
826:
827:
828:
829: /**********************************************************************\
830: * WM_COMMAND, MID_COPYDESTINATION
831: *
832: * Copy destination data to the clipboard.
833: \**********************************************************************/
834: case MID_COPYDESTINATION:
835: if (pDestinationData == NULL) return FALSE;
836:
837: OpenClipboard (hwnd);
838: EmptyClipboard();
839:
840: /* if source NOT unicode, then destination is, else look at dest CP */
841: if (gTypeSource != TYPEUNICODE)
842: SetClipboardData (CF_UNICODETEXT, pDestinationData);
843: else if (giDestinationCodePage == GetOEMCP())
844: SetClipboardData (CF_OEMTEXT, pDestinationData);
845: else
846: SetClipboardData (CF_TEXT, pDestinationData);
847:
848: CloseClipboard ();
849:
850: break;
851:
852:
853:
854: /******************************************************************\
855: * WM_COMMAND, MID_CONVERTNOW
856: *
857: * This is where the conversion actually takes place.
858: * In either case, make the call twice. Once to determine how
859: * much memory is needed, allocate space, and then make the call again.
860: *
861: * If conversion succeeds, it fills pDestinationData.
862: \******************************************************************/
863: case MID_CONVERTNOW: {
864: int nBytesNeeded, nWCharNeeded, nWCharSource;
865:
866:
867: if (nBytesSource == NODATA ) {
868: MessageBox (hwnd, TEXT("Load Source File"),MBTitle, MBFlags);
869: return 0;
870: }
871:
872:
873: /* Converting UNICODE -> giDestinationCodePage*/
874: if (gTypeSource == TYPEUNICODE) {
875:
876: nWCharSource = nBytesSource/2;
877:
878: /* Query the number of bytes required to store the Dest string */
879: nBytesNeeded = WideCharToMultiByte(giDestinationCodePage, gWCFlags,
880: (LPWSTR)pSourceData, nWCharSource,
881: NULL, 0,
882: glpDefaultChar, &gUsedDefaultChar);
883:
884: /* Allocate the required amount of space */
885: pDestinationData= ManageMemory (MMALLOC, MMDESTINATION, nBytesNeeded, pDestinationData);
886:
887: /* Do the conversion */
888: nBytesDestination = WideCharToMultiByte(giDestinationCodePage, gWCFlags,
889: (LPWSTR)pSourceData, nWCharSource,
890: pDestinationData, nBytesNeeded, glpDefaultChar, &gUsedDefaultChar);
891: }
892:
893:
894: /* converting giSourceCodePage -> UNICODE */
895: else if (gTypeSource == TYPECODEPAGE) {
896:
897: /* Query the number of WChar required to store the Dest string */
898: nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
899: pSourceData, nBytesSource, NULL, 0 );
900:
901: /* Allocate the required amount of space */
902: pDestinationData= ManageMemory (MMALLOC, MMDESTINATION, nWCharNeeded*2, pDestinationData);
903:
904: /* Do the conversion */
905: nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
906: pSourceData, nBytesSource,
907: (LPWSTR)pDestinationData, nWCharNeeded);
908:
909: /* MultiByteToWideChar returns # WCHAR, so multiply by 2 */
910: nBytesDestination = 2*nWCharNeeded ;
911: } else {
912: MessageBox (hwnd, TEXT("Source type unknown.\n Specify Source Options"),MBTitle, MBFlags);
913: return 0;
914: }
915:
916:
917: /* code common to all conversions... */
918: SetWindowText (hwndName1, TEXT("Data not saved yet!!"));
919: wsprintf (buffer, szNBytes, nBytesDestination);
920: SetWindowText (hwndSize1, buffer);
921: SetWindowText (hwndByteOrder1, szBlank);
922:
923:
924: /* Throw up "Save as" dialog to help the user along.
925: * They can always <esc> if need be.
926: */
927: SendMessage (hwnd, WM_COMMAND, MID_SAVEAS, 0);
928:
929: } break; /* end case BID_CONVERT */
930:
931:
932:
933: /******************************************************************\
934: * WM_COMMAND, BID_VIEWSOURCE
935: *
936: \******************************************************************/
937: case BID_VIEWSOURCE:
938: if (gTypeSource == TYPEUNICODE)
939: DialogBoxW (hInst, L"ShowTextDlg", hwnd, (DLGPROC)ViewSourceProc);
940: else
941: DialogBoxA (hInst, "ShowTextDlg", hwnd, (DLGPROC)ViewSourceProc);
942: break;
943:
944: /******************************************************************\
945: * WM_COMMAND, BID_VIEWDESTINATION
946: *
947: \******************************************************************/
948: case BID_VIEWDESTINATION:
949: if (gTypeSource == TYPEUNICODE)
950: DialogBoxA (hInst, "ShowTextDlg", hwnd, (DLGPROC)ViewDestinationProc);
951: else
952: DialogBoxW (hInst, L"ShowTextDlg", hwnd, (DLGPROC)ViewDestinationProc);
953: break;
954:
955:
956:
957: /******************************************************************\
958: * WM_COMMAND, MID_SOURCEOPT
959: *
960: * Allows user to change interpretation options for the source data.
961: *
962: * Put up appropriate dialog box, and reset window text in response.
963: \******************************************************************/
964: case MID_SOURCEOPT:
965: if (DialogBox (hInst, TEXT("DataOptionsDlg"), hwnd, (DLGPROC)SourceOptionsProc)) {
966: SendMessage (hwnd, WMU_SETTYPESTRINGS, 0,0);
967: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
968: }
969: break;
970:
971: /******************************************************************\
972: * WM_COMMAND, MID_DESTINATIONOPT
973: *
974: * Allows user to change options for destination data.
975: *
976: * Put up appropriate dialog box, and reset window text in response.
977: \******************************************************************/
978: case MID_DESTINATIONOPT:
979: if (DialogBox (hInst, TEXT("DataOptionsDlg"), hwnd, (DLGPROC)DestinationOptionsProc)) {
980: SendMessage (hwnd, WMU_SETTYPESTRINGS, 0,0);
981: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
982: }
983: break;
984:
985: /******************************************************************\
986: * WM_COMMAND, MID_CONVERSIONOPT
987: *
988: \******************************************************************/
989: case MID_CONVERSIONOPT:
990: if (DialogBox (hInst, TEXT("ConversionOptionsDlg"), hwnd, (DLGPROC)ConversionOptionsProc)) {
991: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
992: }
993: break;
994:
995:
996:
997: /******************************************************************\
998: * WM_COMMAND, MID_SWAPSOURCE
999: *
1000: * Allows user to reverse byte order of data.
1001: *
1002: \******************************************************************/
1003: case MID_SWAPSOURCE: {
1004: int i, end;
1005: BYTE temp;
1006:
1007: if (pSourceData == NULL) return FALSE;
1008:
1009: end = nBytesSource - 2;
1010: for (i = 0; i<= end; i+=2) {
1011: temp = pSourceData[i];
1012: pSourceData[i] = pSourceData[i+1];
1013: pSourceData[i+1] = temp;
1014: }
1015:
1016: if (GetWindowTextLength (hwndByteOrder0) == 0)
1017: SetWindowText (hwndByteOrder0, szByteOrderReversed);
1018: else
1019: SetWindowText (hwndByteOrder0, szBlank);
1020:
1021: /* Since source is different, invalidate Destination data. */
1022: SendMessage (hwnd, WM_COMMAND, MID_CLEARDESTINATION, 0);
1023:
1024: } break;
1025:
1026:
1027:
1028: /******************************************************************\
1029: * WM_COMMAND, MID_SWAPDESTINATION
1030: *
1031: * Allows user to reverse byte order of data.
1032: *
1033: \******************************************************************/
1034: case MID_SWAPDESTINATION: {
1035: int i, end;
1036: BYTE temp;
1037:
1038: if (pDestinationData == NULL) return FALSE;
1039:
1040: end = nBytesDestination - 2;
1041: for (i = 0; i<= end; i+=2) {
1042: temp = pDestinationData[i];
1043: pDestinationData[i] = pDestinationData[i+1];
1044: pDestinationData[i+1] = temp;
1045: }
1046:
1047: if (GetWindowTextLength (hwndByteOrder1) == 0)
1048: SetWindowText (hwndByteOrder1, szByteOrderReversed);
1049: else
1050: SetWindowText (hwndByteOrder1, szBlank);
1051:
1052: } break;
1053:
1054:
1055: /**********************************************************************\
1056: * WM_COMMAND, MID_CLEARDESTINATION
1057: *
1058: * Clear the destination information. May cause data to be lost.
1059: \**********************************************************************/
1060: case MID_CLEARDESTINATION:
1061: SetWindowText (hwndSize1, szBlank);
1062: SetWindowText (hwndName1, szBlank);
1063: SetWindowText (hwndByteOrder1, szBlank);
1064: pDestinationData= ManageMemory (MMFREE, MMDESTINATION, 0, pDestinationData);
1065: break;
1066:
1067:
1068: /**********************************************************************\
1069: * WM_COMMAND, MID_CLEARSOURCE
1070: *
1071: * Clear the SOURCE information. May cause data to be lost.
1072: \**********************************************************************/
1073: case MID_CLEARSOURCE:
1074: SetWindowText (hwndSize0, szBlank);
1075: SetWindowText (hwndName0, szBlank);
1076: SetWindowText (hwndByteOrder0, szBlank);
1077: pSourceData= ManageMemory (MMFREE, MMSOURCE, 0, pSourceData);
1078: break;
1079:
1080:
1081:
1082:
1083:
1084: /******************************************************************\
1085: * WM_COMMAND, MID_INSTALLTABLES
1086: *
1087: \******************************************************************/
1088: case MID_INSTALLTABLES:
1089: DialogBox (hInst, TEXT("InstallTableDlg"), hwnd, (DLGPROC)InstallTableProc);
1090: break;
1091:
1092:
1093:
1094:
1095: /* Simply call WinHelp to display the OnLine help file. */
1096: case MID_HELP:
1097: WinHelp( hwnd, szHelpPathName, HELP_INDEX, (DWORD) NULL );
1098: break;
1099:
1100:
1101: /* No-op Window procedure to simply display the dialog box. */
1102: case MID_ABOUT:
1103: DialogBox (hInst, TEXT("aboutBox"), hwnd, (DLGPROC) AboutProc);
1104: break;
1105:
1106: /* Just close the window. */
1107: case MID_EXIT:
1108: PostMessage (hwnd, WM_CLOSE, 0,0);
1109: break;
1110:
1111:
1112:
1113:
1114: } /* end switch (LOWORD(wParam)) */
1115: break; /* end WM_COMMAND */
1116:
1117:
1118:
1119: default: break;
1120: } /* end switch */
1121:
1122: return (DefWindowProc(hwnd, message, wParam, lParam));
1123: }
1124:
1125:
1126:
1127:
1128:
1129: /**************************************************************************\
1130: *
1131: * function: IsUnicode()
1132: *
1133: * HACK... eventually use a proper function for IsUnicode
1134: * Use function from unipad?
1135: *
1136: \**************************************************************************/
1137: BOOL IsUnicode (PBYTE pb)
1138: {
1139: return (IsBOM (pb));
1140: }
1141:
1142:
1143:
1144: /**************************************************************************\
1145: *
1146: * function: IsBOM()
1147: *
1148: * true iff pb points to a Byte Order Mark.
1149: *
1150: \**************************************************************************/
1151: BOOL IsBOM (PBYTE pb)
1152: {
1153: if ((*pb == 0xFF) & (*(pb+1) == 0xFE)) // BOM
1154: return TRUE;
1155: else
1156: return FALSE;
1157: }
1158:
1159:
1160: /**************************************************************************\
1161: *
1162: * function: IsRBOM()
1163: *
1164: * true iff pb points to a reversed Byte Order Mark.
1165: *
1166: \**************************************************************************/
1167: BOOL IsRBOM (PBYTE pb)
1168: {
1169: if ((*pb == 0xFE) & (*(pb+1) == 0xFF)) // RBOM
1170: return TRUE;
1171: else
1172: return FALSE;
1173: }
1174:
1175:
1176:
1177:
1178: /**************************************************************************\
1179: *
1180: * function: framechildwindow()
1181: *
1182: * Simply draw a 3D frame around child window.
1183: *
1184: \**************************************************************************/
1185: VOID framechildwindow (HDC hdc, HWND hwndParent, HWND hwndChild)
1186: {
1187: RECT rect;
1188:
1189: GetWindowRect (hwndChild, &rect);
1190:
1191: /* minor hack... assumes RECT is two points, right field starting first */
1192: ScreenToClient (hwndParent, (LPPOINT)&rect);
1193: ScreenToClient (hwndParent, (LPPOINT)&(rect.right));
1194:
1195: InflateRect (&rect, 1, 1);
1196: FrameRect (hdc, &rect, GetStockObject (GRAY_BRUSH));
1197: InflateRect (&rect, -1, -1);
1198: SelectObject (hdc, GetStockObject (WHITE_PEN));
1199: MoveToEx (hdc, rect.right, rect.top, NULL);
1200: LineTo (hdc,rect.right, rect.bottom);
1201: LineTo (hdc,rect.left, rect.bottom);
1202:
1203: return;
1204: }
1205:
1206:
1207: /**************************************************************************\
1208: *
1209: * function: underlinechildwindow()
1210: *
1211: * Underline child window.
1212: *
1213: \**************************************************************************/
1214: VOID underlinechildwindow (HDC hdc, HWND hwndParent, HWND hwndChild)
1215: {
1216: RECT rect;
1217:
1218: GetWindowRect (hwndChild, &rect);
1219:
1220: /* minor hack... assumes RECT is two points, right field starting first */
1221: ScreenToClient (hwndParent, (LPPOINT)&rect);
1222: ScreenToClient (hwndParent, (LPPOINT)&(rect.right));
1223:
1224: InflateRect (&rect, 1, 1);
1225: rect.top = rect.bottom-1;
1226: FrameRect (hdc, &rect, GetStockObject (GRAY_BRUSH));
1227: SelectObject (hdc, GetStockObject (WHITE_PEN));
1228: MoveToEx (hdc, rect.right, rect.bottom, NULL);
1229: LineTo (hdc,rect.left, rect.bottom);
1230:
1231: return;
1232: }
1233:
1234:
1235:
1236:
1237:
1238:
1239:
1240: /**************************************************************************\
1241: *
1242: * function: createwindows()
1243: *
1244: * Create the child windows and pass the handles back in parameters.
1245: * Each Window is created relative to (inside of) prect.
1246: * top is a spacial pointer to the Y coordinate of the next window.
1247: *
1248: \**************************************************************************/
1249: VOID createwindows(PRECT prect,
1250: HWND hwndParent,
1251: HWND* hwndLabel,
1252: HWND* hwndName,
1253: HWND* hwndSize,
1254: HWND* hwndCodePage,
1255: HWND* hwndByteOrder,
1256: HWND* hwndButton)
1257: {
1258: int top;
1259:
1260: top = prect->top;
1261: *hwndLabel = CreateWindow(
1262: TEXT("STATIC"),
1263: szBlank,
1264: WS_CHILD | WS_VISIBLE | SS_CENTER,
1265: prect->left,
1266: top,
1267: prect->right - prect->left,
1268: WHEIGHT,
1269: hwndParent, NULL, hInst, 0);
1270:
1271: top += WHEIGHT*5/2;
1272: *hwndName = CreateWindow(
1273: TEXT("STATIC"),
1274: szBlank,
1275: WS_CHILD | WS_VISIBLE | SS_RIGHT,
1276: prect->left,
1277: top,
1278: prect->right - prect->left,
1279: WHEIGHT,
1280: hwndParent, NULL, hInst, 0);
1281:
1282: top += WHEIGHT*2;
1283: *hwndSize = CreateWindow(
1284: TEXT("STATIC"),
1285: szBlank,
1286: WS_CHILD | WS_VISIBLE | SS_LEFT,
1287: prect->left,
1288: top,
1289: (prect->right - prect->left) *3/4,
1290: WHEIGHT,
1291: hwndParent, NULL, hInst, 0);
1292:
1293: top += WHEIGHT*2;
1294: *hwndCodePage = CreateWindow(
1295: TEXT("STATIC"),
1296: szBlank,
1297: WS_CHILD | WS_VISIBLE | SS_LEFT,
1298: prect->left,
1299: top,
1300: (prect->right - prect->left) *3/4,
1301: WHEIGHT,
1302: hwndParent, NULL, hInst, 0);
1303:
1304: top += WHEIGHT*2;
1305: *hwndByteOrder = CreateWindow(
1306: TEXT("STATIC"),
1307: szBlank,
1308: WS_CHILD | WS_VISIBLE | SS_LEFT,
1309: prect->left,
1310: top,
1311: (prect->right - prect->left) *3/4,
1312: WHEIGHT,
1313: hwndParent, NULL, hInst, 0);
1314:
1315: top += WHEIGHT*2;
1316: *hwndButton = CreateWindow(
1317: TEXT("BUTTON"),
1318: TEXT("ViewText"),
1319: WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
1320: prect->left,
1321: top,
1322: prect->right - prect->left,
1323: WHEIGHT*9/7,
1324: hwndParent, NULL, hInst, 0);
1325:
1326: return;
1327: }
1328:
1329:
1330: /**************************************************************************\
1331: *
1332: * function: ManageMemory()
1333: *
1334: * Do all memory management here for the source and destination pointers.
1335: * We also enable/disable the "View..." buttons to reflect existence of data.
1336: *
1337: *
1338: * PARAMETERS
1339: *
1340: * message : {MMALLOC, MMFREE}
1341: * Alloc when requested by MMALLOC, and free the existing, passed in, pointer.
1342: * Free when requested by MMFREE.
1343: * sourcedestination : {MMSOURCE, MMDESTINATION}
1344: * nBytes - number to alloc on MMALLOC messages.
1345: * p - old pointer to be freed.
1346: *
1347: *
1348: * GLOBALS
1349: *
1350: * hwndButton0, hwndButton1
1351: *
1352: \**************************************************************************/
1353: LPVOID ManageMemory (UINT message, UINT sourcedestination, DWORD nBytes, LPVOID p)
1354: {
1355: switch (message) {
1356: case MMFREE :
1357: if (sourcedestination == MMSOURCE)
1358: EnableWindow (hwndButton0, FALSE);
1359: else if (sourcedestination == MMDESTINATION)
1360: EnableWindow (hwndButton1, FALSE);
1361:
1362: if (p != NULL) GlobalFree (GlobalHandle (p));
1363: return NULL;
1364: break;
1365:
1366: case MMALLOC :
1367: if (sourcedestination == MMSOURCE)
1368: EnableWindow (hwndButton0, TRUE);
1369: else if (sourcedestination == MMDESTINATION)
1370: EnableWindow (hwndButton1, TRUE);
1371:
1372: if (p != NULL) GlobalFree (GlobalHandle (p));
1373: p = (LPVOID) GlobalAlloc (GPTR, nBytes);
1374: return p;
1375: break;
1376:
1377: } /* end switch (message) */
1378: return NULL;
1379: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.