![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to toolbox.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 toolbox.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit |
1.1 root 1: /****************************************************************************/
2: /* */
3: /* Microsoft Confidential */
4: /* */
5: /* Copyright (c) Microsoft Corp. 1987, 1990 */
6: /* All Rights Reserved */
7: /* */
8: /****************************************************************************/
9: /****************************** Module Header *******************************
10: * Module Name: toolbox.c
11: *
12: * Contains routines that handle the toolbox.
13: *
14: * History:
15: *
16: * 04/30/91 - Copied from DlgEdit.
17: *
18: ****************************************************************************/
19:
20: #include "imagedit.h"
21: #include "dialogs.h"
22:
23:
24: #define TOOLBOXCOLUMNS 2 // Columns in the Toolbox.
25:
26: /*
27: * Style of the toolbox window.
28: */
29: #define TOOLBOXSTYLE (WS_POPUP | WS_CLIPSIBLINGS | WS_CAPTION | WS_SYSMENU)
30:
31:
32: STATICFN VOID NEAR ToolboxDrawBitmap(HDC hDC, INT tool);
33:
34:
35: /*
36: * Dimensions of a tool button bitmap.
37: */
38: static INT cxToolBtn;
39: static INT cyToolBtn;
40:
41: /*
42: * Index to the last available tool. If tools at the end of the
43: * toolbox are disabled, this number gets lowered.
44: */
45: static INT iToolLast = CTOOLS - 1;
46:
47:
48:
49: /****************************************************************************
50: * ToolboxCreate
51: *
52: * This function creates the toolbox window.
53: *
54: * History:
55: *
56: ****************************************************************************/
57:
58: VOID ToolboxCreate(VOID)
59: {
60: BITMAP bmp;
61: INT i;
62: INT x;
63: INT y;
64: INT cx;
65: INT cy;
66: INT cxDummy;
67: INT cyDummy;
68: RECT rc;
69: RECT rcClient;
70: POINT pt;
71: BOOL fMaximized;
72:
73: /*
74: * Load the bitmaps.
75: */
76: for (i = 0; i < CTOOLS; i++) {
77: if (!(gaTools[i].hbmToolBtnUp = LoadBitmap(ghInst,
78: MAKEINTRESOURCE(gaTools[i].idbmToolBtnUp))))
79: return;
80:
81: if (!(gaTools[i].hbmToolBtnDown = LoadBitmap(ghInst,
82: MAKEINTRESOURCE(gaTools[i].idbmToolBtnDown))))
83: return;
84: }
85:
86: /*
87: * Get the dimensions of the tool button bitmaps.
88: */
89: GetObject(gaTools[0].hbmToolBtnUp, sizeof(BITMAP), (PSTR)&bmp);
90: cxToolBtn = bmp.bmWidth;
91: cyToolBtn = bmp.bmHeight;
92:
93: /*
94: * Calculate the required window size for the client area
95: * size we want. The size leaves room for a margin, and
96: * assumes that adjacent buttons overlap their borders by
97: * one pixel.
98: */
99: rc.left = 0;
100: rc.top = 0;
101: rc.right = PALETTEMARGIN + ((cxToolBtn - 1) * 2) + 1 + PALETTEMARGIN;
102: rc.bottom = PALETTEMARGIN + ((cyToolBtn - 1) *
103: (CTOOLS / 2)) + 1 + PALETTEMARGIN;
104: AdjustWindowRect(&rc, TOOLBOXSTYLE, FALSE);
105: cx = rc.right - rc.left;
106: cy = rc.bottom - rc.top;
107:
108: /*
109: * Get the saved position of the Toolbox. Note that we throw away
110: * the size fields, because we just calculated the required size.
111: */
112: if (!ReadWindowPos(szTBPos, &x, &y, &cxDummy, &cyDummy, &fMaximized)) {
113: /*
114: * The previous position of the Toolbox couldn't be found.
115: * Position the toolbox to the upper right corner of the
116: * client area of the editor, but make sure it is completely
117: * visible.
118: */
119: GetClientRect(ghwndMain, &rcClient);
120: pt.x = rcClient.right - cx - (2 * PALETTEMARGIN);
121: pt.y = rcClient.top + gcyPropBar + (2 * PALETTEMARGIN);
122: ClientToScreen(ghwndMain, &pt);
123: SetRect(&rc, pt.x, pt.y, pt.x + cx, pt.y + cy);
124: FitRectToScreen(&rc);
125: x = rc.left;
126: y = rc.top;
127: }
128:
129: if (!(ghwndToolbox = CreateWindow(szToolboxClass, NULL, TOOLBOXSTYLE,
130: x, y, cx, cy, ghwndMain, NULL, ghInst, NULL)))
131: return;
132:
133: /*
134: * Create the buttons.
135: */
136: x = PALETTEMARGIN;
137: y = PALETTEMARGIN;
138: for (i = 0; i < CTOOLS; i++) {
139: CreateWindow(szToolBtnClass, NULL,
140: WS_CHILD | WS_VISIBLE,
141: x, y, cxToolBtn, cyToolBtn,
142: ghwndToolbox, (HMENU)i, ghInst, NULL);
143:
144: if (x == PALETTEMARGIN) {
145: x += cxToolBtn - 1;
146: }
147: else {
148: x = PALETTEMARGIN;
149: y += cyToolBtn - 1;
150: }
151: }
152:
153: ToolboxUpdate();
154: }
155:
156:
157:
158: /****************************************************************************
159: * ToolboxShow
160: *
161: * This function shows or hides the toolbox window.
162: *
163: * History:
164: *
165: ****************************************************************************/
166:
167: VOID ToolboxShow(
168: BOOL fShow)
169: {
170: if (fShow)
171: ShowWindow(ghwndToolbox, SW_SHOWNA);
172: else
173: ShowWindow(ghwndToolbox, SW_HIDE);
174: }
175:
176:
177:
178: /****************************************************************************
179: * ToolboxUpdate
180: *
181: * This function updates the toolbox. It should be called any time that
182: * a new file is opened/created for editing.
183: *
184: * History:
185: *
186: ****************************************************************************/
187:
188: VOID ToolboxUpdate(VOID)
189: {
190: if (!ghwndToolbox)
191: return;
192:
193: if (giType == FT_CURSOR) {
194: ShowWindow(GetDlgItem(ghwndToolbox, TOOL_HOTSPOT), SW_SHOWNA);
195: iToolLast = CTOOLS - 1;
196: }
197: else {
198: ShowWindow(GetDlgItem(ghwndToolbox, TOOL_HOTSPOT), SW_HIDE);
199: iToolLast = TOOL_HOTSPOT - 1;
200: if (gCurTool == TOOL_HOTSPOT)
201: ToolboxSelectTool(TOOL_FIRST);
202: }
203: }
204:
205:
206:
207: /****************************************************************************
208: * ToolboxWndProc
209: *
210: * This is the window procedure for the toolbox window.
211: *
212: * History:
213: *
214: ****************************************************************************/
215:
216: WINDOWPROC ToolboxWndProc(
217: HWND hwnd,
218: UINT msg,
219: WPARAM wParam,
220: LPARAM lParam)
221: {
222: switch (msg) {
223: case WM_CREATE:
224: {
225: HMENU hmenu = GetSystemMenu(hwnd, FALSE);
226:
227: RemoveMenu(hmenu, 7, MF_BYPOSITION); // Second separator.
228: RemoveMenu(hmenu, 5, MF_BYPOSITION); // First separator.
229:
230: RemoveMenu(hmenu, SC_RESTORE, MF_BYCOMMAND);
231: RemoveMenu(hmenu, SC_SIZE, MF_BYCOMMAND);
232: RemoveMenu(hmenu, SC_MINIMIZE, MF_BYCOMMAND);
233: RemoveMenu(hmenu, SC_MAXIMIZE, MF_BYCOMMAND);
234: RemoveMenu(hmenu, SC_TASKLIST, MF_BYCOMMAND);
235: }
236:
237: return 0;
238:
239: case WM_KEYDOWN:
240: {
241: INT iToolNext;
242:
243: switch (wParam) {
244: case VK_UP:
245: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
246: (GetKeyState(VK_CONTROL) & 0x8000))
247: break;
248:
249: /*
250: * Go up a row, but don't go beyond the top.
251: */
252: iToolNext = gCurTool - TOOLBOXCOLUMNS;
253: if (iToolNext < 0)
254: break;
255:
256: ToolboxSelectTool(iToolNext);
257:
258: break;
259:
260: case VK_DOWN:
261: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
262: (GetKeyState(VK_CONTROL) & 0x8000))
263: break;
264:
265: /*
266: * Go down a row, but don't go beyond the bottom.
267: */
268: iToolNext = gCurTool + TOOLBOXCOLUMNS;
269: if (iToolNext > iToolLast)
270: break;
271:
272: ToolboxSelectTool(iToolNext);
273:
274: break;
275:
276: case VK_LEFT:
277: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
278: (GetKeyState(VK_CONTROL) & 0x8000))
279: break;
280:
281: /*
282: * Already at left edge.
283: */
284: if (!(gCurTool % TOOLBOXCOLUMNS))
285: break;
286:
287: /*
288: * Go left a column.
289: */
290: ToolboxSelectTool(gCurTool - 1);
291:
292: break;
293:
294: case VK_RIGHT:
295: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
296: (GetKeyState(VK_CONTROL) & 0x8000))
297: break;
298:
299: /*
300: * Already at right edge.
301: */
302: if ((gCurTool % TOOLBOXCOLUMNS) == TOOLBOXCOLUMNS - 1)
303: break;
304:
305: /*
306: * Don't go off the end of the available tools.
307: */
308: if (gCurTool + 1 > iToolLast)
309: break;
310:
311: /*
312: * Go right a column.
313: */
314: ToolboxSelectTool(gCurTool + 1);
315:
316: break;
317:
318: case VK_TAB:
319: if (GetKeyState(VK_CONTROL) & 0x8000)
320: break;
321:
322: /*
323: * Is the shift key pressed also?
324: */
325: if (GetKeyState(VK_SHIFT) & 0x8000) {
326: if (gCurTool == TOOL_FIRST)
327: iToolNext = iToolLast;
328: else
329: iToolNext = gCurTool - 1;
330: }
331: else {
332: if (gCurTool == iToolLast)
333: iToolNext = TOOL_FIRST;
334: else
335: iToolNext = gCurTool + 1;
336: }
337:
338: ToolboxSelectTool(iToolNext);
339:
340: break;
341:
342: case VK_END:
343: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
344: (GetKeyState(VK_CONTROL) & 0x8000))
345: break;
346:
347: ToolboxSelectTool(iToolLast);
348:
349: break;
350:
351: case VK_HOME:
352: case VK_ESCAPE:
353: if ((GetKeyState(VK_SHIFT) & 0x8000) ||
354: (GetKeyState(VK_CONTROL) & 0x8000))
355: break;
356:
357: ToolboxSelectTool(TOOL_FIRST);
358:
359: break;
360: }
361: }
362:
363: break;
364:
365: case WM_ACTIVATE:
366: if (LOWORD(wParam))
367: gidCurrentDlg = DID_TOOLBOX;
368:
369: break;
370:
371: case WM_PAINT:
372: {
373: HDC hdc;
374: PAINTSTRUCT ps;
375:
376: hdc = BeginPaint(hwnd, &ps);
377: DrawMarginBorder(hwnd, hdc);
378: EndPaint(hwnd, &ps);
379: }
380:
381: break;
382:
383: case WM_CLOSE:
384: /*
385: * The user closed the toolbox from the system menu.
386: * Hide the toolbox (we don't actually destroy it so
387: * that it will appear in the same spot when they show
388: * it again).
389: */
390: ToolboxShow(FALSE);
391: gfShowToolbox = FALSE;
392: break;
393:
394: case WM_DESTROY:
395: {
396: INT i;
397: RECT rc;
398:
399: for (i = 0; i < CTOOLS; i++) {
400: DeleteObject(gaTools[i].hbmToolBtnUp);
401: gaTools[i].hbmToolBtnUp = NULL;
402: DeleteObject(gaTools[i].hbmToolBtnDown);
403: gaTools[i].hbmToolBtnDown = NULL;
404: }
405:
406: /*
407: * Save the position of the toolbox.
408: */
409: GetWindowRect(hwnd, &rc);
410: WriteWindowPos(&rc, FALSE, szTBPos);
411:
412: /*
413: * Null out the global window handle for the toolbox
414: * for safety's sake.
415: */
416: ghwndToolbox = NULL;
417: }
418:
419: break;
420:
421: default:
422: return DefWindowProc(hwnd, msg, wParam, lParam);
423: }
424:
425: return 0;
426: }
427:
428:
429:
430: /****************************************************************************
431: * ToolBtnWndProc
432: *
433: * This is the window procedure for the buttons in the toolbox window.
434: *
435: * History:
436: *
437: ****************************************************************************/
438:
439: WINDOWPROC ToolBtnWndProc(
440: HWND hwnd,
441: UINT msg,
442: WPARAM wParam,
443: LPARAM lParam)
444: {
445: switch (msg) {
446: case WM_LBUTTONDOWN:
447: /*
448: * Select the tool that was clicked on.
449: */
450: ToolboxSelectTool((UINT)GetWindowLong((hwnd), GWL_ID));
451:
452: break;
453:
454: case WM_PAINT:
455: {
456: HDC hDC;
457: PAINTSTRUCT ps;
458:
459: hDC = BeginPaint(hwnd, &ps);
460: ToolboxDrawBitmap(hDC, (UINT)GetWindowLong((hwnd), GWL_ID));
461: EndPaint(hwnd, &ps);
462: }
463:
464: break;
465:
466: default:
467: return DefWindowProc(hwnd, msg, wParam, lParam);
468: }
469:
470: return 0;
471: }
472:
473:
474:
475: /****************************************************************************
476: * ToolboxDrawBitmap
477: *
478: *
479: * History:
480: *
481: ****************************************************************************/
482:
483: STATICFN VOID NEAR ToolboxDrawBitmap(
484: HDC hDC,
485: INT tool)
486: {
487: HDC hMemDC;
488: HBITMAP hbmOld;
489:
490: /*
491: * Draw the image.
492: */
493: hMemDC = CreateCompatibleDC(hDC);
494: hbmOld = SelectObject(hMemDC, (tool == gCurTool) ?
495: gaTools[tool].hbmToolBtnDown : gaTools[tool].hbmToolBtnUp);
496: BitBlt(hDC, 0, 0, cxToolBtn, cyToolBtn, hMemDC, 0, 0, SRCCOPY);
497: SelectObject(hMemDC, hbmOld);
498: DeleteDC(hMemDC);
499: }
500:
501:
502:
503: /****************************************************************************
504: * ToolboxSelectTool
505: *
506: *
507: * History:
508: *
509: ****************************************************************************/
510:
511: VOID ToolboxSelectTool(
512: INT tool)
513: {
514: if (gCurTool != tool) {
515: if (ghwndToolbox) {
516: InvalidateRect(GetDlgItem(ghwndToolbox, gCurTool), NULL, FALSE); InvalidateRect(GetDlgItem(ghwndToolbox, tool), NULL, FALSE);
517: }
518:
519: gCurTool = tool;
520: gpfnDrawProc = gaTools[gCurTool].pfnDrawProc;
521: }
522: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.