![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to imagedit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit|
Return to imagedit.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit |
1.1 root 1: /***************************************************************************
2: * *
3: * MODULE : imagedit.c *
4: * *
5: * DESCRIPTION : Contains main entry-level routine for ImagEdit. *
6: * *
7: * FUNCTIONS : WinMain () - Program entry point. *
8: * *
9: * HISTORY : 3/14/89 - LR *
10: * *
11: ***************************************************************************/
12:
13: #include "imagedit.h"
14: #include "dialogs.h"
15: #include "ids.h"
16:
17: #include <string.h>
18: #include <stdlib.h>
19:
20: #include <commdlg.h>
21:
22:
23: /*
24: * External declarations for the Windows variables that contain
25: * command line information.
26: */
27: extern INT __argc;
28: extern CHAR **__argv;
29:
30:
31: STATICFN BOOL NEAR InitApplication(VOID);
32: STATICFN BOOL NEAR InitInstance(LPSTR lpCmdLine, INT cmdShow);
33: STATICFN VOID NEAR PenWinRegister(VOID);
34: STATICFN VOID NEAR ReadEnv(VOID);
35: STATICFN VOID NEAR WriteEnv(VOID);
36: STATICFN VOID NEAR SizeRibbons(HWND hwnd);
37: STATICFN VOID NEAR CleanUp(VOID);
38:
39: static RECT grcAppPos; // Saves the app's window pos.
40: static WORD gmsgHelp; // Registered help msg from commdlg.dll
41: static BOOL fStartAsIcon = FALSE; // TRUE if app is started minimized.
42:
43: /*
44: * Contains the address of the Pen Windows callback.
45: */
46: typedef VOID ( APIENTRY *LPFNPENWIN)(WORD, BOOL);
47: static LPFNPENWIN lpfnRegisterPenApp;
48:
49:
50:
51: /****************************************************************************
52: * *
53: * FUNCTION :int PASCAL WinMain(hInstance,hPrevInstance,lpCmdLine,cmdShow) *
54: * *
55: * PURPOSE :Serves as program entry point and contains message loop *
56: * *
57: ****************************************************************************/
58:
59: INT WINAPI
60: WinMain(
61: HINSTANCE hInstance,
62: HINSTANCE hPrevInstance,
63: LPSTR lpCmdLine,
64: INT nCmdShow)
65: {
66: MSG msg;
67:
68: DBGStackReport(TRUE);
69:
70: ghInst = hInstance;
71:
72: /* if this is the first instance then call initialization procedure */
73: if (!hPrevInstance) {
74: if (!InitApplication())
75: return FALSE;
76: }
77:
78: if (!InitInstance(lpCmdLine, nCmdShow))
79: return FALSE;
80:
81: while (GetMessage(&msg, NULL, 0, 0)) {
82: if (!ghwndColor || !IsDialogMessage(ghwndColor, &msg)) {
83: if (!ghwndPropBar || !IsDialogMessage(ghwndPropBar, &msg)) {
84: if (!TranslateAccelerator(ghwndMain, haccelTbl, &msg)) {
85: TranslateMessage(&msg);
86: DispatchMessage(&msg);
87: }
88: }
89: }
90: }
91:
92: DBGStackReport(FALSE);
93:
94: /*
95: * Return the value from PostQuitMessage.
96: */
97: return msg.wParam;
98: }
99:
100:
101:
102: /****************************************************************************
103: * *
104: * FUNCTION : InitApplication() *
105: * *
106: * PURPOSE : To create all ImagEdit's window classes, namely those of *
107: * the parent window, edit window, mode window and "palette" *
108: * window. *
109: * *
110: * RETURNS : TRUE if class registration was successful, FALSE otherwise *
111: * *
112: * SIDE EFFECTS: All class variables affected for all windows. *
113: * *
114: ****************************************************************************/
115:
116: STATICFN BOOL NEAR InitApplication(VOID)
117: {
118: WNDCLASS wc;
119:
120: /* assign values and register the parent window class */
121: wc.style = 0;
122: wc.lpfnWndProc = MainWndProc;
123: wc.cbClsExtra = 0;
124: wc.cbWndExtra = 0;
125: wc.hInstance = ghInst;
126: wc.hIcon = LoadIcon(ghInst, MAKEINTRESOURCE(IDICON_IMAGEDIT));
127: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
128: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
129: wc.lpszMenuName = "imagedit";
130: wc.lpszClassName = szMainClass;
131: if (!RegisterClass(&wc))
132: return FALSE;
133:
134: wc.style = CS_DBLCLKS;
135: wc.lpfnWndProc = ColorBoxWndProc;
136: wc.cbClsExtra = 0;
137: wc.cbWndExtra = 0;
138: wc.hInstance = ghInst;
139: wc.hIcon = NULL;
140: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
141: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
142: wc.lpszMenuName = (LPSTR)NULL;
143: wc.lpszClassName = szColorBoxClass;
144: if (!RegisterClass(&wc))
145: return FALSE;
146:
147: wc.style = 0;
148: wc.lpfnWndProc = ColorLRWndProc;
149: wc.cbClsExtra = 0;
150: wc.cbWndExtra = 0;
151: wc.hInstance = ghInst;
152: wc.hIcon = NULL;
153: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
154: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
155: wc.lpszMenuName = (LPSTR)NULL;
156: wc.lpszClassName = szColorLRClass;
157: if (!RegisterClass(&wc))
158: return FALSE;
159:
160: wc.style = CS_DBLCLKS;
161: wc.lpfnWndProc = WorkWndProc;
162: wc.cbClsExtra = 0;
163: wc.cbWndExtra = 0;
164: wc.hInstance = ghInst;
165: wc.hIcon = NULL;
166: wc.hCursor = (HCURSOR)NULL;
167: wc.hbrBackground = (HBRUSH)NULL;
168: wc.lpszMenuName = (LPSTR)NULL;
169: wc.lpszClassName = szWorkClass;
170: if (!RegisterClass(&wc))
171: return FALSE;
172:
173: wc.style = 0;
174: wc.lpfnWndProc = ToolboxWndProc;
175: wc.cbClsExtra = 0;
176: wc.cbWndExtra = 0;
177: wc.hInstance = ghInst;
178: wc.hIcon = NULL;
179: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
180: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
181: wc.lpszMenuName = NULL;
182: wc.lpszClassName = szToolboxClass;
183: if (!RegisterClass(&wc))
184: return FALSE;
185:
186: wc.style = 0;
187: wc.lpfnWndProc = ToolBtnWndProc;
188: wc.cbClsExtra = 0;
189: wc.cbWndExtra = 0;
190: wc.hInstance = ghInst;
191: wc.hIcon = NULL;
192: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
193: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
194: wc.lpszMenuName = NULL;
195: wc.lpszClassName = szToolBtnClass;
196: if (!RegisterClass(&wc))
197: return FALSE;
198:
199: wc.style = 0;
200: wc.lpfnWndProc = ViewWndProc;
201: wc.cbClsExtra = 0;
202: wc.cbWndExtra = 0;
203: wc.hInstance = ghInst;
204: wc.hIcon = NULL;
205: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
206: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
207: wc.lpszMenuName = NULL;
208: wc.lpszClassName = szViewClass;
209: if (!RegisterClass(&wc))
210: return FALSE;
211:
212: return TRUE;
213: }
214:
215:
216:
217: /****************************************************************************
218: * *
219: * FUNCTION : InitInstance(lpCmdLine, cmdShow) *
220: * *
221: * PURPOSE : Load strings from resource file, make procedure instances *
222: * of all dialog functions, create ImagEdit's windows, color *
223: * "palettes", tool cursors and do a variety of other initial-*
224: * izations. Also prepare ImagEdit if started up from cmd line*
225: * with an argument. Some of these may be redundant, since a *
226: * lot of pBrush stuff has been retained here. *
227: * *
228: * SIDE EFFECTS: numerous *
229: * *
230: ****************************************************************************/
231:
232: STATICFN BOOL NEAR InitInstance(
233: LPSTR lpCmdLine,
234: INT cmdShow)
235: {
236: INT i;
237: INT iScrollBarWidth; /* width of vertical scrollbar */
238: INT iScrollBarHeight; /* height of horizontal scrollbar */
239: INT iScreenWid;
240: INT iScreenHgt; /* full screen width and height */
241: INT x;
242: INT y;
243: INT cx;
244: INT cy;
245: BOOL fMaximized;
246: RECT rcColor;
247: RECT rcClient;
248: RECT rc;
249: POINT pt;
250:
251: /*
252: * Load the "Out of memory." string now, since we may not be able to
253: * load it if/when it needs to be displayed.
254: */
255: ids(IDS_OUTOFMEMORY);
256:
257: /*
258: * Register for Pen Windows, if it is present.
259: */
260: PenWinRegister();
261:
262: /* register private ImagEdit clipboard format for icons and cursors */
263: if (!(ClipboardFormat = RegisterClipboardFormat("ImagEdit")))
264: return FALSE;
265:
266: if (!(haccelTbl = LoadAccelerators(ghInst, "imagedit")))
267: return FALSE;
268:
269: hcurWait = LoadCursor(NULL, IDC_WAIT);
270: gaTools[TOOL_PENCIL].hcur =
271: LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_PENCIL));
272: gaTools[TOOL_BRUSH].hcur =
273: LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_BRUSH));
274: gaTools[TOOL_SELECT].hcur =
275: gaTools[TOOL_LINE].hcur =
276: gaTools[TOOL_RECT].hcur =
277: gaTools[TOOL_SOLIDRECT].hcur =
278: gaTools[TOOL_CIRCLE].hcur =
279: gaTools[TOOL_SOLIDCIRCLE].hcur =
280: LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_CROSS));
281: gaTools[TOOL_FLOODFILL].hcur =
282: LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_FLOOD));
283: gaTools[TOOL_HOTSPOT].hcur =
284: LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_HOTSPOT));
285:
286: /*
287: * Select the default tool. Since the toolbox is not created yet,
288: * this just sets up some globals.
289: */
290: ToolboxSelectTool(TOOL_FIRST);
291:
292: /*
293: * Create a dark gray pen for use in borders later.
294: */
295: if (!(hpenDarkGray = CreatePen(PS_SOLID, 1, RGB_DARKGRAY)))
296: return FALSE;
297:
298: /*
299: * Initialize the two color palettes to the default colors.
300: */
301: for (i = 0; i < COLORSMAX; i++) {
302: gargbColor[i] = gargbDefaultColor[i];
303: gargbMono[i] = gargbDefaultMono[i];
304: }
305:
306: /* get some system parameters */
307: iScrollBarWidth = GetSystemMetrics(SM_CXVSCROLL);
308: iScrollBarHeight = GetSystemMetrics(SM_CYHSCROLL);
309: iScreenWid = GetSystemMetrics(SM_CXFULLSCREEN);
310: iScreenHgt = GetSystemMetrics(SM_CYFULLSCREEN);
311: gcyBorder = GetSystemMetrics(SM_CYBORDER);
312:
313: /*
314: * Build the help file name path. Assume the help file is in the
315: * same directory as the executable.
316: */
317: GetModuleFileName(ghInst, gszHelpFile, CCHMAXPATH);
318: *FileInPath(gszHelpFile) = '\0';
319: lstrcat(gszHelpFile, ids(IDS_HELPFILE));
320:
321: /*
322: * Register the message for help from the common dialogs.
323: */
324: gmsgHelp = RegisterWindowMessage(HELPMSGSTRING);
325:
326: /*
327: * Hook the message filter stream so that we can detect F1 keystrokes.
328: */
329: lpfnMsgFilterHookFunc =
330: MakeProcInstance((FARPROC)MsgFilterHookFunc, ghInst);
331: ghhkMsgFilter =
332: SetWindowsHook(WH_MSGFILTER, lpfnMsgFilterHookFunc);
333:
334: if (!ReadWindowPos(szAppPos, &x, &y, &cx, &cy, &fMaximized)) {
335: x = 2 * iScrollBarWidth;
336: y = iScrollBarHeight;
337: cx = min(iScreenWid - (4 * iScrollBarWidth), MAXDEFAULTAPPCX);
338: cy = min(iScreenHgt - (6 * iScrollBarHeight), MAXDEFAULTAPPCY);
339: fMaximized = FALSE;
340: }
341:
342: /* create parent window */
343: ghwndMain = CreateWindow(szMainClass, ids(IDS_PGMTITLE),
344: WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
345: x, y, cx, cy, NULL, NULL, ghInst, NULL);
346:
347: if (ghwndMain == NULL) {
348: Message(MSG_OUTOFMEMORY);
349: return FALSE;
350: }
351:
352: /*
353: * Read the preferences data saved in the ini file.
354: */
355: ReadEnv();
356:
357: /*
358: * Create the Toolbox and the View window (invisible).
359: */
360: ToolboxCreate();
361: ViewCreate();
362:
363: lpfnColorDlgProc = (WNDPROC)MakeProcInstance(
364: (FARPROC)ColorDlgProc, ghInst);
365: ghwndColor = CreateDialog(ghInst, MAKEINTRESOURCE(DID_COLOR),
366: ghwndMain, lpfnColorDlgProc);
367:
368: ghwndWork = CreateWindow(szWorkClass, NULL,
369: WS_CHILD | WS_BORDER,
370: 0, 0, 0, 0,
371: ghwndMain,
372: NULL, ghInst, NULL);
373:
374: /*
375: * Build the device table.
376: */
377: InitDeviceList();
378:
379: SetColorPalette(gnColors, giType, TRUE);
380: SetScreenColor(grgbScreenDefault);
381:
382: if (!ReadWindowPos(szColorPos, &x, &y, &cx, &cy, &fMaximized)) {
383: /*
384: * The previous position of the Color palette couldn't be found.
385: * Position the palette just below the bottom left corner of the
386: * client area of the editor, but make sure it is completely
387: * visible.
388: */
389: GetWindowRect(ghwndColor, &rcColor);
390: GetClientRect(ghwndMain, &rcClient);
391: cx = rcColor.right - rcColor.left;
392: cy = rcColor.bottom - rcColor.top;
393: pt.x = rcClient.left + (2 * PALETTEMARGIN);
394: pt.y = rcClient.bottom + (2 * PALETTEMARGIN);
395: ClientToScreen(ghwndMain, &pt);
396: SetRect(&rc, pt.x, pt.y, pt.x + cx, pt.y + cy);
397: FitRectToScreen(&rc);
398: x = rc.left;
399: y = rc.top;
400: }
401:
402: SetWindowPos(ghwndColor, NULL, x, y, 0, 0,
403: SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
404:
405: SetFileName(NULL);
406:
407: /*
408: * If the app was saved when maximized (and they didn't start it up
409: * with some kind of an option to have it minimized or in some
410: * other funny initial state from the shell), then cause it to
411: * be maximized when shown.
412: */
413: if (fMaximized && (cmdShow == SW_SHOWNORMAL || cmdShow == SW_SHOW))
414: cmdShow = SW_SHOWMAXIMIZED;
415:
416: ShowWindow(ghwndMain, cmdShow);
417: UpdateWindow(ghwndMain);
418:
419: /*
420: * Did the user start this app minimized from the program manager?
421: */
422: if (IsIconic(ghwndMain)) {
423: /*
424: * Set a flag. The showing of the palettes will be deferred
425: * until the app is restored.
426: */
427: fStartAsIcon = TRUE;
428: }
429: else {
430: /*
431: * If they had the Toolbox/Color Palette before, show them now.
432: */
433: ToolboxShow(gfShowToolbox);
434: ColorShow(gfShowColor);
435: }
436:
437: /*
438: * If there was a command line argument specified, try and open
439: * it as the initial file.
440: */
441: if (__argc > 1)
442: OpenCmdLineFile(__argv[1]);
443:
444: return TRUE;
445: }
446:
447:
448:
449: /************************************************************************
450: * PenWinRegister
451: *
452: * This function will register for Pen Windows, if it is present.
453: *
454: ************************************************************************/
455:
456: STATICFN VOID NEAR PenWinRegister(VOID)
457: {
458: HANDLE hmod;
459:
460: if (!(hmod = (HANDLE)GetSystemMetrics(SM_PENWINDOWS)))
461: return;
462:
463: if (lpfnRegisterPenApp =
464: (LPFNPENWIN)GetProcAddress(hmod, "RegisterPenApp"))
465: (*lpfnRegisterPenApp)(1, TRUE); // Be Pen-Enhanced!
466: }
467:
468:
469:
470: /************************************************************************
471: * MainWndProc
472: *
473: * Main window procedure for ImagEdit.
474: *
475: * History:
476: *
477: ************************************************************************/
478:
479: WINDOWPROC MainWndProc(
480: HWND hwnd,
481: UINT msg,
482: WPARAM wParam,
483: LPARAM lParam)
484: {
485: switch (msg) {
486: case WM_CREATE:
487: {
488: RECT rc;
489:
490: /*
491: * Create the PropBar window.
492: */
493: lpfnPropBarDlgProc = (WNDPROC)MakeProcInstance(
494: (FARPROC)PropBarDlgProc, ghInst);
495: CreateDialog(ghInst, MAKEINTRESOURCE(DID_PROPBAR), hwnd,
496: lpfnPropBarDlgProc);
497:
498: /*
499: * Save away its height for sizing later (like when
500: * the app is minimized then restored).
501: */
502: GetWindowRect(ghwndPropBar, &rc);
503: gcyPropBar = rc.bottom - rc.top;
504: }
505:
506: break;
507:
508: case WM_NCCALCSIZE:
509: /*
510: * Save away what is going to be the new window position.
511: */
512: if (!IsIconic(hwnd) && !IsZoomed(hwnd))
513: grcAppPos = *((LPRECT)lParam);
514:
515: /*
516: * Now let the DefWindowProc calculate the client area normally.
517: */
518: goto DoDefault;
519:
520: case WM_ACTIVATE:
521: /*
522: * If the main window is getting activated, there is no
523: * currently active dialog.
524: */
525: if (LOWORD(wParam))
526: gidCurrentDlg = 0;
527:
528: goto DoDefault;
529:
530: case WM_INITMENU:
531: if (GetMenu(ghwndMain) == (HMENU)wParam)
532: InitMenu((HMENU)wParam);
533:
534: break;
535:
536: case WM_COMMAND:
537: MenuCmd(LOWORD(wParam));
538: break;
539:
540: case WM_SIZE:
541: SizeRibbons(hwnd);
542:
543: if (wParam != SIZEICONIC)
544: WorkReset();
545:
546: /*
547: * Did the app start minimized and is it being restored
548: * for the first time? If so, show the palettes as
549: * the user has requested.
550: */
551: if (fStartAsIcon && !IsIconic(hwnd)) {
552: ToolboxShow(gfShowToolbox);
553: ColorShow(gfShowColor);
554: fStartAsIcon = FALSE;
555: }
556:
557: break;
558:
559: case WM_MENUSELECT:
560: if ((UINT)(int)(short)HIWORD(wParam) &
561: (MF_POPUP | MF_SYSMENU))
562: gMenuSelected = 0;
563: else
564: gMenuSelected = LOWORD(wParam);
565:
566: break;
567:
568: case WM_CLOSE:
569: if (VerifySaveFile()) {
570: DestroyWindow(hwnd);
571: CleanUp();
572: }
573:
574: break;
575:
576: case WM_DESTROY:
577: /*
578: * Save the position of the app's window.
579: */
580: WriteWindowPos(&grcAppPos, IsZoomed(hwnd), szAppPos);
581:
582: WinHelp(ghwndMain, gszHelpFile, HELP_QUIT, 0L);
583:
584: PostQuitMessage(0);
585:
586: break;
587:
588: case WM_QUERYENDSESSION:
589: return VerifySaveFile();
590:
591: default:
592: /*
593: * Is this the registered help message from one of the common
594: * dialogs? If so, show the help for it.
595: *
596: * The check to be sure gmsgHelp is non-zero is just in
597: * case the call to register the help message failed
598: * (it will return zero) and there happens to be a zero
599: * message that gets sent to this window somehow.
600: */
601: if (msg == gmsgHelp && gmsgHelp) {
602: ShowHelp(FALSE);
603: return 0;
604: }
605:
606: DoDefault:
607: return DefWindowProc(hwnd, msg, wParam, lParam);
608: }
609:
610: return 0;
611: }
612:
613:
614:
615: /************************************************************************
616: * ReadWindowPos
617: *
618: * This function retrieves the saved window position for a window and
619: * returns it in the specified variables. It is used between sessions
620: * to restore the application windows to the position they had when
621: * the editor was last exited.
622: *
623: * Returns TRUE if the position could be read, or FALSE otherwise.
624: * If FALSE is returned, the values in the specified variables are
625: * not valid! The caller must be able to handle a FALSE return and
626: * supply a default position for the window.
627: *
628: * Arguments:
629: * PSTR pstrKeyName - KeyName the position was saved under.
630: * PINT px - Saved x position.
631: * PINT py - Saved y position.
632: * PINT pcx - Saved width.
633: * PINT pcy - Saved height.
634: * BOOL *pfMaximized - Set to TRUE if window was maximized when saved.
635: *
636: * History:
637: *
638: ************************************************************************/
639:
640: BOOL ReadWindowPos(
641: PSTR pstrKeyName,
642: PINT px,
643: PINT py,
644: PINT pcx,
645: PINT pcy,
646: BOOL *pfMaximized)
647: {
648: static CHAR szSep[] = " ,";
649: CHAR szBuf[CCHTEXTMAX];
650: PSTR pstr;
651:
652: if (!GetPrivateProfileString(ids(IDS_APPNAME),
653: pstrKeyName, "", szBuf, CCHTEXTMAX, ids(IDS_IMAGEDITINI)))
654: return FALSE;
655:
656: if (!(pstr = strtok(szBuf, szSep)))
657: return FALSE;
658:
659: *px = atoi(pstr);
660:
661: if (!(pstr = strtok(NULL, szSep)))
662: return FALSE;
663:
664: *py = atoi(pstr);
665:
666: if (!(pstr = strtok(NULL, szSep)))
667: return FALSE;
668:
669: *pcx = atoi(pstr);
670:
671: if (!(pstr = strtok(NULL, szSep)))
672: return FALSE;
673:
674: *pcy = atoi(pstr);
675:
676: /*
677: * If there is a "1" following the coordinates, the window was
678: * maximized when it was saved.
679: */
680: *pfMaximized = FALSE;
681: if ((pstr = strtok(NULL, szSep)) && atoi(pstr) == 1)
682: *pfMaximized = TRUE;
683:
684: /*
685: * Don't allow a zero sized window.
686: */
687: if (*pcx == 0 || *pcy == 0)
688: return FALSE;
689:
690: /*
691: * Return success.
692: */
693: return TRUE;
694: }
695:
696:
697:
698: /************************************************************************
699: * WriteWindowPos
700: *
701: * This function writes the position of a window to the
702: * editor's profile file under the specified keyname.
703: * The ReadWindowPos function is the counterpart of this
704: * function.
705: *
706: * Arguments:
707: * PRECT prc - Rectangle for the "restored" window size.
708: * BOOL fMaximized - TRUE if the window is maximized.
709: * PSTR pstrKeyName - KeyName to save the position under.
710: *
711: * History:
712: *
713: ************************************************************************/
714:
715: VOID WriteWindowPos(
716: PRECT prc,
717: BOOL fMaximized,
718: PSTR pstrKeyName)
719: {
720: CHAR szBuf[CCHTEXTMAX];
721:
722: wsprintf(szBuf, "%d %d %d %d", prc->left, prc->top,
723: prc->right - prc->left, prc->bottom - prc->top);
724:
725: if (fMaximized)
726: strcat(szBuf, " 1");
727:
728: WritePrivateProfileString(ids(IDS_APPNAME),
729: pstrKeyName, szBuf, ids(IDS_IMAGEDITINI));
730: }
731:
732:
733:
734: /*************************************************************************
735: * ReadEnv
736: *
737: * This function initializes variables from their counterparts
738: * in the private profile file for ImagEdit. The application
739: * merely needs to construct an array of INIENTRY structures
740: * to describe the variables that must be initialized.*
741: * Note that the original value read from the profile is saved when
742: * it is read. This allows us to optimize what needs to be written
743: * out with WriteEnv.
744: *
745: * History:
746: *
747: *************************************************************************/
748:
749: STATICFN VOID NEAR ReadEnv(VOID)
750: {
751: register INT i;
752: HDC hdc;
753: CHAR szBuf[CCHTEXTMAX];
754: DWORD rgb;
755:
756: for (i = 0; gaie[i].pstrKeyName; i++) {
757: *gaie[i].pnVar = gaie[i].nSave =
758: GetPrivateProfileInt(ids(IDS_APPNAME),
759: gaie[i].pstrKeyName, gaie[i].nDefault,
760: ids(IDS_IMAGEDITINI));
761: }
762:
763: /*
764: * Look for the saved screen color.
765: */
766: if (GetPrivateProfileString(ids(IDS_APPNAME), szrgbScreen, "",
767: szBuf, CCHTEXTMAX, ids(IDS_IMAGEDITINI))) {
768: rgb = (DWORD)atol(szBuf);
769: }
770: else {
771: /*
772: * The last screen color was not found. The default will be
773: * the current system screen background color.
774: */
775: rgb = GetSysColor(COLOR_BACKGROUND);
776: }
777:
778: /*
779: * Make the ImagEdit default screen color a solid color.
780: */
781: hdc = GetDC(ghwndMain);
782: grgbScreenDefault = GetNearestColor(hdc, rgb);
783: ReleaseDC(ghwndMain, hdc);
784: }
785:
786:
787:
788: /*************************************************************************
789: * WriteEnv
790: *
791: * This function is the counterpart to ReadEnv. It saves values
792: * in the profile file.
793: *
794: * History:
795: *
796: *************************************************************************/
797:
798: STATICFN VOID NEAR WriteEnv(VOID)
799: {
800: register INT i;
801: CHAR szBuf[CCHTEXTMAX];
802:
803: for (i = 0; gaie[i].pstrKeyName; i++) {
804: /*
805: * Has the user changed the value since it was read?
806: */
807: if (gaie[i].nSave != *gaie[i].pnVar) {
808: /*
809: * If the new value is the same as the default value,
810: * erase the entry from the ini file. Otherwise,
811: * write the user-specified value out.
812: */
813: if (*gaie[i].pnVar == gaie[i].nDefault) {
814: WritePrivateProfileString(ids(IDS_APPNAME),
815: gaie[i].pstrKeyName, NULL, ids(IDS_IMAGEDITINI));
816: }
817: else {
818: itoa(*gaie[i].pnVar, szBuf, 10);
819: WritePrivateProfileString(ids(IDS_APPNAME),
820: gaie[i].pstrKeyName, szBuf, ids(IDS_IMAGEDITINI));
821: }
822: }
823: }
824:
825: /*
826: * Save the current screen color.
827: */
828: ltoa((LONG)grgbScreen, szBuf, 10);
829: WritePrivateProfileString(ids(IDS_APPNAME),
830: szrgbScreen, szBuf, ids(IDS_IMAGEDITINI));
831: }
832:
833:
834:
835: /************************************************************************
836: * SizeRibbons
837: *
838: * This function positions and sizes the child ribbons in the editor.
839: * It needs to be called any time the size of the main windows changes.
840: *
841: * Arguments:
842: * HWND hwnd - Parent window handle.
843: *
844: * History:
845: *
846: ************************************************************************/
847:
848: STATICFN VOID NEAR SizeRibbons(
849: HWND hwnd)
850: {
851: RECT rcClient;
852:
853: if (ghwndPropBar && !IsIconic(hwnd)) {
854: /*
855: * Get the client area.
856: */
857: GetClientRect(hwnd, &rcClient);
858:
859: /*
860: * Size/move the PropBar window to fit
861: * the new client area.
862: */
863: SetWindowPos(ghwndPropBar, NULL,
864: 0, 0,
865: rcClient.right - rcClient.left,
866: min(rcClient.bottom - rcClient.top, gcyPropBar),
867: SWP_NOACTIVATE | SWP_NOZORDER);
868: }
869: }
870:
871:
872:
873: /************************************************************************
874: * CleanUp
875: *
876: * Cleans up all the resources allocated by the editor.
877: *
878: * History:
879: *
880: ************************************************************************/
881:
882: STATICFN VOID NEAR CleanUp(VOID)
883: {
884: WriteEnv();
885:
886: if (ghdcANDMask) {
887: DeleteDC(ghdcANDMask);
888: DeleteObject(ghbmANDMask);
889: }
890: if (ghdcImage) {
891: DeleteDC(ghdcImage);
892: DeleteObject(ghbmImage);
893: }
894:
895: ImageFreeUndo();
896:
897: if (hpenDarkGray)
898: DeleteObject(hpenDarkGray);
899:
900: if (ghbrLeft)
901: DeleteObject(ghbrLeft);
902:
903: if (ghbrLeftSolid)
904: DeleteObject(ghbrLeftSolid);
905:
906: if (ghbrRight)
907: DeleteObject(ghbrRight);
908:
909: if (ghbrRightSolid)
910: DeleteObject(ghbrRightSolid);
911:
912: if (ghbrScreen)
913: DeleteObject(ghbrScreen);
914:
915: if (ghbrInverse)
916: DeleteObject(ghbrInverse);
917:
918: if (ghpenLeft)
919: DeleteObject(ghpenLeft);
920:
921: if (ghpenRight)
922: DeleteObject(ghpenRight);
923:
924: ImageLinkFreeList();
925:
926: if (lpfnMsgFilterHookFunc) {
927: UnhookWindowsHook(WH_MSGFILTER, lpfnMsgFilterHookFunc);
928: FreeProcInstance(lpfnMsgFilterHookFunc);
929: }
930:
931: if (lpfnPropBarDlgProc)
932: FreeProcInstance((FARPROC)lpfnPropBarDlgProc);
933:
934: if (lpfnColorDlgProc)
935: FreeProcInstance((FARPROC)lpfnColorDlgProc);
936: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.