![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to addctrl.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 addctrl.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: addctrl.c
14: *
15: * Contains routines for adding (creating) and deleting controls.
16: *
17: * Functions:
18: *
19: * AddNewDialog()
20: * DropControl()
21: * AddControl()
22: * CreateControl()
23: * CreateDlgFont()
24: * MyGetCharDimensions()
25: * AdjustDefaultSizes()
26: * DeleteControl()
27: * DeleteDialog()
28: * DeleteControl2()
29: * FreeCTYPE()
30: *
31: * Comments:
32: *
33: ****************************************************************************/
34:
35: #include "dlgedit.h"
36: #include "dlgfuncs.h"
37: #include "dlgextrn.h"
38: #include "dialogs.h"
39:
40: #include <stdlib.h>
41: #include <string.h>
42:
43: STATICFN HFONT CreateDlgFont(HWND hwnd, LPTSTR pszFontName,
44: INT nPointSize);
45: STATICFN INT MyGetCharDimensions(HWND hwnd, HFONT hFont,
46: PTEXTMETRIC ptm);
47: STATICFN VOID AdjustDefaultSizes(VOID);
48: STATICFN VOID DeleteControl2(NPCTYPE npcDel);
49: STATICFN VOID FreeCTYPE(NPCTYPE npc);
50:
51:
52:
53: /************************************************************************
54: * AddNewDialog
55: *
56: * High level function to add a new dialog to the current resource.
57: * Any existing dialog will be saved away in the resource buffer.
58: * The dialog is created at a default position and size with default
59: * styles.
60: *
61: ************************************************************************/
62:
63: VOID AddNewDialog(VOID)
64: {
65: RECT rc;
66:
67: if (gfEditingDlg) {
68: if (!SynchDialogResource())
69: return;
70:
71: DeleteDialog(FALSE);
72: }
73:
74: /*
75: * Now drop a new dialog window.
76: */
77: SetRect(&rc, DEFDIALOGXPOS, DEFDIALOGYPOS,
78: DEFDIALOGXPOS + awcd[W_DIALOG].cxDefault,
79: DEFDIALOGYPOS + awcd[W_DIALOG].cyDefault);
80: DropControl(&awcd[W_DIALOG], &rc);
81: }
82:
83:
84:
85: /************************************************************************
86: * DropControl
87: *
88: * This function drops a new control of Type at the specified
89: * location. The default style and text of the control is
90: * determined from the awcd table based on its type. The control
91: * is selected after being dropped. This function changes the status
92: * window to reflect the selected control.
93: *
94: * Arguments:
95: * PWINDOWCLASSDESC pwcd - Describes the type of new control.
96: * PRECT prc - Rectangle of the new control (in dialog units).
97: *
98: ************************************************************************/
99:
100: VOID DropControl(
101: PWINDOWCLASSDESC pwcd,
102: PRECT prc)
103: {
104: ORDINAL ordIcon;
105: ORDINAL ordDlg;
106: LPTSTR pszText;
107: NPCTYPE npcNew;
108: INT idCtrl;
109: DIALOGINFO di;
110:
111: /*
112: * Get the next available id to use for the new control.
113: */
114: idCtrl = NextID((pwcd->iType == W_DIALOG) ? NEXTID_DIALOG : NEXTID_CONTROL,
115: plInclude, 0);
116:
117: if (pwcd->iType == W_ICON) {
118: /*
119: * For icon controls, the text is really an ordinal or name
120: * of the icon resource to display. We get the next available
121: * id (skipping the id we just got for the control itself) to
122: * use as an ordinal.
123: */
124: WriteOrd(&ordIcon, NextID(NEXTID_CONTROL, plInclude, idCtrl));
125: pszText = (LPTSTR)&ordIcon;
126: }
127: else {
128: pszText = pwcd->pszTextDefault;
129: }
130:
131: /*
132: * Make the control.
133: */
134: if (pwcd->iType == W_DIALOG) {
135: /*
136: * Pick a default name for the dialog.
137: */
138: WriteOrd(&ordDlg, NextID(NEXTID_DIALOG, plInclude, 0));
139:
140: di.fResFlags = DEFDLGMEMFLAGS;
141: di.wLanguage = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
142: di.pszClass = NULL;
143: di.pszMenu = NULL;
144: di.DataVersion = 0;
145: di.Version = 0;
146: di.Characteristics = 0;
147: di.nPointSize = DEFPOINTSIZE;
148: lstrcpy(di.szFontName, ids(IDS_DEFFONTNAME));
149:
150: npcNew = AddControl(pwcd, pszText,
151: pwcd->flStyles, pwcd->flExtStyle, idCtrl,
152: prc->left, prc->top,
153: prc->right - prc->left, prc->bottom - prc->top,
154: (LPTSTR)&ordDlg, &di);
155: }
156: else {
157: npcNew = AddControl(pwcd, pszText,
158: pwcd->flStyles, pwcd->flExtStyle, idCtrl,
159: prc->left, prc->top,
160: prc->right - prc->left, prc->bottom - prc->top,
161: NULL, NULL);
162: }
163:
164: if (!npcNew)
165: return;
166:
167: /*
168: * If we just dropped a dialog, we need to now show it.
169: * It it was some other control, mark the dialog as having
170: * been changed.
171: */
172: if (pwcd->iType == W_DIALOG) {
173: ShowWindow(npcNew->hwnd, SW_SHOWNA);
174: ToolboxOnTop();
175: }
176: else {
177: gfDlgChanged = TRUE;
178: }
179:
180: SelectControl(npcNew, FALSE);
181:
182: gfResChged = TRUE;
183: ShowFileStatus(FALSE);
184:
185: /*
186: * Now we determine if one of the fields in the status ribbon
187: * should be given the focus initially. The assumption is that
188: * there are some things that a user will always want to change
189: * when dropping a new control, such as the text in a push
190: * button, for example.
191: */
192: idCtrl = 0;
193: switch (pwcd->iType) {
194: case W_ICON:
195: /*
196: * For icons, the first thing the user will
197: * probably want to do is to change the name.
198: */
199: idCtrl = DID_STATUSNAME;
200: break;
201:
202: default:
203: /*
204: * If this control has text, they will probably want
205: * to change it. This includes the caption if the
206: * control is a dialog.
207: */
208: if (pwcd->fHasText)
209: idCtrl = DID_STATUSTEXT;
210:
211: break;
212: }
213:
214: if (idCtrl) {
215: SendDlgItemMessage(hwndStatus, idCtrl,
216: EM_SETSEL, (WPARAM)(0), (LONG)(-1));
217: SetFocus(GetDlgItem(hwndStatus, idCtrl));
218: }
219: }
220:
221:
222:
223: /************************************************************************
224: * AddControl
225: *
226: * This function is used to add a new control. CreateControl() does
227: * half the work.
228: *
229: * Arguments:
230: * PWINDOWCLASSDESC pwcd - Window class structure. Describes the
231: * type of control to add.
232: * LPTSTR pszText - Text for the new control.
233: * DWORD style - Style of the new control.
234: * DWORD flExtStyle - Extended style of the new control.
235: * INT id - ID for the new control.
236: * INT x - X location of the new control.
237: * INT y - Y location of the new control.
238: * INT cx - Width of the new control.
239: * INT cy - Height of the new control.
240: * LPTSTR pszDlgName - For dialogs, has dialog name.
241: * PDIALOGINFO pdi - Ptr to additional dialog info (NULL for controls).
242: *
243: * Returns:
244: * A pointer to the CTYPE structure for the new control.
245: * NULL if it couldn't create the control.
246: *
247: ************************************************************************/
248:
249: NPCTYPE AddControl(
250: PWINDOWCLASSDESC pwcd,
251: LPTSTR pszText,
252: DWORD style,
253: DWORD flExtStyle,
254: INT id,
255: INT x,
256: INT y,
257: INT cx,
258: INT cy,
259: LPTSTR pszDlgName,
260: PDIALOGINFO pdi)
261: {
262: NPCTYPE npcNew;
263: NPCTYPE npcT;
264: NPCTYPE *npnpcLast;
265: HWND hwndBehind;
266:
267: if (!(npcNew = (NPCTYPE)MyAlloc(sizeof(CTYPE))))
268: return NULL;
269:
270: /*
271: * These are checked later if a failure occurs,
272: * so we null them out now.
273: */
274: npcNew->hwnd = NULL;
275: npcNew->hwndDrag = NULL;
276: npcNew->text = NULL;
277:
278: /*
279: * Set up some fields and create the control.
280: */
281: npcNew->npcNext = NULL;
282: npcNew->pwcd = pwcd;
283: npcNew->fSelected = FALSE;
284: SetRect(&npcNew->rc, x, y, x + cx, y + cy);
285:
286: if (pwcd->iType == W_DIALOG)
287: hwndBehind = (HWND)NULL;
288: else
289: hwndBehind = (HWND)1;
290:
291: if (!CreateControl(npcNew, pszText, style, flExtStyle, id, &npcNew->rc,
292: hwndBehind, pdi))
293: goto CreateFailed;
294:
295: /*
296: * Create the drag window, unless this is the dialog.
297: */
298: if (pwcd->iType != W_DIALOG) {
299: npcNew->hwndDrag = CreateWindow(
300: szDragClass,
301: NULL,
302: WS_CHILD,
303: 0, 0, 0, 0,
304: gcd.npc->hwnd,
305: NULL,
306: ghInst,
307: NULL);
308:
309: /*
310: * Store the CTYPE pointer into the control's drag window.
311: * This will be used by PCFROMHWND later.
312: */
313: SETPCINTOHWND(npcNew->hwndDrag, npcNew);
314:
315: /*
316: * Move the drag window to the top of the Z-Order.
317: */
318: SetWindowPos(npcNew->hwndDrag, NULL, 0, 0, 0, 0,
319: SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW);
320:
321: SizeDragToControl(npcNew);
322: }
323:
324: /*
325: * Did we just create a dialog?
326: */
327: if (pwcd->iType == W_DIALOG) {
328: /*
329: * First, copy the new name (it can be an ordinal!).
330: */
331: if (!(gcd.pszDlgName = MyAlloc(NameOrdLen(pszDlgName))))
332: goto CreateFailed;
333:
334: NameOrdCpy(gcd.pszDlgName, pszDlgName);
335:
336: /*
337: * Now, setup some other globals. We clear the gcd.prl pointer,
338: * because we are assuming that this dialog was not created
339: * from a res link (it was dropped instead). The routines
340: * that call AddControl when creating a dialog from a res
341: * link are responsible for setting this global later.
342: */
343: gcd.prl = NULL;
344: gcd.npc = npcNew;
345: gfEditingDlg = TRUE;
346: }
347: else {
348: /*
349: * Search for the last control in the list.
350: */
351: npnpcLast = &npcHead;
352: for (npcT = npcHead; npcT; npcT = npcT->npcNext)
353: npnpcLast = &npcT->npcNext;
354:
355: /*
356: * Link in the new control at the end of the list.
357: */
358: *npnpcLast = npcNew;
359: cWindows++;
360: }
361:
362: return npcNew;
363:
364: CreateFailed:
365: FreeCTYPE(npcNew);
366: return NULL;
367: }
368:
369:
370:
371: /************************************************************************
372: * CreateControl
373: *
374: * Creates a control. Some styles may be masked off of the actual
375: * control created. This function can also create the dialog box.
376: *
377: * If the control created is the dialog box, it will not be made visible.
378: * This must be done by the caller. This allows the caller to first add
379: * all the controls to the dialog before showing it.
380: *
381: * The x, y, cx and cy coordinates are all in dialog units. For a
382: * type of W_DIALOG, this will be relative to the apps client. For a
383: * control, this will be relative to the "client" area of the dialog.
384: *
385: * Arguments:
386: * NPCTYPE npc - The CTYPE pointer to the new control. The hwnd
387: * fields of the npc will be set.
388: * LPTSTR pszText - The window text.
389: * DWORD flStyle - The style to use.
390: * DWORD flExtStyle - Extended style of the new control.
391: * INT id - ID for the control.
392: * PRECT prc - The size and location of the new control.
393: * HWND hwndBehind - Put new control behind this hwnd in Z-order.
394: * PDIALOGINFO pdi - Pointer to additional dialog info (NULL for controls).
395: *
396: * Returns:
397: * Handle of the control created.
398: * NULL if control was not created.
399: *
400: ************************************************************************/
401:
402: HWND CreateControl(
403: NPCTYPE npc,
404: LPTSTR pszText,
405: DWORD flStyle,
406: DWORD flExtStyle,
407: INT id,
408: PRECT prc,
409: HWND hwndBehind,
410: PDIALOGINFO pdi)
411: {
412: HWND hwnd;
413: HWND hwndChild;
414: WNDPROC lpfnChild;
415: RECT rcT;
416: TEXTMETRIC tm;
417: LPTSTR pszCreateClass;
418: LPTSTR pszTextOld;
419: INT iType = npc->pwcd->iType;
420:
421: /*
422: * Set the text field. Remember that it can be an ordinal
423: * (for icon controls).
424: */
425: pszTextOld = npc->text;
426: if (pszText && *pszText) {
427: if (!(npc->text = MyAlloc(NameOrdLen(pszText))))
428: return NULL;
429:
430: NameOrdCpy(npc->text, pszText);
431: }
432: else {
433: npc->text = NULL;
434: }
435:
436: /*
437: * If there was text before on this control, free it now.
438: * This should be done after the new text is allocated and
439: * copied, because it is common to pass this routine the same
440: * pointer, and we don't want to free the text before we have
441: * copied it!
442: */
443: if (pszTextOld)
444: MyFree(pszTextOld);
445:
446: /*
447: * Also set some other values in the CTYPE structure.
448: */
449: npc->id = id;
450: npc->flStyle = flStyle;
451: npc->flExtStyle = flExtStyle;
452:
453: /*
454: * If this is a dialog and it has the WS_CHILD style, remove
455: * it and make it WS_POPUP instead. This prevents some problems
456: * when editing the dialog.
457: */
458: if (iType == W_DIALOG && (flStyle & WS_CHILD)) {
459: flStyle &= ~WS_CHILD;
460: flStyle |= WS_POPUP;
461: }
462:
463: /*
464: * If this is an emulated custom control, we always make it with the
465: * default styles no matter what the user has specified. If not,
466: * remove any styles that can cause problems for a control of this
467: * type, such as OWNERDRAW styles.
468: */
469: if (npc->pwcd->fEmulated)
470: flStyle = awcd[W_CUSTOM].flStyles;
471: else
472: flStyle &= ~npc->pwcd->flStylesBad;
473:
474: if (iType == W_DIALOG) {
475: /*
476: * If the style includes the DS_MODALFRAME bit, set the appropriate
477: * extended style bit.
478: */
479: if (flStyle & DS_MODALFRAME)
480: flExtStyle |= WS_EX_DLGMODALFRAME;
481:
482: /*
483: * Create the dialog, but don't show it yet.
484: */
485: hwnd = CreateWindowEx(
486: flExtStyle,
487: MAKEINTRESOURCE(DIALOGCLASS),
488: npc->text,
489: flStyle & ~WS_VISIBLE,
490: 0, 0, 0, 0,
491: ghwndSubClient,
492: 0,
493: ghInst,
494: NULL);
495: }
496: else {
497: /*
498: * Get the size of the control.
499: */
500: rcT = *prc;
501:
502: /*
503: * Map the dialog unit rectangle to window coords.
504: */
505: DUToWinRect(&rcT);
506:
507: /*
508: * If this is an icon, the text field is actually going
509: * to be an ordinal that has the resource id. We must map this to
510: * an id of our own or when we create the control it will cause a
511: * "Resource not found" error.
512: */
513: if (iType == W_ICON)
514: pszText = (LPTSTR)&gordIcon;
515: else
516: pszText = npc->text;
517:
518: /*
519: * Get the class name to use. In the case of custom controls,
520: * if the control is emulated, use the special emulator class.
521: * Otherwise, it is an installed custom control, and we can use
522: * it's real class string.
523: */
524: if (iType == W_CUSTOM) {
525: if (npc->pwcd->fEmulated)
526: pszCreateClass = szCustomClass;
527: else
528: pszCreateClass = npc->pwcd->pszClass;
529: }
530: else {
531: pszCreateClass = ids(acsd[awcd[iType].iClass].idsClass);
532: }
533:
534: /*
535: * Create the control. We always create it visible in work mode,
536: * even if the style says it isn't.
537: */
538: hwnd = CreateWindowEx(
539: flExtStyle,
540: pszCreateClass,
541: pszText,
542: flStyle | WS_VISIBLE,
543: rcT.left, rcT.top,
544: rcT.right - rcT.left,
545: rcT.bottom - rcT.top,
546: gcd.npc->hwnd,
547: 0,
548: ghInst,
549: NULL);
550: }
551:
552: if (!hwnd) {
553: Message(MSG_CREATECTRLERROR, pszCreateClass);
554: return NULL;
555: }
556:
557: if (iType == W_DIALOG) {
558: /*
559: * Did they specify a font?
560: */
561: if (*pdi->szFontName) {
562: gcd.hFont = CreateDlgFont(hwnd, pdi->szFontName, pdi->nPointSize);
563: lstrcpy(gcd.di.szFontName, pdi->szFontName);
564: gcd.di.nPointSize = pdi->nPointSize;
565: gcd.fFontSpecified = TRUE;
566: }
567: else {
568: gcd.hFont = NULL;
569: *gcd.di.szFontName = CHAR_NULL;
570: gcd.di.nPointSize = 0;
571: gcd.fFontSpecified = FALSE;
572: }
573:
574: /*
575: * Get the dimensions of the font. It is a possible case that
576: * they specified a font but it could not be created, so in
577: * that case we use the system font as well as if they didn't
578: * specify a font at all.
579: */
580: if (gcd.hFont) {
581: gcd.cxChar = MyGetCharDimensions(hwnd, gcd.hFont, &tm);
582: gcd.cyChar = tm.tmHeight;
583: }
584: else {
585: gcd.cxChar = gcxSysChar;
586: gcd.cyChar = gcySysChar;
587: }
588:
589: /*
590: * Now that we know what font we are using, adjust some entries
591: * in the awcd (array of window class data) table for default
592: * sizing of controls.
593: */
594: AdjustDefaultSizes();
595: }
596:
597: /*
598: * If there is a valid user specified font, inform the control
599: * of it. Once the font has been set into the dialog, it
600: * must not be destroyed, because the dialog window will
601: * clean it up when it is destroyed.
602: */
603: if (gcd.hFont)
604: SendMessage(hwnd, WM_SETFONT, (WPARAM)gcd.hFont, 0L);
605:
606: /*
607: * Move the window into the requested Z-Order.
608: */
609: SetWindowPos(hwnd, hwndBehind, 0, 0, 0, 0,
610: SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW);
611:
612: /*
613: * Store the CTYPE pointer into the control's hwnd.
614: * This will be used by PCFROMHWND later.
615: */
616: SETPCINTOHWND(hwnd, npc);
617:
618: /*
619: * Subclass the control.
620: */
621: npc->pwcd->pfnOldWndProc =
622: (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC,
623: (iType == W_DIALOG) ? (DWORD)DialogCtrlWndProc :
624: (DWORD)CtrlWndProc);
625:
626: /*
627: * Be sure double-clicks are enabled for this control.
628: */
629: (UINT)SetClassLong((hwnd), GCL_STYLE, (LONG)((UINT)GetClassLong((hwnd), GCL_STYLE) | CS_DBLCLKS));
630:
631: /*
632: * Subclass any children this control may have.
633: */
634: for (hwndChild = GetTopWindow(hwnd); hwndChild;
635: hwndChild = GetNextWindow(hwndChild, GW_HWNDNEXT)) {
636: lpfnChild = (WNDPROC)SetWindowLong(hwndChild,
637: GWL_WNDPROC, (DWORD)ChildWndProc);
638: SETCHILDPROC(hwndChild, lpfnChild);
639: }
640:
641: /*
642: * Did we just create a dialog?
643: */
644: if (iType == W_DIALOG) {
645: /*
646: * Now that the dialog is created, we can figure out how to
647: * size it. We start by mapping the dialog units to window
648: * coordinates,
649: */
650: rcT = *prc;
651: DUToWinRect(&rcT);
652:
653: /*
654: * We now have the rectangle for the client area. Expand it
655: * to account for the frame controls.
656: */
657: AdjustWindowRectEx(&rcT, flStyle, FALSE, flExtStyle);
658:
659: /*
660: * Now we can map the rect from the apps client area
661: * to the desktop, then we set the dialogs position.
662: */
663: ClientToScreenRect(ghwndSubClient, &rcT);
664: SetWindowPos(hwnd, NULL,
665: rcT.left, rcT.top,
666: rcT.right - rcT.left, rcT.bottom - rcT.top,
667: SWP_NOZORDER | SWP_NOACTIVATE);
668:
669: SaveDlgClientRect(hwnd);
670:
671: /*
672: * Save the class name, if any.
673: */
674: if (pdi->pszClass && *pdi->pszClass) {
675: if (!(gcd.di.pszClass = MyAlloc(NameOrdLen(pdi->pszClass)))) {
676: DestroyWindow(hwnd);
677: return (HWND)NULL;
678: }
679:
680: NameOrdCpy(gcd.di.pszClass, pdi->pszClass);
681: }
682: else {
683: gcd.di.pszClass = NULL;
684: }
685:
686: /*
687: * Save the menu name, if any.
688: */
689: if (pdi->pszMenu && *pdi->pszMenu) {
690: if (!(gcd.di.pszMenu = MyAlloc(NameOrdLen(pdi->pszMenu)))) {
691: DestroyWindow(hwnd);
692: return (HWND)NULL;
693: }
694:
695: NameOrdCpy(gcd.di.pszMenu, pdi->pszMenu);
696: }
697: else {
698: gcd.di.pszMenu = NULL;
699: }
700:
701: /*
702: * Set some other fields in the additional dialog info structure.
703: */
704: gcd.di.fResFlags = pdi->fResFlags;
705: gcd.di.wLanguage = pdi->wLanguage;
706: gcd.di.DataVersion = pdi->DataVersion;
707: gcd.di.Version = pdi->Version;
708: gcd.di.Characteristics = pdi->Characteristics;
709: }
710:
711: npc->hwnd = hwnd;
712: return hwnd;
713: }
714:
715:
716:
717: /************************************************************************
718: * CreateDlgFont
719: *
720: * This function creates a font with the given face name and point size
721: * and returns a handle to it.
722: *
723: * Arguments:
724: * HWND hwnd - Dialog window handle.
725: * LPTSTR pszFontName - Name of the font (for example: "Helv").
726: * INT nPointSize - Point size of the font (for example: 8 or 12).
727: *
728: * Returns:
729: * A handle to the created font, or NULL if it could not be created.
730: *
731: ************************************************************************/
732:
733: STATICFN HFONT CreateDlgFont(
734: HWND hwnd,
735: LPTSTR pszFontName,
736: INT nPointSize)
737: {
738: HFONT hFont;
739: HFONT hFontOld;
740: HDC hDC;
741: LOGFONT lf;
742: TCHAR szFaceName[LF_FACESIZE];
743:
744: /*
745: * Initialize the logical font structure. Note that filling the
746: * structure with zeros gives it all the default settings.
747: */
748: memset(&lf, 0, sizeof(LOGFONT));
749: lf.lfHeight = (SHORT)-PointSizeToPixels(nPointSize);
750: lf.lfWeight = FW_BOLD;
751: lstrcpy(lf.lfFaceName, pszFontName);
752:
753: if (!(hFont = CreateFontIndirect(&lf)))
754: return NULL;
755:
756: /*
757: * If we didn't get the face name that was requested, delete the
758: * new font and return NULL. This will effectively select the
759: * system font for this dialog.
760: */
761: hDC = GetDC(hwnd);
762: if (hFontOld = SelectObject(hDC, hFont)) {
763: GetTextFace(hDC, LF_FACESIZE, szFaceName);
764: SelectObject(hDC, hFontOld);
765:
766: if (lstrcmpi(szFaceName, pszFontName) != 0) {
767: DeleteObject(hFont);
768: hFont = NULL;
769: }
770: }
771: else {
772: DeleteObject(hFont);
773: hFont = NULL;
774: }
775:
776: ReleaseDC(hwnd, hDC);
777:
778: return hFont;
779: }
780:
781:
782:
783: /************************************************************************
784: * MyGetCharDimensions
785: *
786: * This function calculates the average character width of the given
787: * font for the given window. This must be used instead of
788: * simply using the tmAveCharWidth field of the text metrics, because
789: * this value is not correct for proportional fonts.
790: *
791: * Arguments:
792: * HWND hwnd - The window handle.
793: * HFONT hFont - The font handle.
794: * PTEXTMETRIC ptm - Where to return the text metrics.
795: *
796: * Returns:
797: * The average character width. The text metrics are returned in
798: * the TEXTMETRIC structure pointed to by ptm.
799: *
800: ************************************************************************/
801:
802: STATICFN INT MyGetCharDimensions(
803: HWND hwnd,
804: HFONT hFont,
805: PTEXTMETRIC ptm)
806: {
807: register INT i;
808: HDC hDC;
809: SIZE size;
810: INT iWidth;
811: TCHAR szAveCharWidth[52];
812: HFONT hFontOld;
813:
814: hDC = GetDC(hwnd);
815: hFontOld = SelectObject(hDC, hFont);
816:
817: GetTextMetrics(hDC, ptm);
818:
819: /*
820: * Is this a variable pitch font?
821: */
822: if (ptm->tmPitchAndFamily & 0x01) {
823: for (i = 0; i < 26; i++)
824: szAveCharWidth[i] = (TCHAR)(i + CHAR_A);
825:
826: for (i = 0; i < 26; i++)
827: szAveCharWidth[i + 26] = (TCHAR)(i + CHAR_CAP_A);
828:
829: GetTextExtentPoint(hDC, szAveCharWidth, 52, &size);
830: iWidth = (INT)size.cx / 26;
831:
832: //
833: // Round it up.
834: //
835: iWidth = (iWidth + 1) / 2;
836: }
837: else {
838: iWidth = ptm->tmAveCharWidth;
839: }
840:
841: SelectObject(hDC, hFontOld);
842: ReleaseDC(hwnd, hDC);
843:
844: return iWidth;
845: }
846:
847:
848:
849: /************************************************************************
850: * AdjustDefaultSizes
851: *
852: * This functions adjusts some default size entries in the awcd (array of
853: * window class data) table.
854: * This must be done at run time, because the actual values depend on the
855: * system that dlgedit is being run on and the font of the current dialog.
856: *
857: * This function should be called any time that a dialog is created,
858: * or its font is changed.
859: *
860: ************************************************************************/
861:
862: STATICFN VOID AdjustDefaultSizes(VOID)
863: {
864: awcd[W_ICON].cxDefault =
865: (((GetSystemMetrics(SM_CXICON) * 4) * 2) + gcd.cxChar)
866: / (gcd.cxChar * 2);
867:
868: awcd[W_ICON].cyDefault =
869: (((GetSystemMetrics(SM_CYICON) * 8) * 2) + gcd.cyChar)
870: / (gcd.cyChar * 2);
871:
872: awcd[W_VERTSCROLL].cxDefault =
873: (((GetSystemMetrics(SM_CXVSCROLL) * 4) * 2) + gcd.cxChar)
874: / (gcd.cxChar * 2);
875:
876: awcd[W_HORZSCROLL].cyDefault =
877: (((GetSystemMetrics(SM_CYHSCROLL) * 8) * 2) + gcd.cyChar)
878: / (gcd.cyChar * 2);
879: }
880:
881:
882:
883: /************************************************************************
884: * DeleteControl
885: *
886: * This deletes all selected controls from the dialog being edited
887: * (or the dialog itself, if it is selected).
888: *
889: ************************************************************************/
890:
891: VOID DeleteControl(VOID)
892: {
893: if (gfDlgSelected) {
894: if (Message(MSG_DELETEDIALOG) == IDYES)
895: /*
896: * Delete the dialog, including the resource for it.
897: */
898: DeleteDialog(TRUE);
899: }
900: else {
901: while (gnpcSel)
902: DeleteControl2(gnpcSel);
903:
904: gfDlgChanged = TRUE;
905: }
906:
907: gfResChged = TRUE;
908: ShowFileStatus(FALSE);
909: StatusUpdate();
910: StatusSetEnable();
911: }
912:
913:
914:
915: /************************************************************************
916: * DeleteControl2
917: *
918: * This deletes a control by destroying its window and removing it
919: * from the linked list of controls associated with the dialog box.
920: * The control is destroyed and the window is unlinked and the CTYPE free'd.
921: *
922: ************************************************************************/
923:
924: STATICFN VOID DeleteControl2(
925: NPCTYPE npcDel)
926: {
927: register NPCTYPE npcT;
928: register NPCTYPE *npnpcLast;
929:
930: UnSelectControl(npcDel);
931:
932: /*
933: * Search for the control, unlink it from the list and free it.
934: */
935: npcT = npcHead;
936: npnpcLast = &npcHead;
937: while (npcT) {
938: if (npcT == npcDel) {
939: *npnpcLast = npcT->npcNext;
940: FreeCTYPE(npcT);
941: cWindows--;
942: break;
943: }
944:
945: npnpcLast = &npcT->npcNext;
946: npcT = npcT->npcNext;
947: }
948: }
949:
950:
951:
952: /************************************************************************
953: * DeleteDialog
954: *
955: * This deletes the dialog box being worked on and sets globals
956: * and the Status Window appropriately. All CTYPEs are freed, the
957: * status window is updated and the dialog window is destroyed.
958: *
959: * Arguments:
960: * BOOL fResAlso - If TRUE, delete the dialog resource also.
961: *
962: ************************************************************************/
963:
964: VOID DeleteDialog(
965: BOOL fResAlso)
966: {
967: register NPCTYPE npcT;
968: register NPCTYPE npcNext;
969:
970: CancelSelection(FALSE);
971:
972: /*
973: * If they requested that the dialog resource be deleted also,
974: * do it first while some globals are still set.
975: */
976: if (fResAlso)
977: DeleteDialogResource();
978:
979: /*
980: * Hide the window for better painting speed.
981: */
982: ShowWindow(gcd.npc->hwnd, SW_HIDE);
983:
984: /*
985: * Free all the controls.
986: */
987: npcT = npcHead;
988: while (npcT) {
989: npcNext = npcT->npcNext;
990: FreeCTYPE(npcT);
991: npcT = npcNext;
992: }
993: npcHead = NULL;
994: cWindows = 0;
995:
996: /*
997: * Free the dialog itself.
998: */
999: FreeCTYPE(gcd.npc);
1000:
1001: if (gcd.pszDlgName) {
1002: MyFree(gcd.pszDlgName);
1003: gcd.pszDlgName = NULL;
1004: }
1005:
1006: if (gcd.di.pszClass) {
1007: MyFree(gcd.di.pszClass);
1008: gcd.di.pszClass = NULL;
1009: }
1010:
1011: if (gcd.di.pszMenu) {
1012: MyFree(gcd.di.pszMenu);
1013: gcd.di.pszMenu = NULL;
1014: }
1015:
1016: if (gcd.hFont) {
1017: DeleteObject(gcd.hFont);
1018: gcd.hFont = NULL;
1019: }
1020:
1021: gcd.fFontSpecified = FALSE;
1022: *gcd.di.szFontName = CHAR_NULL;
1023:
1024: /*
1025: * Set these globals back to the system font values so that
1026: * workers like WinToDUPoint will still work.
1027: */
1028: gcd.cxChar = gcxSysChar;
1029: gcd.cyChar = gcySysChar;
1030:
1031: gcd.prl = NULL;
1032:
1033: gcd.npc = NULL;
1034: gfEditingDlg = FALSE;
1035: gfDlgChanged = FALSE;
1036:
1037: ToolboxSelectTool(W_NOTHING, FALSE);
1038: StatusUpdate();
1039: StatusSetEnable();
1040: }
1041:
1042:
1043:
1044: /************************************************************************
1045: * FreeCTYPE
1046: *
1047: * This function frees an allocated CTYPE. The associated control or
1048: * dialog window is destroyed, and memory for the text and/or class
1049: * is freed, followed by freeing the actual CTYPE structure itself.
1050: *
1051: * If the hwnd in the CTYPE is NULL, only the text (if not NULL) is
1052: * assumed to be valid and will be freed, followed by the CTYPE structure
1053: * itself. This allows FreeCTYPE to be called when the CTYPE is only
1054: * partially initialized. This is a little dependant on the order that
1055: * a CTYPE is allocated and initialized in AddControl().
1056: *
1057: * Arguments:
1058: * NPCTYPE npc = The CTYPE to free.
1059: *
1060: ************************************************************************/
1061:
1062: STATICFN VOID FreeCTYPE(
1063: NPCTYPE npc)
1064: {
1065: if (npc->hwnd)
1066: DestroyWindow(npc->hwnd);
1067:
1068: if (npc->hwndDrag)
1069: DestroyWindow(npc->hwndDrag);
1070:
1071: if (npc->text)
1072: MyFree(npc->text);
1073:
1074: MyFree(npc);
1075: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.