568 lines
18 KiB
C++
568 lines
18 KiB
C++
|
// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
|
||
|
|
|
||
|
|
#include "header.h"
|
||
|
|
#include "internet.h"
|
||
|
|
#include <stddef.h>
|
||
|
|
|
||
|
|
#ifndef _DEBUG
|
||
|
|
#undef THIS_FILE
|
||
|
|
static const char THIS_FILE[] = __FILE__;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
HDC _CreateOleDC(DVTARGETDEVICE *ptd);
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::Draw [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Draws a representation of an object onto the specified device context.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] draw aspect
|
||
|
|
// LONG - [in] part of object to draw [not relevant]
|
||
|
|
// void * - NULL
|
||
|
|
// DVTARGETDEVICE * - [in] specifies the target device
|
||
|
|
// HDC - [in] information context for target device
|
||
|
|
// HDC - [in] target device context
|
||
|
|
// LPCRECTL - [in] rectangle in which the object is drawn
|
||
|
|
// LPCRECTL - [in] window extent and origin for metafiles
|
||
|
|
// BOOL (*)(DWORD) - [in] callback for continuing or cancelling drawing
|
||
|
|
// DWORD - [in] parameter to pass to callback.
|
||
|
|
//
|
||
|
|
// Output:
|
||
|
|
// HRESULT
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
// - we support the following OCX 96 extensions
|
||
|
|
// a. flicker free drawing [multi-pass drawing]
|
||
|
|
// b. pvAspect != NULL for optimized DC handling
|
||
|
|
// c. prcBounds == NULL for windowless inplace active objects
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::Draw(DWORD dwDrawAspect, LONG lIndex,
|
||
|
|
void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDevice,
|
||
|
|
HDC hdcDraw, LPCRECTL prcBounds,
|
||
|
|
LPCRECTL prcWBounds,
|
||
|
|
BOOL (__stdcall *pfnContinue)(ULONG_PTR dwContinue),
|
||
|
|
ULONG_PTR dwContinue)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
RECTL rc;
|
||
|
|
POINT pVp, pW;
|
||
|
|
BOOL fOptimize = FALSE;
|
||
|
|
int iMode;
|
||
|
|
BYTE fMetafile = FALSE;
|
||
|
|
BYTE fDeleteDC = FALSE;
|
||
|
|
|
||
|
|
// support the aspects required for multi-pass drawing
|
||
|
|
|
||
|
|
switch (dwDrawAspect) {
|
||
|
|
case DVASPECT_CONTENT:
|
||
|
|
case DVASPECT_OPAQUE:
|
||
|
|
case DVASPECT_TRANSPARENT:
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return DV_E_DVASPECT;
|
||
|
|
}
|
||
|
|
|
||
|
|
// first, have to do a little bit to support printing.
|
||
|
|
|
||
|
|
if (GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE) {
|
||
|
|
|
||
|
|
// We are dealing with a metafile.
|
||
|
|
//
|
||
|
|
fMetafile = TRUE;
|
||
|
|
|
||
|
|
// If attributes DC is NULL, create one, based on ptd.
|
||
|
|
|
||
|
|
if (!hicTargetDevice) {
|
||
|
|
|
||
|
|
// Does _CreateOleDC have to return an hDC
|
||
|
|
// or can it be flagged to return an hIC
|
||
|
|
// for this particular case?
|
||
|
|
//
|
||
|
|
hicTargetDevice = _CreateOleDC(ptd);
|
||
|
|
fDeleteDC = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// check to see if we have any flags passed in the pvAspect parameter.
|
||
|
|
|
||
|
|
if (pvAspect && ((DVASPECTINFO *)pvAspect)->cb == sizeof(DVASPECTINFO))
|
||
|
|
fOptimize = (((DVASPECTINFO *)pvAspect)->dwFlags & DVASPECTINFOFLAG_CANOPTIMIZE) ? TRUE : FALSE;
|
||
|
|
|
||
|
|
// if we are windowless, then we just pass this on to the end control code.
|
||
|
|
|
||
|
|
if (m_fInPlaceActive) {
|
||
|
|
// Can't use CopyRect because OLE decided to use RECTL instead of RECT
|
||
|
|
memcpy(&rc, &m_rcLocation, sizeof(m_rcLocation));
|
||
|
|
} else {
|
||
|
|
memcpy(&rc, prcBounds, sizeof(rc));
|
||
|
|
|
||
|
|
// first -- convert the DC back to MM_TEXT mapping mode so that the
|
||
|
|
// window proc and OnDraw can share the same painting code. save
|
||
|
|
// some information on it, so we can restore it later [without using
|
||
|
|
// a SaveDC/RestoreDC]
|
||
|
|
//
|
||
|
|
|
||
|
|
// Don't do anything to hdcDraw if it's a metafile.
|
||
|
|
// The control's Draw method must make the appropriate
|
||
|
|
// accomodations for drawing to a metafile
|
||
|
|
//
|
||
|
|
if (!fMetafile) {
|
||
|
|
LPtoDP(hdcDraw, (POINT *)&rc, 2);
|
||
|
|
SetViewportOrgEx(hdcDraw, 0, 0, &pVp);
|
||
|
|
SetWindowOrgEx(hdcDraw, 0, 0, &pW);
|
||
|
|
iMode = SetMapMode(hdcDraw, MM_TEXT);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// prcWBounds is NULL and not used if we are not dealing with a metafile.
|
||
|
|
// For metafiles, we pass on rc as *prcBounds, we should also include
|
||
|
|
// prcWBounds
|
||
|
|
|
||
|
|
hr = OnDraw(dwDrawAspect, hdcDraw, &rc, prcWBounds, hicTargetDevice, fOptimize);
|
||
|
|
|
||
|
|
// clean up the DC when we're done with it, if appropriate.
|
||
|
|
|
||
|
|
if (!m_fInPlaceActive) {
|
||
|
|
SetViewportOrgEx(hdcDraw, pVp.x, pVp.y, NULL);
|
||
|
|
SetWindowOrgEx(hdcDraw, pW.x, pW.y, NULL);
|
||
|
|
SetMapMode(hdcDraw, iMode);
|
||
|
|
}
|
||
|
|
|
||
|
|
// if we created a dc, blow it away now
|
||
|
|
|
||
|
|
if (fDeleteDC)
|
||
|
|
DeleteDC(hicTargetDevice);
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::DoSuperClassPaint
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// design time painting of a subclassed control.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// HDC - [in] dc to work with
|
||
|
|
// LPCRECTL - [in] rectangle to paint to. should be in pixels
|
||
|
|
|
||
|
|
HRESULT COleControl::DoSuperClassPaint(HDC hdc, LPCRECTL prcBounds)
|
||
|
|
{
|
||
|
|
HWND hwnd;
|
||
|
|
RECT rcClient;
|
||
|
|
int iMapMode;
|
||
|
|
POINT ptWOrg, ptVOrg;
|
||
|
|
SIZE sWOrg, sVOrg;
|
||
|
|
|
||
|
|
// make sure we have a window.
|
||
|
|
|
||
|
|
hwnd = CreateInPlaceWindow(0,0, FALSE);
|
||
|
|
if (!hwnd)
|
||
|
|
return E_FAIL;
|
||
|
|
|
||
|
|
GetClientRect(hwnd, &rcClient);
|
||
|
|
|
||
|
|
// set up the DC for painting. this code largely taken from the MFC CDK
|
||
|
|
// DoSuperClassPaint() fn. doesn't always get things like command
|
||
|
|
// buttons quite right ...
|
||
|
|
//
|
||
|
|
// NOTE: there is a windows 95 problem in which the font instance manager
|
||
|
|
// will leak a bunch of bytes in the global GDI pool whenever you
|
||
|
|
// change your extents and have an active font. this code gets around
|
||
|
|
// this for on-screen cases, but not for printing [which shouldn't be
|
||
|
|
// too serious, because you're not often changing your control size and
|
||
|
|
// printing rapidly in succession]
|
||
|
|
|
||
|
|
if ((rcClient.right - rcClient.left != prcBounds->right - prcBounds->left)
|
||
|
|
&& (rcClient.bottom - rcClient.top != prcBounds->bottom - prcBounds->top)) {
|
||
|
|
|
||
|
|
iMapMode = SetMapMode(hdc, MM_ANISOTROPIC);
|
||
|
|
SetWindowExtEx(hdc, rcClient.right, rcClient.bottom, &sWOrg);
|
||
|
|
SetViewportExtEx(hdc, prcBounds->right - prcBounds->left, prcBounds->bottom - prcBounds->top, &sVOrg);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetWindowOrgEx(hdc, 0, 0, &ptWOrg);
|
||
|
|
SetViewportOrgEx(hdc, prcBounds->left, prcBounds->top, &ptVOrg);
|
||
|
|
|
||
|
|
CallWindowProc((WNDPROC)SUBCLASSWNDPROCOFCONTROL(m_ObjectType), hwnd, (g_fSysWin95Shell) ? WM_PRINT : WM_PAINT, (WPARAM)hdc, (LPARAM)(g_fSysWin95Shell ? PRF_CHILDREN | PRF_CLIENT : 0));
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetColorSet [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Returns the logical palette that the control will use for drawing in its
|
||
|
|
// IViewObject::Draw method with the corresponding parameters.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] how the object is to be represented
|
||
|
|
// LONG - [in] part of the object to draw [not relevant]
|
||
|
|
// void * - NULL
|
||
|
|
// DVTARGETDEVICE * - [in] specifies the target device
|
||
|
|
// HDC - [in] information context for the target device
|
||
|
|
// LOGPALETTE ** - [out] where to put palette
|
||
|
|
//
|
||
|
|
// Output:
|
||
|
|
// S_OK - Control has a palette, and returned it through the out param.
|
||
|
|
// S_FALSE - Control does not currently have a palette.
|
||
|
|
// E_NOTIMPL - Control will never have a palette so optimize handling of this control.
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetColorSet(DWORD dwDrawAspect, LONG lindex,
|
||
|
|
void *IgnoreMe, DVTARGETDEVICE *ptd, HDC hicTargetDevice,
|
||
|
|
LOGPALETTE **ppColorSet)
|
||
|
|
{
|
||
|
|
if (dwDrawAspect != DVASPECT_CONTENT)
|
||
|
|
return DV_E_DVASPECT;
|
||
|
|
|
||
|
|
*ppColorSet = NULL;
|
||
|
|
return (OnGetPalette(hicTargetDevice, ppColorSet)) ? ((*ppColorSet) ? S_OK : S_FALSE) : E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::Freeze [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Freezes a certain aspect of the object's presentation so that it does not
|
||
|
|
// change until the IViewObject::Unfreeze method is called.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// LONG - [in] part of object to draw
|
||
|
|
// void * - NULL
|
||
|
|
// DWORD * - [out] for Unfreeze
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::Freeze(DWORD dwDrawAspect, LONG lIndex,
|
||
|
|
void *IgnoreMe, DWORD *pdwFreeze)
|
||
|
|
{
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::Unfreeze [IVewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Releases a previously frozen drawing. The most common use of this method
|
||
|
|
// is for banded printing.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] cookie from freeze
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::Unfreeze(DWORD dwFreeze)
|
||
|
|
{
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::SetAdvise [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Sets up a connection between the control and an advise sink so that the
|
||
|
|
// advise sink can be notified about changes in the control's view.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// DWORD - [in] info about the sink
|
||
|
|
// IAdviseSink * - [in] the sink
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::SetAdvise(DWORD dwAspects, DWORD dwAdviseFlags,
|
||
|
|
IAdviseSink *pAdviseSink)
|
||
|
|
{
|
||
|
|
// if it's not a content aspect, we don't support it.
|
||
|
|
|
||
|
|
if (!(dwAspects & DVASPECT_CONTENT)) {
|
||
|
|
return DV_E_DVASPECT;
|
||
|
|
}
|
||
|
|
|
||
|
|
// set up some flags [we gotta stash for GetAdvise ...]
|
||
|
|
|
||
|
|
m_fViewAdvisePrimeFirst = (dwAdviseFlags & ADVF_PRIMEFIRST) ? TRUE : FALSE;
|
||
|
|
m_fViewAdviseOnlyOnce = (dwAdviseFlags & ADVF_ONLYONCE) ? TRUE : FALSE;
|
||
|
|
|
||
|
|
RELEASE_OBJECT(m_pViewAdviseSink);
|
||
|
|
m_pViewAdviseSink = pAdviseSink;
|
||
|
|
ADDREF_OBJECT(m_pViewAdviseSink);
|
||
|
|
|
||
|
|
// prime them if they want it [we need to store this so they can get flags later]
|
||
|
|
|
||
|
|
if (m_fViewAdvisePrimeFirst)
|
||
|
|
ViewChanged();
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetAdvise [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Retrieves the existing advisory connection on the control if there is one.
|
||
|
|
// This method simply returns the parameters used in the most recent call to
|
||
|
|
// the IViewObject::SetAdvise method.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD * - [out] aspects
|
||
|
|
// DWORD * - [out] advise flags
|
||
|
|
// IAdviseSink ** - [out] the sink
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetAdvise(DWORD *pdwAspects, DWORD *pdwAdviseFlags,
|
||
|
|
IAdviseSink **ppAdviseSink)
|
||
|
|
{
|
||
|
|
// if they want it, give it to them
|
||
|
|
|
||
|
|
if (pdwAspects)
|
||
|
|
*pdwAspects = DVASPECT_CONTENT;
|
||
|
|
|
||
|
|
if (pdwAdviseFlags) {
|
||
|
|
*pdwAdviseFlags = 0;
|
||
|
|
if (m_fViewAdviseOnlyOnce) *pdwAdviseFlags |= ADVF_ONLYONCE;
|
||
|
|
if (m_fViewAdvisePrimeFirst) *pdwAdviseFlags |= ADVF_PRIMEFIRST;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ppAdviseSink) {
|
||
|
|
*ppAdviseSink = m_pViewAdviseSink;
|
||
|
|
ADDREF_OBJECT(*ppAdviseSink);
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetExtent [IViewObject2]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// Returns the size that the control will be drawn on the
|
||
|
|
// specified target device.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] draw aspect
|
||
|
|
// LONG - [in] part of object to draw
|
||
|
|
// DVTARGETDEVICE * - [in] information about target device
|
||
|
|
// LPSIZEL - [out] where to put the size
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetExtent(DWORD dwDrawAspect, LONG lindex,
|
||
|
|
DVTARGETDEVICE *ptd, LPSIZEL psizel)
|
||
|
|
{
|
||
|
|
// we already have an implementation of this [from IOleObject]
|
||
|
|
|
||
|
|
return GetExtent(dwDrawAspect, psizel);
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::OnGetPalette [overridable]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// called when the host wants palette information. ideally, people should use
|
||
|
|
// this sparingly and carefully.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// HDC - [in] HIC for the target device
|
||
|
|
// LOGPALETTE ** - [out] where to put the palette
|
||
|
|
//
|
||
|
|
// Output:
|
||
|
|
// BOOL - TRUE means we processed it, false means nope.
|
||
|
|
|
||
|
|
BOOL COleControl::OnGetPalette(HDC hicTargetDevice, LOGPALETTE **ppColorSet)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetRect [IViewObjectEx]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// returns a rectnagle describing a given drawing aspect
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// LPRECTL - [out] region rectangle
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetRect(DWORD dvAspect, LPRECTL prcRect)
|
||
|
|
{
|
||
|
|
RECTL rc;
|
||
|
|
BOOL f;
|
||
|
|
|
||
|
|
// call the user routine and let them return the size
|
||
|
|
|
||
|
|
f = OnGetRect(dvAspect, &rc);
|
||
|
|
if (!f) return DV_E_DVASPECT;
|
||
|
|
|
||
|
|
// transform these dudes.
|
||
|
|
|
||
|
|
PixelToHiMetric((LPSIZEL)&rc, (LPSIZEL)prcRect);
|
||
|
|
PixelToHiMetric((LPSIZEL)(LPBYTE)&rc + sizeof(SIZEL), (LPSIZEL)((LPBYTE)prcRect + sizeof(SIZEL)));
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetViewStatus [IViewObjectEx]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// returns information about the opactiy of the object and what drawing
|
||
|
|
// aspects are supported
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD * - [out] the status
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetViewStatus(DWORD *pdwStatus)
|
||
|
|
{
|
||
|
|
// depending on the flag in the CONTROLOBJECTINFO structure, indicate our
|
||
|
|
// transparency vs opacity.
|
||
|
|
// OVERRIDE: controls that wish to support multi-pass drawing should
|
||
|
|
// override this routine and return, in addition to the flags indication
|
||
|
|
// opacity, flags indicating what sort of drawing aspects they support.
|
||
|
|
|
||
|
|
*pdwStatus = FCONTROLISOPAQUE(m_ObjectType) ? VIEWSTATUS_OPAQUE : 0;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::QueryHitPoint [IViewObjectEx]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// indicates whether a point is within a given aspect of an object.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// LPCRECT - [in] Bounds rectangle
|
||
|
|
// POINT - [in] hit location client coordinates
|
||
|
|
// LONG - [in] what the container considers close
|
||
|
|
// DWORD * - [out] info about the hit
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::QueryHitPoint(DWORD dvAspect, LPCRECT prcBounds,
|
||
|
|
POINT ptLocation, LONG lCloseHint, DWORD *pdwHitResult)
|
||
|
|
{
|
||
|
|
// OVERRIDE: override me if you want to provide additional [non-opaque]
|
||
|
|
// functionality
|
||
|
|
|
||
|
|
if (dvAspect != DVASPECT_CONTENT)
|
||
|
|
return DV_E_DVASPECT;
|
||
|
|
|
||
|
|
*pdwHitResult = PtInRect(prcBounds, ptLocation) ? HITRESULT_HIT : HITRESULT_OUTSIDE;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::QueryHitRect [IViewObjectEx]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// indicates whether any point in a rectangle is within a given drawing aspect
|
||
|
|
// of an object.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// LPCRECT - [in] bounds
|
||
|
|
// LPCRECT - [in] location
|
||
|
|
// LONG - [in] what host considers close
|
||
|
|
// DWORD * - [out] hit result
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::QueryHitRect(DWORD dvAspect, LPCRECT prcBounds,
|
||
|
|
LPCRECT prcLocation, LONG lCloseHint, DWORD *pdwHitResult)
|
||
|
|
{
|
||
|
|
RECT rc;
|
||
|
|
|
||
|
|
// OVERRIDE: override this for additional behaviour
|
||
|
|
|
||
|
|
if (dvAspect != DVASPECT_CONTENT)
|
||
|
|
return DV_E_DVASPECT;
|
||
|
|
|
||
|
|
*pdwHitResult = IntersectRect(&rc, prcBounds, prcLocation) ? HITRESULT_HIT : HITRESULT_OUTSIDE;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::GetNaturalExtent [IViewObjectEx]
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// supports two types of control sizing, content and integral.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect
|
||
|
|
// LONG - [in] index
|
||
|
|
// DVTARGETDEVICE * - [in] target device information
|
||
|
|
// HDC - [in] HIC
|
||
|
|
// DVEXTENTINFO * - [in] sizing data
|
||
|
|
// LPSIZEL - [out] sizing data retunred by control
|
||
|
|
|
||
|
|
STDMETHODIMP COleControl::GetNaturalExtent(DWORD dvAspect, LONG lIndex,
|
||
|
|
DVTARGETDEVICE *ptd, HDC hicTargetDevice, DVEXTENTINFO *pExtentInfo,
|
||
|
|
LPSIZEL pSizel)
|
||
|
|
{
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// COleControl::OnGetRect [overridable
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// returns our rectangle
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DWORD - [in] aspect they want the rect for
|
||
|
|
// RECTL * - [out] the rectangle that matches this aspect
|
||
|
|
//
|
||
|
|
// Output:
|
||
|
|
// BOOL - false means we don't like the aspect
|
||
|
|
|
||
|
|
BOOL COleControl::OnGetRect(DWORD dvAspect, RECTL *pRect)
|
||
|
|
{
|
||
|
|
// by default, we only support content drawing.
|
||
|
|
|
||
|
|
if (dvAspect != DVASPECT_CONTENT)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
// just give them our bounding rectangle
|
||
|
|
|
||
|
|
*((LPRECT)pRect) = m_rcLocation;
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// _CreateOleDC
|
||
|
|
//=--------------------------------------------------------------------------=
|
||
|
|
// creates an HDC given a DVTARGETDEVICE structure.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// DVTARGETDEVICE * - [in] duh.
|
||
|
|
|
||
|
|
HDC _CreateOleDC(DVTARGETDEVICE *ptd)
|
||
|
|
{
|
||
|
|
LPDEVMODEW pDevModeW;
|
||
|
|
DEVMODEA DevModeA, *pDevModeA;
|
||
|
|
LPOLESTR lpwszDriverName;
|
||
|
|
LPOLESTR lpwszDeviceName;
|
||
|
|
LPOLESTR lpwszPortName;
|
||
|
|
HDC hdc;
|
||
|
|
|
||
|
|
// return screen DC for NULL target device
|
||
|
|
|
||
|
|
if (!ptd)
|
||
|
|
return CreateDC("DISPLAY", NULL, NULL, NULL);
|
||
|
|
|
||
|
|
if (ptd->tdExtDevmodeOffset == 0)
|
||
|
|
pDevModeW = NULL;
|
||
|
|
else
|
||
|
|
pDevModeW = (LPDEVMODEW)((LPSTR)ptd + ptd->tdExtDevmodeOffset);
|
||
|
|
|
||
|
|
lpwszDriverName = (LPOLESTR)((BYTE*)ptd + ptd->tdDriverNameOffset);
|
||
|
|
lpwszDeviceName = (LPOLESTR)((BYTE*)ptd + ptd->tdDeviceNameOffset);
|
||
|
|
lpwszPortName = (LPOLESTR)((BYTE*)ptd + ptd->tdPortNameOffset);
|
||
|
|
|
||
|
|
MAKE_ANSIPTR_FROMWIDE(pszDriverName, lpwszDriverName);
|
||
|
|
MAKE_ANSIPTR_FROMWIDE(pszDeviceName, lpwszDeviceName);
|
||
|
|
MAKE_ANSIPTR_FROMWIDE(pszPortName, lpwszPortName);
|
||
|
|
|
||
|
|
if (pDevModeW) {
|
||
|
|
WideCharToMultiByte(CP_ACP, 0, pDevModeW->dmDeviceName, -1,
|
||
|
|
(LPSTR) DevModeA.dmDeviceName, CCHDEVICENAME, NULL, NULL);
|
||
|
|
memcpy(&DevModeA.dmSpecVersion, &pDevModeW->dmSpecVersion,
|
||
|
|
offsetof(DEVMODEA, dmFormName) - offsetof(DEVMODEA, dmSpecVersion));
|
||
|
|
WideCharToMultiByte(CP_ACP, 0, pDevModeW->dmFormName, -1, (LPSTR)DevModeA.dmFormName, CCHFORMNAME, NULL, NULL);
|
||
|
|
memcpy(&DevModeA.dmLogPixels, &pDevModeW->dmLogPixels, sizeof(DEVMODEA) - offsetof(DEVMODEA, dmLogPixels));
|
||
|
|
if (pDevModeW->dmDriverExtra) {
|
||
|
|
pDevModeA = (DEVMODEA *)lcCalloc(sizeof(DEVMODEA) + pDevModeW->dmDriverExtra);
|
||
|
|
if (!pDevModeA)
|
||
|
|
return NULL;
|
||
|
|
memcpy(pDevModeA, &DevModeA, sizeof(DEVMODEA));
|
||
|
|
memcpy(pDevModeA + 1, pDevModeW + 1, pDevModeW->dmDriverExtra);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pDevModeA = &DevModeA;
|
||
|
|
|
||
|
|
DevModeA.dmSize = sizeof(DEVMODEA);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pDevModeA = NULL;
|
||
|
|
|
||
|
|
hdc = CreateDC(pszDriverName, pszDeviceName, pszPortName, pDevModeA);
|
||
|
|
if (pDevModeA != &DevModeA)
|
||
|
|
lcFree(pDevModeA);
|
||
|
|
return hdc;
|
||
|
|
}
|