![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hatch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui|
Return to hatch.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * HATCH.C
3: *
4: * Miscellaneous API's to generate hatch window for in-place active
5: * objects. This is part of the OLE 2.0 User Interface Support Library.
6: *
7: * Copyright (c)1993 Microsoft Corporation, All Right Reserved
8: */
9:
10: #define STRICT 1
11: #include "ole2ui.h"
12:
13: // offsets in the extra bytes stored with the hatch window
14: #define EB_HATCHWIDTH 0
15: #define EB_HATCHRECT_LEFT 2
16: #define EB_HATCHRECT_TOP 4
17: #define EB_HATCHRECT_RIGHT 6
18: #define EB_HATCHRECT_BOTTOM 8
19:
20: // class name of hatch window
21: #define CLASS_HATCH "Hatch Window"
22:
23: // local function prototypes
24: LRESULT FAR PASCAL EXPORT HatchWndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam);
25:
26:
27: /*
28: * HatchRegisterClass
29: *
30: * Purpose:
31: * Register the hatch window
32: *
33: * Parameters:
34: * hInst Process instance
35: *
36: * Return Value:
37: * TRUE if successful
38: * FALSE if failed
39: *
40: */
41: STDAPI_(BOOL) RegisterHatchWindowClass(HINSTANCE hInst)
42: {
43: WNDCLASS wc;
44:
45: // Register Hatch Window Class
46: wc.style = CS_BYTEALIGNWINDOW;
47: wc.lpfnWndProc = HatchWndProc;
48: wc.cbClsExtra = 0;
49: wc.cbWndExtra = 5 * sizeof(int); // extra bytes stores
50: // uHatchWidth
51: // rcHatchRect
52: wc.hInstance = hInst;
53: wc.hIcon = NULL;
54: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
55: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
56: wc.lpszMenuName = NULL;
57: wc.lpszClassName = CLASS_HATCH;
58:
59: if (!RegisterClass(&wc))
60: return FALSE;
61: else
62: return TRUE;
63: }
64:
65:
66: /*
67: * CreateHatchWindow
68: *
69: * Purpose:
70: * Create the hatch window
71: *
72: * Parameters:
73: * hWndParent parent of hatch window
74: * hInst instance handle
75: *
76: * Return Value:
77: * pointer to hatch window if successful
78: * NULL if failed
79: *
80: */
81: STDAPI_(HWND) CreateHatchWindow(HWND hWndParent, HINSTANCE hInst)
82: {
83: HWND hWnd;
84:
85: if (!hWndParent || !hInst)
86: return NULL;
87:
88: hWnd = CreateWindow(
89: CLASS_HATCH,
90: "Hatch Window",
91: WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
92: 0, 0, 0, 0,
93: hWndParent,
94: (HMENU)NULL,
95: hInst,
96: 0L
97: );
98:
99: if (!hWnd)
100: return NULL;
101:
102: return hWnd;
103: }
104:
105: /*
106: * GetHatchWidth
107: *
108: * Purpose:
109: * Get width of hatch border
110: *
111: * Parameters:
112: * hWndHatch hatch window handle
113: *
114: * Return Value:
115: * width of the hatch border
116: */
117: STDAPI_(UINT) GetHatchWidth(HWND hWndHatch)
118: {
119: if (!IsWindow(hWndHatch))
120: return 0;
121:
122: return (UINT)GetWindowWord(hWndHatch, EB_HATCHWIDTH);
123: }
124:
125: /*
126: * GetHatchRect
127: *
128: * Purpose:
129: * Get hatch rect. this is the size of the hatch window if it were
130: * not clipped by the ClipRect.
131: *
132: * Parameters:
133: * hWndHatch hatch window handle
134: * lprcHatchRect hatch rect
135: *
136: * Return Value:
137: * none
138: */
139: STDAPI_(void) GetHatchRect(HWND hWndHatch, LPRECT lprcHatchRect)
140: {
141: if (!IsWindow(hWndHatch)) {
142: SetRect(lprcHatchRect, 0, 0, 0, 0);
143: return;
144: }
145:
146: lprcHatchRect->left = GetWindowWord(hWndHatch, EB_HATCHRECT_LEFT);
147: lprcHatchRect->top = GetWindowWord(hWndHatch, EB_HATCHRECT_TOP);
148: lprcHatchRect->right = GetWindowWord(hWndHatch, EB_HATCHRECT_RIGHT);
149: lprcHatchRect->bottom = GetWindowWord(hWndHatch, EB_HATCHRECT_BOTTOM);
150: }
151:
152:
153: /* SetHatchRect
154: *
155: *
156: * Purpose:
157: * Store hatch rect with HatchRect window.
158: * this rect is the size of the hatch window if it were
159: * not clipped by the ClipRect.
160: *
161: * Parameters:
162: * hWndHatch hatch window handle
163: * lprcHatchRect hatch rect
164: *
165: * Return Value:
166: * none
167: */
168: STDAPI_(void) SetHatchRect(HWND hWndHatch, LPRECT lprcHatchRect)
169: {
170: if (!IsWindow(hWndHatch))
171: return;
172:
173: SetWindowWord(hWndHatch, EB_HATCHRECT_LEFT, (WORD)lprcHatchRect->left);
174: SetWindowWord(hWndHatch, EB_HATCHRECT_TOP, (WORD)lprcHatchRect->top);
175: SetWindowWord(hWndHatch, EB_HATCHRECT_RIGHT, (WORD)lprcHatchRect->right);
176: SetWindowWord(hWndHatch, EB_HATCHRECT_BOTTOM,(WORD)lprcHatchRect->bottom);
177: }
178:
179:
180: /* SetHatchWindowSize
181: *
182: *
183: * Purpose:
184: * Move/size the HatchWindow correctly given the rect required by the
185: * in-place server object window and the lprcClipRect imposed by the
186: * in-place container. both rect's are expressed in the client coord.
187: * of the in-place container's window (which is the parent of the
188: * HatchWindow).
189: *
190: * OLE2NOTE: the in-place server must honor the lprcClipRect specified
191: * by its in-place container. it must NOT draw outside of the ClipRect.
192: * in order to achieve this, the hatch window is sized to be
193: * exactly the size that should be visible (rcVisRect). the
194: * rcVisRect is defined as the intersection of the full size of
195: * the HatchRect window and the lprcClipRect.
196: * the ClipRect could infact clip the HatchRect on the
197: * right/bottom and/or on the top/left. if it is clipped on the
198: * right/bottom then it is sufficient to simply resize the hatch
199: * window. but if the HatchRect is clipped on the top/left then
200: * in-place server document window (child of HatchWindow) must be moved
201: * by the delta that was clipped. the window origin of the
202: * in-place server window will then have negative coordinates relative
203: * to its parent HatchWindow.
204: *
205: * Parameters:
206: * hWndHatch hatch window handle
207: * lprcIPObjRect full size of in-place server object window
208: * lprcClipRect clipping rect imposed by in-place container
209: * lpptOffset offset required to position in-place server object
210: * window properly. caller should call:
211: * OffsetRect(&rcObjRect,lpptOffset->x,lpptOffset->y)
212: *
213: * Return Value:
214: * none
215: */
216: STDAPI_(void) SetHatchWindowSize(
217: HWND hWndHatch,
218: LPRECT lprcIPObjRect,
219: LPRECT lprcClipRect,
220: LPPOINT lpptOffset
221: )
222: {
223: RECT rcHatchRect;
224: RECT rcVisRect;
225: UINT uHatchWidth;
226: POINT ptOffset;
227:
228: if (!IsWindow(hWndHatch))
229: return;
230:
231: rcHatchRect = *lprcIPObjRect;
232: uHatchWidth = GetHatchWidth(hWndHatch);
233: InflateRect((LPRECT)&rcHatchRect, uHatchWidth + 1, uHatchWidth + 1);
234:
235: IntersectRect((LPRECT)&rcVisRect, (LPRECT)&rcHatchRect, lprcClipRect);
236: MoveWindow(
237: hWndHatch,
238: rcVisRect.left,
239: rcVisRect.top,
240: rcVisRect.right-rcVisRect.left,
241: rcVisRect.bottom-rcVisRect.top,
242: TRUE /* fRepaint */
243: );
244: InvalidateRect(hWndHatch, NULL, TRUE);
245:
246: ptOffset.x = -rcHatchRect.left + (rcHatchRect.left - rcVisRect.left);
247: ptOffset.y = -rcHatchRect.top + (rcHatchRect.top - rcVisRect.top);
248:
249: /* convert the rcHatchRect into the client coordinate system of the
250: ** HatchWindow itself
251: */
252: OffsetRect((LPRECT)&rcHatchRect, ptOffset.x, ptOffset.y);
253:
254: SetHatchRect(hWndHatch, (LPRECT)&rcHatchRect);
255:
256: // calculate offset required to position in-place server doc window
257: lpptOffset->x = ptOffset.x;
258: lpptOffset->y = ptOffset.y;
259: }
260:
261:
262: /*
263: * HatchWndProc
264: *
265: * Purpose:
266: * WndProc for hatch window
267: *
268: * Parameters:
269: * hWnd
270: * Message
271: * wParam
272: * lParam
273: *
274: * Return Value:
275: * message dependent
276: */
277: LRESULT FAR PASCAL EXPORT HatchWndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
278: {
279: int nBorderWidth;
280:
281: switch (Message) {
282:
283: case WM_CREATE:
284: nBorderWidth = GetProfileInt(
285: "windows",
286: "oleinplaceborderwidth",
287: DEFAULT_HATCHBORDER_WIDTH
288: );
289: SetWindowWord(hWnd, EB_HATCHWIDTH, (WORD)nBorderWidth);
290: break;
291:
292: case WM_PAINT:
293: {
294: HDC hDC;
295: PAINTSTRUCT ps;
296: RECT rcHatchRect;
297:
298: nBorderWidth = GetHatchWidth(hWnd);
299: hDC = BeginPaint(hWnd, &ps);
300: GetHatchRect(hWnd, (LPRECT)&rcHatchRect);
301: OleUIDrawShading(&rcHatchRect, hDC, OLEUI_SHADE_BORDERIN,
302: nBorderWidth);
303: InflateRect((LPRECT)&rcHatchRect, -nBorderWidth, -nBorderWidth);
304: OleUIDrawHandles(&rcHatchRect, hDC, OLEUI_HANDLES_OUTSIDE,
305: nBorderWidth+1, TRUE);
306: EndPaint(hWnd, &ps);
307: break;
308: }
309:
310: default:
311: return DefWindowProc(hWnd, Message, wParam, lParam);
312: }
313:
314: return 0L;
315: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.