able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/oleutest/letest/ole2ui/oleutl.c

661 lines
21 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* OLEUTL.C
*
* Miscellaneous utility functions for OLE 2.0 Applications:
*
* Function Purpose
* -------------------------------------------------------------------
* SetDCToDrawInHimetricRect Sets up an HIMETRIC mapping mode in a DC.
* ResetOrigDC Performs the opposite of
* SetDCToDrawInHimetricRect
* XformWidthInPixelsToHimetric Converts an int width into HiMetric units
* XformWidthInHimetricToPixels Converts an int width from HiMetric units
* XformHeightInPixelsToHimetric Converts an int height into HiMetric units
* XformHeightInHimetricToPixels Converts an int height from HiMetric units
* XformRectInPixelsToHimetric Converts a rect into HiMetric units
* XformRectInHimetricToPixels Converts a rect from HiMetric units
* XformSizeInPixelsToHimetric Converts a SIZEL into HiMetric units
* XformSizeInHimetricToPixels Converts a SIZEL from HiMetric units
* AreRectsEqual Compares to Rect's
*
* ParseCmdLine Determines if -Embedding exists
* OpenOrCreateRootStorage Creates a root docfile for OLE storage
* CommitStorage Commits all changes in a docfile
* CreateChildStorage Creates child storage in another storage
* OpenChildStorage Opens child storage in another storage
*
*
* Copyright (c)1992 Microsoft Corporation, All Right Reserved
*/
#define STRICT 1
#include "ole2ui.h"
#include <stdlib.h>
#include <ctype.h>
//Internal function to this module. No need for UNICODE in this function
static LPSTR GetWord(LPSTR lpszSrc, LPSTR lpszDst);
/*
* SetDCToAnisotropic
*
* Purpose:
* Setup the correspondence between the rect in device unit (Viewport) and
* the rect in logical unit (Window) so that the proper scaling of
* coordinate systems will be calculated. set up both the Viewport and
* the window as follows:
*
* 1) ------------------ ( 2
* | |
* | |
* | |
* | |
* | |
* 3) ------------------ ( 4
*
* Origin = P3
* X extent = P2x - P3x
* Y extent = P2y - P3y
*
* Parameters:
* hDC HDC to affect
* lprcPhysical LPRECT containing the physical (device) extents of DC
* lprcLogical LPRECT containing the logical extents
* lprcWindowOld LPRECT in which to preserve the window for ResetOrigDC
* lprcViewportOld LPRECT in which to preserver the viewport for ResetOrigDC
*
* Return Value:
* int The original mapping mode of the DC.
*/
STDAPI_(int) SetDCToAnisotropic(
HDC hDC,
LPRECT lprcPhysical, LPRECT lprcLogical,
LPRECT lprcWindowOld, LPRECT lprcViewportOld)
{
int nMapModeOld=SetMapMode(hDC, MM_ANISOTROPIC);
SetWindowOrgEx(hDC, lprcLogical->left, lprcLogical->bottom, (LPPOINT)&lprcWindowOld->left);
SetWindowExtEx(hDC, (lprcLogical->right-lprcLogical->left), (lprcLogical->top-lprcLogical->bottom), (LPSIZE)&lprcWindowOld->right);
SetViewportOrgEx(hDC, lprcPhysical->left, lprcPhysical->bottom, (LPPOINT)&lprcViewportOld->left);
SetViewportExtEx(hDC, (lprcPhysical->right-lprcPhysical->left), (lprcPhysical->top-lprcPhysical->bottom), (LPSIZE)&lprcViewportOld->right);
return nMapModeOld;
}
/*
* SetDCToDrawInHimetricRect
*
* Purpose:
* Setup the correspondence between the rect in pixels (Viewport) and
* the rect in HIMETRIC (Window) so that the proper scaling of
* coordinate systems will be calculated. set up both the Viewport and
* the window as follows:
*
* 1) ------------------ ( 2
* | |
* | |
* | |
* | |
* | |
* 3) ------------------ ( 4
*
* Origin = P3
* X extent = P2x - P3x
* Y extent = P2y - P3y
*
* Parameters:
* hDC HDC to affect
* lprcPix LPRECT containing the pixel extents of DC
* lprcHiMetric LPRECT to receive the himetric extents
* lprcWindowOld LPRECT in which to preserve the window for ResetOrigDC
* lprcViewportOld LPRECT in which to preserver the viewport for ResetOrigDC
*
* Return Value:
* int The original mapping mode of the DC.
*/
STDAPI_(int) SetDCToDrawInHimetricRect(
HDC hDC,
LPRECT lprcPix, LPRECT lprcHiMetric,
LPRECT lprcWindowOld, LPRECT lprcViewportOld)
{
int nMapModeOld=SetMapMode(hDC, MM_ANISOTROPIC);
BOOL fSystemDC =FALSE;
if (NULL==hDC)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
XformRectInPixelsToHimetric(hDC, lprcPix, lprcHiMetric);
SetWindowOrgEx(hDC, lprcHiMetric->left, lprcHiMetric->bottom, (LPPOINT)&lprcWindowOld->left);
SetWindowExtEx(hDC, (lprcHiMetric->right-lprcHiMetric->left), (lprcHiMetric->top-lprcHiMetric->bottom), (LPSIZE)&lprcWindowOld->right);
SetViewportOrgEx(hDC, lprcPix->left, lprcPix->bottom, (LPPOINT)&lprcViewportOld->left);
SetViewportExtEx(hDC, (lprcPix->right-lprcPix->left), (lprcPix->top-lprcPix->bottom), (LPSIZE)&lprcViewportOld->right);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return nMapModeOld;
}
/*
* ResetOrigDC
*
* Purpose:
* Restores a DC set to draw in himetric from SetDCToDrawInHimetricRect.
*
* Parameters:
* hDC HDC to restore
* nMapModeOld int original mapping mode of hDC
* lprcWindowOld LPRECT filled in SetDCToDrawInHimetricRect
* lprcViewportOld LPRECT filled in SetDCToDrawInHimetricRect
*
* Return Value:
* int Same as nMapModeOld.
*/
STDAPI_(int) ResetOrigDC(
HDC hDC, int nMapModeOld,
LPRECT lprcWindowOld, LPRECT lprcViewportOld)
{
POINT pOld;
SetMapMode(hDC, nMapModeOld);
SetWindowOrgEx(hDC, lprcWindowOld->left, lprcWindowOld->top, (LPPOINT)&pOld);
SetWindowExtEx(hDC, lprcWindowOld->right, lprcWindowOld->bottom, (LPSIZE)&pOld);
SetViewportOrgEx(hDC, lprcViewportOld->left, lprcViewportOld->top, (LPPOINT)&pOld);
SetViewportExtEx(hDC, lprcViewportOld->right, lprcViewportOld->bottom, (LPSIZE)&pOld);
return nMapModeOld;
}
/*
* XformWidthInPixelsToHimetric
* XformWidthInHimetricToPixels
* XformHeightInPixelsToHimetric
* XformHeightInHimetricToPixels
*
* Functions to convert an int between a device coordinate system and
* logical HiMetric units.
*
* Parameters:
* hDC HDC providing reference to the pixel mapping. If
* NULL, a screen DC is used.
*
* Size Functions:
* lpSizeSrc LPSIZEL providing the structure to convert. This
* contains pixels in XformSizeInPixelsToHimetric and
* logical HiMetric units in the complement function.
* lpSizeDst LPSIZEL providing the structure to receive converted
* units. This contains pixels in
* XformSizeInPixelsToHimetric and logical HiMetric
* units in the complement function.
*
* Width Functions:
* iWidth int containing the value to convert.
*
* Return Value:
* Size Functions: None
* Width Functions: Converted value of the input parameters.
*
* NOTE:
* When displaying on the screen, Window apps display everything enlarged
* from its actual size so that it is easier to read. For example, if an
* app wants to display a 1in. horizontal line, that when printed is
* actually a 1in. line on the printed page, then it will display the line
* on the screen physically larger than 1in. This is described as a line
* that is "logically" 1in. along the display width. Windows maintains as
* part of the device-specific information about a given display device:
* LOGPIXELSX -- no. of pixels per logical in along the display width
* LOGPIXELSY -- no. of pixels per logical in along the display height
*
* The following formula converts a distance in pixels into its equivalent
* logical HIMETRIC units:
*
* DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
* -------------------------------
* PIXELS_PER_LOGICAL_IN
*
*/
STDAPI_(int) XformWidthInPixelsToHimetric(HDC hDC, int iWidthInPix)
{
int iXppli; //Pixels per logical inch along width
int iWidthInHiMetric;
BOOL fSystemDC=FALSE;
if (NULL==hDC)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
//We got pixel units, convert them to logical HIMETRIC along the display
iWidthInHiMetric = MAP_PIX_TO_LOGHIM(iWidthInPix, iXppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return iWidthInHiMetric;
}
STDAPI_(int) XformWidthInHimetricToPixels(HDC hDC, int iWidthInHiMetric)
{
int iXppli; //Pixels per logical inch along width
int iWidthInPix;
BOOL fSystemDC=FALSE;
if (NULL==hDC)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
//We got logical HIMETRIC along the display, convert them to pixel units
iWidthInPix = MAP_LOGHIM_TO_PIX(iWidthInHiMetric, iXppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return iWidthInPix;
}
STDAPI_(int) XformHeightInPixelsToHimetric(HDC hDC, int iHeightInPix)
{
int iYppli; //Pixels per logical inch along height
int iHeightInHiMetric;
BOOL fSystemDC=FALSE;
if (NULL==hDC)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//* We got pixel units, convert them to logical HIMETRIC along the display
iHeightInHiMetric = MAP_PIX_TO_LOGHIM(iHeightInPix, iYppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return iHeightInHiMetric;
}
STDAPI_(int) XformHeightInHimetricToPixels(HDC hDC, int iHeightInHiMetric)
{
int iYppli; //Pixels per logical inch along height
int iHeightInPix;
BOOL fSystemDC=FALSE;
if (NULL==hDC)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//* We got logical HIMETRIC along the display, convert them to pixel units
iHeightInPix = MAP_LOGHIM_TO_PIX(iHeightInHiMetric, iYppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return iHeightInPix;
}
/*
* XformRectInPixelsToHimetric
* XformRectInHimetricToPixels
*
* Purpose:
* Convert a rectangle between pixels of a given hDC and HIMETRIC units
* as manipulated in OLE. If the hDC is NULL, then a screen DC is used
* and assumes the MM_TEXT mapping mode.
*
* Parameters:
* hDC HDC providing reference to the pixel mapping. If
* NULL, a screen DC is used.
* lprcSrc LPRECT providing the rectangle to convert. This
* contains pixels in XformRectInPixelsToHimetric and
* logical HiMetric units in the complement function.
* lprcDst LPRECT providing the rectangle to receive converted units.
* This contains pixels in XformRectInPixelsToHimetric and
* logical HiMetric units in the complement function.
*
* Return Value:
* None
*
* NOTE:
* When displaying on the screen, Window apps display everything enlarged
* from its actual size so that it is easier to read. For example, if an
* app wants to display a 1in. horizontal line, that when printed is
* actually a 1in. line on the printed page, then it will display the line
* on the screen physically larger than 1in. This is described as a line
* that is "logically" 1in. along the display width. Windows maintains as
* part of the device-specific information about a given display device:
* LOGPIXELSX -- no. of pixels per logical in along the display width
* LOGPIXELSY -- no. of pixels per logical in along the display height
*
* The following formula converts a distance in pixels into its equivalent
* logical HIMETRIC units:
*
* DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
* -------------------------------
* PIXELS_PER_LOGICAL_IN
*
* Rect in Pixels (MM_TEXT):
*
* 0---------- X
* |
* | 1) ------------------ ( 2 P1 = (rc.left, rc.top)
* | | | P2 = (rc.right, rc.top)
* | | | P3 = (rc.left, rc.bottom)
* | | | P4 = (rc.right, rc.bottom)
* | |
* Y | |
* 3) ------------------ ( 4
*
* NOTE: Origin = (P1x, P1y)
* X extent = P4x - P1x
* Y extent = P4y - P1y
*
*
* Rect in Himetric (MM_HIMETRIC):
*
*
* 1) ------------------ ( 2 P1 = (rc.left, rc.top)
* Y | | P2 = (rc.right, rc.top)
* | | P3 = (rc.left, rc.bottom)
* | | | P4 = (rc.right, rc.bottom)
* | | |
* | | |
* | 3) ------------------ ( 4
* |
* 0---------- X
*
* NOTE: Origin = (P3x, P3y)
* X extent = P2x - P3x
* Y extent = P2y - P3y
*
*
*/
STDAPI_(void) XformRectInPixelsToHimetric(
HDC hDC, LPRECT lprcPix, LPRECT lprcHiMetric)
{
int iXppli; //Pixels per logical inch along width
int iYppli; //Pixels per logical inch along height
int iXextInPix=(lprcPix->right-lprcPix->left);
int iYextInPix=(lprcPix->bottom-lprcPix->top);
BOOL fSystemDC=FALSE;
if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//We got pixel units, convert them to logical HIMETRIC along the display
lprcHiMetric->right = MAP_PIX_TO_LOGHIM(iXextInPix, iXppli);
lprcHiMetric->top = MAP_PIX_TO_LOGHIM(iYextInPix, iYppli);
lprcHiMetric->left = 0;
lprcHiMetric->bottom = 0;
if (fSystemDC)
ReleaseDC(NULL, hDC);
return;
}
STDAPI_(void) XformRectInHimetricToPixels(
HDC hDC, LPRECT lprcHiMetric, LPRECT lprcPix)
{
int iXppli; //Pixels per logical inch along width
int iYppli; //Pixels per logical inch along height
int iXextInHiMetric=(lprcHiMetric->right-lprcHiMetric->left);
int iYextInHiMetric=(lprcHiMetric->bottom-lprcHiMetric->top);
BOOL fSystemDC=FALSE;
if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//We got pixel units, convert them to logical HIMETRIC along the display
lprcPix->right = MAP_LOGHIM_TO_PIX(iXextInHiMetric, iXppli);
lprcPix->top = MAP_LOGHIM_TO_PIX(iYextInHiMetric, iYppli);
lprcPix->left = 0;
lprcPix->bottom= 0;
if (fSystemDC)
ReleaseDC(NULL, hDC);
return;
}
/*
* XformSizeInPixelsToHimetric
* XformSizeInHimetricToPixels
*
* Functions to convert a SIZEL structure (Size functions) or
* an int (Width functions) between a device coordinate system and
* logical HiMetric units.
*
* Parameters:
* hDC HDC providing reference to the pixel mapping. If
* NULL, a screen DC is used.
*
* Size Functions:
* lpSizeSrc LPSIZEL providing the structure to convert. This
* contains pixels in XformSizeInPixelsToHimetric and
* logical HiMetric units in the complement function.
* lpSizeDst LPSIZEL providing the structure to receive converted
* units. This contains pixels in
* XformSizeInPixelsToHimetric and logical HiMetric
* units in the complement function.
*
* Width Functions:
* iWidth int containing the value to convert.
*
* Return Value:
* Size Functions: None
* Width Functions: Converted value of the input parameters.
*
* NOTE:
* When displaying on the screen, Window apps display everything enlarged
* from its actual size so that it is easier to read. For example, if an
* app wants to display a 1in. horizontal line, that when printed is
* actually a 1in. line on the printed page, then it will display the line
* on the screen physically larger than 1in. This is described as a line
* that is "logically" 1in. along the display width. Windows maintains as
* part of the device-specific information about a given display device:
* LOGPIXELSX -- no. of pixels per logical in along the display width
* LOGPIXELSY -- no. of pixels per logical in along the display height
*
* The following formula converts a distance in pixels into its equivalent
* logical HIMETRIC units:
*
* DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
* -------------------------------
* PIXELS_PER_LOGICAL_IN
*
*/
STDAPI_(void) XformSizeInPixelsToHimetric(
HDC hDC, LPSIZEL lpSizeInPix, LPSIZEL lpSizeInHiMetric)
{
int iXppli; //Pixels per logical inch along width
int iYppli; //Pixels per logical inch along height
BOOL fSystemDC=FALSE;
if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//We got pixel units, convert them to logical HIMETRIC along the display
lpSizeInHiMetric->cx = (long)MAP_PIX_TO_LOGHIM((int)lpSizeInPix->cx, iXppli);
lpSizeInHiMetric->cy = (long)MAP_PIX_TO_LOGHIM((int)lpSizeInPix->cy, iYppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return;
}
STDAPI_(void) XformSizeInHimetricToPixels(
HDC hDC, LPSIZEL lpSizeInHiMetric, LPSIZEL lpSizeInPix)
{
int iXppli; //Pixels per logical inch along width
int iYppli; //Pixels per logical inch along height
BOOL fSystemDC=FALSE;
if (NULL==hDC || GetDeviceCaps(hDC, LOGPIXELSX) == 0)
{
hDC=GetDC(NULL);
fSystemDC=TRUE;
}
iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
//We got logical HIMETRIC along the display, convert them to pixel units
lpSizeInPix->cx = (long)MAP_LOGHIM_TO_PIX((int)lpSizeInHiMetric->cx, iXppli);
lpSizeInPix->cy = (long)MAP_LOGHIM_TO_PIX((int)lpSizeInHiMetric->cy, iYppli);
if (fSystemDC)
ReleaseDC(NULL, hDC);
return;
}
#if defined( OBSOLETE )
// This function has been converted to a macro
/* AreRectsEqual
** -------------
*/
STDAPI_(BOOL) AreRectsEqual(LPRECT lprc1, LPRECT lprc2)
{
if ((lprc1->top == lprc2->top) &&
(lprc1->left == lprc2->left) &&
(lprc1->right == lprc2->right) &&
(lprc1->bottom == lprc2->bottom))
return TRUE;
return FALSE;
}
#endif // OBSOLETE
/*
* ParseCmdLine
*
* Parses the Windows command line which was passed to WinMain.
* This function determines if the -Embedding switch has been given.
*
*/
STDAPI_(void) ParseCmdLine(
LPSTR lpszLine,
BOOL FAR* lpfEmbedFlag,
LPSTR szFileName)
{
int i=0;
CHAR szBuf[256];
if(lpfEmbedFlag)
*lpfEmbedFlag = FALSE;
szFileName[0]='\0'; // NULL string
// skip blanks
while(isspace(*lpszLine)) lpszLine++;
if(!*lpszLine) // No filename or options, so start a fresh document.
return;
// Check for "-Embedding" or "/Embedding" and set fEmbedding.
if(lpfEmbedFlag && (*lpszLine == '-' || *lpszLine == '/')) {
lpszLine++;
lpszLine = GetWord(lpszLine, szBuf);
*lpfEmbedFlag = (BOOL) !strcmp(szBuf, EMBEDDINGFLAG);
}
// skip blanks
while(isspace(*lpszLine)) lpszLine++;
// set szFileName to argument
while(lpszLine[i]) {
szFileName[i]=lpszLine[i];
i++;
}
szFileName[i]='\0';
}
/* GetWord
* -------
*
* LPSTR lpszSrc - Pointer to a source string
* LPSTR lpszDst - Pointer to destination buffer
*
* Will copy one space-terminated or null-terminated word from the source
* string to the destination buffer.
* returns: pointer to next character following the word.
*/
static LPSTR GetWord(LPSTR lpszSrc, LPSTR lpszDst)
{
while (*lpszSrc && !isspace(*lpszSrc))
*lpszDst++ = *lpszSrc++;
*lpszDst = '\0';
return lpszSrc;
}

Reference in a new issue Copy permalink