![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to status.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 status.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: status.c
14: *
15: * Support for the Status window.
16: *
17: * Functions:
18: *
19: * StatusDlgProc()
20: * StatusApplyChanges()
21: * StatusFillSymbolList()
22: * StatusSetCoords()
23: * StatusUpdate()
24: * StatusSetEnable()
25: * StatusInit()
26: * StatusProcessCommand()
27: * ValidateNewName()
28: * ValidateNewID()
29: * ApplyNewName()
30: * ApplyNewID()
31: * ApplyNewText()
32: * StatusSetText()
33: * StatusSetTextLabels()
34: * StatusSetID()
35: * StatusSetName()
36: * StatusSetNameID()
37: * StatusClearID()
38: * StatusClearName()
39: * StatusClear()
40: * StatusShowFields()
41: *
42: * Comments:
43: *
44: ****************************************************************************/
45:
46: #include "dlgedit.h"
47: #include "dlgfuncs.h"
48: #include "dlgextrn.h"
49: #include "dialogs.h"
50:
51:
52: STATICFN BOOL StatusInit(HWND hwnd);
53: STATICFN VOID StatusProcessCommand(HWND hwnd, INT idCtrl,
54: INT NotifyCode);
55: STATICFN BOOL ValidateNewName(NPCTYPE npc, LPTSTR pszName,
56: LPTSTR pszID, LPTSTR pszSym, PINT pidNew, BOOL *pfAddLabel);
57: STATICFN BOOL ValidateNewID(NPCTYPE npc, LPTSTR pszSym, LPTSTR pszID,
58: PINT pidNew, BOOL *pfAddLabel);
59: STATICFN BOOL ApplyNewName(NPCTYPE npc, LPTSTR pszName,
60: BOOL fAddLabel, LPTSTR pszSym, INT idNew);
61: STATICFN BOOL ApplyNewID(NPCTYPE npc, INT idNew, BOOL fAddLabel,
62: LPTSTR pszSym);
63: STATICFN BOOL ApplyNewText(NPCTYPE npc, LPTSTR pszNewText);
64: STATICFN VOID StatusSetText(LPTSTR pszText, INT Type);
65: STATICFN VOID StatusSetTextLabels(INT Type, BOOL fIsOrd);
66: STATICFN VOID StatusSetID(INT id, BOOL fSymAlso);
67: STATICFN VOID StatusSetName(LPTSTR pszName, INT Type);
68: STATICFN VOID StatusSetNameID(INT id, INT Type);
69: STATICFN VOID StatusClearID(VOID);
70: STATICFN VOID StatusClearName(VOID);
71: STATICFN VOID StatusClear(VOID);
72: STATICFN VOID StatusShowFields(INT Type);
73:
74: /*
75: * TRUE if the user has changed the entry fields in the status window.
76: * This will be reset to FALSE whenever new information is placed
77: * into the fields.
78: */
79: static BOOL gfStatusChanged = FALSE;
80:
81: /*
82: * These globals save the window positions of the upper and lower
83: * combo boxes and edit controls. This is used to position them
84: * depending on what type of control is selected.
85: */
86: static RECT grcTopCombo;
87: static RECT grcBottomCombo;
88: static RECT grcTopEdit;
89: static RECT grcBottomEdit;
90:
91:
92:
93: /************************************************************************
94: * StatusDlgProc
95: *
96: * This is the dialog procedure for the Status ribbon window.
97: *
98: ************************************************************************/
99:
100: DIALOGPROC StatusDlgProc(
101: HWND hwnd,
102: UINT msg,
103: WPARAM wParam,
104: LPARAM lParam)
105: {
106: switch (msg) {
107: case WM_INITDIALOG:
108: return StatusInit(hwnd);
109:
110: case WM_PAINT:
111: {
112: HDC hdc;
113: RECT rc;
114: PAINTSTRUCT ps;
115: HPEN hpenWindowFrame;
116:
117: /*
118: * Draw our border lines.
119: */
120: GetClientRect(hwnd, &rc);
121: hdc = BeginPaint(hwnd, &ps);
122:
123: SelectObject(hdc, GetStockObject(WHITE_PEN));
124: MoveToEx(hdc, rc.left, rc.top, NULL);
125: LineTo(hdc, rc.right, rc.top);
126:
127: SelectObject(hdc, hpenDarkGray);
128: MoveToEx(hdc, rc.left, (rc.top + gcyStatus) - gcyBorder - 1, NULL);
129: LineTo(hdc, rc.right, (rc.top + gcyStatus) - gcyBorder - 1);
130:
131: hpenWindowFrame = CreatePen(PS_SOLID, gcyBorder,
132: GetSysColor(COLOR_WINDOWFRAME));
133: SelectObject(hdc, hpenWindowFrame);
134: MoveToEx(hdc, rc.left, (rc.top + gcyStatus) - gcyBorder, NULL);
135: LineTo(hdc, rc.right, (rc.top + gcyStatus) - gcyBorder);
136:
137: EndPaint(hwnd, &ps);
138: DeleteObject(hpenWindowFrame);
139: }
140:
141: break;
142:
143: case WM_CTLCOLORDLG:
144: case WM_CTLCOLORLISTBOX:
145: case WM_CTLCOLORSTATIC:
146: switch ((WORD)(msg - WM_CTLCOLORMSGBOX)) {
147: case CTLCOLOR_DLG:
148: case CTLCOLOR_LISTBOX:
149: return (BOOL)GetStockObject(LTGRAY_BRUSH);
150:
151: case CTLCOLOR_STATIC:
152: SetBkColor((HDC)(wParam),
153: LIGHTGRAY);
154: return (BOOL)GetStockObject(LTGRAY_BRUSH);
155: }
156:
157: return (BOOL)NULL;
158:
159: case WM_COMMAND:
160: StatusProcessCommand(hwnd,
161: LOWORD(wParam),
162: HIWORD(wParam));
163: break;
164:
165: default:
166: return FALSE;
167: }
168:
169: return FALSE;
170: }
171:
172:
173:
174: /************************************************************************
175: * StatusInit
176: *
177: * Initializes the Status ribbon window.
178: *
179: * Arguments:
180: * HWND hwnd = The window handle.
181: *
182: * Returns:
183: *
184: * TRUE
185: *
186: ************************************************************************/
187:
188: STATICFN BOOL StatusInit(
189: HWND hwnd)
190: {
191: /*
192: * Set this global right away. Other routines that will be called
193: * before CreateDialog returns depend on this global.
194: */
195: hwndStatus = hwnd;
196:
197: GetChildRect(GetDlgItem(hwnd, DID_STATUSSYM), &grcTopCombo);
198: GetChildRect(GetDlgItem(hwnd, DID_STATUSSYMID), &grcTopEdit);
199: GetChildRect(GetDlgItem(hwnd, DID_STATUSNAME), &grcBottomCombo);
200: GetChildRect(GetDlgItem(hwnd, DID_STATUSNAMEID), &grcBottomEdit);
201:
202: SendDlgItemMessage(hwnd, DID_STATUSSYM, EM_LIMITTEXT, CCHTEXTMAX, 0L);
203: SendDlgItemMessage(hwnd, DID_STATUSNAME, EM_LIMITTEXT, CCHTEXTMAX, 0L);
204: SendDlgItemMessage(hwnd, DID_STATUSSYMID, EM_LIMITTEXT, CCHIDMAX, 0L);
205: SendDlgItemMessage(hwnd, DID_STATUSNAMEID, EM_LIMITTEXT, CCHIDMAX, 0L);
206: SendDlgItemMessage(hwnd, DID_STATUSTEXT, EM_LIMITTEXT, CCHTEXTMAX, 0L);
207:
208: StatusFillSymbolList(plInclude);
209: StatusUpdate();
210: StatusSetEnable();
211:
212: /*
213: * Return TRUE so that the dialog manager does NOT set the focus
214: * for me. This prevents the status window from initially having
215: * the focus when the editor is started.
216: */
217: return TRUE;
218: }
219:
220:
221:
222: /************************************************************************
223: * StatusProcessCommand
224: *
225: * Function that processes commands sent to the status window.
226: *
227: * Arguments:
228: * HWND hwnd - The window handle.
229: * INT idCtrl - The id of the control the WM_COMMAND is for.
230: * INT NotifyCode - The control's notification code.
231: *
232: *
233: ************************************************************************/
234:
235: STATICFN VOID StatusProcessCommand(
236: HWND hwnd,
237: INT idCtrl,
238: INT NotifyCode)
239: {
240: TCHAR szSym[CCHTEXTMAX];
241: TCHAR szID[CCHIDMAX + 1];
242: NPLABEL npLabel;
243: INT id;
244: INT nIndex;
245: LPTSTR pszOldName;
246:
247: switch (idCtrl) {
248: case DID_STATUSSYM:
249: /*
250: * Did the symbol edit field change and is
251: * something selected?
252: */
253: if (gnpcSel && (NotifyCode == CBN_EDITCHANGE ||
254: NotifyCode == CBN_SELCHANGE)) {
255: /*
256: * Get the symbol and begin looking for it.
257: */
258: if (NotifyCode == CBN_EDITCHANGE) {
259: /*
260: * The edit field was typed into. Get the
261: * new text from there.
262: */
263: GetDlgItemText(hwnd, DID_STATUSSYM, szSym, CCHTEXTMAX);
264: }
265: else {
266: /*
267: * A new string was selected from the list
268: * box. Get it from the list box, because
269: * at this point the new text is not yet set
270: * into the edit control!
271: */
272: nIndex = (INT)SendDlgItemMessage(hwnd,
273: DID_STATUSSYM, CB_GETCURSEL, 0, 0L);
274:
275: if (nIndex != CB_ERR)
276: SendDlgItemMessage(hwnd, DID_STATUSSYM, CB_GETLBTEXT,
277: nIndex, (DWORD)szSym);
278: else
279: *szSym = CHAR_NULL;
280: }
281:
282: /*
283: * Convert the symbol field to the associated id value,
284: * taking into account the special IDOK values, etc.
285: */
286: if (!LabelToID(szSym, &id)) {
287: /*
288: * The symbol was not found.
289: * If the symbol is not blank, and the
290: * id of the control is already taken
291: * by another label, fill the id field
292: * with the next available id. Otherwise,
293: * fill the id field with the controls
294: * id value. It is assumed here that the
295: * dialog cannot be selected if the symbol
296: * field was able to be changed.
297: */
298: if (*szSym && FindID(gnpcSel->id, plInclude))
299: id = NextID(NEXTID_CONTROL, plInclude, 0);
300: else
301: id = gnpcSel->id;
302: }
303:
304: StatusSetID(id, FALSE);
305:
306: gfStatusChanged = TRUE;
307: }
308:
309: break;
310:
311: case DID_STATUSNAME:
312: /*
313: * Did the name edit field change and is
314: * something selected?
315: */
316: if (gnpcSel && (NotifyCode == CBN_EDITCHANGE ||
317: NotifyCode == CBN_SELCHANGE)) {
318: /*
319: * Get the symbol and begin looking for it.
320: */
321: if (NotifyCode == CBN_EDITCHANGE) {
322: /*
323: * The edit field was typed into. Get the
324: * new text from there.
325: */
326: GetDlgItemText(hwnd, DID_STATUSNAME, szSym, CCHTEXTMAX);
327: }
328: else {
329: /*
330: * A new string was selected from the list
331: * box. Get it from the list box, because
332: * at this point the new text is not yet set
333: * into the edit control!
334: */
335: nIndex = (INT)SendDlgItemMessage(hwnd,
336: DID_STATUSNAME, CB_GETCURSEL, 0, 0L);
337:
338: if (nIndex != CB_ERR)
339: SendDlgItemMessage(hwnd, DID_STATUSNAME, CB_GETLBTEXT,
340: nIndex, (DWORD)szSym);
341: else
342: *szSym = CHAR_NULL;
343: }
344:
345: /*
346: * Try and convert the name to an ordinal.
347: */
348: StrToNameOrd(szSym, (gnpcSel->pwcd->iType == W_DIALOG) ?
349: TRUE : FALSE);
350:
351: /*
352: * Was the name converted to an ordinal?
353: */
354: if (IsOrd(szSym)) {
355: id = OrdID(szSym);
356: }
357: /*
358: * Is it an existing label?
359: */
360: else if (npLabel = FindLabel(szSym, plInclude)) {
361: id = npLabel->id;
362: }
363: else {
364: /*
365: * Get a pointer to the original name.
366: */
367: pszOldName = (gnpcSel->pwcd->iType == W_DIALOG) ?
368: gcd.pszDlgName : gnpcSel->text;
369:
370: /*
371: * If the old name was originally an ordinal, and
372: * there was no corresponding label for it,
373: * assume that the user is trying to enter a
374: * define for it and leave it alone. Otherwise,
375: * pick the next available id. But if the user
376: * completely blanks out the field, leave it
377: * alone also (this is a benign case).
378: */
379: if (IsOrd(pszOldName) &&
380: (!*szSym || !FindID(OrdID(pszOldName), plInclude)))
381: id = OrdID(pszOldName);
382: else
383: id = NextID((gnpcSel->pwcd->iType == W_DIALOG) ?
384: NEXTID_DIALOG : NEXTID_CONTROL, plInclude, 0);
385: }
386:
387: StatusSetNameID(id, gnpcSel->pwcd->iType);
388:
389: /*
390: * Change the labels to reflect that the entered name
391: * is an ID instead of a name.
392: */
393: StatusSetTextLabels(gnpcSel->pwcd->iType, TRUE);
394:
395: gfStatusChanged = TRUE;
396: }
397:
398: break;
399:
400: case DID_STATUSSYMID:
401: case DID_STATUSNAMEID:
402: case DID_STATUSTEXT:
403: if (!gnpcSel)
404: break;
405:
406: if (NotifyCode == EN_CHANGE)
407: gfStatusChanged = TRUE;
408:
409: if (idCtrl == DID_STATUSNAMEID) {
410: GetDlgItemText(hwnd, DID_STATUSNAME, szSym, CCHTEXTMAX);
411: GetDlgItemText(hwnd, DID_STATUSNAMEID, szID, CCHIDMAX + 1);
412: StrToNameOrd(szSym, (gnpcSel->pwcd->iType == W_DIALOG) ?
413: TRUE : FALSE);
414:
415: /*
416: * Change the labels to reflect whether the entered name
417: * is an ID or a name. It is considered an id if the
418: * edit field has something in it, or if the name field
419: * is a valid label, or if the name field represents an
420: * ordinal (it is numeric).
421: */
422: StatusSetTextLabels(gnpcSel->pwcd->iType,
423: (IsOrd(szSym) || *szID ||
424: FindLabel(szSym, plInclude)) ? TRUE : FALSE);
425: }
426:
427: break;
428:
429: case IDOK:
430: if (StatusApplyChanges())
431: SetFocus(ghwndMain);
432:
433: break;
434:
435: case IDCANCEL:
436: StatusUpdate();
437: SetFocus(ghwndMain);
438: break;
439: }
440: }
441:
442:
443:
444: /************************************************************************
445: * StatusApplyChanges
446: *
447: * Processes the Enter command from the "Status" bar window to apply
448: * the current value of the fields to the current control.
449: *
450: * Returns:
451: *
452: * TRUE is successful; otherwise, FALSE is returned.
453: *
454: ************************************************************************/
455:
456: BOOL StatusApplyChanges(VOID)
457: {
458: TCHAR szText[CCHTEXTMAX];
459: TCHAR szSym[CCHTEXTMAX];
460: TCHAR szName[CCHTEXTMAX];
461: TCHAR szSymID[CCHIDMAX + 1];
462: TCHAR szNameID[CCHIDMAX + 1];
463: TCHAR szNameSym[CCHTEXTMAX];
464: INT idSymNew;
465: INT idNameNew;
466: BOOL fAddSymLabel;
467: BOOL fAddNameLabel;
468: BOOL fSuccess = FALSE;
469:
470: /*
471: * Quit if nothing is selected, or if nothing was changed.
472: */
473: if (!gnpcSel || !gfStatusChanged)
474: return TRUE;
475:
476: idSymNew = gnpcSel->id;
477:
478: switch (gnpcSel->pwcd->iType) {
479: case W_DIALOG:
480: GetDlgItemText(hwndStatus, DID_STATUSNAME, szName, CCHTEXTMAX);
481: GetDlgItemText(hwndStatus, DID_STATUSNAMEID, szNameID, CCHIDMAX + 1);
482: GetDlgItemText(hwndStatus, DID_STATUSTEXT, szText, CCHTEXTMAX);
483: if (!ValidateNewName(gnpcSel, szName, szNameID, szNameSym,
484: &idNameNew, &fAddNameLabel))
485: return FALSE;
486:
487: if (ApplyNewName(gnpcSel, szName, fAddNameLabel,
488: szNameSym, idNameNew) &&
489: ApplyNewText(gnpcSel, szText))
490: fSuccess = TRUE;
491:
492: break;
493:
494: case W_ICON:
495: GetDlgItemText(hwndStatus, DID_STATUSNAME, szName, CCHTEXTMAX);
496: GetDlgItemText(hwndStatus, DID_STATUSNAMEID, szNameID, CCHIDMAX + 1);
497: GetDlgItemText(hwndStatus, DID_STATUSSYM, szSym, CCHTEXTMAX);
498: GetDlgItemText(hwndStatus, DID_STATUSSYMID, szSymID, CCHIDMAX + 1);
499: if (!ValidateNewName(gnpcSel, szName, szNameID, szNameSym,
500: &idNameNew, &fAddNameLabel) ||
501: !ValidateNewID(gnpcSel, szSym, szSymID,
502: &idSymNew, &fAddSymLabel))
503: return FALSE;
504:
505: if (ApplyNewID(gnpcSel, idSymNew, fAddSymLabel, szSym) &&
506: ApplyNewName(gnpcSel, szName, fAddNameLabel,
507: szNameSym, idNameNew))
508: fSuccess = TRUE;
509:
510: break;
511:
512: default:
513: GetDlgItemText(hwndStatus, DID_STATUSSYM, szSym, CCHTEXTMAX);
514: GetDlgItemText(hwndStatus, DID_STATUSSYMID, szSymID, CCHIDMAX + 1);
515: GetDlgItemText(hwndStatus, DID_STATUSTEXT, szText, CCHTEXTMAX);
516: if (!ValidateNewID(gnpcSel, szSym, szSymID, &idSymNew, &fAddSymLabel))
517: return FALSE;
518:
519: if (ApplyNewID(gnpcSel, idSymNew, fAddSymLabel, szSym) &&
520: ApplyNewText(gnpcSel, szText))
521: fSuccess = TRUE;
522:
523: break;
524: }
525:
526: if (fSuccess) {
527: ShowFileStatus(FALSE);
528: StatusUpdate();
529: }
530:
531: return fSuccess;
532: }
533:
534:
535:
536: /************************************************************************
537: * ValidateNewName
538: *
539: * Validates the new name from the processing of the OK command
540: * from the Status ribbon window.
541: *
542: * The name is considered valid if it does not have any blanks in it,
543: * it is not already used by another dialog in the resource file, and
544: * it is not an empty string.
545: *
546: * Arguments:
547: * NPCTYPE npc - Pointer to the control.
548: * LPTSTR pszName - The new name.
549: * LPTSTR pszID - The ID.
550: * LPTSTR pszSym - The symbol.
551: * PINT pidNew - Where to return the new ID if successful.
552: * BOOL *pfAddLabel - Set to TRUE if this symbol/id should be added
553: * to the include list. Not touched otherwise.
554: *
555: * Returns:
556: * TRUE if the new name is valid, FALSE otherwise.
557: *
558: ************************************************************************/
559:
560: STATICFN BOOL ValidateNewName(
561: NPCTYPE npc,
562: LPTSTR pszName,
563: LPTSTR pszID,
564: LPTSTR pszSym,
565: PINT pidNew,
566: BOOL *pfAddLabel)
567: {
568: NPLABEL npLabel;
569: BOOL fIDEmpty = FALSE;
570: BOOL fNameEmpty = FALSE;
571: BOOL fAddLabel = FALSE;
572: INT idNew;
573: TCHAR szIDTemp[CCHIDMAX + 1];
574:
575: /*
576: * Start by assuming that the label will NOT be added.
577: */
578: *pfAddLabel = FALSE;
579:
580: /*
581: * Is the ID field non-blank?
582: */
583: if (*pszID) {
584: /*
585: * Is the id valid?
586: */
587: if (!IsValue(pszID)) {
588: Message(MSG_BADSYMBOLID);
589: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAMEID));
590: return FALSE;
591: }
592:
593: idNew = valtoi(pszID);
594: }
595: else {
596: /*
597: * The id field is blank.
598: */
599: fIDEmpty = TRUE;
600: }
601:
602: /*
603: * Is the name field blank?
604: */
605: if (!(*pszName))
606: fNameEmpty = TRUE;
607:
608: if (fNameEmpty) {
609: if (fIDEmpty) {
610: Message((npc->pwcd->iType == W_DIALOG) ?
611: MSG_NODLGNAME : MSG_NOICONNAME);
612: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAME));
613: return FALSE;
614: }
615: else {
616: WriteOrd((PORDINAL)pszName, idNew);
617: }
618: }
619: else {
620: /*
621: * Error if there are imbedded blanks.
622: */
623: if (HasBlanks(pszName)) {
624: Message((npc->pwcd->iType == W_DIALOG) ?
625: MSG_DLGNAMEHASBLANKS : MSG_ICONNAMEHASBLANKS);
626: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAME));
627: return FALSE;
628: }
629:
630: /*
631: * Convert the name to an ordinal, if appropriate.
632: */
633: StrToNameOrd(pszName, (npc->pwcd->iType == W_DIALOG) ? TRUE : FALSE);
634:
635: /*
636: * If the name was translated to an ordinal, we are done.
637: * Otherwise, keep trying to figure out whether it is a
638: * name or a define.
639: */
640: if (!IsOrd(pszName)) {
641: /*
642: * Is the name a symbol in the current include list?
643: */
644: if (npLabel = FindLabel(pszName, plInclude)) {
645: /*
646: * Yes. If the id field was blank, just assume they
647: * wanted the corresponding id.
648: */
649: if (fIDEmpty)
650: idNew = npLabel->id;
651:
652: /*
653: * If they somehow entered a valid define but tried to
654: * give it a different id value, show an error.
655: */
656: if (npLabel->id != idNew) {
657: Myitoa(npLabel->id, szIDTemp);
658: Message(MSG_IDSYMMISMATCH, szIDTemp);
659: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAMEID));
660: return FALSE;
661: }
662:
663: /*
664: * Make the name field into an ordinal.
665: */
666: WriteOrd((PORDINAL)pszName, idNew);
667: }
668: else {
669: /*
670: * The name was not found as a label. Is the id field
671: * empty?
672: */
673: if (fIDEmpty) {
674: /*
675: * Since the id field is empty, we can assume that
676: * what they entered is a name (not a define)
677: * and we are done.
678: */
679: }
680: else {
681: /*
682: * At this point we know the name field is not empty,
683: * and there is an id entered along with it. We also
684: * know that the name (which we can now assume is
685: * a symbol) is not already found in the include file.
686: * We will check it for validity, copy it to the
687: * pszSym buffer, translate the name to an ordinal
688: * and set a flag saying that the sym/id pair should
689: * be added to the include list.
690: */
691: if (!IsSymbol(pszName)) {
692: Message(MSG_BADSYMBOLID);
693: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAME));
694: return FALSE;
695: }
696:
697: /*
698: * Pass back the values.
699: */
700: lstrcpy(pszSym, pszName);
701: WriteOrd((PORDINAL)pszName, idNew);
702: *pidNew = idNew;
703:
704: fAddLabel = TRUE;
705: }
706: }
707: }
708: }
709:
710: /*
711: * Inform caller whether they should add this id/symbol
712: * as a label to the include list.
713: */
714: *pfAddLabel = fAddLabel;
715:
716: /*
717: * Return success.
718: */
719: return TRUE;
720: }
721:
722:
723:
724: /************************************************************************
725: * ValidateNewID
726: *
727: * Validates the new ID from the processing of the OK command from
728: * the Status ribbon window. It will return the new id in *pidNew.
729: * Note that the control is not actually updated by this routine. This
730: * is so that if other validations fail nothing will have been done to the
731: * control. It is assumed that ApplyNewID will be called later to do
732: * the actual update of the control.
733: *
734: * Arguments:
735: * NPCTYPE npc = Pointer to the control.
736: * LPTSTR pszSym = The symbol.
737: * LPTSTR pszID = The ID.
738: * PINT pidNew = Where to return the new ID if successful.
739: * BOOL *pfAddLabel = Set to TRUE if this symbol/id should be added
740: * to the include list. Not touched otherwise.
741: *
742: * Returns:
743: * TRUE if successful, FALSE otherwise. If TRUE is returned and they
744: * changed the id, the new id will have been placed in *pidNew.
745: *
746: ************************************************************************/
747:
748: STATICFN BOOL ValidateNewID(
749: NPCTYPE npc,
750: LPTSTR pszSym,
751: LPTSTR pszID,
752: PINT pidNew,
753: BOOL *pfAddLabel)
754: {
755: NPLABEL npLabel;
756: BOOL fIDEmpty = FALSE;
757: BOOL fIDChanged = FALSE;
758: BOOL fSymEmpty = FALSE;
759: BOOL fSymChanged = FALSE;
760: BOOL fAddLabel = FALSE;
761: INT idNew;
762: TCHAR szIDTemp[CCHIDMAX + 1];
763:
764: /*
765: * Start by assuming that the label will NOT be added.
766: */
767: *pfAddLabel = FALSE;
768:
769: /*
770: * If in translate mode, they cannot change the symbol or id,
771: * and so it should not be validated. Even if there was a
772: * problem, they could not fix it.
773: */
774: if (gfTranslateMode)
775: return TRUE;
776:
777: /*
778: * Special case if they selected the "unused" label.
779: * Blank out the symbol so it doesn't cause trouble
780: * later, force the id to be zero, and then check if
781: * the id was changed.
782: */
783: if (lstrcmp(pszSym, ids(IDS_UNUSED)) == 0) {
784: pszSym = szEmpty;
785: idNew = IDUNUSED;
786: if (idNew != npc->id)
787: fIDChanged = TRUE;
788: }
789: else if (lstrcmp(pszSym, ids(IDS_IDOK)) == 0 &&
790: !FindLabel(ids(IDS_IDOK), plInclude)) {
791: pszSym = szEmpty;
792: idNew = IDOK;
793: if (idNew != npc->id)
794: fIDChanged = TRUE;
795: }
796: else if (lstrcmp(pszSym, ids(IDS_IDCANCEL)) == 0 &&
797: !FindLabel(ids(IDS_IDCANCEL), plInclude)) {
798: pszSym = szEmpty;
799: idNew = IDCANCEL;
800: if (idNew != npc->id)
801: fIDChanged = TRUE;
802: }
803: /*
804: * Is the ID field non-blank?
805: */
806: else if (*pszID) {
807: /*
808: * Is the id valid?
809: */
810: if (!IsValue(pszID)) {
811: Message(MSG_BADSYMBOLID);
812: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYMID));
813: return FALSE;
814: }
815:
816: /*
817: * Did they change the id value?
818: */
819: idNew = valtoi(pszID);
820: if (idNew != npc->id)
821: fIDChanged = TRUE;
822: }
823: else {
824: /*
825: * The id field is blank. This implies they changed it.
826: */
827: fIDEmpty = TRUE;
828: fIDChanged = TRUE;
829: }
830:
831: /*
832: * Is the symbol field blank?
833: */
834: if (!(*pszSym))
835: fSymEmpty = TRUE;
836:
837: /*
838: * Determine if they have changed the symbol.
839: * Did the original id have a symbol associated with it?
840: */
841: if (npLabel = FindID(npc->id, plInclude)) {
842: if (lstrcmp(npLabel->pszLabel, pszSym) != 0)
843: fSymChanged = TRUE;
844: }
845: else {
846: /*
847: * Since the original id did not have a symbol, if they
848: * have entered a symbol it is changed.
849: */
850: if (!fSymEmpty)
851: fSymChanged = TRUE;
852: }
853:
854: /*
855: * Quit if nothing changed.
856: */
857: if (!fSymChanged && !fIDChanged)
858: return TRUE;
859:
860: /*
861: * Is the symbol field empty?
862: */
863: if (fSymEmpty) {
864: /*
865: * If the id field is empty also, return an error.
866: */
867: if (fIDEmpty) {
868: Message(MSG_BADSYMBOLID);
869: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYMID));
870: return FALSE;
871: }
872: else {
873: /*
874: * Otherwise, go on to the final test. It doesn't matter
875: * if this new id has a symbol or not.
876: */
877: goto CheckForDups;
878: }
879: }
880:
881: /*
882: * At this point we know the symbol field is not empty.
883: * Is it a valid symbol?
884: */
885: if (!IsSymbol(pszSym)) {
886: Message(MSG_BADSYMBOLID);
887: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYM));
888: return FALSE;
889: }
890:
891: /*
892: * Does this symbol already exist?
893: */
894: if (npLabel = FindLabel(pszSym, plInclude)) {
895: /*
896: * Since the symbol exists, if they blanked the id field
897: * be friendly and assume they want the matching id value.
898: */
899: if (fIDEmpty)
900: idNew = npLabel->id;
901:
902: /*
903: * Does the id that is in the id field match the id of the
904: * symbol they entered?
905: */
906: if (npLabel->id == idNew) {
907: /*
908: * Yes, go on to the final test.
909: */
910: goto CheckForDups;
911: }
912: else {
913: /*
914: * No, give them an error message saying that it has to.
915: */
916: Myitoa(npLabel->id, szIDTemp);
917: Message(MSG_IDSYMMISMATCH, szIDTemp);
918: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYMID));
919: return FALSE;
920: }
921: }
922: else {
923: /*
924: * Since the symbol doesn't exist, if they left the id field
925: * blank, assume they want the next available id.
926: */
927: if (fIDEmpty)
928: idNew = NextID(NEXTID_CONTROL, plInclude, 0);
929:
930: /*
931: * They should add this id/symbol as a label to the
932: * include list.
933: */
934: fAddLabel = TRUE;
935: goto CheckForDups;
936: }
937:
938: CheckForDups:
939: /*
940: * If the id changed, it is not the special "unused" id,
941: * and it is a duplicate of another id, don't allow it.
942: */
943: if (idNew != npc->id && !IsUniqueID(idNew)) {
944: Message(MSG_CTRLDUPID);
945: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYM));
946: return FALSE;
947: }
948: else {
949: /*
950: * Pass back the new id value.
951: */
952: *pidNew = idNew;
953:
954: /*
955: * Inform caller whether they should add this id/symbol
956: * as a label to the include list.
957: */
958: *pfAddLabel = fAddLabel;
959:
960: /*
961: * Return success.
962: */
963: return TRUE;
964: }
965: }
966:
967:
968:
969: /************************************************************************
970: * ApplyNewName
971: *
972: * Updates an icon control's or dialog's name with a new name.
973: *
974: * If fAddLabel is TRUE, pszSym is assumed to be a string that is
975: * the symbol to be added and idNew contains the value associated with
976: * it. This will cause a new define to be added to the current include
977: * file. In either event, pszName will contain either a new name or
978: * an ordinal that is to be the name. For dialogs, the dialog name will
979: * be updated. For icon controls, the icon's text is updated with the
980: * name/ordinal.
981: *
982: * Arguments:
983: * NPCTYPE npc = Pointer to the control.
984: * LPTSTR pszName = New name. A string or ordinal.
985: * BOOL fAddLabel = TRUE if a new label for this id/name should be added.
986: * LPTSTR pszSym = The new symbol to add (only valid if fAddLabel is TRUE).
987: * INT idNew = The new ID (only valid if fAddLabel is TRUE).
988: *
989: * Returns:
990: *
991: * TRUE if successful; otherwise, FALSE is returned.
992: *
993: ************************************************************************/
994:
995: STATICFN BOOL ApplyNewName(
996: NPCTYPE npc,
997: LPTSTR pszName,
998: BOOL fAddLabel,
999: LPTSTR pszSym,
1000: INT idNew)
1001: {
1002: LPTSTR psz;
1003:
1004: if (fAddLabel) {
1005: /*
1006: * Go ahead and quietly add the label for them.
1007: */
1008: if (AddLabel(pszSym, idNew, FPOS_MAX, 0, &plInclude,
1009: &plDelInclude, NULL, NULL)) {
1010: /*
1011: * Return the controls new id, update the status
1012: * windows symbol combo box, mark the fact that
1013: * we have changed the include file, and return
1014: * success.
1015: */
1016: gfIncChged = TRUE;
1017: StatusFillSymbolList(plInclude);
1018: }
1019: else {
1020: /*
1021: * An error occurred on the AddLabel. The most likely
1022: * cause of this is if they are trying to add a symbol
1023: * with a duplicate id.
1024: */
1025: SetFocus(GetDlgItem(hwndStatus, DID_STATUSNAMEID));
1026: return FALSE;
1027: }
1028: }
1029:
1030: switch (npc->pwcd->iType) {
1031: case W_ICON:
1032: /*
1033: * The resource name for an icon is stored in it's text.
1034: */
1035: ApplyNewText(npc, pszName);
1036: break;
1037:
1038: case W_DIALOG:
1039: /*
1040: * We are done if the name was not changed.
1041: */
1042: if (NameOrdCmp(gcd.pszDlgName, pszName) == 0)
1043: break;
1044:
1045: /*
1046: * Allocate room for the new name (it can be an ordinal!).
1047: */
1048: if (!(psz = MyAlloc(NameOrdLen(pszName))))
1049: return FALSE;
1050:
1051: NameOrdCpy(psz, pszName);
1052:
1053: if (gcd.pszDlgName)
1054: MyFree(gcd.pszDlgName);
1055:
1056: gcd.pszDlgName = psz;
1057:
1058: /*
1059: * If the new name is an ordinal, update the base id of
1060: * the dialog with it.
1061: */
1062: if (IsOrd(gcd.pszDlgName))
1063: gcd.npc->id = OrdID(gcd.pszDlgName);
1064:
1065: /*
1066: * Finally, set the "changed" flag.
1067: */
1068: gfResChged = gfDlgChanged = TRUE;
1069:
1070: break;
1071: }
1072:
1073: return TRUE;
1074: }
1075:
1076:
1077:
1078: /************************************************************************
1079: * ApplyNewID
1080: *
1081: * Updates the control with the new id.
1082: *
1083: * Arguments:
1084: * NPCTYPE npc = Pointer to the control.
1085: * INT idNew = The ID.
1086: * BOOL fAddLabel = TRUE if a new label for this id/symbol should be added.
1087: * LPTSTR pszSym = Symbol to add if fAddLabel is TRUE.
1088: *
1089: * Returns:
1090: *
1091: * TRUE if successful; otherwise, FALSE is returned.
1092: *
1093: ************************************************************************/
1094:
1095: STATICFN BOOL ApplyNewID(
1096: NPCTYPE npc,
1097: INT idNew,
1098: BOOL fAddLabel,
1099: LPTSTR pszSym)
1100: {
1101: if (fAddLabel) {
1102: /*
1103: * Go ahead and quietly add the label for them.
1104: */
1105: if (AddLabel(pszSym, idNew, FPOS_MAX, 0, &plInclude,
1106: &plDelInclude, NULL, NULL)) {
1107: /*
1108: * Return the controls new id, update the status
1109: * windows symbol combo box, mark the fact that
1110: * we have changed the include file, and return
1111: * success.
1112: */
1113: gfIncChged = TRUE;
1114: StatusFillSymbolList(plInclude);
1115: }
1116: else {
1117: /*
1118: * An error occurred on the AddLabel. The most likely
1119: * cause of this is if they are trying to add a symbol
1120: * with a duplicate id.
1121: */
1122: SetFocus(GetDlgItem(hwndStatus, DID_STATUSSYMID));
1123: return FALSE;
1124: }
1125: }
1126:
1127: /*
1128: * Return if the id wasn't changed.
1129: */
1130: if (npc->id == idNew)
1131: return TRUE;
1132:
1133: /*
1134: * Update the controls id and set the resource changed flag.
1135: */
1136: npc->id = idNew;
1137: gfResChged = gfDlgChanged = TRUE;
1138: return TRUE;
1139: }
1140:
1141:
1142:
1143: /************************************************************************
1144: * ApplyNewText
1145: *
1146: * Sets the new text from the processing of the OK command from
1147: * the Status ribbon window. If the text was changed, the selected
1148: * control will have its text updated.
1149: *
1150: * Arguments:
1151: * NPCTYPE npc = Pointer to the control.
1152: * LPTSTR pszNewText = The new text.
1153: *
1154: * Returns:
1155: *
1156: * TRUE if successful, FALSE otherwise.
1157: *
1158: ************************************************************************/
1159:
1160: STATICFN BOOL ApplyNewText(
1161: NPCTYPE npc,
1162: LPTSTR pszNewText)
1163: {
1164: INT cb;
1165: LPTSTR psz;
1166:
1167: /*
1168: * Did the text change?
1169: */
1170: if ((npc->text == NULL && *pszNewText) ||
1171: (npc->text != NULL && NameOrdCmp(npc->text, pszNewText) != 0)) {
1172: if (*pszNewText) {
1173: cb = NameOrdLen(pszNewText);
1174:
1175: if (npc->text == NULL)
1176: psz = MyAlloc(cb);
1177: else
1178: psz = MyRealloc(npc->text, cb);
1179:
1180: if (psz == NULL) {
1181: return FALSE;
1182: }
1183: else {
1184: NameOrdCpy(psz, pszNewText);
1185: npc->text = psz;
1186: }
1187: }
1188: else {
1189: if (npc->text) {
1190: MyFree(npc->text);
1191: npc->text = NULL;
1192: }
1193: }
1194:
1195: /*
1196: * Change the text of the control, except for W_ICON controls
1197: * because they have resource names. In that case, we don't
1198: * want to change the text of the actual control because
1199: * the resource would probably not be found.
1200: */
1201: if (npc->pwcd->iType != W_ICON) {
1202: SetWindowText(npc->hwnd, pszNewText);
1203:
1204: /*
1205: * Redraw the control after the text changed. This is
1206: * necessary because changing the text probably caused
1207: * the drag handles to get overwritten.
1208: */
1209: if (npc->pwcd->iType == W_DIALOG)
1210: /*
1211: * Redraw the frame, which just overwrote the drag
1212: * handles when the text was changed.
1213: */
1214: SetWindowPos(npc->hwnd, NULL, 0, 0, 0, 0,
1215: SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOMOVE |
1216: SWP_NOSIZE | SWP_NOZORDER);
1217: else
1218: /*
1219: * Redraw the control(s).
1220: */
1221: RedrawSelection();
1222: }
1223:
1224: gfResChged = gfDlgChanged = TRUE;
1225: }
1226:
1227: return TRUE;
1228: }
1229:
1230:
1231:
1232: /************************************************************************
1233: * StatusFillSymbolList
1234: *
1235: * This function fills the Symbol and Name combo boxes with
1236: * the given list of labels.
1237: *
1238: * Arguments:
1239: * NPLABEL plHead - pointer to the list of labels.
1240: *
1241: ************************************************************************/
1242:
1243: VOID StatusFillSymbolList(
1244: NPLABEL plHead)
1245: {
1246: NPLABEL npLabel;
1247: HWND hwndSymCB;
1248: HWND hwndNameCB;
1249: HCURSOR hcurSave;
1250:
1251: hcurSave = SetCursor(hcurWait);
1252:
1253: /*
1254: * Get the handles to the combo boxes and clear out all items.
1255: */
1256: hwndSymCB = GetDlgItem(hwndStatus, DID_STATUSSYM);
1257: hwndNameCB = GetDlgItem(hwndStatus, DID_STATUSNAME);
1258: SendMessage(hwndSymCB, CB_RESETCONTENT, 0, 0L);
1259: SendMessage(hwndNameCB, CB_RESETCONTENT, 0, 0L);
1260:
1261: /*
1262: * Fill the combo boxes with the items.
1263: */
1264: for (npLabel = plHead; npLabel; npLabel = npLabel->npNext) {
1265: SendMessage(hwndSymCB, CB_ADDSTRING, 0, (DWORD)npLabel->pszLabel);
1266: SendMessage(hwndNameCB, CB_ADDSTRING, 0, (DWORD)npLabel->pszLabel);
1267: }
1268:
1269: /*
1270: * Put some special entries into the symbol combo. Note that we allow
1271: * the user to have defined IDOK and IDCANCEL to be something else,
1272: * in which case we will NOT add these special entries after all.
1273: */
1274: SendMessage(hwndSymCB, CB_ADDSTRING, 0, (DWORD)ids(IDS_UNUSED));
1275:
1276: if (!FindLabel(ids(IDS_IDOK), plInclude))
1277: SendMessage(hwndSymCB, CB_ADDSTRING, 0, (DWORD)ids(IDS_IDOK));
1278:
1279: if (!FindLabel(ids(IDS_IDCANCEL), plInclude))
1280: SendMessage(hwndSymCB, CB_ADDSTRING, 0, (DWORD)ids(IDS_IDCANCEL));
1281:
1282: SetCursor(hcurSave);
1283: }
1284:
1285:
1286:
1287: /************************************************************************
1288: * StatusSetCoords
1289: *
1290: * This function sets the coordinates in the status display
1291: * to the given rectangle.
1292: *
1293: * Arguments:
1294: * PRECT prc - coordinates.
1295: *
1296: ************************************************************************/
1297:
1298: VOID StatusSetCoords(
1299: PRECT prc)
1300: {
1301: static INT xSave = 0x7FFF;
1302: static INT ySave = 0x7FFF;
1303: static INT cxSave = 0x7FFF;
1304: static INT cySave = 0x7FFF;
1305: static INT x2Save = 0x7FFF;
1306: static INT y2Save = 0x7FFF;
1307: TCHAR szBuf[CCHTEXTMAX];
1308:
1309: if (prc) {
1310: if (prc->bottom - prc->top != cySave) {
1311: /*
1312: * Save it for the next time.
1313: */
1314: cySave = prc->bottom - prc->top;
1315:
1316: wsprintf(szBuf, ids(IDS_CYFMTSTR), cySave);
1317: SetDlgItemText(hwndStatus, DID_STATUSCY, szBuf);
1318: }
1319:
1320: if (prc->right != x2Save || prc->bottom != y2Save) {
1321: /*
1322: * Save them for the next time.
1323: */
1324: x2Save = prc->right;
1325: y2Save = prc->bottom;
1326:
1327: wsprintf(szBuf, L"(%d, %d)", x2Save, y2Save);
1328: SetDlgItemText(hwndStatus, DID_STATUSX2Y2, szBuf);
1329: }
1330:
1331: if (prc->left != xSave || prc->top != ySave) {
1332: /*
1333: * Save them for the next time.
1334: */
1335: xSave = prc->left;
1336: ySave = prc->top;
1337:
1338: wsprintf(szBuf, L"(%d, %d)", xSave, ySave);
1339: SetDlgItemText(hwndStatus, DID_STATUSXY, szBuf);
1340: }
1341:
1342: if (prc->right - prc->left != cxSave) {
1343: /*
1344: * Save it for the next time.
1345: */
1346: cxSave = prc->right - prc->left;
1347:
1348: wsprintf(szBuf, ids(IDS_CXFMTSTR), cxSave);
1349: SetDlgItemText(hwndStatus, DID_STATUSCX, szBuf);
1350: }
1351: }
1352: else {
1353: /*
1354: * Clear the fields.
1355: */
1356: SetDlgItemText(hwndStatus, DID_STATUSXY, szEmpty);
1357: SetDlgItemText(hwndStatus, DID_STATUSX2Y2, szEmpty);
1358: SetDlgItemText(hwndStatus, DID_STATUSCX, szEmpty);
1359: SetDlgItemText(hwndStatus, DID_STATUSCY, szEmpty);
1360:
1361: /*
1362: * Reset the cache variables so that the next "set" of
1363: * the coords is sure to update the display fields.
1364: */
1365: xSave =
1366: ySave =
1367: cxSave =
1368: cySave =
1369: x2Save =
1370: y2Save = 0x7FFF;
1371: }
1372: }
1373:
1374:
1375:
1376: /************************************************************************
1377: * StatusSetText
1378: *
1379: * This function sets the "Text" field in the status display
1380: * to the given text.
1381: *
1382: * Arguments:
1383: * LPTSTR pszText - The text to display. This can be NULL.
1384: * INT Type - Type of control. One of the W_* constants.
1385: *
1386: ************************************************************************/
1387:
1388: STATICFN VOID StatusSetText(
1389: LPTSTR pszText,
1390: INT Type)
1391: {
1392: /*
1393: * Protect against getting a null value.
1394: */
1395: if (!pszText)
1396: pszText = szEmpty;
1397:
1398: /*
1399: * If this is an icon control, set the name instead (the text
1400: * of an icon is really a resource name).
1401: */
1402: if (Type == W_ICON)
1403: StatusSetName(pszText, Type);
1404: else
1405: SetDlgItemText(hwndStatus, DID_STATUSTEXT, pszText);
1406: }
1407:
1408:
1409:
1410: /************************************************************************
1411: * StatusSetTextLabels
1412: *
1413: * This function sets the labels of the descriptive text fields in
1414: * Status window based on the type of control that is selected.
1415: *
1416: * Arguments:
1417: * INT Type - Type of control. One of the W_* constants.
1418: * BOOL fIsOrd - TRUE if the name is an ordinal. This is ignored
1419: * unless Type is W_DIALOG or W_ICON.
1420: *
1421: ************************************************************************/
1422:
1423: STATICFN VOID StatusSetTextLabels(
1424: INT Type,
1425: BOOL fIsOrd)
1426: {
1427: WORD ids1;
1428: WORD ids2;
1429:
1430: switch (Type) {
1431: case W_DIALOG:
1432: ids1 = (WORD)(fIsOrd ? IDS_DLGIDLABEL : IDS_DLGNAMELABEL);
1433: ids2 = IDS_CAPTIONLABEL;
1434: break;
1435:
1436: case W_ICON:
1437: ids1 = IDS_SYMBOLLABEL;
1438: ids2 = (WORD)(fIsOrd ? IDS_ICONIDLABEL : IDS_ICONNAMELABEL);
1439: break;
1440:
1441: default:
1442: ids1 = IDS_SYMBOLLABEL;
1443: ids2 = IDS_TEXTLABEL;
1444: break;
1445: }
1446:
1447: SetDlgItemText(hwndStatus, DID_STATUSLABEL1, ids(ids1));
1448: SetDlgItemText(hwndStatus, DID_STATUSLABEL2, ids(ids2));
1449: }
1450:
1451:
1452:
1453: /************************************************************************
1454: * StatusSetID
1455: *
1456: * Updates the id field of the given label.
1457: *
1458: * Arguments:
1459: * INT id = The id.
1460: * BOOL fSymAlso = Find the corresponding label and update the
1461: * symbol field also.
1462: *
1463: ************************************************************************/
1464:
1465: STATICFN VOID StatusSetID(
1466: INT id,
1467: BOOL fSymAlso)
1468: {
1469: TCHAR szValue[CCHIDMAX + 1];
1470: NPLABEL npLabel;
1471: LPTSTR pszLabel;
1472:
1473: Myitoa(id, szValue);
1474: SetDlgItemText(hwndStatus, DID_STATUSSYMID, szValue);
1475:
1476: if (fSymAlso) {
1477: /*
1478: * If a matching label is found, the text is used.
1479: * Otherwise, if the id is zero, we use the "unused"
1480: * label. Otherwise, we just use an empty string.
1481: */
1482: if (npLabel = FindID(id, plInclude))
1483: pszLabel = npLabel->pszLabel;
1484: else if (id == IDUNUSED)
1485: pszLabel = ids(IDS_UNUSED);
1486: else if (id == IDOK && !FindLabel(ids(IDS_IDOK), plInclude))
1487: pszLabel = ids(IDS_IDOK);
1488: else if (id == IDCANCEL && !FindLabel(ids(IDS_IDCANCEL), plInclude))
1489: pszLabel = ids(IDS_IDCANCEL);
1490: else
1491: pszLabel = szEmpty;
1492:
1493: SetDlgItemText(hwndStatus, DID_STATUSSYM, pszLabel);
1494: }
1495: }
1496:
1497:
1498:
1499: /************************************************************************
1500: * StatusSetName
1501: *
1502: * This function sets the "Res. Name" field in the status display
1503: * to the given text.
1504: *
1505: * Arguments:
1506: *
1507: * LPTSTR pszName - The name to display. NULL values and ordinals
1508: * are handled properly.
1509: * INT Type - Type of control. One of the W_* constants.
1510: *
1511: ************************************************************************/
1512:
1513: STATICFN VOID StatusSetName(
1514: LPTSTR pszName,
1515: INT Type)
1516: {
1517: NPLABEL npLabel;
1518:
1519: /*
1520: * Protect against getting a null value.
1521: */
1522: if (!pszName)
1523: pszName = szEmpty;
1524:
1525: /*
1526: * Does the name represent an ordinal? If so, set the nameid
1527: * field to the value and fill in the name field with the
1528: * associated symbol, if there is one.
1529: *
1530: * Note that this does NOT produce a hex value in Hex Mode for
1531: * dialog names, because rc.exe does not parse hex ordinals
1532: * for dialog names.
1533: */
1534: if (IsOrd(pszName)) {
1535: StatusSetNameID(OrdID(pszName), Type);
1536:
1537: if (npLabel = FindID(OrdID(pszName), plInclude))
1538: pszName = npLabel->pszLabel;
1539: else
1540: pszName = szEmpty;
1541: }
1542: else {
1543: SetDlgItemText(hwndStatus, DID_STATUSNAMEID, szEmpty);
1544: }
1545:
1546: SetDlgItemText(hwndStatus, DID_STATUSNAME, pszName);
1547: }
1548:
1549:
1550:
1551: /************************************************************************
1552: * StatusSetNameID
1553: *
1554: * This function sets the id edit field associated with the
1555: * "Res. Name" field in the status display
1556: *
1557: * Arguments:
1558: *
1559: * INT id - The id to set into the field.
1560: * INT Type - Type of control. One of the W_* constants.
1561: *
1562: ************************************************************************/
1563:
1564: STATICFN VOID StatusSetNameID(
1565: INT id,
1566: INT Type)
1567: {
1568: TCHAR szValue[CCHIDMAX + 1];
1569:
1570: /*
1571: * If the current control is a dialog, do NOT produce a hex
1572: * value, even if the hex mode is on. RC.Exe doesn't recognize
1573: * hex values for the dialog name as ordinals.
1574: */
1575: if (Type == W_DIALOG)
1576: itoaw(id, szValue, 10);
1577: else
1578: Myitoa(id, szValue);
1579:
1580: SetDlgItemText(hwndStatus, DID_STATUSNAMEID, szValue);
1581: }
1582:
1583:
1584:
1585: /************************************************************************
1586: * StatusClearID
1587: *
1588: * Clears the id of the status window..
1589: *
1590: ************************************************************************/
1591:
1592: STATICFN VOID StatusClearID(VOID)
1593: {
1594: SetDlgItemText(hwndStatus, DID_STATUSSYM, szEmpty);
1595: SetDlgItemText(hwndStatus, DID_STATUSSYMID, szEmpty);
1596: }
1597:
1598:
1599:
1600: /************************************************************************
1601: * StatusClearName
1602: *
1603: * Clears the name of the status window.
1604: *
1605: ************************************************************************/
1606:
1607: STATICFN VOID StatusClearName(VOID)
1608: {
1609: SetDlgItemText(hwndStatus, DID_STATUSNAME, szEmpty);
1610: SetDlgItemText(hwndStatus, DID_STATUSNAMEID, szEmpty);
1611: }
1612:
1613:
1614:
1615: /************************************************************************
1616: * StatusClear
1617: *
1618: * Clears the status window.
1619: *
1620: ************************************************************************/
1621:
1622: STATICFN VOID StatusClear(VOID)
1623: {
1624: StatusSetCoords(NULL);
1625: StatusSetText(NULL, W_NOTHING);
1626: StatusShowFields(W_NOTHING);
1627: StatusClearID();
1628: StatusClearName();
1629: gfStatusChanged = FALSE;
1630: }
1631:
1632:
1633:
1634: /************************************************************************
1635: * StatusUpdate
1636: *
1637: * Updates the status window to the current selection.
1638: *
1639: ************************************************************************/
1640:
1641: VOID StatusUpdate(VOID)
1642: {
1643: if (gnpcSel) {
1644: StatusSetCoords(&gnpcSel->rc);
1645: StatusSetText(gnpcSel->text, gnpcSel->pwcd->iType);
1646:
1647: if (gfDlgSelected)
1648: StatusSetName(gcd.pszDlgName, W_DIALOG);
1649: else
1650: StatusSetID(gnpcSel->id, TRUE);
1651:
1652: StatusShowFields(gnpcSel->pwcd->iType);
1653:
1654: gfStatusChanged = FALSE;
1655: }
1656: else {
1657: StatusClear();
1658: }
1659: }
1660:
1661:
1662:
1663: /************************************************************************
1664: * StatusShowFields
1665: *
1666: * This function shows and hides fields in the Status ribbon based on
1667: * whether the dialog is currently selected or not. This is necessary
1668: * because dialogs have a name, whereas controls do not, and controls
1669: * have an id that dialogs do not have, etc.
1670: *
1671: * It will also call StatusSetTextLabels to set the text for the
1672: * descriptive labels in front of the fields.
1673: *
1674: * This function should be called whenever it is possible that the current
1675: * selection has been changed.
1676: *
1677: * Arguments:
1678: * INT Type - Type of control that is selected (W_* constant).
1679: *
1680: ************************************************************************/
1681:
1682: STATICFN VOID StatusShowFields(
1683: INT Type)
1684: {
1685: /*
1686: * This static caches the type of the selected control.
1687: */
1688: static INT TypeSave = W_NOTHING;
1689:
1690: /*
1691: * We only have special cases for the dialog and for icon controls.
1692: * All other types are treated the same (we use W_CHECKBOX arbitrarily).
1693: * This prevents some repainting when switching between controls that
1694: * have the same layout of fields in the status window.
1695: */
1696: if (Type != W_DIALOG && Type != W_ICON)
1697: Type = W_CHECKBOX;
1698:
1699: if (Type != TypeSave) {
1700: switch (Type) {
1701: case W_DIALOG:
1702: MoveWindow(GetDlgItem(hwndStatus, DID_STATUSNAME),
1703: grcTopCombo.left, grcTopCombo.top,
1704: grcTopCombo.right - grcTopCombo.left,
1705: grcTopCombo.bottom - grcTopCombo.top, TRUE);
1706: MoveWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID),
1707: grcTopEdit.left, grcTopEdit.top,
1708: grcTopEdit.right - grcTopEdit.left,
1709: grcTopEdit.bottom - grcTopEdit.top, TRUE);
1710:
1711: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAME), SW_SHOW);
1712: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID), SW_SHOW);
1713: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSTEXT), SW_SHOW);
1714: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYM), SW_HIDE);
1715: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYMID), SW_HIDE);
1716:
1717: StatusSetTextLabels(Type, IsOrd(gcd.pszDlgName));
1718:
1719: break;
1720:
1721: case W_ICON:
1722: MoveWindow(GetDlgItem(hwndStatus, DID_STATUSNAME),
1723: grcBottomCombo.left, grcBottomCombo.top,
1724: grcBottomCombo.right - grcBottomCombo.left,
1725: grcBottomCombo.bottom - grcBottomCombo.top, TRUE);
1726: MoveWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID),
1727: grcBottomEdit.left, grcBottomEdit.top,
1728: grcBottomEdit.right - grcBottomEdit.left,
1729: grcBottomEdit.bottom - grcBottomEdit.top, TRUE);
1730:
1731: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAME), SW_SHOW);
1732: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID), SW_SHOW);
1733: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSTEXT), SW_HIDE);
1734: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYM), SW_SHOW);
1735: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYMID), SW_SHOW);
1736:
1737: StatusSetTextLabels(Type,
1738: gnpcSel->text ? IsOrd(gnpcSel->text) : FALSE);
1739:
1740: break;
1741:
1742: default:
1743: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSTEXT), SW_SHOW);
1744: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYM), SW_SHOW);
1745: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSSYMID), SW_SHOW);
1746: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAME), SW_HIDE);
1747: ShowWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID), SW_HIDE);
1748:
1749: StatusSetTextLabels(Type, FALSE);
1750:
1751: break;
1752: }
1753:
1754: TypeSave = Type;
1755: }
1756: }
1757:
1758:
1759:
1760: /************************************************************************
1761: * StatusSetEnable
1762: *
1763: * This routine sets the enable state of the editable controls in the
1764: * status window based on various state globals.
1765: *
1766: * The controls will be disabled on the following conditions:
1767: *
1768: * 1. Nothing is selected.
1769: * 2. We are in Test mode.
1770: * 3. One of the editors own dialogs is up (gfDisabled == TRUE).
1771: *
1772: * In addition, some controls will always be disabled if in Translate
1773: * mode, and the text field will be disabled if this control cannot
1774: * have text.
1775: *
1776: ************************************************************************/
1777:
1778: VOID StatusSetEnable(VOID)
1779: {
1780: BOOL fEnableText = TRUE;
1781: BOOL fEnableSym = TRUE;
1782: BOOL fEnableName = TRUE;
1783:
1784: if (!gnpcSel || gfTestMode || gfDisabled)
1785: fEnableText = fEnableSym = fEnableName = FALSE;
1786:
1787: /*
1788: * Disable the text field if this control cannot have text.
1789: */
1790: if (gnpcSel && !gnpcSel->pwcd->fHasText)
1791: fEnableText = FALSE;
1792:
1793: /*
1794: * If the dialog is selected and the style does not include
1795: * a caption, disable the text field.
1796: */
1797: if (gfDlgSelected && (gnpcSel->flStyle & WS_CAPTION) != WS_CAPTION)
1798: fEnableText = FALSE;
1799:
1800: /*
1801: * Always disable the symbol and name fields if Translating.
1802: */
1803: if (gfTranslateMode)
1804: fEnableSym = fEnableName = FALSE;
1805:
1806: EnableWindow(GetDlgItem(hwndStatus, DID_STATUSTEXT), fEnableText);
1807:
1808: EnableWindow(GetDlgItem(hwndStatus, DID_STATUSSYM), fEnableSym);
1809: EnableWindow(GetDlgItem(hwndStatus, DID_STATUSSYMID), fEnableSym);
1810:
1811: EnableWindow(GetDlgItem(hwndStatus, DID_STATUSNAME), fEnableName);
1812: EnableWindow(GetDlgItem(hwndStatus, DID_STATUSNAMEID), fEnableName);
1813: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.