![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rwdlg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit|
Return to rwdlg.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: rwdlg.c
14: *
15: * Does the writing of .DLG files.
16: *
17: * Functions:
18: * WriteDlg()
19: * WriteDlgInclude()
20: * WriteDialogHeader()
21: * WriteDialogHeaderLanguage()
22: * WriteControl()
23: * WriteNameOrd()
24: * WriteText()
25: * WriteIDDlg()
26: * GetControlKeyword()
27: * WriteClass()
28: * WriteStyles()
29: * WriteClassStyle()
30: * WriteCustomStyle()
31: * WriteCoords()
32: * WriteValue()
33: * WriteHexWord()
34: * WriteHexDWord()
35: * WriteString()
36: * WriteQuotedString()
37: * WriteEscapedString()
38: * WriteDlgChar()
39: * WriteDlgFlush()
40: * Tab()
41: * NewLine()
42: * Quote()
43: * Comma()
44: * Space()
45: * ORSymbol()
46: *
47: * Comments:
48: *
49: ****************************************************************************/
50:
51: #include "dlgedit.h"
52: #include "dlgfuncs.h"
53: #include "dlgextrn.h"
54:
55:
56: /*
57: * Wrap lines before they go over this right margin.
58: */
59: #define CCHRIGHTMARGIN 76
60:
61: /*
62: * Defines for the tabs and tab indent levels.
63: */
64: #define CCHTABWIDTH 4 // Tabs are four spaces wide.
65: #define TABLEVELNONE 0 // No indent (at left margin).
66: #define TABLEVELCONTROL 1 // Indent to start of controls.
67: #define TABLEVELCONTROLDESC 5 // Indent to control description.
68:
69: /*
70: * Macro to set the current tab level. The level is multiplied
71: * by the tab width.
72: */
73: #define SetTab(t) (cTabStop = ((t)*CCHTABWIDTH))
74:
75: /*
76: * Macro that determines if the current position is the first
77: * column for the current tab setting.
78: */
79: #define AtFirstTabColumn() ((cColumn == cTabStop) ? TRUE : FALSE)
80:
81: STATICFN VOID WriteDlgInclude(LPTSTR pszFullDlgFile);
82: STATICFN PCONTROLDATA WriteDialogHeader(PRES pRes, PDIALOGBOXHEADER pdbh);
83: STATICFN VOID WriteDialogHeaderLanguage(WORD wLanguage);
84: STATICFN PCONTROLDATA WriteControl(PCONTROLDATA pcd);
85: STATICFN VOID WriteNameOrd(LPTSTR pszNameOrd);
86: STATICFN VOID WriteText(LPTSTR pszText);
87: STATICFN VOID WriteIDDlg(INT id, BOOL fHexOK);
88: STATICFN LPTSTR GetControlKeyword(INT iClass, DWORD flStyle,
89: DWORD *pflStylePredef, DWORD *pflStyleDefault, BOOL *pfWriteText,
90: BOOL *pfNotFound);
91: STATICFN VOID WriteClass(LPTSTR pszClass);
92: STATICFN BOOL WriteStyles(INT iClass, LPTSTR pszClass, DWORD flStyle,
93: DWORD flStylePredef, DWORD flStyleDefault, PDWORD pflStyleLeft,
94: BOOL fNullStyles, BOOL fCommaPrefix);
95: STATICFN BOOL WriteClassStyle(INT iClass, DWORD flStyle,
96: DWORD flStylePredef, DWORD flStyleDefault, PDWORD pflStyleLeft,
97: BOOL fPrevWritten, BOOL fNullStyles, BOOL fCommaPrefix);
98: STATICFN BOOL WriteCustomStyle(LPTSTR pszClass, DWORD flStyle,
99: PDWORD pflStyleLeft);
100: STATICFN VOID WriteCoords(INT x, INT y, INT cx, INT cy);
101: STATICFN VOID WriteValue(INT n);
102: STATICFN VOID WriteHexWord(WORD w);
103: STATICFN VOID WriteHexDWord(DWORD dw);
104: STATICFN VOID WriteString(LPTSTR psz);
105: STATICFN VOID WriteQuotedString(LPTSTR psz);
106: STATICFN VOID WriteEscapedString(LPTSTR psz);
107: STATICFN VOID WriteDlgChar(TCHAR ch);
108: STATICFN VOID WriteDlgFlush(VOID);
109: STATICFN VOID Tab(VOID);
110: STATICFN VOID NewLine(VOID);
111: STATICFN VOID Quote(VOID);
112: STATICFN VOID Comma(VOID);
113: STATICFN VOID Space(VOID);
114: STATICFN VOID ORSymbol(VOID);
115:
116: static INT cColumn; /* Current column in the line. */
117: static INT cTabStop; /* Current tabstop column. */
118: static HANDLE hfDlg; /* All workers write to this file. */
119: static jmp_buf jbWriteDlg; /* Capture the state for longjmp. */
120:
121:
122:
123: /************************************************************************
124: * WriteDlg
125: *
126: * This function writes the dialog boxes in the given resource to the
127: * hfWrite file in the .DLG file RC format.
128: *
129: * Arguments:
130: * HANDLE - handle to the file
131: * LPTSTR - pointer to the resource file name
132: *
133: ************************************************************************/
134:
135: BOOL WriteDlg(
136: HANDLE hfWrite,
137: LPTSTR pszFullDlgFile)
138: {
139: HANDLE hResLocked = NULL;
140: PRES pRes = NULL;
141: PRESLINK prl;
142: PDIALOGBOXHEADER pdbh;
143: PCONTROLDATA pcd;
144: INT cItems;
145:
146: /*
147: * Set our error trap up. The api setjmp will return a zero at first,
148: * then if a write error occurs later and longjmp is called, it
149: * will return non-zero and we will return the failure up to the
150: * caller. After this point, there must be no calls to allocate
151: * memory, open files, etc., unless this trap has a way to detect
152: * what happened and clean it up. See the c-runtime help file for more
153: * information about setjump/longjmp.
154: */
155: if (_setjmp(jbWriteDlg)) {
156: /*
157: * If the resource is locked, unlock it.
158: */
159: if (hResLocked)
160: GlobalUnlock(hResLocked);
161:
162: return FALSE;
163: }
164:
165: /*
166: * Initialize our globals. The hfDlg global is used so that hfWrite
167: * doesn't have to be passed on the stack over and over.
168: */
169: hfDlg = hfWrite;
170: cColumn = 0;
171: SetTab(TABLEVELNONE);
172:
173: WriteDlgInclude(pszFullDlgFile);
174:
175: /*
176: * Process each resource in the list.
177: */
178: for (prl = gprlHead; prl; prl = prl->prlNext) {
179: /*
180: * Skip if it is not a dialog resource.
181: */
182: if (!prl->fDlgResource)
183: continue;
184:
185: /*
186: * Set up pointers to this dialog resource.
187: */
188: pRes = (PRES)GlobalLock(prl->hRes);
189: hResLocked = prl->hRes;
190:
191: pdbh = (PDIALOGBOXHEADER)SkipResHeader(pRes);
192:
193: NewLine();
194: pcd = WriteDialogHeader(pRes, pdbh);
195:
196: WriteString(ids(IDS_BEGIN));
197: NewLine();
198:
199: /*
200: * Write the controls.
201: */
202: cItems = (INT)pdbh->NumberOfItems;
203: while (cItems--)
204: pcd = WriteControl(pcd);
205:
206: /*
207: * Finish up dialog template.
208: */
209: WriteString(ids(IDS_END));
210: NewLine();
211:
212: GlobalUnlock(prl->hRes);
213: hResLocked = NULL;
214: }
215:
216: /*
217: * Flush any remaining characters in the write buffer.
218: */
219: WriteDlgFlush();
220:
221: return TRUE;
222: }
223:
224:
225:
226: /************************************************************************
227: * WriteDlgInclude
228: *
229: * This routine writes out the "DLGINCLUDE" lines to the .DLG file.
230: *
231: * Arguments:
232: * LPTSTR - dialog file name
233: *
234: ************************************************************************/
235:
236: STATICFN VOID WriteDlgInclude(
237: LPTSTR pszFullDlgFile)
238: {
239: if (pszIncludeFile) {
240: WriteValue(ORDID_DLGINCLUDE_NAME);
241: Space();
242: WriteString(ids(IDS_DLGINCLUDE));
243: Space();
244: Quote();
245:
246: /*
247: * If the include file is in a different directory than the resource
248: * file, write the full path to it. Otherwise, we just write the
249: * include file name.
250: */
251: if (DifferentDirs(pszFullDlgFile, szFullIncludeFile))
252: WriteEscapedString(szFullIncludeFile);
253: else
254: WriteEscapedString(pszIncludeFile);
255:
256: Quote();
257: NewLine();
258: }
259: }
260:
261:
262:
263: /************************************************************************
264: * WriteDialogHeader
265: *
266: * Writes out the dialog header lines.
267: *
268: * Arguments:
269: * PRES - pointer to the resource
270: * PDIALOGBOXHEADER - pointer to the dialog box header
271: *
272: ************************************************************************/
273:
274: STATICFN PCONTROLDATA WriteDialogHeader(
275: PRES pRes,
276: PDIALOGBOXHEADER pdbh)
277: {
278: DWORD flStyle;
279: DWORD flExtStyle;
280: DWORD flStyleLeft;
281: INT cdit;
282: INT x;
283: INT y;
284: INT cx;
285: INT cy;
286: LPTSTR pszMenuName;
287: LPTSTR pszClass;
288: LPTSTR pszCaption;
289: INT nPointSize;
290: LPTSTR pszFontName;
291: PCONTROLDATA pcd;
292: PRES2 pRes2;
293: BOOL fWritten;
294:
295: pRes2 = ResourcePart2(pRes);
296:
297: WriteNameOrd(ResourceName(pRes));
298: Space();
299: WriteString(ids(IDS_DIALOG));
300:
301: if (pRes2->MemoryFlags & MMF_PRELOAD) {
302: Space();
303: WriteString(ids(IDS_PRELOAD));
304: }
305:
306: if (!(pRes2->MemoryFlags & MMF_MOVEABLE)) {
307: Space();
308: WriteString(ids(IDS_FIXED));
309: }
310:
311: if (!(pRes2->MemoryFlags & MMF_PURE)) {
312: Space();
313: WriteString(ids(IDS_IMPURE));
314: }
315:
316: /*
317: * Parse out the dialog template.
318: */
319: pcd = ParseDialogBoxHeader(pdbh, &flStyle, &flExtStyle, &cdit, &x, &y,
320: &cx, &cy, &pszMenuName, &pszClass, &pszCaption,
321: &nPointSize, &pszFontName);
322:
323: Space();
324: WriteCoords(x, y, cx, cy);
325:
326: NewLine();
327:
328: /*
329: * Write the language.
330: */
331: WriteDialogHeaderLanguage(pRes2->LanguageId);
332:
333: /*
334: * Print out the "STYLE" line for the dialog.
335: */
336: WriteString(ids(IDS_STYLE));
337: Space();
338: SetTab(TABLEVELCONTROL);
339: WriteStyles(IC_DIALOG, NULL, flStyle, 0L, 0L, &flStyleLeft, TRUE, FALSE);
340: SetTab(TABLEVELNONE);
341: NewLine();
342:
343: /*
344: * Print out the "EXSTYLE" line for the dialog, if necessary.
345: */
346: if (flExtStyle) {
347: WriteString(ids(IDS_EXSTYLE));
348: Space();
349: SetTab(TABLEVELCONTROL);
350:
351: fWritten = WriteClassStyle(IC_EXSTYLE, flExtStyle, 0L, 0L,
352: &flStyleLeft, FALSE, TRUE, FALSE);
353:
354: /*
355: * If there is anything left (styles that the dialog editor
356: * does not know about) write it out as a hex constant.
357: */
358: if (flStyleLeft) {
359: if (fWritten)
360: ORSymbol();
361:
362: WriteHexDWord(flStyleLeft);
363: }
364:
365: SetTab(TABLEVELNONE);
366: NewLine();
367: }
368:
369: /*
370: * If it has a caption, print it out.
371: */
372: if (*pszCaption) {
373: WriteString(ids(IDS_CAPTION));
374: Space();
375: WriteText(pszCaption);
376: NewLine();
377: }
378:
379: /*
380: * If it has a font specified, print it out.
381: */
382: if (flStyle & DS_SETFONT) {
383: WriteString(ids(IDS_FONT));
384: Space();
385:
386: WriteValue(nPointSize);
387: Comma();
388: WriteQuotedString(pszFontName);
389: NewLine();
390: }
391:
392: /*
393: * If it has a class specified, print it out.
394: */
395: if (*pszClass) {
396: WriteString(ids(IDS_CLASS));
397: Space();
398: WriteText(pszClass);
399: NewLine();
400: }
401:
402: /*
403: * If it has a menu specified, print it out.
404: */
405: if (*pszMenuName) {
406: WriteString(ids(IDS_MENU));
407: Space();
408: WriteNameOrd(pszMenuName);
409: NewLine();
410: }
411:
412: if (pRes2->Version) {
413: WriteString(ids(IDS_VERSION));
414: Space();
415: WriteValue(pRes2->Version);
416: NewLine();
417: }
418:
419: if (pRes2->Characteristics) {
420: WriteString(ids(IDS_CHARACTERISTICS));
421: Space();
422: WriteValue(pRes2->Characteristics);
423: NewLine();
424: }
425:
426: return pcd;
427: }
428:
429:
430:
431: /************************************************************************
432: * WriteDialogHeaderLanguage
433: *
434: * Writes out the dialog header "LANGUAGE" line.
435: *
436: * Arguments:
437: * WORD - language to write out
438: *
439: ************************************************************************/
440:
441: STATICFN VOID WriteDialogHeaderLanguage(
442: WORD wLanguage)
443: {
444: WORD wPrimary;
445: WORD wSubLang;
446: INT i;
447: INT j;
448: INT idsLang;
449: INT idsSubLang;
450:
451: WriteString(ids(IDS_LANGUAGE));
452: Space();
453:
454: idsLang = 0;
455: idsSubLang = 0;
456: wPrimary = (WORD)PRIMARYLANGID(wLanguage);
457: wSubLang = SUBLANGID(wLanguage);
458: for (i = 0; i < gcLanguages; i++) {
459: if (gaLangTable[i].wPrimary == wPrimary) {
460: idsLang = gaLangTable[i].idsLang;
461:
462: for (j = 0; j < gaLangTable[i].cSubLangs; j++) {
463: if (gaLangTable[i].asl[j].wSubLang == wSubLang) {
464: idsSubLang = gaLangTable[i].asl[j].idsSubLang;
465: break;
466: }
467: }
468:
469: break;
470: }
471: }
472:
473: if (idsLang)
474: WriteString(ids(idsLang));
475: else
476: WriteHexWord(wPrimary);
477:
478: Comma();
479:
480: if (idsSubLang)
481: WriteString(ids(idsSubLang));
482: else
483: WriteHexWord(wSubLang);
484:
485: NewLine();
486: }
487:
488:
489:
490: /************************************************************************
491: * WriteControl
492: *
493: * Writes out a control line.
494: *
495: * Arguments:
496: * PCONTROLDATA - pointer to the control data
497: *
498: ************************************************************************/
499:
500: STATICFN PCONTROLDATA WriteControl(
501: PCONTROLDATA pcd)
502: {
503: INT x;
504: INT y;
505: INT cx;
506: INT cy;
507: INT id;
508: DWORD flStyle;
509: DWORD flExtStyle;
510: LPTSTR pszClass;
511: LPTSTR pszText;
512: INT iClass;
513: LPTSTR pszKeyword;
514: BOOL fWriteText;
515: BOOL fNotFound;
516: DWORD flStylePredef;
517: DWORD flStyleDefault;
518: DWORD flStyleLeft;
519: BOOL fWritten;
520:
521: pcd = ParseControlData(pcd, &flStyle, &flExtStyle, &x, &y, &cx, &cy,
522: &id, &pszClass, &pszText);
523:
524: /*
525: * Determine the class of the control.
526: */
527: iClass = GetiClass(pszClass);
528:
529: /*
530: * Determine if there are any predefined RC keywords that we
531: * can use instead of the generic "CONTROL" keyword for this
532: * style of control.
533: */
534: pszKeyword = GetControlKeyword(iClass, flStyle, &flStylePredef,
535: &flStyleDefault, &fWriteText, &fNotFound);
536:
537: SetTab(TABLEVELCONTROL);
538: Tab();
539: WriteString(pszKeyword);
540: SetTab(TABLEVELCONTROLDESC);
541: Tab();
542:
543: /*
544: * Write out the text field, if this type of control has one.
545: */
546: if (fWriteText) {
547: WriteText(pszText);
548: Comma();
549: }
550:
551: /*
552: * Write out the id for the control.
553: */
554: WriteIDDlg(id, TRUE);
555:
556: /*
557: * If we did not find a predefined keyword to use instead of "CONTROL",
558: * we have to write out the fields in a different order, and specify
559: * the class as well.
560: */
561: if (fNotFound) {
562: WriteClass(pszClass);
563: Comma();
564: fWritten = WriteStyles(iClass, pszClass, flStyle, flStylePredef,
565: flStyleDefault, &flStyleLeft, fNotFound, FALSE);
566:
567: if (!fWritten || flStyleLeft) {
568: if (fWritten)
569: ORSymbol();
570:
571: WriteHexWord(LOWORD(flStyleLeft));
572: }
573:
574: Comma();
575: WriteCoords(x, y, cx, cy);
576: }
577: else {
578: Comma();
579: WriteCoords(x, y, cx, cy);
580: fWritten = WriteStyles(iClass, pszClass, flStyle, flStylePredef,
581: flStyleDefault, &flStyleLeft, fNotFound, TRUE);
582:
583: if (flStyleLeft) {
584: if (fWritten)
585: ORSymbol();
586: else
587: Comma();
588:
589: WriteHexWord(LOWORD(flStyleLeft));
590: fWritten = TRUE;
591: }
592: }
593:
594: /*
595: * Write out the extended styles for the control, if necessary.
596: */
597: if (flExtStyle) {
598: /*
599: * If writing a predefined keyword (not CONTROL), and there
600: * were no styles written out at the end of the line, write
601: * a style of zero. RC doesn't like consecutive comma's,
602: * and we need to skip the styles field to get to the
603: * extended styles field.
604: */
605: if (!fNotFound && !fWritten) {
606: Comma();
607: WriteValue(0);
608: }
609:
610: Comma();
611:
612: fWritten = WriteClassStyle(IC_EXSTYLE, flExtStyle, 0L, 0L,
613: &flStyleLeft, FALSE, TRUE, FALSE);
614:
615: /*
616: * If there is anything left (styles that the dialog editor
617: * does not know about) write it out as a hex constant.
618: */
619: if (flStyleLeft) {
620: if (fWritten)
621: ORSymbol();
622:
623: WriteHexDWord(flStyleLeft);
624: }
625: }
626:
627: SetTab(TABLEVELNONE);
628: NewLine();
629:
630: return pcd;
631: }
632:
633:
634:
635: /************************************************************************
636: * WriteNameOrd
637: *
638: * Writes out the name/ordinal. Handles the case where the name
639: * is really an ordinal instead of a string. When it is a string,
640: * it will not be quoted.
641: *
642: * This routine never writes the ordinal out in hex, because the
643: * items that it is intended to write are not parsed properly by
644: * the Windows RC.EXE if they are written in hex notation.
645: *
646: * Arguments:
647: * LPTSTR pszNameOrd - The name/ordinal to write.
648: *
649: ************************************************************************/
650:
651: STATICFN VOID WriteNameOrd(
652: LPTSTR pszNameOrd)
653: {
654: if (IsOrd(pszNameOrd))
655: /*
656: * Write the name as a numeric ordinal.
657: */
658: WriteIDDlg(OrdID(pszNameOrd), FALSE);
659: else
660: WriteString(pszNameOrd);
661: }
662:
663:
664:
665: /************************************************************************
666: * WriteText
667: *
668: * Writes out the text for a control or dialog. This will either be
669: * an ordinal (icon's text field) or a quoted string.
670: *
671: * Arguments:
672: * LPTSTR pszText - text to write out
673: *
674: ************************************************************************/
675:
676: STATICFN VOID WriteText(
677: LPTSTR pszText)
678: {
679: if (IsOrd(pszText))
680: /*
681: * Write the text as an ID. Hex notation is allowed.
682: */
683: WriteIDDlg(OrdID(pszText), TRUE);
684: else
685: WriteQuotedString(pszText);
686: }
687:
688:
689:
690: /************************************************************************
691: * WriteIDDlg
692: *
693: * Writes out the ID. This may be written out as either a symbol
694: * or a numeric.
695: *
696: * Arguments:
697: * INT id - id to write out
698: * BOOL fHexOK - flag specifies whether the id is a hex numeric.
699: *
700: ************************************************************************/
701:
702: STATICFN VOID WriteIDDlg(
703: INT id,
704: BOOL fHexOK)
705: {
706: TCHAR szID[CCHTEXTMAX];
707:
708: IDToLabel(szID, id, fHexOK);
709: WriteString(szID);
710: }
711:
712:
713:
714: /************************************************************************
715: * GetControlKeyword
716: *
717: * This routine does a lookup in the predefined RC keyword table
718: * associated with the given class for a keyword that can be used
719: * instead of "CONTROL". The match is based on the style of the control
720: * that is passed in. If a match is not found, it defaults all the
721: * returned values to use the "CONTROL" keyword.
722: *
723: * Arguments:
724: * INT iClass - The class of the control.
725: * DWORD flStyle - The style of the control.
726: * DWORD *pflStylePredef - Return for the bits of the predefined control
727: * (if found). These can be removed later from
728: * the style flag.
729: * DWORD *pflStyleDefault - Return for the default styles.
730: * BOOL *pfWriteText - Return for the "Write Text" flag. This will
731: * be TRUE if this control has a text field.
732: * BOOL *pfNotFound - Return for the "Not Found" flag. This will
733: * be TRUE if no match was found and the "CONTROL"
734: * keyword was defaulted to.
735: *
736: * Returns:
737: * A pointer to the control keyword to use.
738: * If a match was found, *pflStylePredef is set to the bits for the match.
739: * If not found, this is set to zero.
740: * The default style bits for this keyword will be returned.
741: * The "Write Text" flag will be set.
742: * The "Not Found" flag will be set.
743: *
744: ************************************************************************/
745:
746: STATICFN LPTSTR GetControlKeyword(
747: INT iClass,
748: DWORD flStyle,
749: DWORD *pflStylePredef,
750: DWORD *pflStyleDefault,
751: BOOL *pfWriteText,
752: BOOL *pfNotFound)
753: {
754: register INT i;
755: INT iMax;
756: PRCKEYWORD prckwd;
757:
758: if (gfUseNewKeywords && iClass != IC_UNKNOWN) {
759: iMax = acsd[iClass].cKeywords;
760: prckwd = acsd[iClass].parckwd;
761:
762: /*
763: * Loop through all the keywords for this class.
764: */
765: for (i = 0; i < iMax; i++, prckwd++) {
766: /*
767: * Does the style (masked) exactly match the keywords style?
768: */
769: if ((flStyle & prckwd->flStyleMask) == prckwd->flStyle) {
770: /*
771: * Yes. Set the "Has Text" flag, we did find a match,
772: * put the found bits in the predefined style flag,
773: * set the default styles flag and return the found
774: * keyword.
775: */
776: *pfWriteText = prckwd->fHasText;
777: *pfNotFound = FALSE;
778: *pflStylePredef = prckwd->flStyle;
779: *pflStyleDefault = prckwd->flStyleDefault;
780: return ids(prckwd->idsKeyword);
781: }
782: }
783: }
784:
785: /*
786: * A match was not found. We must write text, we didn't find a
787: * match, we will be using the "CONTROL" keyword and the default
788: * styles that this keyword implies is the "child" and "visible"
789: * bits (rc.exe OR's these styles in implicitly).
790: */
791: *pfWriteText = TRUE;
792: *pfNotFound = TRUE;
793: *pflStylePredef = 0L;
794: *pflStyleDefault = WS_VISIBLE | WS_CHILD;
795: return ids(IDS_CONTROL);
796: }
797:
798:
799:
800: /************************************************************************
801: * WriteClass
802: *
803: * Writes out the class for a control.
804: *
805: * Arguments:
806: * LPTSTR pszClass - pointer to the class string
807: *
808: ************************************************************************/
809:
810: STATICFN VOID WriteClass(
811: LPTSTR pszClass)
812: {
813: INT i;
814: WORD idOrd;
815:
816: Comma();
817:
818: /*
819: * Is this class a predefined type instead of a string?
820: */
821: if (IsOrd(pszClass)) {
822: /*
823: * Figure out which type it is and get the class string to
824: * write.
825: */
826: idOrd = OrdID(pszClass);
827: for (i = 0; i < IC_DIALOG; i++) {
828: if (acsd[i].idOrd == idOrd) {
829: pszClass = ids(acsd[i].idsClass);
830: break;
831: }
832: }
833: }
834:
835: WriteQuotedString(pszClass);
836: }
837:
838:
839:
840: /************************************************************************
841: * WriteStyles
842: *
843: * This function writes the class and style info to the file
844: * for the control or dialog box in the RC format.
845: *
846: * Arguments:
847: * INT iClass = The class of the item.
848: * LPTSTR pszClass = Class name of the control.
849: * DWORD flStyle = The style of the item.
850: * DWORD flStylePredef = The styles bits implicit in the predefined
851: * keyword for this control. This should be
852: * zero if this control doesn't have a predefined
853: * keyword for it.
854: * DWORD flStyleDefault = The default styles implicit in the item.
855: * PDWORD pflStyleLeft = Where to return any style bits that do not
856: * get written out.
857: * BOOL fNullStyles = TRUE if we should still write the style word
858: * even if the style flag is zero.
859: * BOOL fCommaPrefix = TRUE means that a comma will be written out
860: * before writing any styles. If no styles
861: * are written, no comma will be written either.
862: *
863: * Returns:
864: * TRUE => Something was written out.
865: * FALSE => Nothing was written out.
866: *
867: ************************************************************************/
868:
869: STATICFN BOOL WriteStyles(
870: INT iClass,
871: LPTSTR pszClass,
872: DWORD flStyle,
873: DWORD flStylePredef,
874: DWORD flStyleDefault,
875: PDWORD pflStyleLeft,
876: BOOL fNullStyles,
877: BOOL fCommaPrefix)
878: {
879: DWORD flStyleLeft;
880: BOOL fWritten = FALSE;
881:
882: /*
883: * Write the control specific styles.
884: */
885: if (iClass == IC_CUSTOM) {
886: fWritten = WriteCustomStyle(pszClass, flStyle, &flStyleLeft);
887: }
888: else {
889: fWritten = WriteClassStyle(iClass, flStyle, flStylePredef,
890: flStyleDefault, &flStyleLeft, FALSE, fNullStyles,
891: fCommaPrefix);
892: }
893:
894: /*
895: * If we are writing styles for the dialog, remove the WS_GROUP
896: * and WS_TABSTOP bits from the style before proceeding. This is
897: * because the WS_MINIMIZEBOX and WS_MAXIMIZEBOX styles use the
898: * same bits, and these keywords will have already been written
899: * out by the preceding WriteClassStyle call if those bits are
900: * present.
901: */
902: if (iClass == IC_DIALOG)
903: flStyle &= ~(WS_GROUP | WS_TABSTOP);
904:
905: /*
906: * Write the window styles that are common to the different
907: * controls (the high word).
908: */
909: fWritten |= WriteClassStyle(IC_WINDOW, flStyleLeft, flStylePredef,
910: flStyleDefault, &flStyleLeft, fWritten, fNullStyles, fCommaPrefix);
911:
912: /*
913: * Pass back any styles that were not written.
914: */
915: *pflStyleLeft = flStyleLeft;
916:
917: return fWritten;
918: }
919:
920:
921:
922: /************************************************************************
923: * WriteClassStyle
924: *
925: * This function writes the class style symbols to the file. The styles
926: * to write out are passed in flStyle, and the styles that are implicitly
927: * set by this type of control already are passed in flStyleDefault. The
928: * style keywords corresponding to the bits in flStyle are written out,
929: * separated by " | ", and any bits in flStyleDefault that are NOT set
930: * are written out preceded by a "NOT" to explicitly turn them off. This
931: * is used in the case of the predefined RC keywords, which often have
932: * styles like WS_TABSTOP or WS_VISIBLE already implicit in them. There
933: * is no need to explicitly specify them, but if they are not present, we
934: * must NOT them out. The parameter flStylePredef contains the style bits
935: * that identified the predefined control keyword itself (if any) and
936: * thus are removed from the style before writing anything out.
937: *
938: * Arguments:
939: * INT iClass = The class of the control. See the
940: * IC_ constants defined in dlgedit.h.
941: * DWORD flStyle = The style of control. This nails
942: * down the exact type of control.
943: * DWORD flStylePredef = The styles bits implicit in the predefined
944: * keyword for this control. This should be
945: * zero if this control doesn't have a predefined
946: * keyword for it.
947: * DWORD flStyleDefault = The default styles that are implicit with
948: * this control. This will only be set if this
949: * control is using a predefined RC keyword. A
950: * value of zero means that there are no default
951: * styles implicitly specified.
952: * PDWORD pflStyleLeft = Where to return any style bits that do not
953: * get written out.
954: * BOOL fPrevWritten = TRUE means a previous style symbol has
955: * been written and to put " | " before
956: * the next symbol.
957: * BOOL fNullStyles = TRUE if we should still write the style word
958: * even if the style flag is zero. This is used
959: * to handle the case where a predefined keyword
960: * has been written out that implies a style that
961: * also happens to be zero. Without this flag
962: * being FALSE the style flag implicit in the
963: * keyword would be redundantly written out again.
964: * In general, if we have written out a predefined
965: * keyword this flag should be FALSE.
966: * BOOL fCommaPrefix = TRUE means that a comma will be written out
967: * before writing any styles. This will only
968: * happen if fPrevWritten is FALSE. If no styles
969: * are written, no comma will be written either.
970: *
971: * Returns:
972: * TRUE => Something was written out.
973: * FALSE => Nothing was written out.
974: *
975: ************************************************************************/
976:
977: STATICFN BOOL WriteClassStyle(
978: INT iClass,
979: DWORD flStyle,
980: DWORD flStylePredef,
981: DWORD flStyleDefault,
982: PDWORD pflStyleLeft,
983: BOOL fPrevWritten,
984: BOOL fNullStyles,
985: BOOL fCommaPrefix)
986: {
987: register WORD i;
988: WORD iMax;
989: DWORD flStyleMask;
990: PCLASSSTYLE pcs;
991:
992: iMax = (WORD)acsd[iClass].cClassStyles;
993: pcs = acsd[iClass].pacs;
994:
995: /*
996: * Remove the bits that identified the predefined control keyword
997: * from the style flag before proceeding. For instance, if I already
998: * am going to be writing out a "PUSHBUTTON", there is no reason
999: * to write out the "BS_PUSHBUTTON" style. If there is no predefined
1000: * control keyword, flStylePredef will be zero and this will do
1001: * nothing.
1002: */
1003: flStyle &= ~flStylePredef;
1004:
1005: /*
1006: * Go through all possible flags for this style.
1007: */
1008: for (i = 0; i < iMax; i++, pcs++) {
1009: flStyleMask = pcs->flStyleMask ? pcs->flStyleMask : pcs->flStyle;
1010:
1011: /*
1012: * Is this styles bits set?
1013: */
1014: if ((flStyle & flStyleMask) == pcs->flStyle) {
1015: /*
1016: * Remove these bits from the styles left. Even if
1017: * we do not write them out, they are still accounted
1018: * for and can be removed from the styles remaining.
1019: */
1020: flStyle &= ~pcs->flStyle;
1021:
1022: /*
1023: * Skip this style if we don't want to write styles that are
1024: * zero, or if the style is already implicitly specified for
1025: * this control (a non-zero default style mask must be specified).
1026: */
1027: if ((!pcs->flStyle && !fNullStyles) ||
1028: (flStyleDefault &&
1029: (flStyleDefault & flStyleMask) == pcs->flStyle))
1030: continue;
1031:
1032: /*
1033: * If there is a string for this style, write it out, preceded
1034: * by an "|" symbol if necessary.
1035: */
1036: if (*ids(acsd[iClass].idsStylesStart + i)) {
1037: if (fPrevWritten) {
1038: ORSymbol();
1039: }
1040: else {
1041: if (fCommaPrefix)
1042: Comma();
1043:
1044: fPrevWritten = TRUE;
1045: }
1046:
1047: /*
1048: * Write the string.
1049: */
1050: WriteString(ids(acsd[iClass].idsStylesStart + i));
1051: }
1052: }
1053: /*
1054: * No the styles bit is not set. Is it implicit in the keyword
1055: * being used? If so, we need to explicitly NOT it
1056: * out in the dialog template.
1057: * Note that this should not be done in the case where the style
1058: * is zero.
1059: */
1060: else if (flStyleDefault &&
1061: (flStyleDefault & flStyleMask) == pcs->flStyle &&
1062: pcs->flStyle) {
1063: if (fPrevWritten) {
1064: ORSymbol();
1065: }
1066: else {
1067: if (fCommaPrefix)
1068: Comma();
1069:
1070: fPrevWritten = TRUE;
1071: }
1072:
1073: WriteString(ids(IDS_NOT));
1074: Space();
1075: WriteString(ids(acsd[iClass].idsStylesStart + i));
1076: }
1077: }
1078:
1079: /*
1080: * Pass back the style bits that were not written out.
1081: */
1082: *pflStyleLeft = flStyle;
1083:
1084: return fPrevWritten;
1085: }
1086:
1087:
1088:
1089: /************************************************************************
1090: * WriteCustomStyle
1091: *
1092: * Writes our the custom control information
1093: *
1094: * Arguments:
1095: * LPTSTR - class name of the control
1096: * DWORD - style of the control
1097: * PDWORD - styles left to be written
1098: *
1099: * Returns:
1100: * TRUE if custom styles were written out; otherwise, FALSE.
1101: *
1102: ************************************************************************/
1103:
1104: STATICFN BOOL WriteCustomStyle(
1105: LPTSTR pszClass,
1106: DWORD flStyle,
1107: PDWORD pflStyleLeft)
1108: {
1109: PCUSTLINK pcl;
1110: LPCCSTYLEFLAG pStyleFlags;
1111: DWORD flStyleMask;
1112: INT i;
1113: BOOL fWritten = FALSE;
1114:
1115: /*
1116: * Search the list of installed custom controls for one
1117: * that matches the class.
1118: */
1119: for (pcl = gpclHead;
1120: pcl && lstrcmpi(pcl->pwcd->pszClass, pszClass) != 0;
1121: pcl = pcl->pclNext)
1122: ;
1123:
1124: /*
1125: * Was a match found and is this control from a DLL (not emulated)?
1126: */
1127: if (pcl && !pcl->pwcd->fEmulated) {
1128: for (i = 0, pStyleFlags = pcl->pwcd->aStyleFlags;
1129: i < pcl->pwcd->cStyleFlags;
1130: i++, pStyleFlags++) {
1131: flStyleMask = pStyleFlags->flStyleMask ?
1132: pStyleFlags->flStyleMask : pStyleFlags->flStyle;
1133:
1134: /*
1135: * Is this styles bits set?
1136: */
1137: if ((flStyle & flStyleMask) == pStyleFlags->flStyle) {
1138: /*
1139: * Remove these bits from the styles left.
1140: */
1141: flStyle &= ~pStyleFlags->flStyle;
1142:
1143: if (fWritten)
1144: ORSymbol();
1145: else
1146: fWritten = TRUE;
1147:
1148: /*
1149: * Write the string.
1150: */
1151: WriteString(pStyleFlags->pszStyle);
1152: }
1153: }
1154: }
1155:
1156: /*
1157: * Return the styles that remain to be written.
1158: */
1159: *pflStyleLeft = flStyle;
1160:
1161: return fWritten;
1162: }
1163:
1164:
1165:
1166: /************************************************************************
1167: * WriteCoords
1168: *
1169: * This function writes the coordinates out to the file as decimal
1170: * ascii numbers separated by ", ".
1171: *
1172: * Arguments:
1173: * INT x, y, cx, cy = The coordinates.
1174: *
1175: ************************************************************************/
1176:
1177: STATICFN VOID WriteCoords(
1178: INT x,
1179: INT y,
1180: INT cx,
1181: INT cy)
1182: {
1183: WriteValue(x);
1184: Comma();
1185: WriteValue(y);
1186: Comma();
1187: WriteValue(cx);
1188: Comma();
1189: WriteValue(cy);
1190: }
1191:
1192:
1193:
1194: /************************************************************************
1195: * WriteValue
1196: *
1197: * This function writes the value of 'n' as a decimal ascii string to
1198: * the file.
1199: *
1200: * Arguments:
1201: * INT n = The number to write.
1202: *
1203: ************************************************************************/
1204:
1205: STATICFN VOID WriteValue(
1206: INT n)
1207: {
1208: TCHAR szNum[32];
1209:
1210: itoaw(n, szNum, 10);
1211: WriteString(szNum);
1212: }
1213:
1214:
1215:
1216: /************************************************************************
1217: * WriteHexWord
1218: *
1219: * This function writes the value of 'w' as a hex constant to the file.
1220: *
1221: * Arguments:
1222: * WORD w - The word to write.
1223: *
1224: ************************************************************************/
1225:
1226: STATICFN VOID WriteHexWord(
1227: WORD w)
1228: {
1229: TCHAR szNum[17];
1230:
1231: itoax(w, szNum);
1232: WriteString(szNum);
1233: }
1234:
1235:
1236:
1237: /************************************************************************
1238: * WriteHexDWord
1239: *
1240: * This function writes the value of 'dw' as a hex constant to the file.
1241: *
1242: * Arguments:
1243: * DWORD dw - The dword to write.
1244: *
1245: ************************************************************************/
1246:
1247: STATICFN VOID WriteHexDWord(
1248: DWORD dw)
1249: {
1250: TCHAR szNum[32];
1251:
1252: wsprintf(szNum, L"0x%8.8X", dw);
1253: WriteString(szNum);
1254: }
1255:
1256:
1257:
1258: /************************************************************************
1259: * WriteString
1260: *
1261: * This function writes the given string to the file. If the string
1262: * would cause it to overflow the margin, a new line, with indenting
1263: * to the current tab level, is forced before writing the string.
1264: *
1265: * Arguments:
1266: * LPTSTR psz = The string to write out.
1267: *
1268: ************************************************************************/
1269:
1270: STATICFN VOID WriteString(
1271: LPTSTR psz)
1272: {
1273: register INT nLen;
1274:
1275: nLen = lstrlen(psz);
1276:
1277: if (!AtFirstTabColumn() && cColumn + nLen > CCHRIGHTMARGIN)
1278: NewLine();
1279:
1280: while (nLen--)
1281: WriteDlgChar(*psz++);
1282: }
1283:
1284:
1285:
1286: /************************************************************************
1287: * WriteQuotedString
1288: *
1289: * This function writes the given string to the file. If the string
1290: * would cause it to overflow the margin, a new line, with indenting
1291: * to the current tab level, is forced before writing the string.
1292: * This function will also enclose the given string in double-quotes,
1293: * and ensures that the string will not be broken when it is written.
1294: * If there are any escape characters (backslashes or quotes) in the
1295: * string, they will be escaped properly so that rc.exe can read them
1296: * properly.
1297: *
1298: * Arguments:
1299: * LPTSTR psz = The string to write out.
1300: *
1301: ************************************************************************/
1302:
1303: STATICFN VOID WriteQuotedString(
1304: LPTSTR psz)
1305: {
1306: register INT nLen;
1307: LPTSTR pszT;
1308:
1309: /*
1310: * Find the actual length of the string. To do this, we must scan
1311: * for the characters that will be escaped later.
1312: */
1313: nLen = lstrlen(psz);
1314: pszT = psz;
1315: while (*pszT) {
1316: if (*pszT == CHAR_DBLQUOTE || *pszT == CHAR_BACKSLASH)
1317: nLen++;
1318:
1319: pszT++;
1320: }
1321:
1322: /*
1323: * Start a new line if necessary. Add 2 for the quotes.
1324: */
1325: if (!AtFirstTabColumn() && cColumn + nLen + 2 > CCHRIGHTMARGIN)
1326: NewLine();
1327:
1328: Quote();
1329: WriteEscapedString(psz);
1330: Quote();
1331: }
1332:
1333:
1334:
1335: /************************************************************************
1336: * WriteEscapedString
1337: *
1338: * This function writes the given string to the file. It is different
1339: * from WriteString in that it will add a '\' in front of other
1340: * backslashes and a second double quote in front of double quotes.
1341: * This is necessary when writing out a string which will be surrounded
1342: * by quotes, such as the Text fields in the .DLG file.
1343: *
1344: * Arguments:
1345: * LPTSTR psz = The string to write out.
1346: *
1347: ************************************************************************/
1348:
1349: STATICFN VOID WriteEscapedString(
1350: LPTSTR psz)
1351: {
1352: while (*psz) {
1353: if (*psz == CHAR_DBLQUOTE)
1354: WriteDlgChar(CHAR_DBLQUOTE);
1355: else if (*psz == CHAR_BACKSLASH)
1356: WriteDlgChar(CHAR_BACKSLASH);
1357:
1358: WriteDlgChar(*psz++);
1359: }
1360: }
1361:
1362:
1363:
1364: /************************************************************************
1365: * WriteDlgChar
1366: *
1367: * Low level function to do an actual character write to the file.
1368: * Some buffering is done then _lwrite is called.
1369: *
1370: * Because it is buffered, before closing the file any remaining
1371: * characters in the buffer must be flushed to disk using WriteDlgFlush.
1372: *
1373: * If an error occurs on the write, Throw will be called to jump back
1374: * up to WriteDlg and return the failure to the caller.
1375: *
1376: * The globals gachWriteBuffer and cbWritePos are updated by this routine.
1377: *
1378: * Arguments:
1379: * TCHAR ch - The character to write.
1380: *
1381: * Returns:
1382: * If an error occurs on the _lwrite, the execution will be thrown
1383: * back to the WriteDlg function. Otherwise, nothing is returned.
1384: *
1385: ************************************************************************/
1386:
1387: STATICFN VOID WriteDlgChar(
1388: TCHAR ch)
1389: {
1390: INT cbWritten;
1391:
1392: gachWriteBuffer[cbWritePos++] = ch;
1393:
1394: /*
1395: * Is the buffer full?
1396: */
1397: if (cbWritePos == CCHFILEBUFFER) {
1398: CHAR abWriteBuffer[CCHFILEBUFFER];
1399: BOOL fDefCharUsed;
1400:
1401: WideCharToMultiByte(CP_ACP, 0, gachWriteBuffer, CCHFILEBUFFER,
1402: abWriteBuffer, CCHFILEBUFFER, NULL, &fDefCharUsed);
1403:
1404: cbWritten = (INT)_lwrite((HFILE)hfDlg, abWriteBuffer, cbWritePos);
1405: if (cbWritten != cbWritePos)
1406: longjmp(jbWriteDlg, 1);
1407:
1408: cbWritePos = 0;
1409: }
1410:
1411: /*
1412: * Update the current column counter.
1413: */
1414: if (ch == CHAR_RETURN || ch == CHAR_NEWLINE) {
1415: /*
1416: * Carriage return or newline resets column position to 0.
1417: */
1418: cColumn = 0;
1419: }
1420: else {
1421: cColumn++;
1422: }
1423: }
1424:
1425:
1426:
1427: /************************************************************************
1428: * WriteDlgFlush
1429: *
1430: * This routine flushes the write buffer. This must be done before
1431: * the file is closed or data can be lost.
1432: *
1433: * The global cbWritePos is updated by this routine.
1434: *
1435: * Returns:
1436: * If an error occurs on the _lwrite, the execution will be thrown
1437: * back to the WriteDlg function. Otherwise, nothing is returned.
1438: *
1439: ************************************************************************/
1440:
1441: STATICFN VOID WriteDlgFlush(VOID)
1442: {
1443: INT cbWritten;
1444:
1445: /*
1446: * Are any bytes remaining in the buffer?
1447: */
1448: if (cbWritePos) {
1449: CHAR abWriteBuffer[CCHFILEBUFFER];
1450: BOOL fDefCharUsed;
1451:
1452: WideCharToMultiByte(CP_ACP, 0, gachWriteBuffer, cbWritePos,
1453: abWriteBuffer, CCHFILEBUFFER, NULL, &fDefCharUsed);
1454:
1455: cbWritten = (INT)_lwrite((HFILE)hfDlg, abWriteBuffer, cbWritePos);
1456: if (cbWritten != cbWritePos)
1457: longjmp(jbWriteDlg, 1);
1458:
1459: cbWritePos = 0;
1460: }
1461: }
1462:
1463:
1464:
1465: /****************************************************************************
1466: * Tab
1467: *
1468: * Writes spaces up to the current tab level setting.
1469: *
1470: ****************************************************************************/
1471:
1472: STATICFN VOID Tab(VOID)
1473: {
1474: while (cColumn < cTabStop)
1475: WriteDlgChar(CHAR_SPACE);
1476: }
1477:
1478:
1479:
1480: /****************************************************************************
1481: * NewLine
1482: *
1483: * Begins a new line by writing a carriage return and linefeed. Also
1484: * indents the following line up to the current tab level.
1485: *
1486: ****************************************************************************/
1487:
1488: STATICFN VOID NewLine(VOID)
1489: {
1490: WriteDlgChar(CHAR_RETURN);
1491: WriteDlgChar(CHAR_NEWLINE);
1492: Tab();
1493: }
1494:
1495:
1496:
1497: /****************************************************************************
1498: * Quote
1499: *
1500: * Writes a double quote.
1501: *
1502: ****************************************************************************/
1503:
1504: STATICFN VOID Quote(VOID)
1505: {
1506: WriteDlgChar(CHAR_DBLQUOTE);
1507: }
1508:
1509:
1510:
1511: /****************************************************************************
1512: * Comma
1513: *
1514: * Writes a comma then a space.
1515: *
1516: ****************************************************************************/
1517:
1518: STATICFN VOID Comma(VOID)
1519: {
1520: WriteDlgChar(CHAR_COMMA);
1521: WriteDlgChar(CHAR_SPACE);
1522: }
1523:
1524:
1525:
1526: /****************************************************************************
1527: * Space
1528: *
1529: * Writes a space.
1530: *
1531: ****************************************************************************/
1532:
1533: STATICFN VOID Space(VOID)
1534: {
1535: WriteDlgChar(CHAR_SPACE);
1536: }
1537:
1538:
1539:
1540: /****************************************************************************
1541: * ORSymbol
1542: *
1543: * Writes " | ".
1544: *
1545: ****************************************************************************/
1546:
1547: STATICFN VOID ORSymbol(VOID)
1548: {
1549: WriteDlgChar(CHAR_SPACE);
1550: WriteDlgChar(CHAR_ORSYMBOL);
1551: WriteDlgChar(CHAR_SPACE);
1552: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.