![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to oleutl.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 oleutl.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * OLEUTL.C
3: *
4: * Miscellaneous utility functions for OLE 2.0 Applications:
5: *
6: * Function Purpose
7: * -------------------------------------------------------------------
8: * SetDCToDrawInHimetricRect Sets up an HIMETRIC mapping mode in a DC.
9: * ResetOrigDC Performs the opposite of
10: * SetDCToDrawInHimetricRect
11: * XformRectInPixelsToHimetric Converts a rect into HiMetric units
12: * XformRectInHimetricToPixels Converts a rect from HiMetric units
13: * XformSizeInPixelsToHimetric Converts a SIZEL into HiMetric units
14: * XformSizeInHimetricToPixels Converts a SIZEL from HiMetric units
15: * AreRectsEqual Compares to Rect's
16: *
17: * ParseCmdLine Determines if -Embedding exists
18: * OpenOrCreateRootStorage Creates a root docfile for OLE storage
19: * CommitStorage Commits all changes in a docfile
20: * CreateChildStorage Creates child storage in another storage
21: * OpenChildStorage Opens child storage in another storage
22: *
23: *
24: * Copyright (c)1992 Microsoft Corporation, All Right Reserved
25: */
26:
27:
28: #define STRICT 1
29: #include "ole2ui.h"
30: #include <stdlib.h>
31: #include <ctype.h>
32:
33: //Internal function to this module
34: static LPSTR GetWord(LPSTR lpszSrc, LPSTR lpszDst);
35:
36:
37: /*
38: * SetDCToAnisotropic
39: *
40: * Purpose:
41: * Setup the correspondence between the rect in device unit (Viewport) and
42: * the rect in logical unit (Window) so that the proper scaling of
43: * coordinate systems will be calculated. set up both the Viewport and
44: * the window as follows:
45: *
46: * 1) ------------------ ( 2
47: * | |
48: * | |
49: * | |
50: * | |
51: * | |
52: * 3) ------------------ ( 4
53: *
54: * Origin = P3
55: * X extent = P2x - P3x
56: * Y extent = P2y - P3y
57: *
58: * Parameters:
59: * hDC HDC to affect
60: * lprcPhysical LPRECT containing the physical (device) extents of DC
61: * lprcLogical LPRECT containing the logical extents
62: * lprcWindowOld LPRECT in which to preserve the window for ResetOrigDC
63: * lprcViewportOld LPRECT in which to preserver the viewport for ResetOrigDC
64: *
65: * Return Value:
66: * int The original mapping mode of the DC.
67: */
68:
69: STDAPI_(int) SetDCToAnisotropic(
70: HDC hDC,
71: LPRECT lprcPhysical, LPRECT lprcLogical,
72: LPRECT lprcWindowOld, LPRECT lprcViewportOld)
73: {
74: int nMapModeOld=SetMapMode(hDC, MM_ANISOTROPIC);
75:
76: SetWindowOrgEx(hDC, lprcLogical->left, lprcLogical->bottom, (LPPOINT)&lprcWindowOld->left);
77: SetWindowExtEx(hDC, (lprcLogical->right-lprcLogical->left), (lprcLogical->top-lprcLogical->bottom), (LPSIZE)&lprcWindowOld->right);
78: SetViewportOrgEx(hDC, lprcPhysical->left, lprcPhysical->bottom, (LPPOINT)&lprcViewportOld->left);
79: SetViewportExtEx(hDC, (lprcPhysical->right-lprcPhysical->left), (lprcPhysical->top-lprcPhysical->bottom), (LPSIZE)&lprcViewportOld->right);
80:
81: return nMapModeOld;
82: }
83:
84:
85: /*
86: * SetDCToDrawInHimetricRect
87: *
88: * Purpose:
89: * Setup the correspondence between the rect in pixels (Viewport) and
90: * the rect in HIMETRIC (Window) so that the proper scaling of
91: * coordinate systems will be calculated. set up both the Viewport and
92: * the window as follows:
93: *
94: * 1) ------------------ ( 2
95: * | |
96: * | |
97: * | |
98: * | |
99: * | |
100: * 3) ------------------ ( 4
101: *
102: * Origin = P3
103: * X extent = P2x - P3x
104: * Y extent = P2y - P3y
105: *
106: * Parameters:
107: * hDC HDC to affect
108: * lprcPix LPRECT containing the pixel extents of DC
109: * lprcHiMetric LPRECT to receive the himetric extents
110: * lprcWindowOld LPRECT in which to preserve the window for ResetOrigDC
111: * lprcViewportOld LPRECT in which to preserver the viewport for ResetOrigDC
112: *
113: * Return Value:
114: * int The original mapping mode of the DC.
115: */
116: STDAPI_(int) SetDCToDrawInHimetricRect(
117: HDC hDC,
118: LPRECT lprcPix, LPRECT lprcHiMetric,
119: LPRECT lprcWindowOld, LPRECT lprcViewportOld)
120: {
121: int nMapModeOld=SetMapMode(hDC, MM_ANISOTROPIC);
122: BOOL fSystemDC =FALSE;
123:
124: if (NULL==hDC)
125: {
126: hDC=GetDC(NULL);
127: fSystemDC=TRUE;
128: }
129:
130: XformRectInPixelsToHimetric(hDC, lprcPix, lprcHiMetric);
131:
132: SetWindowOrgEx(hDC, lprcHiMetric->left, lprcHiMetric->bottom, (LPPOINT)&lprcWindowOld->left);
133: SetWindowExtEx(hDC, (lprcHiMetric->right-lprcHiMetric->left), (lprcHiMetric->top-lprcHiMetric->bottom), (LPSIZE)&lprcWindowOld->right);
134: SetViewportOrgEx(hDC, lprcPix->left, lprcPix->bottom, (LPPOINT)&lprcViewportOld->left);
135: SetViewportExtEx(hDC, (lprcPix->right-lprcPix->left), (lprcPix->top-lprcPix->bottom), (LPSIZE)&lprcViewportOld->right);
136:
137: if (fSystemDC)
138: ReleaseDC(NULL, hDC);
139:
140: return nMapModeOld;
141: }
142:
143:
144:
145: /*
146: * ResetOrigDC
147: *
148: * Purpose:
149: * Restores a DC set to draw in himetric from SetDCToDrawInHimetricRect.
150: *
151: * Parameters:
152: * hDC HDC to restore
153: * nMapModeOld int original mapping mode of hDC
154: * lprcWindowOld LPRECT filled in SetDCToDrawInHimetricRect
155: * lprcViewportOld LPRECT filled in SetDCToDrawInHimetricRect
156: *
157: * Return Value:
158: * int Same as nMapModeOld.
159: */
160:
161: STDAPI_(int) ResetOrigDC(
162: HDC hDC, int nMapModeOld,
163: LPRECT lprcWindowOld, LPRECT lprcViewportOld)
164: {
165: POINT pOld;
166:
167: SetMapMode(hDC, nMapModeOld);
168:
169: SetWindowOrgEx(hDC, lprcWindowOld->left, lprcWindowOld->top, (LPPOINT)&pOld);
170: SetWindowExtEx(hDC, lprcWindowOld->right, lprcWindowOld->bottom, (LPSIZE)&pOld);
171: SetViewportOrgEx(hDC, lprcViewportOld->left, lprcViewportOld->top, (LPPOINT)&pOld);
172: SetViewportExtEx(hDC, lprcViewportOld->right, lprcViewportOld->bottom, (LPSIZE)&pOld);
173:
174: return nMapModeOld;
175: }
176:
177:
178:
179:
180:
181:
182: /*
183: * XformRectInPixelsToHimetric
184: * XformRectInHimetricToPixels
185: *
186: * Purpose:
187: * Convert a rectangle between pixels of a given hDC and HIMETRIC units
188: * as manipulated in OLE. If the hDC is NULL, then a screen DC is used
189: * and assumes the MM_TEXT mapping mode.
190: *
191: * Parameters:
192: * hDC HDC providing reference to the pixel mapping. If
193: * NULL, a screen DC is used.
194: * lprcSrc LPRECT providing the rectangle to convert. This
195: * contains pixels in XformRectInPixelsToHimetric and
196: * logical HiMetric units in the complement function.
197: * lprcDst LPRECT providing the rectangle to receive converted units.
198: * This contains pixels in XformRectInPixelsToHimetric and
199: * logical HiMetric units in the complement function.
200: *
201: * Return Value:
202: * None
203: *
204: * NOTE:
205: * When displaying on the screen, Window apps display everything enlarged
206: * from its actual size so that it is easier to read. For example, if an
207: * app wants to display a 1in. horizontal line, that when printed is
208: * actually a 1in. line on the printed page, then it will display the line
209: * on the screen physically larger than 1in. This is described as a line
210: * that is "logically" 1in. along the display width. Windows maintains as
211: * part of the device-specific information about a given display device:
212: * LOGPIXELSX -- no. of pixels per logical in along the display width
213: * LOGPIXELSY -- no. of pixels per logical in along the display height
214: *
215: * The following formula converts a distance in pixels into its equivalent
216: * logical HIMETRIC units:
217: *
218: * DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
219: * -------------------------------
220: * PIXELS_PER_LOGICAL_IN
221: *
222: * Rect in Pixels (MM_TEXT):
223: *
224: * 0---------- X
225: * |
226: * | 1) ------------------ ( 2 P1 = (rc.left, rc.top)
227: * | | | P2 = (rc.right, rc.top)
228: * | | | P3 = (rc.left, rc.bottom)
229: * | | | P4 = (rc.right, rc.bottom)
230: * | |
231: * Y | |
232: * 3) ------------------ ( 4
233: *
234: * NOTE: Origin = (P1x, P1y)
235: * X extent = P4x - P1x
236: * Y extent = P4y - P1y
237: *
238: *
239: * Rect in Himetric (MM_HIMETRIC):
240: *
241: *
242: * 1) ------------------ ( 2 P1 = (rc.left, rc.top)
243: * Y | | P2 = (rc.right, rc.top)
244: * | | P3 = (rc.left, rc.bottom)
245: * | | | P4 = (rc.right, rc.bottom)
246: * | | |
247: * | | |
248: * | 3) ------------------ ( 4
249: * |
250: * 0---------- X
251: *
252: * NOTE: Origin = (P3x, P3y)
253: * X extent = P2x - P3x
254: * Y extent = P2y - P3y
255: *
256: *
257: */
258:
259: STDAPI_(void) XformRectInPixelsToHimetric(
260: HDC hDC, LPRECT lprcPix, LPRECT lprcHiMetric)
261: {
262: int iXppli; //Pixels per logical inch along width
263: int iYppli; //Pixels per logical inch along height
264: int iXextInPix=(lprcPix->right-lprcPix->left);
265: int iYextInPix=(lprcPix->bottom-lprcPix->top);
266: BOOL fSystemDC=FALSE;
267:
268: if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
269: {
270: hDC=GetDC(NULL);
271: fSystemDC=TRUE;
272: }
273:
274: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
275: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
276:
277: //We got pixel units, convert them to logical HIMETRIC along the display
278: lprcHiMetric->right = MAP_PIX_TO_LOGHIM(iXextInPix, iXppli);
279: lprcHiMetric->top = MAP_PIX_TO_LOGHIM(iYextInPix, iYppli);
280:
281: lprcHiMetric->left = 0;
282: lprcHiMetric->bottom = 0;
283:
284: if (fSystemDC)
285: ReleaseDC(NULL, hDC);
286:
287: return;
288: }
289:
290:
291:
292: STDAPI_(void) XformRectInHimetricToPixels(
293: HDC hDC, LPRECT lprcHiMetric, LPRECT lprcPix)
294: {
295: int iXppli; //Pixels per logical inch along width
296: int iYppli; //Pixels per logical inch along height
297: int iXextInHiMetric=(lprcHiMetric->right-lprcHiMetric->left);
298: int iYextInHiMetric=(lprcHiMetric->bottom-lprcHiMetric->top);
299: BOOL fSystemDC=FALSE;
300:
301: if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
302: {
303: hDC=GetDC(NULL);
304: fSystemDC=TRUE;
305: }
306:
307: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
308: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
309:
310: //We got pixel units, convert them to logical HIMETRIC along the display
311: lprcPix->right = MAP_LOGHIM_TO_PIX(iXextInHiMetric, iXppli);
312: lprcPix->top = MAP_LOGHIM_TO_PIX(iYextInHiMetric, iYppli);
313:
314: lprcPix->left = 0;
315: lprcPix->bottom= 0;
316:
317: if (fSystemDC)
318: ReleaseDC(NULL, hDC);
319:
320: return;
321: }
322:
323:
324:
325:
326: /*
327: * XformSizeInPixelsToHimetric
328: * XformSizeInHimetricToPixels
329: *
330: * Functions to convert a SIZEL structure (Size functions) or
331: * an int (Width functions) between a device coordinate system and
332: * logical HiMetric units.
333: *
334: * Parameters:
335: * hDC HDC providing reference to the pixel mapping. If
336: * NULL, a screen DC is used.
337: *
338: * Size Functions:
339: * lpSizeSrc LPSIZEL providing the structure to convert. This
340: * contains pixels in XformSizeInPixelsToHimetric and
341: * logical HiMetric units in the complement function.
342: * lpSizeDst LPSIZEL providing the structure to receive converted
343: * units. This contains pixels in
344: * XformSizeInPixelsToHimetric and logical HiMetric
345: * units in the complement function.
346: *
347: * Width Functions:
348: * iWidth int containing the value to convert.
349: *
350: * Return Value:
351: * Size Functions: None
352: * Width Functions: Converted value of the input parameters.
353: *
354: * NOTE:
355: * When displaying on the screen, Window apps display everything enlarged
356: * from its actual size so that it is easier to read. For example, if an
357: * app wants to display a 1in. horizontal line, that when printed is
358: * actually a 1in. line on the printed page, then it will display the line
359: * on the screen physically larger than 1in. This is described as a line
360: * that is "logically" 1in. along the display width. Windows maintains as
361: * part of the device-specific information about a given display device:
362: * LOGPIXELSX -- no. of pixels per logical in along the display width
363: * LOGPIXELSY -- no. of pixels per logical in along the display height
364: *
365: * The following formula converts a distance in pixels into its equivalent
366: * logical HIMETRIC units:
367: *
368: * DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
369: * -------------------------------
370: * PIXELS_PER_LOGICAL_IN
371: *
372: */
373:
374: STDAPI_(void) XformSizeInPixelsToHimetric(
375: HDC hDC, LPSIZEL lpSizeInPix, LPSIZEL lpSizeInHiMetric)
376: {
377: int iXppli; //Pixels per logical inch along width
378: int iYppli; //Pixels per logical inch along height
379: BOOL fSystemDC=FALSE;
380:
381: if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
382: {
383: hDC=GetDC(NULL);
384: fSystemDC=TRUE;
385: }
386:
387: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
388: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
389:
390: //We got pixel units, convert them to logical HIMETRIC along the display
391: lpSizeInHiMetric->cx = (long)MAP_PIX_TO_LOGHIM((int)lpSizeInPix->cx, iXppli);
392: lpSizeInHiMetric->cy = (long)MAP_PIX_TO_LOGHIM((int)lpSizeInPix->cy, iYppli);
393:
394: if (fSystemDC)
395: ReleaseDC(NULL, hDC);
396:
397: return;
398: }
399:
400:
401: STDAPI_(void) XformSizeInHimetricToPixels(
402: HDC hDC, LPSIZEL lpSizeInHiMetric, LPSIZEL lpSizeInPix)
403: {
404: int iXppli; //Pixels per logical inch along width
405: int iYppli; //Pixels per logical inch along height
406: BOOL fSystemDC=FALSE;
407:
408: if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
409: {
410: hDC=GetDC(NULL);
411: fSystemDC=TRUE;
412: }
413:
414: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
415: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
416:
417: //We got logical HIMETRIC along the display, convert them to pixel units
418: lpSizeInPix->cx = (long)MAP_LOGHIM_TO_PIX((int)lpSizeInHiMetric->cx, iXppli);
419: lpSizeInPix->cy = (long)MAP_LOGHIM_TO_PIX((int)lpSizeInHiMetric->cy, iYppli);
420:
421: if (fSystemDC)
422: ReleaseDC(NULL, hDC);
423:
424: return;
425: }
426:
427:
428:
429: /* AreRectsEqual
430: ** -------------
431: ** Returns TRUE if all fields of the two Rect's are equal,
432: ** else FALSE.
433: */
434: STDAPI_(BOOL) AreRectsEqual(LPRECT lprc1, LPRECT lprc2)
435: {
436: if ((lprc1->top == lprc2->top) &&
437: (lprc1->left == lprc2->left) &&
438: (lprc1->right == lprc2->right) &&
439: (lprc1->bottom == lprc2->bottom))
440: return TRUE;
441:
442: return FALSE;
443: }
444:
445:
446: /*
447: * ParseCmdLine
448: *
449: * Parses the Windows command line which was passed to WinMain.
450: * This function determines if the -Embedding switch has been given.
451: *
452: */
453:
454: STDAPI_(void) ParseCmdLine(
455: LPSTR lpszLine,
456: BOOL FAR* lpfEmbedFlag,
457: LPSTR szFileName)
458: {
459: int i=0;
460: char szBuf[256];
461:
462: if(lpfEmbedFlag)
463: *lpfEmbedFlag = FALSE;
464: szFileName[0]='\0'; // NULL string
465:
466: // skip blanks
467: while(isspace(*lpszLine)) lpszLine++;
468:
469: if(!*lpszLine) // No filename or options, so start a fresh document.
470: return;
471:
472: // Check for "-Embedding" or "/Embedding" and set fEmbedding.
473: if(lpfEmbedFlag && (*lpszLine == '-' || *lpszLine == '/')) {
474: lpszLine++;
475: lpszLine = GetWord(lpszLine, szBuf);
476: *lpfEmbedFlag = !lstrcmp(szBuf, EMBEDDINGFLAG);
477: }
478:
479: // skip blanks
480: while(isspace(*lpszLine)) lpszLine++;
481:
482: // set szFileName to argument
483: while(lpszLine[i]) {
484: szFileName[i]=lpszLine[i];
485: i++;
486: }
487: szFileName[i]='\0';
488: }
489:
490:
491: /* GetWord
492: * -------
493: *
494: * LPSTR lpszSrc - Pointer to a source string
495: * LPSTR lpszDst - Pointer to destination buffer
496: *
497: * Will copy one space-terminated or null-terminated word from the source
498: * string to the destination buffer.
499: * returns: pointer to next character following the word.
500: */
501: static LPSTR GetWord(LPSTR lpszSrc, LPSTR lpszDst)
502: {
503: while (*lpszSrc && !isspace(*lpszSrc))
504: *lpszDst++ = *lpszSrc++;
505:
506: *lpszDst = '\0';
507: return lpszSrc;
508: }
509:
510:
511:
512:
513:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.