![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to restodlg.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 restodlg.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: restodlg.c
14: *
15: * Routines that take a dialog resource and create the dialog to edit, or
16: * the other way around.
17: *
18: * Fucntions:
19: * SynchDialogResource()
20: * AllocDialogResource()
21: * ResLinkToDialog()
22: * ResToDialog()
23: * GetiClass()
24: * Duplicate()
25: * MakeCopyFromRes()
26: * TypeFromClassStyle()
27: *
28: * Comments:
29: *
30: ****************************************************************************/
31:
32: #include "dlgedit.h"
33: #include "dlgfuncs.h"
34: #include "dlgextrn.h"
35:
36: STATICFN INT TypeFromClassStyle(INT iClass, DWORD flStyle);
37:
38:
39:
40: /************************************************************************
41: * SynchDialogResource
42: *
43: * This routine synchronizes the resource buffer with the contents of
44: * the current dialog being edited. This may involve deleting the old
45: * contents of the current dialog prior to adding the new data.
46: *
47: * It is ok to call this routine even if there is not an existing dialog
48: * being edited (it will just return) and it should be called before any
49: * operation that needs the in memory copy of the dialog to accurately
50: * reflect the contents of the current dialog, such as just before a
51: * save to disk.
52: *
53: * Returns:
54: * TRUE if all goes well (includes the case where nothing was done).
55: * FALSE if an error occurs updating the resource.
56: *
57: ************************************************************************/
58:
59: BOOL SynchDialogResource(VOID)
60: {
61: PRES pRes;
62: PRESLINK prl;
63: PRESLINK prlNew;
64: PRESLINK prlPrev;
65:
66: if (!gfEditingDlg)
67: return TRUE;
68:
69: /*
70: * Allocate a resource for the current dialog.
71: */
72: if (!(pRes = AllocDialogResource(FALSE, FALSE)))
73: return FALSE;
74:
75: /*
76: * Allocate a new link for it.
77: */
78: if (!(prlNew = AllocResLink(pRes)))
79: return FALSE;
80:
81: /*
82: * Free the local copy of the dialog resource now that the
83: * link has been created (and the resource copied to global
84: * memory).
85: */
86: MyFree(pRes);
87:
88: /*
89: * Does a link for the dialog already exist?
90: */
91: if (gcd.prl) {
92: /*
93: * Find the existing link and get it's previous link.
94: */
95: for (prl = gprlHead, prlPrev = NULL; prl && prl != gcd.prl;
96: prlPrev = prl, prl = prl->prlNext)
97: ;
98:
99: /*
100: * Start linking it in.
101: */
102: prlNew->prlNext = gcd.prl->prlNext;
103:
104: if (prlPrev)
105: prlPrev->prlNext = prlNew;
106: else
107: gprlHead = prlNew;
108:
109: /*
110: * Delete the old link now that it is replaced.
111: */
112: FreeResLink(gcd.prl);
113: }
114: else {
115: /*
116: * Search for the end of the list. Get a pointer to the last link.
117: */
118: for (prl = gprlHead, prlPrev = NULL; prl;
119: prlPrev = prl, prl = prl->prlNext)
120: ;
121:
122: /*
123: * Add the new link to the end of the list.
124: */
125: if (prlPrev)
126: prlPrev->prlNext = prlNew;
127: else
128: gprlHead = prlNew;
129: }
130:
131: /*
132: * Update our global with the new link. Clear the "dialog changed"
133: * flag.
134: */
135: gcd.prl = prlNew;
136: gfDlgChanged = FALSE;
137:
138: return TRUE;
139: }
140:
141:
142:
143: /************************************************************************
144: * AllocDialogResource
145: *
146: * This function allocates memory and builds a resource file format
147: * image in it of the current dialog.
148: *
149: * Arguments:
150: * BOOL fTestMode - TRUE if a special test mode version of the current
151: * dialog should be created.
152: * BOOL fClipboard - If TRUE, only the selected control(s) will be
153: * placed in the resource. This is used when putting
154: * controls or groups of controls into the clipboard.
155: * If the dialog is selected, this flag is ignored,
156: * because selecting the dialog implies all the
157: * controls will be written out also.
158: *
159: * Returns:
160: * Pointer to the resource buffer.
161: * NULL if unable to create the resource.
162: *
163: ************************************************************************/
164:
165: PRES AllocDialogResource(
166: BOOL fTestMode,
167: BOOL fClipboard)
168: {
169: NPCTYPE npc;
170: INT cControls;
171: BOOL fSelectedOnly = FALSE;
172: INT cbDlgName;
173: INT cbCaption;
174: INT cbPointSize;
175: INT cbFontName;
176: INT cbCD;
177: INT cbResHeader;
178: INT cbResData;
179: INT cbResSize;
180: INT cbMenuName;
181: INT cbClass;
182: INT cbText;
183: INT cbAlloc;
184: PBYTE pb;
185: PRES pResBegin;
186: PRES pResBegin2;
187: LPTSTR pszClass;
188: LPTSTR pszMenu;
189: LPTSTR pszText;
190: DWORD flStyle;
191: PDIALOGBOXHEADER pdbh;
192: PCONTROLDATA pcd;
193: ORDINAL ordClass;
194:
195: cControls = cWindows;
196: if (fClipboard && !gfDlgSelected) {
197: fSelectedOnly = TRUE;
198: for (cControls = 0, npc = npcHead; npc; npc = npc->npcNext)
199: if (npc->fSelected)
200: cControls++;
201: }
202:
203: /*
204: * If testing, don't allow a dialog to be created with any
205: * special class, or with the real menu.
206: */
207: if (fTestMode) {
208: pszClass = NULL;
209: pszMenu = NULL;
210: }
211: else {
212: pszClass = gcd.di.pszClass;
213: pszMenu = gcd.di.pszMenu;
214: }
215:
216: cbDlgName = NameOrdLen(gcd.pszDlgName);
217: cbCaption = (gcd.npc->text) ?
218: (lstrlen(gcd.npc->text) + 1) * sizeof(TCHAR) : sizeof(TCHAR);
219: cbClass = pszClass ? NameOrdLen(pszClass) : sizeof(TCHAR);
220: cbMenuName = pszMenu ? NameOrdLen(pszMenu) : sizeof(TCHAR);
221:
222: if (gcd.fFontSpecified) {
223: cbPointSize = sizeof(WORD);
224: cbFontName = (lstrlen(gcd.di.szFontName) + 1) * sizeof(TCHAR);
225: }
226: else {
227: cbPointSize = cbFontName = 0;
228: }
229:
230: /*
231: * Calculate the size of the resource header.
232: */
233: cbResHeader = sizeof(RES) + // The first fixed part.
234: sizeof(ORDINAL) + // The RT_DIALOG ordinal.
235: cbDlgName; // The dialog's name.
236: DWordAlign((PBYTE *)&cbResHeader); // Pad for the dialog's name.
237: cbResHeader += sizeof(RES2); // The last fixed part.
238:
239: /*
240: * Calculate the size of the resource data. This will just include
241: * the dialog box header right now.
242: */
243: cbResData = SIZEOF_DIALOGBOXHEADER + // The first fixed part.
244: cbMenuName + // The menu.
245: cbClass + // The class.
246: cbCaption + // The caption.
247: cbPointSize + // The point size.
248: cbFontName; // The font name.
249:
250: /*
251: * Allocate some buffer space. Be sure to round this up to a DWORD
252: * boundary to allow space for padding if necessary, but don't round
253: * cbResData field because it will need to be written into the header
254: * later, and the value that is written is an exact size (not rounded
255: * up).
256: */
257: cbAlloc = cbResSize = cbResHeader + cbResData;
258: DWordAlign((PBYTE *)&cbAlloc);
259: if (!(pResBegin = (PRES)MyAlloc(cbAlloc)))
260: return NULL;
261:
262: /*
263: * Write the resource header.
264: */
265: pdbh = (PDIALOGBOXHEADER)WriteResHeader(pResBegin, 0, ORDID_RT_DIALOG,
266: gcd.pszDlgName, gcd.di.fResFlags, gcd.di.wLanguage,
267: gcd.di.DataVersion, gcd.di.Version, gcd.di.Characteristics);
268:
269: /*
270: * Write out the style.
271: */
272: flStyle = gcd.npc->flStyle;
273: if (fTestMode) {
274: flStyle &= ~awcd[W_DIALOG].flStylesTestBad;
275: flStyle |= WS_VISIBLE;
276: }
277:
278: pdbh->lStyle = flStyle;
279: pdbh->lExtendedStyle = gcd.npc->flExtStyle;
280: pdbh->NumberOfItems = (WORD)cControls;
281:
282: /*
283: * Write the coordinates.
284: *
285: * If we are allocating a template that only has the selected controls
286: * in it, we put the value of CONTROLS_ONLY in the "cx" field of the
287: * dialog header. This is what we will check when the user pastes
288: * something from the clipboard into a dialog to determine whether
289: * to paste the entire dialog, or only the controls within the dialog
290: * item array.
291: */
292: pdbh->x = (WORD)gcd.npc->rc.left;
293: pdbh->y = (WORD)gcd.npc->rc.top;
294:
295: if (fSelectedOnly)
296: pdbh->cx = CONTROLS_ONLY;
297: else
298: pdbh->cx = (WORD)(gcd.npc->rc.right - gcd.npc->rc.left);
299:
300: pdbh->cy = (WORD)(gcd.npc->rc.bottom - gcd.npc->rc.top);
301:
302: pb = (PBYTE)pdbh + SIZEOF_DIALOGBOXHEADER;
303:
304: /*
305: * Write the menu name if there is one (we always write at least a null.
306: */
307: pb = NameOrdCpy((LPTSTR)pb, pszMenu ? pszMenu : szEmpty);
308:
309: /*
310: * Write the class if there is one (we always write at least a null.
311: */
312: pb = NameOrdCpy((LPTSTR)pb, pszClass ? pszClass : szEmpty);
313:
314: /*
315: * Write the caption if there is one (we always write at least a null).
316: */
317: pb = WriteSz((LPTSTR)pb, gcd.npc->text ? gcd.npc->text : szEmpty);
318:
319: /*
320: * Write out the font, if there is one specified.
321: */
322: if (gcd.fFontSpecified) {
323: *(PWORD)pb = (WORD)gcd.di.nPointSize;
324: pb += sizeof(WORD);
325:
326: pb = WriteSz((LPTSTR)pb, gcd.di.szFontName);
327: }
328:
329: /*
330: * Pad to a DWORD boundary. This is ok even if there are no controls
331: * that follow, because we were sure to allocate on an even dword
332: * boundary above.
333: */
334: DWordPad(&pb);
335:
336: /*
337: * Now do dialog items.
338: */
339: for (npc = npcHead; npc; npc = npc->npcNext) {
340: /*
341: * Skip the control if it is NOT selected and we only want the
342: * selected controls.
343: */
344: if (fSelectedOnly && !npc->fSelected)
345: continue;
346:
347: /*
348: * If we are testing, we don't want to really create a control
349: * with some funny class because it probably won't be found.
350: * We will substitute our custom class emulator instead.
351: */
352: if (fTestMode && npc->pwcd->fEmulated)
353: pszClass = szCustomClass;
354: else
355: pszClass = npc->pwcd->pszClass;
356:
357: /*
358: * Get a pointer to the text. If this is an icon control and
359: * we are going into test mode, change the text field so that
360: * it points to an ordinal for DlgEdit's icon to display, or
361: * the icon resource will probably not be found when the dialog
362: * is created.
363: */
364: pszText = npc->text;
365: if (npc->pwcd->iType == W_ICON && fTestMode)
366: pszText = (LPTSTR)&gordIcon;
367:
368: cbText = pszText ? NameOrdLen(pszText) : sizeof(TCHAR);
369: cbClass = pszClass ? NameOrdLen(pszClass) : sizeof(ORDINAL);
370:
371: cbCD = SIZEOF_CONTROLDATA + // The fixed portion.
372: cbClass + // The class.
373: cbText + // The text.
374: sizeof(WORD); // nExtraStuff field.
375:
376: /*
377: * Since we are adding a new control, we dword align the
378: * previous size of the resource data to ensure the new
379: * control starts on a dword boundary.
380: */
381: DWordAlign((PBYTE *)&cbResSize);
382:
383: /*
384: * Allocate room for this control. This includes room for the
385: * template structure, class, text and a byte for the cb field
386: * for the create struct data.
387: */
388: cbAlloc = cbResSize + cbCD;
389: DWordAlign((PBYTE *)&cbAlloc);
390: pResBegin2 = (PRES)MyRealloc((PBYTE)pResBegin, cbAlloc);
391: if (!pResBegin2) {
392: MyFree(pResBegin);
393: return NULL;
394: }
395:
396: pResBegin = pResBegin2;
397: pcd = (PCONTROLDATA)((PBYTE)pResBegin + cbResSize);
398: cbResSize += cbCD;
399:
400: /*
401: * Write the style. If testing, remove any styles that can
402: * cause problems, such as ownerdraw styles. If testing and
403: * this is an emulated custom control, always make it with
404: * the default styles no matter what the user has specified.
405: */
406: flStyle = npc->flStyle;
407: if (fTestMode) {
408: if (npc->pwcd->fEmulated)
409: flStyle = awcd[W_CUSTOM].flStyles;
410: else
411: flStyle &= ~npc->pwcd->flStylesTestBad;
412: }
413:
414: pcd->lStyle = flStyle;
415: pcd->lExtendedStyle = npc->flExtStyle;
416:
417: /*
418: * Write the coordinates.
419: */
420: pcd->x = (WORD)npc->rc.left;
421: pcd->y = (WORD)npc->rc.top;
422: pcd->cx = (WORD)(npc->rc.right - npc->rc.left);
423: pcd->cy = (WORD)(npc->rc.bottom - npc->rc.top);
424:
425: /*
426: * Write the id.
427: */
428: pcd->wId = (WORD)npc->id;
429:
430: pb = (PBYTE)pcd + SIZEOF_CONTROLDATA;
431:
432: /*
433: * Write the class. This will be a string, except for the
434: * predefined control classes, which all have an ordinal
435: * value defined for them.
436: */
437: if (pszClass) {
438: pb = NameOrdCpy((LPTSTR)pb, pszClass);
439: }
440: else {
441: WriteOrd(&ordClass, acsd[awcd[npc->pwcd->iType].iClass].idOrd);
442: pb = NameOrdCpy((LPTSTR)pb, (LPTSTR)&ordClass);
443: }
444:
445: /*
446: * Write the text.
447: */
448: pb = NameOrdCpy((LPTSTR)pb, pszText ? pszText : szEmpty);
449:
450: /*
451: * Write out a zero because there are no additional bytes
452: * of create struct data.
453: */
454: *(PWORD)pb = 0;
455: pb += sizeof(WORD);
456:
457: /*
458: * Pad to a DWORD boundary. This is ok even if there are no more
459: * controls, because we were sure to allocate on an even dword
460: * boundary above.
461: */
462: DWordPad(&pb);
463: }
464:
465: /*
466: * Now go back and fill in the resource data size field.
467: */
468: pResBegin->DataSize = cbResSize - cbResHeader;
469:
470: return pResBegin;
471: }
472:
473:
474:
475: /************************************************************************
476: * ResLinkToDialog
477: *
478: * This function is used to create a dialog out of a dialog resource
479: * that has been stored in the resource linked list.
480: *
481: * Arguments:
482: * PRESLINK prl - Points to the link that describes the dialog to
483: * create. It is assumed that the resource is a
484: * dialog resource.
485: *
486: ************************************************************************/
487:
488: VOID ResLinkToDialog(
489: PRESLINK prl)
490: {
491: PRES pRes;
492:
493: pRes = (PRES)GlobalLock(prl->hRes);
494: ResToDialog(pRes, TRUE);
495: GlobalUnlock(prl->hRes);
496:
497: /*
498: * If the dialog was successfully created, remember which res link
499: * it was created from.
500: */
501: if (gfEditingDlg)
502: gcd.prl = prl;
503: }
504:
505:
506:
507: /************************************************************************
508: * ResToDialog
509: *
510: * This function creates a dialog box, complete with controls,
511: * from a dialog resource template.
512: *
513: * Arguments:
514: * PRES pRes - Pointer to the dialog resource to use.
515: * BOOL fDoDialog - TRUE if a new dialog should be created, followed
516: * by the controls. If this is FALSE, just the
517: * controls will be created and added to the current
518: * dialog.
519: *
520: * Returns:
521: * TRUE on success, FALSE if an error occured.
522: *
523: ************************************************************************/
524:
525: BOOL ResToDialog(
526: PRES pRes,
527: BOOL fDoDialog)
528: {
529: LPTSTR pszText;
530: LPTSTR pszClass;
531: INT x;
532: INT y;
533: INT cx;
534: INT cy;
535: INT id;
536: INT iClass;
537: INT cdit;
538: INT Type;
539: DWORD flStyle;
540: DWORD flExtStyle;
541: NPCTYPE npc;
542: LPTSTR pszMenuName;
543: LPTSTR pszFontName;
544: INT nPointSize;
545: LPTSTR pszDlgName;
546: LPTSTR pszCaption;
547: PDIALOGBOXHEADER pdbh;
548: PCONTROLDATA pcd;
549: PWINDOWCLASSDESC pwcd;
550: PCUSTLINK pcl;
551: PRES2 pRes2;
552: DIALOGINFO di;
553: CCINFO cci;
554:
555: /*
556: * First check that the pointer is ok.
557: */
558: if (!pRes)
559: return FALSE;
560:
561: pRes2 = ResourcePart2(pRes);
562: pdbh = (PDIALOGBOXHEADER)SkipResHeader(pRes);
563:
564: /*
565: * Parse out the dialog box header.
566: * After this point, pcd is pointing to the first dialog control item.
567: */
568: pcd = ParseDialogBoxHeader(pdbh,
569: &flStyle, &flExtStyle, &cdit, &x, &y, &cx, &cy,
570: &pszMenuName, &pszClass, &pszCaption,
571: &nPointSize, &pszFontName);
572:
573: /*
574: * Are we pasting the entire dialog?
575: */
576: if (fDoDialog) {
577: pszDlgName = ResourceName(pRes);
578:
579: /*
580: * Determine the best base id for the dialog.
581: */
582: if (IsOrd(pszDlgName))
583: id = OrdID(pszDlgName);
584: else
585: id = NextID(NEXTID_DIALOG, plInclude, 0);
586:
587: di.fResFlags = pRes2->MemoryFlags;
588: di.wLanguage = pRes2->LanguageId;
589: di.pszClass = pszClass;
590: di.pszMenu = pszMenuName;
591: di.DataVersion = pRes2->DataVersion;
592: di.Version = pRes2->Version;
593: di.Characteristics = pRes2->Characteristics;
594: di.nPointSize = nPointSize;
595: lstrcpy(di.szFontName, pszFontName ? pszFontName : szEmpty);
596:
597: /*
598: * Create the dialog.
599: */
600: if (!AddControl(&awcd[W_DIALOG], pszCaption, flStyle, flExtStyle, id,
601: x, y, cx, cy, pszDlgName, &di))
602: return FALSE;
603: }
604:
605: while (cdit--) {
606: pcd = ParseControlData(pcd, &flStyle, &flExtStyle, &x, &y, &cx, &cy,
607: &id, &pszClass, &pszText);
608:
609: /*
610: * If we are not creating a new dialog, and the id in
611: * the resource is already in use, we will use the next
612: * available one instead.
613: */
614: if (!fDoDialog && !IsUniqueID(id))
615: id = NextID(NEXTID_CONTROL, plInclude, 0);
616:
617: /*
618: * Fix up the class. If the class is a predefined ordinal type,
619: * we will null out pszClass so it doesn't confuse AddControl
620: * into thinking that there is a string class for this control.
621: */
622: iClass = GetiClass(pszClass);
623: Type = TypeFromClassStyle(iClass, flStyle);
624: if (IsOrd(pszClass))
625: pszClass = NULL;
626:
627: if (Type == W_CUSTOM) {
628: /*
629: * Search the list of installed custom controls for one
630: * that matches the class.
631: */
632: for (pcl = gpclHead;
633: pcl && lstrcmpi(pcl->pwcd->pszClass, pszClass) != 0;
634: pcl = pcl->pclNext)
635: ;
636:
637: /*
638: * Was a match found?
639: */
640: if (pcl) {
641: pwcd = pcl->pwcd;
642: }
643: else {
644: /*
645: * An existing custom control link for this class was
646: * not found. We will add an emulated custom control
647: * to support it. We assume the default style and size
648: * should be what this control has.
649: */
650: lstrcpy(cci.szClass, pszClass);
651: cci.flOptions = 0;
652: *cci.szDesc = TEXT('\0');
653: cci.cxDefault = cx;
654: cci.cyDefault = cy;
655: cci.flStyleDefault = flStyle;
656: cci.flExtStyleDefault = flExtStyle;
657: *cci.szTextDefault = TEXT('\0');
658: cci.cStyleFlags = 0;
659: cci.aStyleFlags = NULL;
660: cci.lpfnStyle = NULL;
661: cci.lpfnSizeToText = NULL;
662: cci.dwReserved1 = 0;
663: cci.dwReserved2 = 0;
664:
665: if (pcl = AddCustomLink(&cci, TRUE, FALSE, NULL, NULL))
666: pwcd = pcl->pwcd;
667: else
668: /*
669: * Skip this control and continue creating the
670: * rest of the dialog.
671: */
672: continue;
673: }
674: }
675: else {
676: pwcd = &awcd[Type];
677: }
678:
679: /*
680: * If we are not creating the entire dialog (we allow existing
681: * resource files to be a little messed up), and this control
682: * is a default pushbutton, we will then loop through all the
683: * existing controls checking for another default pushbutton.
684: * If one is found, we convert the default pushbutton being
685: * created into a normal pushbutton instead. It is not allowed
686: * to have more than one default pushbuttons in the same dialog.
687: */
688: if (!fDoDialog && Type == W_PUSHBUTTON &&
689: (flStyle & BS_ALL) == BS_DEFPUSHBUTTON) {
690: for (npc = npcHead; npc; npc = npc->npcNext) {
691: if (npc->pwcd->iType == W_PUSHBUTTON &&
692: (npc->flStyle & BS_ALL) == BS_DEFPUSHBUTTON) {
693: flStyle = (flStyle & ~BS_ALL) | BS_PUSHBUTTON;
694: break;
695: }
696: }
697: }
698:
699: npc = AddControl(pwcd, pszText, flStyle, flExtStyle, id,
700: x, y, cx, cy, NULL, NULL);
701:
702: /*
703: * If the control creation succeeded, and we are just adding
704: * controls (not creating a whole new dialog), select the
705: * controls as they are added, but don't do any drawing yet.
706: */
707: if (!fDoDialog && npc)
708: SelectControl2(npc, TRUE);
709: }
710:
711: /*
712: * Update the selected rectangle. This is normally done by
713: * SelectControl2 but we told it not to so that the selection
714: * could be done faster. We also select the first control here.
715: */
716: if (!fDoDialog) {
717: SetAnchorToFirstSel(TRUE);
718: CalcSelectedRect();
719: }
720:
721: ShowWindow(gcd.npc->hwnd, SW_SHOWNA);
722: ToolboxOnTop();
723:
724: return TRUE;
725: }
726:
727:
728:
729: /************************************************************************
730: * TypeFromClassStyle
731: *
732: * This function returns the type of a control (one of the W_ constants)
733: * based on the class in iClass and the style in flStyle.
734: *
735: * Arguments:
736: * INT iClass = The class of the control, as an IC_* defined constant.
737: * DWORD flStyle = The style of the control.
738: *
739: * Returns:
740: * The type of the control (W_* constant).
741: * W_NOTHING is the error return.
742: *
743: ************************************************************************/
744:
745: STATICFN INT TypeFromClassStyle(
746: INT iClass,
747: DWORD flStyle)
748: {
749: switch (iClass) {
750: case IC_BUTTON:
751: return rgmpiClsBtnType[flStyle & BS_ALL];
752:
753: case IC_EDIT:
754: return W_EDIT;
755:
756: case IC_SCROLLBAR:
757: return (flStyle & SBS_VERT) ? W_VERTSCROLL : W_HORZSCROLL;
758:
759: case IC_STATIC:
760: return rgmpiClsStcType[flStyle & SS_ALL];
761:
762: case IC_LISTBOX:
763: return W_LISTBOX;
764:
765: case IC_COMBOBOX:
766: return W_COMBOBOX;
767:
768: case IC_CUSTOM:
769: return W_CUSTOM;
770:
771: case IC_DIALOG:
772: return W_DIALOG;
773:
774: default:
775: return W_NOTHING;
776: }
777: }
778:
779:
780:
781: /************************************************************************
782: * GetiClass
783: *
784: * This function returns the class identifier number for the
785: * window class of the control, given the class string from the
786: * dialog template.
787: *
788: * An ordinal class is a special ordinal that is used to identify
789: * each of the standard control classes. It is used in the
790: * dialog template to save space. The class string passed in
791: * can be an ordinal and if so, it will be checked against these
792: * predefined ordinal class values for a match.
793: *
794: * Arguments:
795: * LPTSTR pszClass - The class string or ordinal.
796: *
797: * Returns:
798: * The class identifier, one of the IC_* symbols in dlgedit.h.
799: * If the class cannot be determined, it assumes it is a custom
800: * class and returns IC_CUSTOM.
801: *
802: ************************************************************************/
803:
804: INT GetiClass(
805: LPTSTR pszClass)
806: {
807: INT i;
808: WORD idOrd;
809:
810: if (IsOrd(pszClass)) {
811: idOrd = OrdID(pszClass);
812: for (i = 0; i < IC_DIALOG; i++) {
813: if (acsd[i].idOrd == idOrd)
814: return i;
815: }
816: }
817: else {
818: for (i = 0; i < IC_DIALOG; i++) {
819: if (lstrcmpi(ids(acsd[i].idsClass), pszClass) == 0)
820: return i;
821: }
822: }
823:
824: /*
825: * Not found. Assume it is a user defined class.
826: */
827: return IC_CUSTOM;
828: }
829:
830:
831:
832: /************************************************************************
833: * Duplicate
834: *
835: * This routine duplicates the current selection.
836: *
837: ************************************************************************/
838:
839: VOID Duplicate(VOID)
840: {
841: PRES pRes;
842:
843: if (gcSelected) {
844: /*
845: * Store the current selection in a dialog resource.
846: */
847: if (!(pRes = AllocDialogResource(FALSE, TRUE)))
848: return;
849:
850: MakeCopyFromRes(pRes);
851: }
852: }
853:
854:
855:
856: /************************************************************************
857: * MakeCopyFromRes
858: *
859: * This function uses the given dialog template to either add a new
860: * dialog to the current resource file, or drop controls from the
861: * template into the current dialog. If copying a dialog, it is created
862: * right away. If copying controls, an operation is begun to start
863: * tracking them to their final destination in the current dialog.
864: *
865: * The caller of this function should NOT free pRes. This will
866: * be done either before the function returns, or after the drag
867: * operation is complete.
868: *
869: * Arguments:
870: * PRES pRes - Points to the dialog resource that contains
871: * the dialog or controls to make a copy of.
872: *
873: ************************************************************************/
874:
875: VOID MakeCopyFromRes(
876: PRES pRes)
877: {
878: PDIALOGBOXHEADER pdbh;
879: PCONTROLDATA pcd;
880: INT cControls;
881: INT i;
882: BOOL fFreeData = TRUE;
883: INT iType;
884: INT iClass;
885: INT nBottom;
886: INT nBottomLowest;
887:
888: gpResCopy = pRes;
889: pdbh = (PDIALOGBOXHEADER)SkipResHeader(gpResCopy);
890:
891: /*
892: * If cx is CONTROLS_ONLY, then we know that we only
893: * want to copy the controls in the template, not
894: * the entire dialog plus controls.
895: */
896: if (pdbh->cx == CONTROLS_ONLY) {
897: /*
898: * Begin copying in new controls into the current dialog.
899: */
900: cControls = pdbh->NumberOfItems;
901: if (cControls) {
902: /*
903: * Seed the rectangle with impossible values.
904: */
905: SetRect(&grcCopy, 32000, 32000, -32000, -32000);
906: nBottomLowest = 0;
907:
908: /*
909: * Loop through all the controls, expanding the rectangle
910: * to fit around all of them.
911: */
912: pcd = SkipDialogBoxHeader(pdbh);
913: for (i = 0; i < cControls; i++) {
914: iClass = GetiClass((LPTSTR)((PBYTE)pcd + SIZEOF_CONTROLDATA));
915: iType = TypeFromClassStyle(iClass, pcd->lStyle);
916:
917: if (grcCopy.left > (INT)pcd->x)
918: grcCopy.left = (INT)pcd->x;
919:
920: if (grcCopy.top > (INT)pcd->y)
921: grcCopy.top = (INT)pcd->y;
922:
923: if (grcCopy.right < (INT)pcd->x + (INT)pcd->cx)
924: grcCopy.right = (INT)pcd->x + (INT)pcd->cx;
925:
926: nBottom = ((INT)pcd->y + (INT)pcd->cy) -
927: GetOverHang(iType, (INT)pcd->cy);
928: if (nBottom > nBottomLowest)
929: nBottomLowest = nBottom;
930:
931: if (grcCopy.bottom < (INT)pcd->y + (INT)pcd->cy)
932: grcCopy.bottom = (INT)pcd->y + (INT)pcd->cy;
933:
934: pcd = SkipControlData(pcd);
935: }
936:
937: /*
938: * Begin dragging the new control(s). Set a flag so that
939: * the resource data is NOT free'd until after the drag
940: * is finished.
941: */
942: DragNewBegin(grcCopy.right - grcCopy.left,
943: grcCopy.bottom - grcCopy.top,
944: grcCopy.bottom - nBottomLowest);
945: fFreeData = FALSE;
946: }
947: }
948: else {
949: /*
950: * Begin copying in a new dialog, complete with controls.
951: */
952: if (SynchDialogResource()) {
953: /*
954: * Remove any existing dialog.
955: */
956: if (gfEditingDlg)
957: DeleteDialog(FALSE);
958:
959: if (ResToDialog(gpResCopy, TRUE)) {
960: SelectControl(gcd.npc, FALSE);
961: gfResChged = TRUE;
962: ShowFileStatus(FALSE);
963: }
964: }
965: }
966:
967: if (fFreeData) {
968: MyFree(gpResCopy);
969: gpResCopy = NULL;
970: }
971: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.