![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sty_file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / style|
Return to sty_file.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / style |
1.1 root 1: /*==============================================================*\
2: * File.c - routines for handling the standard file menu
3: * commands
4: * Created 1990, Microsoft, IBM Corp.
5: *--------------------------------------------------------------
6: *
7: * This module contains the code for the WM_COMMAND messages
8: * posted by the standard File menu.
9: *
10: *--------------------------------------------------------------
11: *
12: * This source file contains the following functions:
13: *
14: * FileNew(mp2);
15: * FileOpen(mp2);
16: * FileSave(mp2);
17: * FileSaveAs(mp2);
18: * FilePrint(mp2);
19: * FilePageSetup(mp2);
20: * FilePrintSetup(mp2);
21: * FileExit(mp2);
22: * WriteFileToDisk(hf);
23: * GetFileName();
24: * UpdateTitleText(hwnd);
25: *
26: \*==============================================================*/
27:
28: /*--------------------------------------------------------------*\
29: * Include files, macros, defined constants, and externs
30: \*--------------------------------------------------------------*/
31:
32: #define INCL_WINFRAMEMGR
33: #define INCL_WINSWITCHLIST
34: #define INCL_WINMLE
35: #define INCL_WINSTDFILE
36:
37:
38: /* The comments around this line should be removed when the import/export
39: bug in MLEs is fixed */
40: /* #define MLE_BUGS_FIXED */
41:
42: #include <os2.h>
43: #include <string.h>
44: #include "sty_main.h"
45: #include "sty_xtrn.h"
46: #include "sty_dlg.h"
47:
48: /*--------------------------------------------------------------*\
49: * Global variables
50: \*--------------------------------------------------------------*/
51:
52: CHAR szFullPath[CCHMAXPATH] = "";
53:
54: /*--------------------------------------------------------------*\
55: * Entry point declarations
56: \*--------------------------------------------------------------*/
57:
58:
59: /****************************************************************\
60: * New file routine
61: *--------------------------------------------------------------
62: *
63: * Name: FileNew(mp2)
64: *
65: * Purpose: Processes the File menu's New item
66: *
67: * Usage: called whenever New from the File menu is selected
68: *
69: * Method:
70: *
71: *
72: * Returns:
73: *
74: \****************************************************************/
75: VOID FileNew(mp2)
76: MPARAM mp2; /* second parameter of WM_COMMAND message */
77: {
78: SHORT sT;
79:
80: /*--------------------------------------------------------------*\
81: * Enter routines for creating a new file and window
82: \*--------------------------------------------------------------*/
83:
84: /* save file if changed */
85: if(WinSendMsg(hwndMLE, MLM_QUERYCHANGED, NULL, NULL)) {
86: sT = MessageBox(hwndMLE,
87: IDMSG_OVERWRITEFILE,
88: MB_QUERY | MB_YESNOCANCEL,
89: FALSE);
90:
91:
92: if(sT == MBID_CANCEL) /* if user cancels the New, then return */
93: return;
94: #ifdef MLE_BUGS_FIXED
95: else
96: if(sT == MBID_YES)
97: FileSave(NULL);
98: #endif
99: /* if sT == MBID_NO, continue with New File processing */
100:
101:
102: }
103:
104: /* disable redrawing of the MLE so the text doesn't "flash" when
105: the MLE is cleared */
106: WinSendMsg(hwndMLE, MLM_DISABLEREFRESH, NULL, NULL);
107:
108: /* clear the MLE by selecting all of the text and clearing it */
109: WinSendMsg(hwndMLE,
110: MLM_SETSEL,
111: MPFROMSHORT(NULL),
112: (MPARAM)WinSendMsg(hwndMLE, MLM_QUERYTEXTLENGTH, NULL, NULL));
113:
114: WinSendMsg(hwndMLE, MLM_CLEAR, NULL, NULL);
115:
116: /* reset the changed flag */
117: WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
118:
119: /* enable redrawing of the MLE */
120: WinSendMsg(hwndMLE, MLM_ENABLEREFRESH, NULL, NULL);
121:
122: /* reset file name to NULL and update the main title bar*/
123: szFullPath[0] = 0;
124: UpdateTitleText(hwndMainFrame);
125:
126:
127: /* This routine currently doesn't use the mp2 parameter but *\
128: * it is referenced here to prevent an 'Unreferenced Parameter'
129: \* warning at compile time. */
130: mp2;
131:
132: } /* FileNew() */
133:
134:
135: #ifdef MLE_BUGS_FIXED
136:
137:
138: /****************************************************************\
139: * Open file routine
140: *--------------------------------------------------------------
141: *
142: * Name: FileOpen(mp2)
143: *
144: * Purpose: Processes the File menu's Open item.
145: *
146: * Usage: called whenever New from the File menu is selected
147: *
148: * Method: calls the standard file open dialog to get the
149: * file name. The file name is passed onto DosOpen
150: * which returns the handle to the file. The file
151: * input procedure is called and then the file handle
152: * is closed.
153: *
154: * Returns:
155: *
156: \****************************************************************/
157: VOID FileOpen(mp2)
158: MPARAM mp2; /* second parameter of WM_COMMAND message */
159: {
160: FILEDLG fdg;
161: HFILE hfIn;
162: ULONG ulAction;
163: FILESTATUS fstsInfo;
164: PVOID pvBuf;
165: CHAR szTitle[MESSAGELEN], szButton[MESSAGELEN];
166:
167: fdg.cbsize = sizeof(FILEDLG);
168:
169: if(!WinLoadString(hab, NULL, IDS_OPENDLGTITLE, MESSAGELEN, szTitle)) {
170: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
171: return;
172: }
173:
174: if(!WinLoadString(hab, NULL, IDS_OPENDLGBUTTON, MESSAGELEN, szButton)) {
175: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
176: return;
177: }
178:
179: fdg.usDialogType = OPEN_DIALOG;
180: fdg.pszTitle = szTitle;
181: fdg.pszOKButton = szButton;
182: fdg.lUser = 0L;
183: fdg.fl = FDS_HELPBUTTON | FDS_CENTER;
184: fdg.pfnDlgProc = NULL;
185: fdg.lReturn = 0L;
186: fdg.lSRC = 0L;
187: fdg.hmod = NULL;
188: fdg.idDlg = IDD_FILEOPEN;
189: fdg.x = 0;
190: fdg.y = 0;
191:
192: if(!WinLoadString(hab,
193: NULL,
194: IDS_FILEOPENEXT,
195: CCHMAXPATH,
196: fdg.szFullFile)) {
197:
198: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
199: return;
200: }
201:
202: fdg.pszIType = 0L;
203: fdg.ppszITypeList = 0L;
204: fdg.pszIDrive = 0L;
205: fdg.ppszIDriveList = 0L;
206: fdg.sEAType = 0;
207:
208: /* get the file */
209: if(!KitFileDlg(hwndMain, (PFILEDLG)&fdg))
210: return;
211:
212:
213: /*--------------------------------------------------------------*\
214: * Upon sucessful return of a file, open it for reading
215: \*--------------------------------------------------------------*/
216:
217: if(fdg.lReturn == ID_OK) {
218: if( DosOpen(fdg.szFullFile,
219: &hfIn,
220: &ulAction,
221: 0L,
222: FILE_NORMAL,
223: FILE_OPEN,
224: OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE,
225: 0L)) {
226:
227: MessageBox(hwndMain,
228: IDMSG_CANNOTOPENINPUTFILE,
229: MB_OK | MB_ERROR,
230: FALSE);
231: return;
232: }
233:
234: /* copy file name into file name buffer */
235: strcpy(szFullPath, fdg.szFullFile);
236:
237: /*--------------------------------------------------------------*\
238: * Place routine for reading the file here
239: \*--------------------------------------------------------------*/
240:
241: /* get the length of the file */
242: if(DosQueryFileInfo(hfIn,
243: 1,
244: (PVOID)&fstsInfo,
245: sizeof(FILESTATUS))) {
246: MessageBox(hwndMain,
247: IDMSG_CANNOTGETFILEINFO,
248: MB_OK | MB_ERROR,
249: FALSE);
250:
251: DosClose(hfIn);
252: return;
253: }
254:
255:
256: /* allocate a buffer for the file */
257: if(DosAllocMem((PPVOID)&pvBuf,
258: (ULONG)fstsInfo.cbFileAlloc,
259: fALLOC)) {
260: MessageBox(hwndMain,
261: IDMSG_CANNOTALLOCATEMEMORY,
262: MB_OK | MB_ERROR,
263: FALSE);
264:
265: DosClose(hfIn);
266: return;
267: }
268:
269: /* read in the file */
270: if(DosRead(hfIn, pvBuf, fstsInfo.cbFileAlloc, &ulAction)) {
271: MessageBox(hwndMain,
272: IDMSG_CANNOTREADFILE,
273: MB_OK | MB_ERROR,
274: FALSE);
275:
276: DosClose(hfIn);
277: return;
278: }
279:
280: /* set the file into the MLE */
281: WinSendMsg(hwndMLE,
282: MLM_SETIMPORTEXPORT,
283: MPFROMP((PBYTE)pvBuf),
284: MPFROMSHORT(fstsInfo.cbFileAlloc));
285:
286: WinSendMsg(hwndMLE,
287: MLM_IMPORT,
288: MPFROMP(NULL),
289: MPFROMSHORT(fstsInfo.cbFileAlloc));
290:
291: /* reset the changed flag */
292: WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
293:
294: DosFreeMem(pvBuf);
295:
296: DosClose(hfIn);
297:
298: UpdateTitleText(hwndMainFrame);
299: }
300:
301:
302:
303: /* This routine currently doesn't use the mp2 parameter but *\
304: * it is referenced here to prevent an 'Unreferenced Parameter'
305: \* warning at compile time. */
306: mp2;
307:
308: } /* FileOpen() */
309:
310:
311: /****************************************************************\
312: * Save file routine
313: *--------------------------------------------------------------
314: *
315: * Name: FileSave(mp2)
316: *
317: * Purpose: Processes the File menu's Save item.
318: *
319: * Usage: called whenever Save from the File menu is
320: * selected
321: *
322: * Method: Routine calls the application's save routine
323: *
324: * Returns:
325: *
326: \****************************************************************/
327: VOID FileSave(mp2)
328: MPARAM mp2; /* second parameter of WM_COMMAND message */
329: {
330: HFILE hf;
331: ULONG ulAction;
332:
333: /*
334: * If the file currently is untitled, we will need to get a file
335: * name from the user before we can open the file. Getting a
336: * file name is normally done during the FileSaveAs operation
337: * so we will treat this save as a SaveAs and call FileSaveAs().
338: * If the file is titled, then we save the file.
339: *
340: * NOTE: This routine will be called by FileSaveAs(), but only
341: * after a valid file name has been obtained. So, FileSaveAs()
342: * will not be called again from this routine.
343: */
344: if(szFullPath[0] == 0) {
345: FileSaveAs(mp2);
346: return;
347: }
348:
349: /* open the file */
350: if( DosOpen(szFullPath,
351: &hf,
352: &ulAction,
353: 0L,
354: FILE_NORMAL,
355: FILE_OPEN | FILE_CREATE,
356: OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYNONE,
357: 0L)) {
358:
359: MessageBox(hwndMain,
360: IDMSG_CANNOTOPENOUTPUTFILE,
361: MB_OK | MB_ERROR,
362: FALSE);
363: return;
364: }
365:
366: WriteFileToDisk(hf);
367:
368: DosClose(hf);
369:
370:
371: /* This routine currently doesn't use the mp2 parameter but *\
372: * it is referenced here to prevent an 'Unreferenced Parameter'
373: \* warning at compile time. */
374: mp2;
375:
376: } /* FileSave() */
377:
378: /****************************************************************\
379: * Save As file routine
380: *--------------------------------------------------------------
381: *
382: * Name: FileSaveAs(mp2)
383: *
384: * Purpose: Processes the File menu's Save As item.
385: *
386: * Usage: called whenever Save As from the File menu is
387: * selected
388: *
389: * Method: Routine calls the application's Save As routine
390: *
391: * Returns:
392: *
393: \****************************************************************/
394: VOID FileSaveAs(mp2)
395: MPARAM mp2; /* second parameter of WM_COMMAND message */
396: {
397: HFILE hf;
398: ULONG ulAction;
399: SHORT sT;
400:
401: while(TRUE) { /* infinite loop until we break out of it */
402:
403: /* if no file name, then get a file name */
404: if(!GetFileName())
405: return;
406:
407: /* See if the file exists. If it does, then confirm that the
408: * user wants to overwrite it. If he doesn't, then get a new
409: * file name
410: */
411: if( DosOpen(szFullPath, /* file name from, GetFileName() */
412: &hf, /* handle of opened file */
413: &ulAction,
414: 0L,
415: FILE_NORMAL,
416: FILE_CREATE,
417: OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYNONE,
418: 0L)) {
419:
420: MessageBox(hwndMain,
421: IDMSG_CANNOTOPENOUTPUTFILE,
422: MB_OK | MB_ERROR,
423: FALSE);
424: return;
425: } else
426: DosClose(hf);
427:
428: /* if file exists, ask if we want to overwrite it */
429: if(ulAction == FILE_EXISTED) {
430: sT = MessageBox(hwndMLE,
431: IDMSG_OVERWRITEFILE,
432: MB_QUERY | MB_YESNOCANCEL,
433: FALSE);
434:
435:
436: if(sT == MBID_CANCEL)
437: return;
438:
439: if(sT == MBID_YES)
440: break;
441:
442: /* if user selected no, repeat the sequence */
443: }
444:
445: } /* while(TRUE) */
446:
447: UpdateTitleText(hwndMainFrame);
448:
449: /*
450: * Now that we have a valid file name, save the file. This is
451: * normally done under the File Save function so we can just
452: * call the FileSave() function here. Note that FileSave() will
453: * not call FileSaveAs() back since there is a valid file name
454: */
455: FileSave(mp2);
456:
457:
458:
459: /* This routine currently doesn't use the mp2 parameter but *\
460: * it is referenced here to prevent an 'Unreferenced Parameter'
461: \* warning at compile time. */
462: mp2;
463:
464: } /* FileSaveAs() */
465:
466: #endif
467:
468: #ifdef PRINT_DLGS_ENABLED
469:
470: /****************************************************************\
471: * Print file routine
472: *--------------------------------------------------------------
473: *
474: * Name: FilePrint(mp2)
475: *
476: * Purpose: Processes the File menu's Print item.
477: *
478: * Usage: called whenever Print from the File menu is
479: * selected
480: *
481: * Method: Routine calls the application's print routine
482: *
483: * Returns:
484: *
485: \****************************************************************/
486: VOID FilePrint(mp2)
487: MPARAM mp2; /* second parameter of WM_COMMAND message */
488: {
489:
490: Print(hwndMain);
491:
492:
493: /* This routine currently doesn't use the mp2 parameter but *\
494: * it is referenced here to prevent an 'Unreferenced Parameter'
495: \* warning at compile time. */
496: mp2;
497:
498: } /* FilePrint() */
499:
500: /****************************************************************\
501: * Page setup routine
502: *--------------------------------------------------------------
503: *
504: * Name: FilePageSetup(mp2)
505: *
506: * Purpose: Processes the File menu's Page Setup item.
507: *
508: * Usage: called whenever Page Setup from the File menu is
509: * selected
510: *
511: * Method: Routine calls the application's page setup routine
512: *
513: * Returns:
514: *
515: \****************************************************************/
516: VOID FilePageSetup(mp2)
517: MPARAM mp2; /* second parameter of WM_COMMAND message */
518: {
519:
520: PageSetup(hwndMain);
521:
522: /* This routine currently doesn't use the mp2 parameter but *\
523: * it is referenced here to prevent an 'Unreferenced Parameter'
524: \* warning at compile time. */
525: mp2;
526:
527: } /* FilePageSetup() */
528:
529: /****************************************************************\
530: * Print Setup routine
531: *--------------------------------------------------------------
532: *
533: * Name: FilePageSetup(mp2)
534: *
535: * Purpose: Processes the File menu's Print Setup item.
536: *
537: * Usage: called whenever Print Setup from the File menu is
538: * selected
539: *
540: * Method: Routine calls the application's Print Setup routine
541: *
542: * Returns:
543: *
544: \****************************************************************/
545: VOID FilePrintSetup(mp2)
546: MPARAM mp2; /* second parameter of WM_COMMAND message */
547: {
548:
549: PrintSetup(hwndMain);
550:
551: /* This routine currently doesn't use the mp2 parameter but *\
552: * it is referenced here to prevent an 'Unreferenced Parameter'
553: \* warning at compile time. */
554: mp2;
555:
556: } /* FilePrintSetup() */
557:
558: #endif /* PRINT_DLGS_ENABLED */
559:
560: /****************************************************************\
561: * Exit routine
562: *--------------------------------------------------------------
563: *
564: * Name: FileExit(mp2)
565: *
566: * Purpose: Processes the File menu's Exit item.
567: *
568: * Usage: called whenever Exit from the file menu is
569: * selected
570: *
571: * Method: Routine posts a WM_CLOSE message to the main
572: * application window.
573: *
574: * Returns:
575: *
576: \****************************************************************/
577: VOID FileExit(mp2)
578: MPARAM mp2; /* second parameter of WM_COMMAND message */
579: {
580:
581: WinPostMsg(hwndMain, WM_CLOSE, (MPARAM)NULL, (MPARAM)NULL);
582:
583:
584: /* This routine currently doesn't use the mp2 parameter but *\
585: * it is referenced here to prevent an 'Unreferenced Parameter'
586: \* warning at compile time. */
587: mp2;
588:
589: } /* FileExit() */
590:
591: #ifdef MLE_BUGS_FIXED
592:
593: /****************************************************************\
594: * Write file routine
595: *--------------------------------------------------------------
596: *
597: * Name: WriteFileToDisk(hf)
598: *
599: * Purpose: Writes the current file to the file in szFileName
600: *
601: * Usage: called from FileSave and FileSaveAs when a file
602: * is to be saved to disk
603: *
604: * Method: Routine uses the file handle specified and gets
605: * the text from the MLE and writes the text to the
606: * file.
607: *
608: * Returns:
609: *
610: \****************************************************************/
611: VOID WriteFileToDisk(hf)
612: HFILE hf; /* handle to the input file */
613: {
614: ULONG ulWrite;
615: PVOID pvBuf;
616: ULONG ulFileLen;
617:
618: /* get the length of the file */
619: ulFileLen = (ULONG)WinSendMsg(hwndMLE, MLM_QUERYTEXTLENGTH, NULL, NULL);
620: if(!ulFileLen)
621: return;
622:
623: /* allocate a buffer for the file */
624: if(DosAllocMem((PPVOID) &pvBuf, ulFileLen, fALLOC)) {
625: MessageBox(hwndMLE,
626: IDMSG_CANNOTALLOCATEMEMORY,
627: MB_OK | MB_ERROR,
628: FALSE);
629: return;
630: }
631:
632:
633: /* get the file from the MLE */
634: WinSendMsg(hwndMLE,
635: MLM_SETIMPORTEXPORT,
636: MPFROMP((PBYTE)pvBuf),
637: MPFROMLONG(ulFileLen));
638:
639: WinSendMsg(hwndMLE,
640: MLM_EXPORT,
641: MPFROMP(NULL),
642: MPFROMLONG(&ulFileLen));
643:
644: /* Write the file */
645: if(DosWrite(hf, pvBuf, ulFileLen, &ulWrite)) {
646: MessageBox(hwndMLE,
647: IDMSG_CANNOTWRITETOFILE,
648: MB_OK | MB_ERROR,
649: FALSE);
650: return;
651: }
652:
653: /* reset the changed flag */
654: WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
655:
656: DosFreeMem(pvBuf);
657:
658:
659: } /* WriteFileToDisk() */
660:
661: /****************************************************************\
662: * Get file name routine
663: *--------------------------------------------------------------
664: *
665: * Name: GetFileName()
666: *
667: * Purpose: Gets the name of the save file.
668: *
669: * Usage: called when the user is needs to supply a name for
670: * the file to be saved
671: *
672: * Method: calls the standard file open dialog to get the
673: * file name.
674: *
675: * Returns: TRUE if successfull in getting a file name, FALSE
676: * if not
677: *
678: \****************************************************************/
679: BOOL GetFileName(VOID)
680: {
681: FILEDLG fdg;
682: CHAR szTitle[MESSAGELEN], szButton[MESSAGELEN];
683:
684: fdg.cbsize = sizeof(FILEDLG);
685: fdg.usDialogType = SAVEAS_DIALOG;
686:
687: if(!WinLoadString(hab, NULL, IDS_SAVEDLGTITLE, MESSAGELEN, szTitle)) {
688: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
689: return FALSE;
690: }
691:
692: if(!WinLoadString(hab, NULL, IDS_SAVEDLGBUTTON, MESSAGELEN, szButton)) {
693: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
694: return FALSE;
695: }
696:
697: fdg.pszTitle = szTitle;
698: fdg.pszOKButton = szButton;
699:
700: fdg.lUser = 0L;
701: fdg.fl = FDS_HELPBUTTON | FDS_CENTER;
702: fdg.pfnDlgProc = NULL;
703: fdg.lReturn = 0L;
704: fdg.lSRC = 0L;
705: fdg.hmod = NULL;
706: fdg.idDlg = IDD_FILESAVE;
707: fdg.x = 0;
708: fdg.y = 0;
709: fdg.pszIType = 0L;
710: fdg.ppszITypeList = 0L;
711: fdg.pszIDrive = 0L;
712: fdg.ppszIDriveList = 0L;
713: fdg.sEAType = 0;
714: strcpy(fdg.szFullFile, szFullPath);
715:
716: /* get the file */
717: if(!KitFileDlg(hwndMLE, (PFILEDLG)&fdg))
718: return FALSE;
719:
720: if(fdg.lReturn != ID_OK)
721: return FALSE;
722:
723: /* copy file name and path returned into buffers */
724: strcpy(szFullPath, fdg.szFullFile);
725:
726: return TRUE;
727:
728: } /* GetFileName() */
729:
730: #endif /* MLE_BUGS_FIXED */
731:
732:
733: /****************************************************************\
734: * Appends the app name to the title bar text
735: *--------------------------------------------------------------
736: *
737: * Name: UpdateTitleText(hwnd)
738: *
739: * Purpose: Updates the text in the main window's title bar to
740: * display the app name, followed by the separator,
741: * followed by the file name
742: *
743: * Usage: called at init time and when the text file is changed
744: *
745: * Method: gets the program name, appends the separator, and
746: * appends the file name.
747: *
748: * Returns:
749: *
750: \****************************************************************/
751: VOID UpdateTitleText(hwnd)
752: HWND hwnd; /* handle to frame window */
753: {
754: CHAR szBuf[MAXNAMEL];
755: CHAR szSeparator[TITLESEPARATORLEN+1];
756: PSZ pszT;
757:
758: WinQueryTaskTitle(NULL, szBuf, MAXNAMEL);
759:
760: WinLoadString(hab,
761: NULL,
762: IDS_TITLEBARSEPARATOR,
763: TITLESEPARATORLEN,
764: szSeparator);
765:
766: strcat(szBuf, szSeparator);
767:
768: if(szFullPath[0] == '\0')
769: pszT = szUntitled;
770: else
771: pszT = szFullPath;
772:
773: strcat(szBuf, pszT);
774:
775: WinSetWindowText(WinWindowFromID(hwnd, FID_TITLEBAR), szBuf);
776:
777: } /* UpdateTitleText() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.