![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to resutil.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 resutil.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: resutil.c
14: *
15: * Contains utility functions for working with the Windows resource file.
16: *
17: * Functions:
18: * ParseDialogBoxHeader()
19: * ParseControlData()
20: * DWordAlign()
21: * DWordPad()
22: * ResourceType)
23: * ResourceName()
24: * ResourcePart2()
25: * ResourceSize()
26: * SkipResHeader()
27: * SkipSz()
28: * SkipDialogBoxHeader()
29: * SkipControlData()
30: * NameOrdCpy()
31: * NameOrdCmp()
32: * NameOrdLen()
33: * NameOrdDup()
34: * StrToNameOrd()
35: * WriteOrd()
36: * WriteResHeader()
37: * WriteSz()
38: *
39: ****************************************************************************/
40:
41: #include "dlgedit.h"
42: #include "dlgfuncs.h"
43: #include "dlgextrn.h"
44:
45: #include <string.h>
46: #include <wchar.h>
47:
48:
49:
50: /************************************************************************
51: * ParseDialogBoxHeader
52: *
53: *
54: * Arguments:
55: * PDIALOGBOXHEADER pdbh - Points to dialog box header to parse.
56: * PDWORD pflStyle - Receives the style.
57: * PDWORD pflExtStyle - Receives the extended style.
58: * PINT pcdit - Receives the number of controls in the dialog.
59: * PINT px - Receives starting x location.
60: * PINT py - Receives starting y location.
61: * PINT pcx - Receives the width.
62: * PINT pcy - Receives the height.
63: * LPTSTR *ppszMenuName - Receives the menu name.
64: * LPTSTR *ppszClass - Receives the class name.
65: * LPTSTR *ppszCaption - Receives the caption.
66: * PINT pPointSize - Receives the point size.
67: * LPTSTR *ppszFontName - Receives the font name.
68: *
69: * Returns:
70: * A pointer to the first dialog item past the dialog template header.
71: *
72: ************************************************************************/
73:
74: PCONTROLDATA ParseDialogBoxHeader(
75: PDIALOGBOXHEADER pdbh,
76: PDWORD pflStyle,
77: PDWORD pflExtStyle,
78: PINT pcdit,
79: PINT px,
80: PINT py,
81: PINT pcx,
82: PINT pcy,
83: LPTSTR *ppszMenuName,
84: LPTSTR *ppszClass,
85: LPTSTR *ppszCaption,
86: PINT pPointSize,
87: LPTSTR *ppszFontName)
88: {
89: BYTE UNALIGNED *pb;
90:
91: *pflStyle = pdbh->lStyle;
92: *pflExtStyle = pdbh->lExtendedStyle;
93: *pcdit = pdbh->NumberOfItems;
94: *px = (SHORT)pdbh->x;
95: *py = (SHORT)pdbh->y;
96: *pcx = (SHORT)pdbh->cx;
97: *pcy = (SHORT)pdbh->cy;
98:
99: pb = (PBYTE)pdbh + SIZEOF_DIALOGBOXHEADER;
100: *ppszMenuName = (LPTSTR)pb;
101: pb += NameOrdLen((LPTSTR)pb);
102:
103: *ppszClass = (LPTSTR)pb;
104: pb += NameOrdLen((LPTSTR)pb);
105:
106: *ppszCaption = (LPTSTR)pb;
107: pb += (lstrlen((LPTSTR)pb) + 1) * sizeof(TCHAR);
108:
109: /*
110: * Does the template specify a font?
111: */
112: if (pdbh->lStyle & DS_SETFONT) {
113: *pPointSize = (SHORT)(*(PWORD)pb);
114: pb += sizeof(WORD);
115: *ppszFontName = (LPTSTR)pb;
116: pb += (lstrlen((LPTSTR)pb) + 1) * sizeof(TCHAR);
117: }
118: else {
119: *pPointSize = 0;
120: *ppszFontName = NULL;
121: }
122:
123: DWordAlign((PBYTE *)&pb);
124:
125: return (PCONTROLDATA)pb;
126: }
127:
128:
129:
130: /************************************************************************
131: * ParseControlData
132: *
133: *
134: * Arguments:
135: * PCONTROLDATA pcd - Points to the control data to parse.
136: * PDWORD pflStyle - Receives the control style.
137: * PDWORD pflExtStyle - Receives the extended control style.
138: * PINT px - Receives starting x location.
139: * PINT py - Receives starting y location.
140: * PINT pcx - Receives the width.
141: * PINT pcy - Receives the height.
142: * PINT pid - Receives the control id.
143: * LPTSTR *ppszClass - Receives the class name.
144: * LPTSTR *ppszText - Receives the text.
145: *
146: * Returns:
147: * A pointer to the next dialog item past the given one.
148: *
149: ************************************************************************/
150:
151: PCONTROLDATA ParseControlData(
152: PCONTROLDATA pcd,
153: PDWORD pflStyle,
154: PDWORD pflExtStyle,
155: PINT px,
156: PINT py,
157: PINT pcx,
158: PINT pcy,
159: PINT pid,
160: LPTSTR *ppszClass,
161: LPTSTR *ppszText)
162: {
163: BYTE UNALIGNED *pb;
164:
165: *pflStyle = pcd->lStyle;
166: *pflExtStyle = pcd->lExtendedStyle;
167:
168: *px = (SHORT)pcd->x;
169: *py = (SHORT)pcd->y;
170: *pcx = (SHORT)pcd->cx;
171: *pcy = (SHORT)pcd->cy;
172: *pid = (SHORT)pcd->wId;
173:
174: pb = (PBYTE)pcd + SIZEOF_CONTROLDATA;
175: *ppszClass = (LPTSTR)pb;
176: pb += NameOrdLen((LPTSTR)pb);
177:
178: *ppszText = (LPTSTR)pb;
179: pb += NameOrdLen((LPTSTR)pb);
180:
181: /*
182: * Finally, skip the Create Struct Data.
183: * After this, pb will be pointing to the next control.
184: */
185: pb += *(PWORD)pb + sizeof(WORD);
186:
187: DWordAlign((PBYTE *)&pb);
188:
189: return (PCONTROLDATA)pb;
190: }
191:
192:
193:
194: /************************************************************************
195: * DWordAlign
196: *
197: * This function aligns the passed pointer to a DWORD boundary.
198: *
199: * Arguments:
200: * PBYTE *ppb - Points to the pointer to align.
201: *
202: ************************************************************************/
203:
204: VOID DWordAlign(
205: PBYTE *ppb)
206: {
207: *ppb += (4 - (((WORD)(DWORD)*ppb) & 3)) % 4;
208: }
209:
210:
211:
212: /************************************************************************
213: * DWordPad
214: *
215: * This function aligns the passed pointer to a DWORD boundary, padding
216: * with nulls as it goes.
217: *
218: * Arguments:
219: * PBYTE *ppb - Points to the pointer to align.
220: *
221: ************************************************************************/
222:
223: VOID DWordPad(
224: PBYTE *ppb)
225: {
226: WORD cbytes;
227:
228: cbytes = (WORD)((4 - (((WORD)(DWORD)*ppb) & 3)) % 4);
229: while (cbytes) {
230: *((*ppb)++) = 0;
231: cbytes--;
232: }
233: }
234:
235:
236:
237: /************************************************************************
238: * ResourceType
239: *
240: * This function returns a pointer to the type of the resource.
241: * The type can be either a string or an ordinal.
242: *
243: * Arguments:
244: * PRES pRes - Points to the start of the resource.
245: *
246: * Returns:
247: * Pointer to the type of the resource.
248: *
249: ************************************************************************/
250:
251: LPTSTR ResourceType(
252: PRES pRes)
253: {
254: /*
255: * Skip past the two size fields.
256: */
257: return (LPTSTR)((PBYTE)pRes + sizeof(DWORD) + sizeof(DWORD));
258: }
259:
260:
261:
262: /************************************************************************
263: * ResourceName
264: *
265: * This function returns a pointer to the name of the resource.
266: * The name can be either a string or an ordinal.
267: *
268: * Arguments:
269: * PRES pRes - Points to the start of the resource.
270: *
271: * Returns:
272: * Pointer to the name of the resource.
273: *
274: ************************************************************************/
275:
276: LPTSTR ResourceName(
277: PRES pRes)
278: {
279: PBYTE pb;
280:
281: /*
282: * Skip past the two size fields.
283: */
284: pb = (PBYTE)pRes + sizeof(DWORD) + sizeof(DWORD);
285:
286: /*
287: * Skip past the "Type" field to the name.
288: */
289: return (LPTSTR)SkipSz((LPTSTR)pb);
290: }
291:
292:
293:
294: /************************************************************************
295: * ResourcePart2
296: *
297: * This function returns a pointer to the second half of the resource
298: * header.
299: *
300: * Arguments:
301: * PRES pRes - Points to the start of the resource.
302: *
303: * Returns:
304: * A pointer to the second part of the resource header.
305: *
306: ************************************************************************/
307:
308: PRES2 ResourcePart2(
309: PRES pRes)
310: {
311: PBYTE pb;
312:
313: /*
314: * Skip past the first part of the resource header.
315: */
316: pb = (PBYTE)pRes + sizeof(RES);
317:
318: /*
319: * Skip past the "Type" field to the name.
320: */
321: pb = SkipSz((LPTSTR)pb);
322:
323: /*
324: * Skip past the name field also.
325: */
326: pb = SkipSz((LPTSTR)pb);
327: DWordAlign(&pb);
328:
329: return (PRES2)pb;
330: }
331:
332:
333:
334: /************************************************************************
335: * ResourceSize
336: *
337: * This returns the size of the given resource.
338: *
339: * Arguments:
340: * PRES pRes - Points to the start of the resource.
341: *
342: * Returns:
343: * Size of the resource, including the header.
344: *
345: ************************************************************************/
346:
347: DWORD ResourceSize(
348: PRES pRes)
349: {
350: return pRes->HeaderSize + pRes->DataSize;
351: }
352:
353:
354:
355: /************************************************************************
356: * SkipResHeader
357: *
358: * This function returns a pointer to the start of the resource data,
359: * just past it's header.
360: *
361: * Arguments:
362: * PRES pRes - Pointer to the resource.
363: *
364: ************************************************************************/
365:
366: PBYTE SkipResHeader(
367: PRES pRes)
368: {
369: return (PBYTE)pRes + pRes->HeaderSize;
370: }
371:
372:
373:
374: /************************************************************************
375: * SkipSz
376: *
377: * This function skips past a string and returns a pointer to just
378: * past it. It detects if the string is really an ordinal and skips
379: * past these also.
380: *
381: * Arguments:
382: * LPTSTR pNameOrd - Pointer to the string/ordinal.
383: *
384: ************************************************************************/
385:
386: PBYTE SkipSz(
387: LPTSTR pNameOrd)
388: {
389: if (IsOrd(pNameOrd))
390: pNameOrd = (LPTSTR)((PBYTE)pNameOrd + sizeof(ORDINAL));
391: else
392: pNameOrd += lstrlen(pNameOrd) + 1;
393:
394: return (PBYTE)pNameOrd;
395: }
396:
397:
398:
399: /************************************************************************
400: * SkipDialogBoxHeader
401: *
402: * This function skips past a dialog template structure and returns
403: * a pointer to the first dialog item template just past it.
404: *
405: * Arguments:
406: * PDIALOGBOXHEADER pdbh - Points to the dialog box header.
407: *
408: * Returns:
409: * A pointer to the first dialog item control data in the resource,
410: * just past the dialog box header that was skipped.
411: *
412: ************************************************************************/
413:
414: PCONTROLDATA SkipDialogBoxHeader(
415: PDIALOGBOXHEADER pdbh)
416: {
417: BYTE UNALIGNED *pb;
418:
419: /*
420: * Skip the fixed portion.
421: */
422: pb = (PBYTE)pdbh + SIZEOF_DIALOGBOXHEADER;
423:
424: /*
425: * Skip the menu.
426: */
427: pb += NameOrdLen((LPTSTR)pb);
428:
429: /*
430: * Skip the class.
431: */
432: pb += NameOrdLen((LPTSTR)pb);
433:
434: /*
435: * Skip the caption.
436: */
437: pb += (lstrlen((LPTSTR)pb) + 1) * sizeof(TCHAR);
438:
439: /*
440: * Does the template specify a font?
441: */
442: if (pdbh->lStyle & DS_SETFONT) {
443: pb += sizeof(WORD);
444: pb += (lstrlen((LPTSTR)pb) + 1) * sizeof(TCHAR);
445: }
446:
447: DWordAlign((PBYTE *)&pb);
448:
449: return (PCONTROLDATA)pb;
450: }
451:
452:
453:
454: /************************************************************************
455: * SkipControlData
456: *
457: * This function skips past the given control data to the next control.
458: *
459: * Arguments:
460: * PCONTROLDATA pcd - Points to the control data structure to skip.
461: *
462: * Returns:
463: * A pointer to the next control data structure.
464: *
465: ************************************************************************/
466:
467: PCONTROLDATA SkipControlData(
468: PCONTROLDATA pcd)
469: {
470: BYTE UNALIGNED *pb;
471:
472: /*
473: * Skip the fixed portion.
474: */
475: pb = (PBYTE)pcd + SIZEOF_CONTROLDATA;
476:
477: /*
478: * Skip the class.
479: */
480: pb += NameOrdLen((LPTSTR)pb);
481:
482: /*
483: * Skip the text.
484: */
485: pb += NameOrdLen((LPTSTR)pb);
486:
487: /*
488: * Finally, skip the Create Struct Data.
489: * After this, pb will be pointing to the next control.
490: */
491: pb += *(PWORD)pb + sizeof(WORD);
492:
493: DWordAlign((PBYTE *)&pb);
494:
495: return (PCONTROLDATA)pb;
496: }
497:
498:
499:
500: /************************************************************************
501: * NameOrdCpy
502: *
503: * This function copies a string or ordinal. This function needs to be
504: * used whenever a string could possibly be an ordinal. It returns a
505: * pointer to the first byte after the copied name/ordinal.
506: *
507: * Arguments:
508: * LPTSTR pNameOrdDest - The destination buffer.
509: * LPTSTR pNameOrdSrc - The source string or ordinal.
510: *
511: ************************************************************************/
512:
513: PBYTE NameOrdCpy(
514: LPTSTR pNameOrdDest,
515: LPTSTR pNameOrdSrc)
516: {
517: if (IsOrd(pNameOrdSrc)) {
518: memcpy((PBYTE)pNameOrdDest, (PBYTE)pNameOrdSrc, sizeof(ORDINAL));
519: return (PBYTE)pNameOrdDest + sizeof(ORDINAL);
520: }
521: else {
522: lstrcpy(pNameOrdDest, pNameOrdSrc);
523: return (PBYTE)(pNameOrdDest + (lstrlen(pNameOrdDest) + 1));
524: }
525: }
526:
527:
528:
529: /************************************************************************
530: * NameOrdCmp
531: *
532: * This function compares two strings or ordinals. It returns a
533: * zero if they are equal, or non-zero if they are not. This
534: * follows the convention of lstrcmp(), but the return should
535: * not be relied upon to determine which is "greater" than
536: * the other.
537: *
538: * Arguments:
539: * LPTSTR pNameOrd1 - The first string or ordinal.
540: * LPTSTR pNameOrd2 - The second string or ordinal.
541: *
542: ************************************************************************/
543:
544: INT NameOrdCmp(
545: LPTSTR pNameOrd1,
546: LPTSTR pNameOrd2)
547: {
548: BOOL fIsOrd1;
549: BOOL fIsOrd2;
550:
551: fIsOrd1 = IsOrd(pNameOrd1);
552: fIsOrd2 = IsOrd(pNameOrd2);
553:
554: if (fIsOrd1 != fIsOrd2)
555: return 1;
556:
557: if (fIsOrd1)
558: return memcmp((PBYTE)pNameOrd1, (PBYTE)pNameOrd2, sizeof(ORDINAL));
559: else
560: return lstrcmp(pNameOrd1, pNameOrd2);
561: }
562:
563:
564:
565: /************************************************************************
566: * NameOrdLen
567: *
568: * This function returns the length of a string or ordinal.
569: * If the given name is a string, the length of the string
570: * plus the terminating null is returned. Otherwise,
571: * the size of an ORDINAL structure is returned.
572: *
573: * The length returned is in bytes, not wide-chars.
574: *
575: * Arguments:
576: * LPTSTR pNameOrd - The string or ordinal.
577: *
578: ************************************************************************/
579:
580: INT NameOrdLen(
581: LPTSTR pNameOrd)
582: {
583: if (IsOrd(pNameOrd))
584: return sizeof(ORDINAL);
585: else
586: return (lstrlen(pNameOrd) + 1) * sizeof(TCHAR);
587: }
588:
589:
590:
591: /****************************************************************************
592: * NameOrdDup
593: *
594: * This function allocates a copy of the given name or ordinal.
595: *
596: * Arguments:
597: * LPTSTR pNameOrd - The name or ordinal to duplicate.
598: *
599: * Returns a pointer to the new copy if successful, NULL if it fails.
600: *
601: ****************************************************************************/
602:
603: LPTSTR NameOrdDup(
604: LPTSTR pNameOrd)
605: {
606: register INT iLen;
607: LPTSTR psz;
608:
609: iLen = NameOrdLen(pNameOrd);
610:
611: if (!(psz = (LPTSTR)MyAlloc(iLen)))
612: return NULL;
613:
614: NameOrdCpy(psz, pNameOrd);
615:
616: return psz;
617: }
618:
619:
620:
621: /************************************************************************
622: * StrToNameOrd
623: *
624: * This function takes the given string, determines if it is
625: * all numeric and if so, converts it in place into an ordinal.
626: * It is used to convert the string from an edit field for
627: * a value that can be an ordinal, such as the dialog name or
628: * an icon's text.
629: *
630: * Note that the pszNameOrd buffer must be large enough for an
631: * ordinal in case the string gets converted to an ordinal.
632: *
633: * Arguments:
634: * LPTSTR pszNameOrd - On input, contains the string to possibly
635: * convert. On output, it will contain the
636: * original string or the string converted to
637: * an ordinal.
638: * BOOL fDecOnly - TRUE if hex values and negative values (the
639: * string starts with a '-') are not allowed.
640: * This flag prevents these types of strings
641: * from being candidates for conversion to
642: * ordinals.
643: *
644: ************************************************************************/
645:
646: VOID StrToNameOrd(
647: LPTSTR pszNameOrd,
648: BOOL fDecOnly)
649: {
650: register INT i;
651: INT nOrd;
652: INT nLen;
653:
654: /*
655: * Empty string?
656: */
657: if (!(*pszNameOrd))
658: return;
659:
660: nLen = lstrlen(pszNameOrd);
661:
662: /*
663: * Is a hex value ok and does this appear to be a hex value?
664: */
665: if (!fDecOnly && pszNameOrd[0] == CHAR_0 &&
666: (pszNameOrd[1] == CHAR_X || pszNameOrd[1] == CHAR_CAP_X)) {
667: for (i = 2; i < nLen; i++) {
668: if (!iswxdigit(pszNameOrd[i]))
669: return;
670: }
671:
672: nOrd = axtoi(&pszNameOrd[2]);
673: }
674: else {
675: /*
676: * All characters must be numeric. Negative numbers may
677: * or may not be allowed, based on the fDecOnly flag.
678: */
679: for (i = 0; i < nLen; i++) {
680: if (!iswdigit(pszNameOrd[i]) &&
681: (fDecOnly || i != 0 || pszNameOrd[0] != CHAR_MINUS))
682: return;
683: }
684:
685: nOrd = awtoi(pszNameOrd);
686: }
687:
688: /*
689: * Return the ordinal in the original buffer.
690: */
691: WriteOrd((PORDINAL)pszNameOrd, nOrd);
692: }
693:
694:
695:
696: /************************************************************************
697: * WriteOrd
698: *
699: * This function writes out the given ordinal to the specified
700: * memory location. It returns the first byte past the newly
701: * written ordinal.
702: *
703: * Arguments:
704: * PORDINAL pMem - Pointer to the location to write the ordinal.
705: * INT nOrdinalID - Ordinal ID to write.
706: *
707: ************************************************************************/
708:
709: PBYTE WriteOrd(
710: PORDINAL pOrd,
711: INT nOrdinalID)
712: {
713: pOrd->wReserved = 0xffff;
714: pOrd->wOrdID = (WORD)nOrdinalID;
715:
716: return (PBYTE)pOrd + sizeof(ORDINAL);
717: }
718:
719:
720:
721: /************************************************************************
722: * WriteResHeader
723: *
724: * This function writes out a resource header to the memory location
725: * specified.
726: *
727: * Arguments:
728: *
729: * PRES pRes - pointer to the resource
730: * DWORD DataSize - size of the data
731: * INT iResType - resource type
732: * LPTSTR pszResName - resource name
733: * WORD fResFlags - resource flags
734: * WORD LanguageId - language id
735: * DWORD DataVersion - data version
736: * DWORD Version - version
737: * DWORD Characteristics-characterstics
738: *
739: * Returns:
740: * number of bytes written
741: *
742: ************************************************************************/
743:
744: PBYTE WriteResHeader(
745: PRES pRes,
746: DWORD DataSize,
747: INT iResType,
748: LPTSTR pszResName,
749: WORD fResFlags,
750: WORD LanguageId,
751: DWORD DataVersion,
752: DWORD Version,
753: DWORD Characteristics)
754: {
755: PBYTE pb;
756: PRES2 pRes2;
757:
758: pb = (PBYTE)pRes + sizeof(RES);
759: pb = WriteOrd((PORDINAL)pb, iResType);
760: pb = NameOrdCpy((LPTSTR)pb, pszResName);
761: DWordPad(&pb);
762:
763: pRes->DataSize = DataSize;
764: pRes->HeaderSize = (pb - (PBYTE)pRes) + sizeof(RES2);
765:
766: pRes2 = (PRES2)pb;
767: pRes2->DataVersion = DataVersion;
768: pRes2->MemoryFlags = fResFlags;
769: pRes2->LanguageId = LanguageId;
770: pRes2->Version = Version;
771: pRes2->Characteristics = Characteristics;
772:
773: return (PBYTE)pRes + pRes->HeaderSize;
774: }
775:
776:
777:
778: /************************************************************************
779: * WriteSz
780: *
781: * This function writes out the string given to the specified
782: * memory location. It returns the first byte past the newly
783: * written string.
784: *
785: * Arguments:
786: * LPTSTR pszDest - Pointer to the location to write the string.
787: * LPTSTR pszSrc - The string to write.
788: *
789: ************************************************************************/
790:
791: PBYTE WriteSz(
792: LPTSTR pszDest,
793: LPTSTR pszSrc)
794: {
795: while (*pszSrc)
796: *pszDest++ = *pszSrc++;
797:
798: *pszDest++ = CHAR_NULL;
799:
800: return (PBYTE)pszDest;
801: }
802:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.