2178 lines
70 KiB
C++
2178 lines
70 KiB
C++
//+---------------------------------------------------------------------------
|
||
//
|
||
// File: o2base.hxx
|
||
//
|
||
// Contents: Compound Document Object helper library definitions
|
||
//
|
||
// Classes:
|
||
// OLEBorder
|
||
// InPlaceBorder
|
||
// StdClassFactory
|
||
// ViewAdviseHolder
|
||
//
|
||
// ---
|
||
//
|
||
// StatusBar // Included only if INC_STATUS_BAR defined
|
||
//
|
||
// Functions:
|
||
// HimetricFromHPix
|
||
// HimetricFromVPix
|
||
// HPixFromHimetric
|
||
// VPixFromHimetric
|
||
//
|
||
// WatchInterface
|
||
//
|
||
// OleAllocMem
|
||
// OleFreeMem
|
||
// OleAllocString
|
||
// OleFreeString
|
||
//
|
||
// IsCompatibleOleVersion
|
||
// IsDraggingDistance
|
||
//
|
||
// TraceIID
|
||
// TraceHRESULT
|
||
//
|
||
// RECTtoRECTL
|
||
// RECTLtoRECT
|
||
// ProportionateRectl
|
||
// RectToScreen
|
||
// RectToClient
|
||
// IsRectInRect
|
||
// lMulDiv
|
||
//
|
||
// LeadResourceData
|
||
// GetChildWindowRect
|
||
// SizeClientRect
|
||
//
|
||
// RegisterOleClipFormats
|
||
// IsCompatibleDevice
|
||
// IsCompatibleFormat
|
||
// FindCompatibleFormat
|
||
// GetObjectDescriptor
|
||
// UpdateObjectDescriptor
|
||
// DrawMetafile
|
||
//
|
||
// InsertServerMenus
|
||
// RemoteServerMenus
|
||
//
|
||
// RegisterAsRunning
|
||
// RevokeAsRunning
|
||
//
|
||
// CreateStreamOnFile
|
||
//
|
||
// CreateOLEVERBEnum
|
||
// CreateFORMATETCEnum
|
||
// CreateStaticEnum
|
||
//
|
||
// GetMonikerDisplayName
|
||
// CreateStorageOnHGlobal
|
||
// ConvertToMemoryStream
|
||
// StmReadString
|
||
// StmWriteString
|
||
//
|
||
// CreateViewAdviseHolder
|
||
//
|
||
// ---
|
||
//
|
||
// Macros: WATCHINTERFACE
|
||
// IsSameIID
|
||
//
|
||
// TaskAllocMem
|
||
// TaskFreeMem
|
||
// TaskAllocString
|
||
// TaskFreeString
|
||
//
|
||
// OK
|
||
// NOTOK
|
||
//
|
||
// DECLARE_IUNKNOWN_METHODS
|
||
// DECLARE_PURE_IUNKNOWN_METHODS
|
||
// DECLARE_STANDARD_IUNKNOWN
|
||
// IMPLEMENT_STANDARD_IUNKNOWN
|
||
// DECLARE_DELEGATING_IUNKNOWN
|
||
// IMPLEMENT_DELEGATING_IUNKNOWN
|
||
// DECLARE_PRIVATE_IUNKNOWN
|
||
// IMPLEMENT_PRIVATE_IUNKNOWN
|
||
//
|
||
// DECLARE_CODE_TIMER
|
||
// IMPLEMENT_CODE_TIMER
|
||
// START_CODE_TIMER
|
||
// STOP_CODE_TIMER
|
||
//
|
||
// Enums:
|
||
// OLE_SERVER_STATE
|
||
//
|
||
// OBPARTS
|
||
// OLECLIPFORMAT
|
||
//
|
||
// ---
|
||
//
|
||
// Notes: Define INC_STATUS_BAR to include the status bar
|
||
// class definition.
|
||
//
|
||
//----------------------------------------------------------------------------
|
||
|
||
#ifndef _O2BASE_HXX_
|
||
#define _O2BASE_HXX_
|
||
|
||
// resource ID offsets for class descriptor information
|
||
#define IDOFF_CLASSID 0
|
||
#define IDOFF_USERTYPEFULL 1
|
||
#define IDOFF_USERTYPESHORT 2
|
||
#define IDOFF_USERTYPEAPP 3
|
||
#define IDOFF_DOCFEXT 5
|
||
#define IDOFF_ICON 10
|
||
#define IDOFF_ACCELS 11
|
||
#define IDOFF_MENU 12
|
||
#define IDOFF_MGW 13
|
||
#define IDOFF_MISCSTATUS 14
|
||
|
||
#ifndef RC_INVOKED // the resource compiler is not interested in the rest
|
||
|
||
|
||
#if DBG
|
||
|
||
extern "C" void FAR PASCAL AssertSFL(
|
||
LPSTR lpszClause,
|
||
LPSTR lpszFileName,
|
||
int nLine);
|
||
#define Assert(f) ((f)? (void)0 : AssertSFL(#f, __FILE__, __LINE__))
|
||
|
||
#else // !DBG
|
||
|
||
#define Assert(x)
|
||
|
||
#endif // DBG
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Windows helper functions
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
LPVOID LoadResourceData(HINSTANCE hinst,
|
||
LPCWSTR lpstrId,
|
||
LPVOID lpvBuf,
|
||
int cbBuf);
|
||
void GetChildWindowRect(HWND hwndChild, LPRECT lprect);
|
||
void SizeClientRect(HWND hwnd, RECT& rc, BOOL fMove);
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Generally useful #defines and inline functions for OLE2.
|
||
//
|
||
//------------------------------------------------------------------------
|
||
|
||
// this macro can be used to put string constants in a read-only code segment
|
||
// usage: char CODE_BASED szFoo[] = "Bar";
|
||
#define CODE_BASED __based(__segname("_CODE"))
|
||
|
||
// These are the major and minor version returned by OleBuildVersion
|
||
#define OLE_MAJ_VER 0x0003
|
||
#define OLE_MIN_VER 0x003A
|
||
|
||
|
||
//---------------------------------------------------------------
|
||
// SCODE and HRESULT macros
|
||
//---------------------------------------------------------------
|
||
|
||
#define OK(r) (SUCCEEDED(r))
|
||
#define NOTOK(r) (FAILED(r))
|
||
|
||
//---------------------------------------------------------------
|
||
// GUIDs, CLSIDs, IIDs
|
||
//---------------------------------------------------------------
|
||
|
||
#define IsSameIID(iid1, iid2) ((iid1)==(iid2))
|
||
|
||
//---------------------------------------------------------------
|
||
// IUnknown
|
||
//---------------------------------------------------------------
|
||
|
||
//
|
||
// This declares the set of IUnknown methods and is for general-purpose
|
||
// use inside classes that inherit from IUnknown
|
||
#define DECLARE_IUNKNOWN_METHODS \
|
||
STDMETHOD(QueryInterface) (REFIID riid, LPVOID FAR* ppvObj); \
|
||
STDMETHOD_(ULONG,AddRef) (void); \
|
||
STDMETHOD_(ULONG,Release) (void)
|
||
|
||
//
|
||
// This declares the set of IUnknown methods as pure virtual methods
|
||
//
|
||
#define DECLARE_PURE_IUNKNOWN_METHODS \
|
||
STDMETHOD(QueryInterface) (REFIID riid, LPVOID FAR* ppvObj) = 0; \
|
||
STDMETHOD_(ULONG,AddRef) (void) = 0; \
|
||
STDMETHOD_(ULONG,Release) (void) = 0
|
||
|
||
//
|
||
// This is for use in declaring non-aggregatable objects. It declares the
|
||
// IUnknown methods and reference counter, _ulRefs.
|
||
// _ulRefs should be initialized to 1 in the constructor of the object
|
||
#define DECLARE_STANDARD_IUNKNOWN(cls) \
|
||
DECLARE_IUNKNOWN_METHODS; \
|
||
ULONG _ulRefs
|
||
|
||
// note: this does NOT implement QueryInterface, which must be
|
||
// implemented by each object
|
||
#define IMPLEMENT_STANDARD_IUNKNOWN(cls) \
|
||
STDMETHODIMP_(ULONG) cls##::AddRef(void) \
|
||
{ ++_ulRefs; \
|
||
return _ulRefs;} \
|
||
STDMETHODIMP_(ULONG) cls##::Release(void) \
|
||
{ ULONG ulRet = --_ulRefs; \
|
||
if (ulRet == 0) delete this; \
|
||
return ulRet; }
|
||
|
||
// This is for use in declaring aggregatable objects. It declares the IUnknown
|
||
// methods and a member pointer to the aggregate controlling unknown, _pUnkOuter,
|
||
// that all IUnknowns delegate to except the controlling unknown of the object
|
||
// itself.
|
||
// _pUnkOuter must be initialized to point to either an external controlling
|
||
// unknown or the object's own controlling unknown, depending on whether the
|
||
// object is being created as part of an aggregate or not.
|
||
#define DECLARE_DELEGATING_IUNKNOWN(cls) \
|
||
DECLARE_IUNKNOWN_METHODS; \
|
||
LPUNKNOWN _pUnkOuter
|
||
|
||
// This, correspondingly, is for use in implementing aggregatable objects.
|
||
// It implements the IUnknown methods by trivially delegating to the controlling
|
||
// unknown described by _pUnkOuter.
|
||
#define IMPLEMENT_DELEGATING_IUNKNOWN(cls) \
|
||
STDMETHODIMP cls##::QueryInterface (REFIID riid, LPVOID FAR* ppvObj) \
|
||
{ return _pUnkOuter->QueryInterface(riid, ppvObj); } \
|
||
STDMETHODIMP_(ULONG) cls##::AddRef (void) \
|
||
{ return _pUnkOuter->AddRef(); } \
|
||
STDMETHODIMP_(ULONG) cls##::Release (void) \
|
||
{ return _pUnkOuter->Release(); }
|
||
|
||
// This declares a nested class that is the private unknown of the object
|
||
#define DECLARE_PRIVATE_IUNKNOWN(cls) \
|
||
class PrivateUnknown: public IUnknown { \
|
||
public: \
|
||
PrivateUnknown(cls* p##cls); \
|
||
DECLARE_IUNKNOWN_METHODS; \
|
||
private: \
|
||
ULONG _ulRefs; \
|
||
cls* _p##cls; }; \
|
||
friend class PrivateUnknown; \
|
||
PrivateUnknown _PrivUnk
|
||
|
||
|
||
//
|
||
// note: this does NOT implement QueryInterface, which must be
|
||
// implemented by each object
|
||
#define IMPLEMENT_PRIVATE_IUNKNOWN(cls) \
|
||
cls##::PrivateUnknown::PrivateUnknown(cls* p##cls) \
|
||
{ _p##cls = p##cls; _ulRefs = 1; } \
|
||
STDMETHODIMP_(ULONG) cls##::PrivateUnknown::AddRef(void) \
|
||
{ ++_ulRefs; \
|
||
return _ulRefs; } \
|
||
STDMETHODIMP_(ULONG) cls##::PrivateUnknown::Release(void) \
|
||
{ ULONG ulRet = --_ulRefs; \
|
||
if (ulRet == 0) delete _p##cls; \
|
||
return ulRet; }
|
||
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Miscellaneous useful OLE helper and debugging functions
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
//
|
||
// Some convenient OLE-related definitions and declarations
|
||
//
|
||
|
||
typedef unsigned short far * LPUSHORT;
|
||
|
||
//REVIEW we are experimenting with a non-standard OLEMISC flag.
|
||
#define OLEMISC_STREAMABLE 1024
|
||
|
||
IsCompatibleOleVersion(WORD wMaj, WORD wMin);
|
||
|
||
|
||
inline BOOL IsDraggingDistance(POINT pt1, POINT pt2)
|
||
{
|
||
#define MIN_DRAG_DIST 12
|
||
return (abs(pt1.x - pt2.x) >= MIN_DRAG_DIST ||
|
||
abs(pt1.y - pt2.y) >= MIN_DRAG_DIST);
|
||
#undef MIN_DRAG_DIST
|
||
}
|
||
|
||
#if ENABLED_DBG == 1
|
||
|
||
void TraceIID(REFIID riid);
|
||
HRESULT TraceHRESULT(HRESULT r);
|
||
|
||
#define TRACEIID(iid) TraceIID(iid)
|
||
#define TRACEHRESULT(r) TraceHRESULT(r)
|
||
|
||
|
||
#else // DBG == 0
|
||
|
||
#define TRACEIID(iid)
|
||
#define TRACEHRESULT(r)
|
||
|
||
#endif // DBG
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Routines to convert Pixels to Himetric and vice versa
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
long HimetricFromHPix(int iPix);
|
||
long HimetricFromVPix(int iPix);
|
||
int HPixFromHimetric(long lHi);
|
||
int VPixFromHimetric(long lHi);
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Timing helpers
|
||
//
|
||
//------------------------------------------------------------------------
|
||
|
||
#ifdef _TIMING
|
||
|
||
#define DECLARE_CODE_TIMER(t) extern CTimer t
|
||
#define IMPLEMENT_CODE_TIMER(t,s) CTimer t(s)
|
||
#define START_CODE_TIMER(t) t.Start()
|
||
#define STOP_CODE_TIMER(t) t.Stop()
|
||
|
||
#else // !_TIMING
|
||
|
||
#define DECLARE_CODE_TIMER(t)
|
||
#define IMPLEMENT_CODE_TIMER(t,s)
|
||
#define START_CODE_TIMER(t)
|
||
#define STOP_CODE_TIMER(t)
|
||
|
||
#endif // _TIMING
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Rectangle helper functions
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: RECTtoRECTL
|
||
//
|
||
// Synopsis: Converts a RECT structure to a RECTL
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline void RECTtoRECTL(RECT& rc, LPRECTL lprcl)
|
||
{
|
||
lprcl->left = (long)rc.left;
|
||
lprcl->top = (long)rc.top;
|
||
lprcl->bottom = (long)rc.bottom;
|
||
lprcl->right = (long)rc.right;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: RECTLtoRECT
|
||
//
|
||
// Synopsis: Converts a RECTL structure to a RECT
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline void RECTLtoRECT(RECTL& rcl, LPRECT lprc)
|
||
{
|
||
lprc->left = (int)rcl.left;
|
||
lprc->top = (int)rcl.top;
|
||
lprc->bottom = (int)rcl.bottom;
|
||
lprc->right = (int)rcl.right;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: lMulDiv, private
|
||
//
|
||
// Synopsis: Does a long MulDiv operation
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline long lMulDiv(long lMultiplicand, long lMultiplier, long lDivisor)
|
||
{
|
||
return (lMultiplicand * lMultiplier)/lDivisor; //FEATURE: 64bit intermediate?
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: ProportionateRectl
|
||
//
|
||
// Synopsis: Calculates rectangle A that is proportionate to rectangle B
|
||
// as rectangle C is to rectangle D,
|
||
// i.e. determine A such that A's relation to B is the same as
|
||
// C's relation to D.
|
||
//
|
||
// Arguments: [lprclA] -- rectangle A to be computed
|
||
// [rclB] -- rectangle B
|
||
// [rclC] -- rectangle C
|
||
// [rclD] -- rectangle D
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline void ProportionateRectl(LPRECTL lprclA, RECTL& rclB,
|
||
RECTL& rclC, RECTL& rclD)
|
||
{
|
||
// start with rectangle C
|
||
*lprclA = rclC;
|
||
|
||
// translate it so the UL corner of D is at the origin
|
||
lprclA->left -= rclD.left;
|
||
lprclA->top -= rclD.top;
|
||
lprclA->right -= rclD.left;
|
||
lprclA->bottom -= rclD.top;
|
||
|
||
// scale it by the ratio of the size of B to D (each axis independently)
|
||
SIZEL sizelB = { rclB.right - rclB.left, rclB.bottom - rclB.top };
|
||
SIZEL sizelD = { rclD.right - rclD.left, rclD.bottom - rclD.top };
|
||
lprclA->left = lMulDiv(lprclA->left, sizelB.cx, sizelD.cx);
|
||
lprclA->top = lMulDiv(lprclA->top, sizelB.cy, sizelD.cy);
|
||
lprclA->right = lMulDiv(lprclA->right, sizelB.cx, sizelD.cx);
|
||
lprclA->bottom = lMulDiv(lprclA->bottom, sizelB.cy, sizelD.cy);
|
||
|
||
// translate it to the coordinates represented by B
|
||
lprclA->left += rclB.left;
|
||
lprclA->top += rclB.top;
|
||
lprclA->right += rclB.left;
|
||
lprclA->bottom += rclB.top;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: RectToScreen
|
||
//
|
||
// Synopsis: Converts a rectangle in client coordinates of a window
|
||
// to screen coordinates.
|
||
//
|
||
// Arguments: [hwnd] -- the window defining the client coordinate space
|
||
// [lprect] -- the rectangle to be converted
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline void RectToScreen(HWND hwnd, LPRECT lprect)
|
||
{
|
||
POINT ptUL = { lprect->left, lprect->top };
|
||
ClientToScreen(hwnd,&ptUL);
|
||
POINT ptLR = { lprect->right, lprect->bottom };
|
||
ClientToScreen(hwnd,&ptLR);
|
||
lprect->left = ptUL.x;
|
||
lprect->top = ptUL.y;
|
||
lprect->right = ptLR.x;
|
||
lprect->bottom = ptLR.y;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: RectToClient
|
||
//
|
||
// Synopsis: Converts a rectangle in screen coordinates to client
|
||
// coordinates of a window.
|
||
//
|
||
// Arguments: [hwnd] -- the window defining the client coordinate space
|
||
// [lprect] -- the rectangle to be converted
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline void RectToClient(HWND hwnd, LPRECT lprect)
|
||
{
|
||
POINT ptUL = { lprect->left, lprect->top };
|
||
ScreenToClient(hwnd,&ptUL);
|
||
POINT ptLR = { lprect->right, lprect->bottom };
|
||
ScreenToClient(hwnd,&ptLR);
|
||
lprect->left = ptUL.x;
|
||
lprect->top = ptUL.y;
|
||
lprect->right = ptLR.x;
|
||
lprect->bottom = ptLR.y;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: IsRectInRect
|
||
//
|
||
// Synopsis: Determines whether one rectangle is wholly contained within
|
||
// another rectangle.
|
||
//
|
||
// Arguments: [rcOuter] -- the containing rectangle
|
||
// [lprect] -- the contained rectangle
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline BOOL IsRectInRect(RECT& rcOuter, RECT& rcInner)
|
||
{
|
||
POINT pt1 = { rcInner.left, rcInner.top };
|
||
POINT pt2 = { rcInner.right, rcInner.bottom };
|
||
return PtInRect(&rcOuter, pt1) && PtInRect(&rcOuter, pt2);
|
||
}
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// IMalloc-related helpers
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
|
||
//REVIEW: We may want to cache the IMalloc pointer for efficiency
|
||
#ifdef WIN16
|
||
//
|
||
// C++ new/delete replacements that use OLE's allocators
|
||
//
|
||
|
||
void FAR* operator new(size_t size);
|
||
void FAR* operator new(size_t size, MEMCTX memctx);
|
||
void operator delete(void FAR* lpv);
|
||
|
||
#endif //WIN16
|
||
|
||
//
|
||
// inline IMalloc memory allocation functions
|
||
//
|
||
|
||
HRESULT OleAllocMem(MEMCTX ctx, ULONG cb, LPVOID FAR* ppv);
|
||
void OleFreeMem(MEMCTX ctx, LPVOID pv);
|
||
HRESULT OleAllocString(MEMCTX ctx, LPCWSTR lpstrSrc, LPWSTR FAR* ppstr);
|
||
void OleFreeString(MEMCTX ctx, LPWSTR lpstr);
|
||
|
||
#define TaskAllocMem(cb, ppv) OleAllocMem(MEMCTX_TASK, cb, ppv)
|
||
#define TaskFreeMem(pv) OleFreeMem(MEMCTX_TASK, pv)
|
||
#define TaskAllocString(lpstr, ppstr) OleAllocString(MEMCTX_TASK, lpstr, ppstr)
|
||
#define TaskFreeString(lpstr) OleFreeString(MEMCTX_TASK, lpstr)
|
||
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Border definitions and helper class
|
||
//
|
||
//------------------------------------------------------------------------
|
||
|
||
|
||
// Default value for border thickness unless over-ridden via SetThickness
|
||
#define FBORDER_THICKNESS 4
|
||
|
||
// Default values for border minimums (customize via SetMinimums)
|
||
#define FBORDER_MINHEIGHT (FBORDER_THICKNESS*2 + 8);
|
||
#define FBORDER_MINWIDTH (FBORDER_THICKNESS*2 + 8);
|
||
|
||
#define OBSTYLE_MODMASK 0xff00 /* Mask style modifier bits */
|
||
#define OBSTYLE_TYPEMASK 0x00ff /* Mask basic type definition bits */
|
||
|
||
#define OBSTYLE_RESERVED 0x8000 /* bit reserved for internal use */
|
||
#define OBSTYLE_INSIDE 0x4000 /* Inside or Outside rect? */
|
||
#define OBSTYLE_HANDLED 0x2000 /* Size Handles Drawn? */
|
||
#define OBSTYLE_ACTIVE 0x1000 /* Active Border Shading? */
|
||
#define OBSTYLE_XOR 0x0800 /* Draw with XOR? */
|
||
#define OBSTYLE_THICK 0x0400 /* double up lines? */
|
||
|
||
#define OBSTYLE_DIAGONAL_FILL 0x0001 /* Open editing */
|
||
#define OBSTYLE_SOLID_PEN 0x0002 /* Simple Outline */
|
||
|
||
#define FB_HANDLED (OBSTYLE_HANDLED | OBSTYLE_SOLID_PEN)
|
||
#define FB_OPEN OBSTYLE_DIAGONAL_FILL
|
||
#define FB_OUTLINED OBSTYLE_SOLID_PEN
|
||
#define FB_HIDDEN 0
|
||
|
||
#define MAX_OBPART 13
|
||
|
||
enum OBPARTS
|
||
{
|
||
BP_NOWHERE,
|
||
BP_TOP, BP_RIGHT, BP_BOTTOM, BP_LEFT,
|
||
BP_TOPRIGHT, BP_BOTTOMRIGHT, BP_BOTTOMLEFT, BP_TOPLEFT,
|
||
BP_TOPHAND, BP_RIGHTHAND, BP_BOTTOMHAND, BP_LEFTHAND,
|
||
BP_INSIDE
|
||
};
|
||
|
||
|
||
class OLEBorder
|
||
{
|
||
public:
|
||
OLEBorder(RECT& r);
|
||
OLEBorder(void);
|
||
~OLEBorder(void);
|
||
|
||
void SetMinimums( SHORT sMinHeight, SHORT sMinWidth );
|
||
int SetThickness(int sBorderThickness);
|
||
int GetThickness(void);
|
||
|
||
USHORT SetState(HDC hdc, HWND hwnd, USHORT usBorderState);
|
||
USHORT GetState(void);
|
||
|
||
void Draw(HDC hdc, HWND hwnd);
|
||
void Erase(HWND hwnd);
|
||
|
||
USHORT QueryHit(POINT point);
|
||
|
||
HCURSOR MapPartToCursor(USHORT usPart);
|
||
|
||
HCURSOR QueryMoveCursor(POINT ptCurrent, BOOL fMustMove);
|
||
HCURSOR BeginMove(HDC hdc, HWND hwnd, POINT ptStart, BOOL fMustMove);
|
||
RECT& UpdateMove(HDC hdc, HWND hwnd, POINT ptCurrent, BOOL fNewRegion);
|
||
RECT& EndMove(HDC hdc, HWND hwnd, POINT ptCurrent, USHORT usBorderState);
|
||
|
||
void SwitchCoords( HWND hwndFrom, HWND hwndTo );
|
||
|
||
//
|
||
//OLEBorder exposes it's RECT as a public data member
|
||
//
|
||
RECT rect;
|
||
|
||
private:
|
||
enum ICURS
|
||
{
|
||
ICURS_STD,
|
||
ICURS_NWSE,
|
||
ICURS_NESW,
|
||
ICURS_NS,
|
||
ICURS_WE
|
||
};
|
||
static BOOL fInit;
|
||
static HCURSOR ahc[5];
|
||
static int iPartMap[14];
|
||
|
||
void InitClass(void);
|
||
void GetBorderRect(RECT& rDest, int iEdge);
|
||
void GetInsideBorder(RECT& rDest, int iEdge);
|
||
void GetOutsideBorder(RECT& rDest, int iEdge);
|
||
|
||
USHORT _state;
|
||
int _sMinHeight;
|
||
int _sMinWidth;
|
||
int _sThickness;
|
||
USHORT _usPart; //which portion of border was hit?
|
||
POINT _pt; //last known point
|
||
BOOL _fErased;
|
||
};
|
||
|
||
|
||
inline void OLEBorder::SetMinimums( SHORT sMinHeight, SHORT sMinWidth )
|
||
{
|
||
_sMinHeight = sMinHeight;
|
||
_sMinWidth = sMinWidth;
|
||
}
|
||
|
||
inline int OLEBorder::GetThickness(void)
|
||
{
|
||
return(_sThickness);
|
||
}
|
||
|
||
inline int OLEBorder::SetThickness(int sBorderThickness)
|
||
{
|
||
if(sBorderThickness > 0)
|
||
{
|
||
_sThickness = sBorderThickness;
|
||
}
|
||
return(_sThickness);
|
||
}
|
||
|
||
inline USHORT OLEBorder::GetState(void)
|
||
{
|
||
return(_state);
|
||
}
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Helper functions for implementing IDataObject and IViewObject
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
//
|
||
// Useful #defines
|
||
//
|
||
|
||
#define DVASPECT_ALL \
|
||
DVASPECT_CONTENT|DVASPECT_THUMBNAIL|DVASPECT_ICON|DVASPECT_DOCPRINT
|
||
|
||
|
||
//
|
||
// Standard OLE Clipboard formats
|
||
//
|
||
|
||
enum OLECLIPFORMAT
|
||
{
|
||
OCF_OBJECTLINK,
|
||
OCF_OWNERLINK,
|
||
OCF_NATIVE,
|
||
OCF_FILENAME,
|
||
OCF_NETWORKNAME,
|
||
OCF_DATAOBJECT,
|
||
OCF_EMBEDDEDOBJECT,
|
||
OCF_EMBEDSOURCE,
|
||
OCF_LINKSOURCE,
|
||
OCF_LINKSRCDESCRIPTOR,
|
||
OCF_OBJECTDESCRIPTOR,
|
||
OCF_OLEDRAW, OCF_LAST = OCF_OLEDRAW
|
||
};
|
||
|
||
extern UINT OleClipFormat[OCF_LAST+1]; // array of OLE standard clipboard formats
|
||
// indexed by OLECLIPFORMAT enumeration.
|
||
|
||
void RegisterOleClipFormats(void); // initializes OleClipFormat table.
|
||
|
||
//
|
||
// FORMATETC helpers
|
||
//
|
||
|
||
BOOL IsCompatibleDevice(DVTARGETDEVICE FAR* ptdLeft, DVTARGETDEVICE FAR* ptdRight);
|
||
BOOL IsCompatibleFormat(FORMATETC& f1, FORMATETC& f2);
|
||
int FindCompatibleFormat(FORMATETC FmtTable[], int iSize, FORMATETC& formatetc);
|
||
|
||
//
|
||
// OBJECTDESCRIPTOR clipboard format helpers
|
||
//
|
||
|
||
HRESULT GetObjectDescriptor(LPDATAOBJECT pDataObj, LPOBJECTDESCRIPTOR pDescOut);
|
||
HRESULT UpdateObjectDescriptor(LPDATAOBJECT pDataObj, POINTL& ptl, DWORD dwAspect);
|
||
|
||
//
|
||
// Other helper functions
|
||
//
|
||
|
||
HRESULT DrawMetafile(LPVIEWOBJECT pVwObj, RECT& rc, DWORD dwAspect,
|
||
HMETAFILE FAR* pHMF);
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// IStream on top of a DOS (non-docfile) file
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
HRESULT CreateStreamOnFile(LPCSTR lpstrFile, DWORD stgm, LPSTREAM FAR* ppstrm);
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Class: InPlaceBorder Class (IP)
|
||
//
|
||
// Synopsis: Helper Class to draw inplace activation borders around an
|
||
// object.
|
||
//
|
||
// Notes: Use of this class limits windows to the use of the
|
||
// non-client region for UIAtive borders only: Standard
|
||
// (non-control window) scroll bars are specifically NOT
|
||
// supported.
|
||
//
|
||
// History: 14-May-93 CliffG Created.
|
||
//
|
||
//------------------------------------------------------------------------
|
||
|
||
|
||
#define IPBORDER_THICKNESS 6
|
||
|
||
|
||
class InPlaceBorder
|
||
{
|
||
public:
|
||
InPlaceBorder(void);
|
||
~InPlaceBorder(void);
|
||
|
||
//
|
||
//Substitute for standard windows API: identical signature & semantics
|
||
//
|
||
LRESULT DefWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
||
//
|
||
//Change the server state: reflected in the nonclient window border
|
||
//
|
||
void SetUIActive(BOOL fUIActive);
|
||
BOOL GetUIActive(void);
|
||
//
|
||
//Force border state to OS_LOADED, managing the cooresponding change
|
||
//in border appearance: guaranteed redraw
|
||
//
|
||
void Erase(void);
|
||
|
||
void SetBorderSize( int cx, int cy );
|
||
void GetBorderSize( LPINT pcx, LPINT pcy );
|
||
void Bind(LPOLEINPLACESITE pSite, HWND hwnd, BOOL fUIActive );
|
||
void Attach( HWND hwnd, BOOL fUIActive );
|
||
void Detach(void);
|
||
void SetSize(HWND hwnd, RECT& rc);
|
||
void SetParentActive( BOOL fActive );
|
||
|
||
private:
|
||
BOOL _fUIActive; //current state of border
|
||
BOOL _fParentActive; //shade as active border?
|
||
HWND _hwnd; //attached window (if any)
|
||
LPOLEINPLACESITE _pSite; //InPlace site we are bound to
|
||
int _cxFrame; //border horizontal thickness
|
||
int _cyFrame; //border vertical thickness
|
||
int _cResizing; //reentrancy control flag
|
||
|
||
static WORD _cUsage; //refcount for static resources
|
||
static HBRUSH _hbrActiveCaption;
|
||
static HBRUSH _hbrInActiveCaption;
|
||
|
||
void DrawFrame(HWND hwnd);
|
||
void CalcClientRect(HWND hwnd, LPRECT lprc);
|
||
LONG HitTest(HWND hwnd, int x, int y);
|
||
void InvalidateFrame(void);
|
||
void RedrawFrame(void);
|
||
};
|
||
|
||
inline void
|
||
InPlaceBorder::Detach(void)
|
||
{
|
||
_pSite = NULL;
|
||
_hwnd = NULL;
|
||
}
|
||
|
||
inline void
|
||
InPlaceBorder::InvalidateFrame(void)
|
||
{
|
||
//cause a WM_NCCALCRECT to be generated
|
||
if(_hwnd != NULL)
|
||
{
|
||
++_cResizing;
|
||
SetWindowPos( _hwnd, NULL, 0, 0, 0, 0, SWP_FRAMECHANGED |
|
||
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
|
||
_cResizing--;
|
||
}
|
||
}
|
||
|
||
inline void
|
||
InPlaceBorder::RedrawFrame(void)
|
||
{
|
||
if(_hwnd != NULL)
|
||
{
|
||
++_cResizing;
|
||
UINT afuRedraw = RDW_INVALIDATE | RDW_UPDATENOW;
|
||
RedrawWindow(_hwnd, NULL, NULL, afuRedraw);
|
||
_cResizing--;
|
||
}
|
||
}
|
||
|
||
inline void
|
||
InPlaceBorder::SetParentActive( BOOL fActive )
|
||
{
|
||
_fParentActive = fActive;
|
||
RedrawFrame();
|
||
}
|
||
|
||
inline void
|
||
InPlaceBorder::CalcClientRect(HWND hwnd, LPRECT lprc)
|
||
{
|
||
if(_fUIActive)
|
||
InflateRect(lprc, -_cxFrame, -_cyFrame);
|
||
}
|
||
|
||
inline BOOL
|
||
InPlaceBorder::GetUIActive(void)
|
||
{
|
||
return _fUIActive;
|
||
}
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Helper functions for in-place activation
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
HRESULT InsertServerMenus(HMENU hmenuShared, HMENU hmenuObject,
|
||
LPOLEMENUGROUPWIDTHS lpmgw);
|
||
|
||
void RemoveServerMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpmgw);
|
||
|
||
|
||
|
||
//---------------------------------------------------------------
|
||
// IStorage
|
||
//---------------------------------------------------------------
|
||
|
||
#define STGM_SHARE 0x000000F0
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Running Object Table helper functions
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
void RegisterAsRunning(LPUNKNOWN lpUnk, LPMONIKER lpmkFull,
|
||
DWORD FAR* lpdwRegister);
|
||
void RevokeAsRunning(DWORD FAR* lpdwRegister);
|
||
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Standard implementations of common enumerators
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
HRESULT CreateOLEVERBEnum(LPOLEVERB pVerbs, ULONG cVerbs,
|
||
LPENUMOLEVERB FAR* ppenum);
|
||
|
||
HRESULT CreateFORMATETCEnum(LPFORMATETC pFormats, ULONG cFormats,
|
||
LPENUMFORMATETC FAR* ppenum);
|
||
|
||
#if 0 // currently not used but useful in the future.
|
||
// we ifdef it out so it doesn't take up space
|
||
// in our servers.
|
||
HRESULT CreateStaticEnum(REFIID riid, LPVOID pStart, ULONG cSize, ULONG cCount,
|
||
LPVOID FAR* ppenum);
|
||
#endif //0
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// Standard IClassFactory implementation
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: StdClassFactory
|
||
//
|
||
// Purpose: Standard implementation of a class factory object
|
||
//
|
||
// Notes: *
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class StdClassFactory: public IClassFactory
|
||
{
|
||
public:
|
||
StdClassFactory(void);
|
||
DECLARE_IUNKNOWN_METHODS;
|
||
STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter,
|
||
REFIID iid,
|
||
LPVOID FAR* ppv) PURE;
|
||
STDMETHOD(LockServer) (BOOL fLock);
|
||
|
||
BOOL CanUnload(void);
|
||
private:
|
||
ULONG _ulRefs;
|
||
ULONG _ulLocks;
|
||
};
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// IStorage and IStream Helper functions
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
#define STGM_DFRALL (STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE)
|
||
#define STGM_DFALL (STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE)
|
||
#define STGM_SALL (STGM_READWRITE | STGM_SHARE_EXCLUSIVE)
|
||
#define STGM_SRO (STGM_READ | STGM_SHARE_EXCLUSIVE)
|
||
|
||
HRESULT GetMonikerDisplayName(LPMONIKER pmk, LPWSTR FAR* ppstr);
|
||
HRESULT CreateStorageOnHGlobal(HGLOBAL hgbl, LPSTORAGE FAR* ppStg);
|
||
LPSTREAM ConvertToMemoryStream(LPSTREAM pStrmFrom);
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: StmReadString
|
||
//
|
||
// Synopsis: Reads a string from a stream
|
||
//
|
||
// Arguments: [pStrm] -- the stream to read from
|
||
// [ppstr] -- where the string read is returned
|
||
//
|
||
// Returns: Success if the string was read successfully
|
||
//
|
||
// Notes: The string is allocated with the task allocator
|
||
// and needs to be freed by the same.
|
||
// This is an inline function.
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline HRESULT StmReadString(LPSTREAM pStrm, LPSTR FAR *ppstr)
|
||
{
|
||
HRESULT r;
|
||
USHORT cb;
|
||
LPSTR lpstr = NULL;
|
||
if (OK(r = pStrm->Read(&cb, sizeof(cb), NULL)))
|
||
{
|
||
if (OK(r = TaskAllocMem(cb+1, (LPVOID FAR*)&lpstr)))
|
||
{
|
||
r = pStrm->Read(lpstr, cb, NULL);
|
||
*(lpstr+cb) = '\0';
|
||
}
|
||
}
|
||
*ppstr = lpstr;
|
||
return r;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Function: StmWriteString
|
||
//
|
||
// Synopsis: Writes a string to a stream
|
||
//
|
||
// Arguments: [pStrm] -- the stream to write to
|
||
// [lpstr] -- the string to write
|
||
//
|
||
// Returns: Success iff the string was written successfully
|
||
//
|
||
// Notes: This is an inline function.
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline HRESULT StmWriteString(LPSTREAM pStrm, LPSTR lpstr)
|
||
{
|
||
HRESULT r;
|
||
USHORT cb = strlen(lpstr);
|
||
if (OK(r = pStrm->Write(&cb, sizeof(cb), NULL)))
|
||
r = pStrm->Write(lpstr, cb, NULL);
|
||
return r;
|
||
}
|
||
|
||
//+---------------------------------------------------------------------
|
||
//
|
||
// View advise holder
|
||
//
|
||
//----------------------------------------------------------------------
|
||
|
||
//
|
||
// forward declaration
|
||
//
|
||
|
||
class ViewAdviseHolder;
|
||
typedef ViewAdviseHolder FAR* LPVIEWADVISEHOLDER;
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: ViewAdviseHolder
|
||
//
|
||
// Purpose: Manages the view advises on behalf of a IViewObject object
|
||
//
|
||
// Notes: This is analogous to the standard DataAdviseHolder provided
|
||
// by OLE. c.f. CreateViewAdviseHolder.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class ViewAdviseHolder: public IUnknown
|
||
{
|
||
friend HRESULT CreateViewAdviseHolder(LPVIEWADVISEHOLDER FAR*);
|
||
public:
|
||
//*** IUnknown methods ***/
|
||
STDMETHOD(QueryInterface) (REFIID riid, LPVOID FAR* ppvObj);
|
||
STDMETHOD_(ULONG,AddRef) (void);
|
||
STDMETHOD_(ULONG,Release) (void);
|
||
|
||
//*** ViewAdviseHolder methods
|
||
STDMETHOD(SetAdvise) (DWORD aspects, DWORD advf, LPADVISESINK pAdvSink);
|
||
STDMETHOD(GetAdvise) (DWORD FAR* pAspects, DWORD FAR* pAdvf,
|
||
LPADVISESINK FAR* ppAdvSink);
|
||
void SendOnViewChange(DWORD dwAspect);
|
||
|
||
private:
|
||
ViewAdviseHolder();
|
||
~ViewAdviseHolder();
|
||
|
||
ULONG _refs;
|
||
LPADVISESINK _pAdvSink; // THE view advise sink
|
||
DWORD _dwAdviseAspects; // view aspects of interest to advise sink
|
||
DWORD _dwAdviseFlags; // view advise flags
|
||
|
||
};
|
||
|
||
HRESULT CreateViewAdviseHolder(LPVIEWADVISEHOLDER FAR* ppViewHolder);
|
||
|
||
#ifdef INC_STATUS_BAR
|
||
|
||
//
|
||
// forward declarations
|
||
//
|
||
|
||
extern "C" LRESULT CALLBACK
|
||
StatusWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
||
|
||
class StatusBar;
|
||
typedef StatusBar FAR* LPSTATUSBAR;
|
||
|
||
//+-------------------------------------------------------------------
|
||
//
|
||
// Class: StatusBar
|
||
//
|
||
// Purpose: A status bar.
|
||
//
|
||
// Notes: Of the guidelines laid down by the UI people, the
|
||
// current implementation violates the following::
|
||
// - height of status bar should equal the height of
|
||
// the window's title bar.
|
||
//
|
||
//--------------------------------------------------------------------
|
||
|
||
class StatusBar
|
||
{
|
||
friend LRESULT CALLBACK StatusWndProc(HWND, UINT, WPARAM, LPARAM);
|
||
|
||
public:
|
||
static BOOL ClassInit(HINSTANCE hinst); // registers window class
|
||
|
||
StatusBar();
|
||
HWND Init(HINSTANCE hinst, HWND hwndParent);
|
||
~StatusBar();
|
||
|
||
void OnSize(LPRECT lprc);
|
||
void DisplayMessage(LPCWSTR);
|
||
WORD GetHeight(void);
|
||
|
||
private:
|
||
void OnPaint(HWND hwnd); // handles WM_PAINT message
|
||
|
||
HWND _hwnd; // our status bar window
|
||
HFONT _hfont; // font used to display messages.
|
||
WCHAR _lpstrString[128]; // string currently being displayed.
|
||
|
||
// various metrics:
|
||
WORD _wHeight; // current height, once computed.
|
||
WORD _wUnitBorder; // border, based on _wHeight;
|
||
WORD _wSpace; // space between controls on bar.
|
||
WORD _wAboveBelow; // space above and below
|
||
};
|
||
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: StatusBar::GetHeight, public
|
||
//
|
||
// Synopsis: Returns the height of the status bar in pixels
|
||
//
|
||
//----------------------------------------------------------------
|
||
|
||
inline WORD StatusBar::GetHeight(void)
|
||
{
|
||
return _wHeight;
|
||
}
|
||
|
||
#endif // INC_STATUS_BAR
|
||
|
||
//+------------------------------------------------------------------------
|
||
//
|
||
// Macro that calculates the number of elements in a statically-defined
|
||
// array.
|
||
//
|
||
//-------------------------------------------------------------------------
|
||
#define ARRAY_SIZE(_a) (sizeof(_a) / sizeof(_a[0]))
|
||
|
||
|
||
|
||
//+------------------------------------------------------------------------
|
||
//
|
||
// Class: CEnumGeneric (enum)
|
||
//
|
||
// Purpose: Implements an OLE2 enumerator for arrays of data. The CAry
|
||
// class uses this class for its enumerator.
|
||
//
|
||
// Interface: Next Returns the next element[s] in the array
|
||
// Skip Skips the next element[s] in the array
|
||
// Reset Restarts at the beginning of the array
|
||
// Clone Creates a copy of theis enumerator
|
||
//
|
||
// Create Creates a new instance of this enumerator, given
|
||
// an interface ID, element size, count, and pointer
|
||
//
|
||
// Members: _refs Ref count
|
||
// _iid Interface implemented by this enumerator
|
||
// _cb Size of each element
|
||
// _c Number of elements
|
||
// _i Current index in the array
|
||
// _pv Pointer to array data
|
||
//
|
||
//-------------------------------------------------------------------------
|
||
class CEnumGeneric : public IUnknown
|
||
{
|
||
public:
|
||
// IUnknown methods
|
||
|
||
STDMETHOD(QueryInterface) (REFIID riid, LPVOID FAR* ppvObj);
|
||
STDMETHOD_(ULONG,AddRef) (THIS);
|
||
STDMETHOD_(ULONG,Release) (THIS);
|
||
|
||
// IEnum methods
|
||
|
||
STDMETHOD(Next) (ULONG celt, void FAR* reelt, ULONG FAR* pceltFetched);
|
||
STDMETHOD(Skip) (ULONG celt);
|
||
STDMETHOD(Reset) ();
|
||
STDMETHOD(Clone) (CEnumGeneric FAR* FAR* ppenm);
|
||
|
||
// CEnumGeneric methods
|
||
|
||
static CEnumGeneric FAR* Create(REFIID, int cb, int c, void FAR* pv, BOOL fAddRef);
|
||
|
||
protected:
|
||
CEnumGeneric( REFIID, int cb, int c, void FAR* pv, BOOL fAddRef );
|
||
CEnumGeneric( CEnumGeneric * );
|
||
|
||
ULONG _refs;
|
||
IID _iid;
|
||
|
||
BOOL _fAddRef;
|
||
int _cb;
|
||
int _c;
|
||
int _i;
|
||
void FAR* _pv;
|
||
};
|
||
|
||
//+------------------------------------------------------------------------
|
||
//
|
||
// Class: CAry (ary)
|
||
//
|
||
// Purpose: Generic resizeable array class
|
||
//
|
||
// Interface: CAry, ~CAry
|
||
// EnsureSize Ensures that the array is at least a certain
|
||
// size, allocating more memory if necessary.
|
||
// Note that the array size is measured in elements,
|
||
// rather than in bytes.
|
||
// Size Returns the current size of the array.
|
||
// SetSize Sets the array size; EnsureSize must be called
|
||
// first to reserve space if the array is growing
|
||
//
|
||
// operator LPVOID Allow the CAry class to be cast to a (void *)
|
||
//
|
||
// Append Adds a new pointer to the end of the array,
|
||
// growing the array if necessary. Only works
|
||
// for arrays of pointers.
|
||
// AppendIndirect As Append, for non-pointer arrays
|
||
//
|
||
// Insert Inserts a new pointer at the given index in
|
||
// the array, growing the array if necessary. Any
|
||
// elements at or following the index are moved
|
||
// out of the way.
|
||
// InsertIndirect As Insert, for non-pointer arrays
|
||
//
|
||
// Delete Deletes an element of the array, moving any
|
||
// elements that follow it to fill
|
||
// DeleteMultiple Deletes a range of elements from the array,
|
||
// moving to fill
|
||
// BringToFront Moves an element of the array to index 0,
|
||
// shuffling elements to make room
|
||
// SendToBack Moves an element to the end of the array,
|
||
// shuffling elements to make room
|
||
//
|
||
// Find Returns the index at which a given pointer
|
||
// is found
|
||
// FindIndirect As Find, for non-pointer arrays
|
||
//
|
||
// EnumElements Create an enumerator which supports the given
|
||
// interface ID for the contents of the array
|
||
//
|
||
// Deref [prot] Returns a pointer to an element of the array;
|
||
// normally used by type-safe methods in derived
|
||
// classes
|
||
//
|
||
// Members: _c Current size of the array
|
||
// _cMac Current number of elements allocated
|
||
// _cb Size of each element
|
||
// _pv Buffer storing the elements
|
||
//
|
||
// Note: The CAry class only supports arrays of elements whose size is
|
||
// less than CARY_MAXELEMSIZE (currently 32).
|
||
//
|
||
//-------------------------------------------------------------------------
|
||
class CAry
|
||
{
|
||
public:
|
||
CAry(size_t cb);
|
||
~CAry();
|
||
|
||
HRESULT EnsureSize(int c);
|
||
int Size(void)
|
||
{ return _c; }
|
||
void SetSize(int c)
|
||
{ _c = c; }
|
||
|
||
operator LPVOID(void)
|
||
{ return _pv; }
|
||
|
||
HRESULT Append(void *);
|
||
HRESULT AppendIndirect(void *);
|
||
HRESULT Insert(int, void *);
|
||
HRESULT InsertIndirect(int, void *);
|
||
|
||
void Delete(int);
|
||
void DeleteAll(void);
|
||
void DeleteMultiple(int, int);
|
||
void BringToFront(int);
|
||
void SendToBack(int);
|
||
|
||
int Find(void *);
|
||
int FindIndirect(void **);
|
||
|
||
HRESULT EnumElements(REFIID iid, LPVOID * ppv, BOOL fAddRef);
|
||
|
||
protected:
|
||
int _c;
|
||
int _cMac;
|
||
size_t _cb;
|
||
void * _pv;
|
||
|
||
void * Deref(int i);
|
||
};
|
||
#define CARY_MAXELEMSIZE 32
|
||
|
||
|
||
//+------------------------------------------------------------------------
|
||
//
|
||
// Macro: DECLARE_ARY
|
||
//
|
||
// Purpose: Declares a type-safe class derived from CAry.
|
||
//
|
||
// Arguments: _Cls -- Name of new array class
|
||
// _Ty -- Type of array element (e.g. FOO)
|
||
// _pTy -- Type which is a pointer to _Ty (e.g. LPFOO)
|
||
//
|
||
// Interface: operator [] Provides a type-safe pointer to an element
|
||
// of the array
|
||
// operator LPFOO Allows the array to be cast to a type-safe
|
||
// pointer to its first element
|
||
//
|
||
//-------------------------------------------------------------------------
|
||
#define DECLARE_ARY(_Cls, _Ty, _pTy) \
|
||
class _Cls : public CAry { public: \
|
||
_Cls(void) : CAry(sizeof(_Ty)) { ; } \
|
||
_Ty& operator[] (int i) { return * (_pTy) Deref(i); } \
|
||
operator _pTy(void) { return (_pTy) _pv; } };
|
||
|
||
|
||
//****************************************************************************
|
||
//
|
||
// IconBar Class
|
||
//
|
||
//****************************************************************************
|
||
|
||
// WM_COMMAND notification codes
|
||
#define IBI_NEWSELECTION 1
|
||
#define IBI_STATUSAVAIL 2
|
||
|
||
#define IBP_LEFTBELOW 0
|
||
#define IBP_RIGHTABOVE 1
|
||
#define IBP_RIGHTBELOW 2
|
||
#define IBP_LEFTABOVE 3
|
||
|
||
|
||
extern "C" LRESULT CALLBACK IconBarWndProc(HWND,UINT,WPARAM,LPARAM);
|
||
|
||
class IconBar;
|
||
typedef IconBar FAR* LPICONBAR;
|
||
|
||
class IconBar
|
||
{
|
||
friend LRESULT CALLBACK IconBarWndProc(HWND,UINT,WPARAM,LPARAM);
|
||
|
||
public:
|
||
static LPICONBAR Create(HINSTANCE hinst, HWND hwndParent, HWND hwndNotify,
|
||
SHORT sIdChild);
|
||
~IconBar(void);
|
||
|
||
HWND GetHwnd(void);
|
||
|
||
void Position(int sTop, int sLeft, int sWhere);
|
||
HRESULT AddCellsFromRegDB(LPWSTR pszFilter);
|
||
void AddCell(CLSID& clsid, HICON hIcon, LPWSTR szTitle);
|
||
void SetCellAspect( int cWide, int cHigh );
|
||
void SelectCell(int iCell, BOOL fStick);
|
||
int GetSelectedCell(void);
|
||
CLSID& GetSelectedClassId(void);
|
||
LPWSTR GetStatusMessage(void);
|
||
BOOL IsStuck(void);
|
||
|
||
private:
|
||
#define MAX_CELLS 24
|
||
#define MAX_ICON_TITLE 64
|
||
|
||
struct IconCell {
|
||
CLSID clsid;
|
||
HICON hIcon;
|
||
HBITMAP hBmp;
|
||
WCHAR achTitle[MAX_ICON_TITLE];
|
||
};
|
||
typedef IconCell FAR *LPICONCELL;
|
||
|
||
IconBar(HWND hwndParent, HWND hwndNotify, SHORT sIDChild);
|
||
|
||
int AddCell(LPICONCELL pCells, int i,
|
||
CLSID& clsid, HICON hIcon, LPWSTR szTitle);
|
||
void AddCache(void);
|
||
void Draw(HDC hdc, POINT pt, BOOL fDown, int iCell);
|
||
|
||
void ncCalcRect(HWND hwnd, LPRECT lprc);
|
||
void ncDrawFrame(HWND hwnd);
|
||
LONG ncHitTest(HWND hwnd, POINT pt);
|
||
LRESULT ncMsgFilter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
||
|
||
static ATOM InitClass(HINSTANCE hinst);
|
||
static BOOL _fInit;
|
||
static ATOM _atomClass;
|
||
static HBRUSH hbrActiveCaption;
|
||
static HBRUSH hbrInActiveCaption;
|
||
static HBRUSH hbrWindowFrame;
|
||
static HBRUSH hbrSysBox;
|
||
static WORD wCnt;
|
||
static COLORREF crLtGray;
|
||
static COLORREF crGray;
|
||
static COLORREF crDkGray;
|
||
static COLORREF crBlack;
|
||
|
||
//windows message handling
|
||
BOOL OnCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct);
|
||
void OnDestroy(HWND hwnd);
|
||
void OnPaint(HWND hwnd);
|
||
void OnGetMinMaxInfo(HWND hwnd, LPMINMAXINFO lpMinMaxInfo);
|
||
void OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);
|
||
void OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
|
||
|
||
SHORT _dxMargin; // horizontal margin between tray border and icon
|
||
SHORT _dyMargin; // vertical margin between tray border and icon
|
||
SHORT _dxCell; // horizontal size of icon
|
||
SHORT _dyCell; // vertical size of icon
|
||
SHORT _cyCaption; // title bar height
|
||
SHORT _cxFrame; // thickness of nc frame
|
||
SHORT _cyFrame;
|
||
SHORT _cxSize; // size of sizing corner
|
||
SHORT _cySize;
|
||
|
||
BOOL _fFloating; // free-floating window?
|
||
HWND _hwnd; // the icon toolbar window
|
||
HWND _hwndNotify; // the window to notify via WM_COMMAND
|
||
SHORT _sIdChild; // child identifier for WM_COMMAND
|
||
|
||
int _numCells; // the number of icon "cells" that have been loaded
|
||
IconCell _cell[MAX_CELLS]; // the array of icon cells
|
||
static int _cUsed; // outstanding users of cached cells
|
||
static int _cCache; // total cached cells
|
||
static IconCell _cache[MAX_CELLS]; // a cache array of icon cells
|
||
|
||
int _cellsPerRow;
|
||
int _selectedCell;
|
||
int _iCellAtCursor;
|
||
BOOL _fStuck;
|
||
|
||
// other private helper members
|
||
void GetCellPoint(LPPOINT lppt, int i);
|
||
void GetCellRect(LPRECT lprc, int i);
|
||
void InvalidateCell(HWND hwnd, int i);
|
||
int CellIndexFromPoint(POINT pt);
|
||
};
|
||
|
||
inline void
|
||
IconBar::OnDestroy(HWND hwnd)
|
||
{
|
||
_hwnd = NULL;
|
||
}
|
||
|
||
inline BOOL
|
||
IconBar::OnCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
inline BOOL
|
||
IconBar::IsStuck(void)
|
||
{
|
||
return _fStuck;
|
||
}
|
||
|
||
inline int
|
||
IconBar::GetSelectedCell(void)
|
||
{
|
||
return _selectedCell;
|
||
}
|
||
|
||
inline HWND
|
||
IconBar::GetHwnd(void)
|
||
{
|
||
return _hwnd;
|
||
}
|
||
|
||
|
||
//****************************************************************************
|
||
//
|
||
// Macros
|
||
//
|
||
//****************************************************************************
|
||
|
||
//+------------------------------------------------------------------------
|
||
//
|
||
// Macro: DECLARE_ARY
|
||
//
|
||
// Purpose: Declares a type-safe class derived from CAry.
|
||
//
|
||
// Arguments: _Cls -- Name of new array class
|
||
// _Ty -- Type of array element (e.g. FOO)
|
||
// _pTy -- Type which is a pointer to _Ty (e.g. LPFOO)
|
||
//
|
||
// Interface: operator [] Provides a type-safe pointer to an element
|
||
// of the array
|
||
// operator LPFOO Allows the array to be cast to a type-safe
|
||
// pointer to its first element
|
||
//
|
||
//-------------------------------------------------------------------------
|
||
#define DECLARE_ARY(_Cls, _Ty, _pTy) \
|
||
class _Cls : public CAry { public: \
|
||
_Cls(void) : CAry(sizeof(_Ty)) { ; } \
|
||
_Ty& operator[] (int i) { return * (_pTy) Deref(i); } \
|
||
operator _pTy(void) { return (_pTy) _pv; } };
|
||
|
||
|
||
//======================================================================
|
||
//
|
||
// The base class stuff...
|
||
//
|
||
//
|
||
// Classes: ClassDescriptor
|
||
// SrvrCtrl
|
||
// SrvrDV
|
||
// SrvrInPlace
|
||
//
|
||
//----------------------------------------------------------------------------
|
||
|
||
|
||
enum OLE_SERVER_STATE
|
||
{
|
||
OS_PASSIVE,
|
||
OS_LOADED, // handler but no server
|
||
OS_RUNNING, // server running, invisible
|
||
OS_INPLACE, // server running, inplace-active, no U.I.
|
||
OS_UIACTIVE, // server running, inplace-active, w/ U.I.
|
||
OS_OPEN // server running, open-edited
|
||
};
|
||
|
||
// forward declarations of classes
|
||
|
||
class ClassDescriptor;
|
||
typedef ClassDescriptor FAR* LPCLASSDESCRIPTOR;
|
||
|
||
class SrvrCtrl;
|
||
typedef SrvrCtrl FAR* LPSRVRCTRL;
|
||
|
||
class SrvrDV;
|
||
typedef SrvrDV FAR* LPSRVRDV;
|
||
|
||
class SrvrInPlace;
|
||
typedef SrvrInPlace FAR* LPSRVRINPLACE;
|
||
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: ClassDescriptor
|
||
//
|
||
// Purpose: Global, static information about a server class
|
||
//
|
||
// Notes: This allows the base classes to implement a lot of
|
||
// OLE functionality with requiring additional virtual
|
||
// method calls on the derived classes.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class ClassDescriptor
|
||
{
|
||
public:
|
||
ClassDescriptor(void);
|
||
BOOL Init(HINSTANCE hinst, WORD wBaseID);
|
||
HMENU LoadMenu(void);
|
||
|
||
HINSTANCE _hinst; // instance handle of module serving this class
|
||
WORD _wBaseResID; // base resource identifier (see IDOFF_ )
|
||
CLSID _clsid; // class's unique identifier
|
||
|
||
HICON _hicon; // iconic representation of class
|
||
HACCEL _haccel; // accelerators for those menus
|
||
OLEMENUGROUPWIDTHS _mgw; // the number of Edit, Object, and Help menus
|
||
|
||
WCHAR _szUserClassType[4][64];// [0] unused
|
||
// [1] the string assigned to classid key in reg db.
|
||
// [2] reg db: \CLSID\<clsid>\AuxUserType\2
|
||
// [3] reg db: \CLSID\<clsid>\AuxUserType\3
|
||
WCHAR _szDocfileExt[8]; // extension for docfile files
|
||
|
||
DWORD _dwMiscStatus; // reg db: \CLSID\<clsid>\MiscStatus
|
||
|
||
//DERIVED: The derived class must supply these tables.
|
||
//REVIEW: These could be loaded from resources, too!
|
||
LPOLEVERB _pVerbTable; // pointer to list of verbs available
|
||
int _cVerbTable; // number of entries in the verb table
|
||
|
||
LPFORMATETC _pGetFmtTable; // format table for IDataObject::GetData[Here]
|
||
int _cGetFmtTable; // number of entries in the table
|
||
|
||
LPFORMATETC _pSetFmtTable; // format table for IDataObject::SetData
|
||
int _cSetFmtTable; // number of entries in the table
|
||
};
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: SrvrCtrl
|
||
//
|
||
// Purpose: Control subobject of OLE compound document server
|
||
//
|
||
// Notes: This class supports the IOleObject interface.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class SrvrCtrl : public IOleObject
|
||
{
|
||
public:
|
||
// standard verb implementations
|
||
typedef HRESULT (*LPFNDOVERB) (LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
static HRESULT DoShow(LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
static HRESULT DoOpen(LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
static HRESULT DoHide(LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
static HRESULT DoUIActivate(LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
static HRESULT DoInPlaceActivate(LPVOID, LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
|
||
|
||
//DERIVED: IUnknown methods are left pure virtual and must be implemented
|
||
// by the derived class
|
||
|
||
// IOleObject interface methods
|
||
STDMETHOD(SetClientSite) (LPOLECLIENTSITE pClientSite);
|
||
STDMETHOD(GetClientSite) (LPOLECLIENTSITE FAR* ppClientSite);
|
||
STDMETHOD(SetHostNames) (LPCWSTR szContainerApp, LPCWSTR szContainerObj);
|
||
STDMETHOD(Close) (DWORD dwSaveOption);
|
||
STDMETHOD(SetMoniker) (DWORD dwWhichMoniker, LPMONIKER pmk);
|
||
STDMETHOD(GetMoniker) (DWORD dwAssign, DWORD dwWhichMoniker,
|
||
LPMONIKER FAR* ppmk);
|
||
STDMETHOD(InitFromData) (LPDATAOBJECT pDataObject,BOOL fCreation,
|
||
DWORD dwReserved);
|
||
STDMETHOD(GetClipboardData) (DWORD dwReserved, LPDATAOBJECT FAR* ppDataObject);
|
||
STDMETHOD(DoVerb) (LONG iVerb, LPMSG lpmsg, LPOLECLIENTSITE pActiveSite,
|
||
LONG lindex, HWND hwndParent, LPCRECT lprcPosRect);
|
||
STDMETHOD(EnumVerbs) (LPENUMOLEVERB FAR* ppenumOleVerb);
|
||
STDMETHOD(Update) (void);
|
||
STDMETHOD(IsUpToDate) (void);
|
||
STDMETHOD(GetUserClassID) (CLSID FAR* pClsid);
|
||
STDMETHOD(GetUserType) (DWORD dwFormOfType, LPWSTR FAR* pszUserType);
|
||
STDMETHOD(SetExtent) (DWORD dwDrawAspect, LPSIZEL lpsizel);
|
||
STDMETHOD(GetExtent) (DWORD dwDrawAspect, LPSIZEL lpsizel);
|
||
|
||
STDMETHOD(Advise)(IAdviseSink FAR* pAdvSink, DWORD FAR* pdwConnection);
|
||
STDMETHOD(Unadvise)(DWORD dwConnection);
|
||
STDMETHOD(EnumAdvise) (LPENUMSTATDATA FAR* ppenumAdvise);
|
||
STDMETHOD(GetMiscStatus) (DWORD dwAspect, DWORD FAR* pdwStatus);
|
||
STDMETHOD(SetColorScheme) (LPLOGPALETTE lpLogpal);
|
||
|
||
// pointers to our data/view and inplace subobjects
|
||
LPSRVRDV _pDV; // our persistent data/view subobject
|
||
LPSRVRINPLACE _pInPlace; // our inplace-active subobject
|
||
// pointers to those objects' private unknowns
|
||
LPUNKNOWN _pPrivUnkDV;
|
||
LPUNKNOWN _pPrivUnkIP;
|
||
|
||
// methods and members required by our data/view and inplace subobjects.
|
||
OLE_SERVER_STATE State(void);
|
||
void SetState(OLE_SERVER_STATE state)
|
||
{
|
||
_state = state;
|
||
};
|
||
HRESULT TransitionTo(OLE_SERVER_STATE state);
|
||
LPOLECLIENTSITE _pClientSite;
|
||
void OnSave(void);
|
||
|
||
void EnableIPB(BOOL fEnabled);
|
||
BOOL IsIPBEnabled(void);
|
||
|
||
virtual HRESULT Init(LPCLASSDESCRIPTOR pClass);
|
||
|
||
// IOleObject-related members
|
||
DWORD _dwRegROT; // our R.O.T. registration value
|
||
LPOLEADVISEHOLDER _pOleAdviseHolder;// for collection our advises
|
||
LPWSTR _lpstrCntrApp; // top-level container application
|
||
LPWSTR _lpstrCntrObj; // and object names
|
||
|
||
|
||
protected:
|
||
|
||
//
|
||
// DERIVED: Each of these correspond to a unique state transition.
|
||
// The derived class may want to override to do additional processing.
|
||
//
|
||
virtual HRESULT PassiveToLoaded();
|
||
virtual HRESULT LoadedToPassive();
|
||
|
||
virtual HRESULT LoadedToRunning();
|
||
virtual HRESULT RunningToLoaded();
|
||
|
||
virtual HRESULT RunningToInPlace();
|
||
virtual HRESULT InPlaceToRunning();
|
||
|
||
virtual HRESULT InPlaceToUIActive();
|
||
virtual HRESULT UIActiveToInPlace();
|
||
|
||
virtual HRESULT RunningToOpened();
|
||
virtual HRESULT OpenedToRunning();
|
||
|
||
// constructors, initializers, and destructors
|
||
SrvrCtrl(void);
|
||
virtual ~SrvrCtrl(void);
|
||
|
||
LPCLASSDESCRIPTOR _pClass; // global info about our OLE server
|
||
|
||
OLE_SERVER_STATE _state; // our current state
|
||
|
||
BOOL _fEnableIPB; // FALSE turns off built-in border
|
||
|
||
//DERIVED: The derived class must supply table of verb functions
|
||
// parallel to the table of verbs in the class descriptor
|
||
LPFNDOVERB FAR* _pVerbFuncs; // verb function table
|
||
};
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrCtrl::State, public
|
||
//
|
||
// Synopsis: Returns the current state of the object
|
||
//
|
||
// Notes: The valid object states are closed, loaded, inplace,
|
||
// U.I. active, and open. These states are defined
|
||
// by the OLE_SERVER_STATE enumeration.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline OLE_SERVER_STATE
|
||
SrvrCtrl::State(void)
|
||
{
|
||
return _state;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrCtrl::EnableIPB, public
|
||
//
|
||
// Synopsis: Enables/Disables built in InPlace border
|
||
//
|
||
//---------------------------------------------------------------
|
||
inline void
|
||
SrvrCtrl::EnableIPB(BOOL fEnabled)
|
||
{
|
||
_fEnableIPB = fEnabled;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrCtrl::IsIPBEnabled, public
|
||
//
|
||
// Synopsis: Answers whether built-in InPlace border is enabled
|
||
//
|
||
//---------------------------------------------------------------
|
||
inline BOOL
|
||
SrvrCtrl::IsIPBEnabled(void)
|
||
{
|
||
return _fEnableIPB;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: SrvrDV
|
||
//
|
||
// Purpose: Data/View subobject of OLE compound document server
|
||
//
|
||
// Notes: This class supports the IDataObject and IViewObject interfaces.
|
||
// It also supports the IPersist-derived interfaces.
|
||
// Objects of this class can operate as part of a complete
|
||
// server aggregation or independently as a transfer data
|
||
// object.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class SrvrDV: public IDataObject,
|
||
public IViewObject,
|
||
public IPersistStorage,
|
||
public IPersistStream,
|
||
public IPersistFile
|
||
{
|
||
public:
|
||
|
||
typedef HRESULT (*LPFNGETDATA) (LPSRVRDV, LPFORMATETC, LPSTGMEDIUM, BOOL);
|
||
typedef HRESULT (*LPFNSETDATA) (LPSRVRDV, LPFORMATETC, LPSTGMEDIUM);
|
||
|
||
// standard format Get/Set implementations
|
||
static HRESULT GetEMBEDDEDOBJECT(LPSRVRDV, LPFORMATETC, LPSTGMEDIUM, BOOL);
|
||
static HRESULT GetMETAFILEPICT(LPSRVRDV, LPFORMATETC, LPSTGMEDIUM, BOOL);
|
||
static HRESULT GetOBJECTDESCRIPTOR(LPSRVRDV, LPFORMATETC, LPSTGMEDIUM, BOOL);
|
||
static HRESULT GetLINKSOURCE(LPSRVRDV, LPFORMATETC, LPSTGMEDIUM, BOOL);
|
||
|
||
//
|
||
//DERIVED: IUnknown methods are left pure virtual and must be implemented
|
||
// by the derived class
|
||
|
||
//
|
||
// IDataObject interface methods
|
||
//
|
||
STDMETHOD(GetData) (LPFORMATETC pformatetcIn, LPSTGMEDIUM pmedium);
|
||
STDMETHOD(GetDataHere) (LPFORMATETC pformatetc, LPSTGMEDIUM pmedium);
|
||
STDMETHOD(QueryGetData) (LPFORMATETC pformatetc);
|
||
STDMETHOD(GetCanonicalFormatEtc) (LPFORMATETC pformatetc,
|
||
LPFORMATETC pformatetcOut);
|
||
STDMETHOD(SetData) (LPFORMATETC pformatetc, LPSTGMEDIUM pmedium,
|
||
BOOL fRelease);
|
||
STDMETHOD(EnumFormatEtc) (DWORD dwDirection, LPENUMFORMATETC FAR* ppenum);
|
||
STDMETHOD(DAdvise) (FORMATETC FAR* pFormatetc, DWORD advf,
|
||
LPADVISESINK pAdvSink, DWORD FAR* pdwConnection);
|
||
STDMETHOD(DUnadvise) (DWORD dwConnection);
|
||
STDMETHOD(EnumDAdvise) (LPENUMSTATDATA FAR* ppenumAdvise);
|
||
|
||
//
|
||
// IViewObject interface methods
|
||
//
|
||
STDMETHOD(Draw) (DWORD dwDrawAspect, LONG lindex,
|
||
void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
|
||
HDC hicTargetDev,
|
||
HDC hdcDraw,
|
||
LPCRECTL lprcBounds,
|
||
LPCRECTL lprcWBounds,
|
||
BOOL (CALLBACK * pfnContinue) (DWORD),
|
||
DWORD dwContinue);
|
||
STDMETHOD(GetColorSet) (DWORD dwDrawAspect, LONG lindex,
|
||
void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
|
||
HDC hicTargetDev,
|
||
LPLOGPALETTE FAR* ppColorSet);
|
||
STDMETHOD(Freeze)(DWORD dwDrawAspect, LONG lindex, void FAR* pvAspect,
|
||
DWORD FAR* pdwFreeze);
|
||
STDMETHOD(Unfreeze) (DWORD dwFreeze);
|
||
STDMETHOD(SetAdvise) (DWORD aspects, DWORD advf, LPADVISESINK pAdvSink);
|
||
STDMETHOD(GetAdvise) (DWORD FAR* pAspects, DWORD FAR* pAdvf,
|
||
LPADVISESINK FAR* ppAdvSink);
|
||
|
||
//
|
||
// IPersist interface methods
|
||
//
|
||
STDMETHOD(GetClassID) (LPCLSID lpClassID);
|
||
|
||
STDMETHOD(IsDirty) (void);
|
||
|
||
//
|
||
// IPersistStream interface methods
|
||
//
|
||
STDMETHOD(Load) (LPSTREAM pStm);
|
||
STDMETHOD(Save) (LPSTREAM pStm, BOOL fClearDirty);
|
||
STDMETHOD(GetSizeMax) (ULARGE_INTEGER FAR * pcbSize);
|
||
|
||
//
|
||
// IPersistStorage interface methods
|
||
//
|
||
STDMETHOD(InitNew) (LPSTORAGE pStg);
|
||
STDMETHOD(Load) (LPSTORAGE pStg);
|
||
STDMETHOD(Save) (LPSTORAGE pStgSave, BOOL fSameAsLoad);
|
||
STDMETHOD(SaveCompleted) (LPSTORAGE pStgNew);
|
||
STDMETHOD(HandsOffStorage) (void);
|
||
|
||
//
|
||
// IPersistFile interface methods
|
||
//
|
||
STDMETHOD(Load) (LPCOLESTR lpszFileName, DWORD grfMode);
|
||
STDMETHOD(Save) (LPCOLESTR lpszFileName, BOOL fRemember);
|
||
STDMETHOD(SaveCompleted) (LPCOLESTR lpszFileName);
|
||
STDMETHOD(GetCurFile) (LPOLESTR FAR * lplpszFileName);
|
||
|
||
//
|
||
// DERIVED: methods required by the control
|
||
//
|
||
virtual HRESULT GetClipboardCopy(LPSRVRDV FAR* ppDV) = 0;
|
||
virtual HRESULT GetExtent(DWORD dwAspect, LPSIZEL lpsizel);
|
||
virtual HRESULT SetExtent(DWORD dwAspect, SIZEL& sizel);
|
||
virtual void SetMoniker(LPMONIKER pmk);
|
||
HRESULT GetMoniker(DWORD dwAssign, LPMONIKER FAR* ppmk);
|
||
LPWSTR GetMonikerDisplayName(DWORD dwAssign = OLEGETMONIKER_ONLYIFTHERE);
|
||
|
||
//
|
||
//DERIVED: The derived class should call this base class method whenever
|
||
// the data changes. This launches all appropriate advises.
|
||
//
|
||
void OnDataChange(DWORD dwAdvf = 0);
|
||
|
||
//
|
||
//DERIVED: The derived class should override these methods to perform
|
||
// rendering of its native data. These are used in the implementation of
|
||
// the IViewObject interface
|
||
//
|
||
virtual HRESULT RenderContent(DWORD dwDrawAspect,
|
||
LONG lindex,
|
||
void FAR* pvAspect,
|
||
DVTARGETDEVICE FAR * ptd,
|
||
HDC hicTargetDev,
|
||
HDC hdcDraw,
|
||
LPCRECTL lprectl,
|
||
LPCRECTL lprcWBounds,
|
||
BOOL (CALLBACK * pfnContinue) (DWORD),
|
||
DWORD dwContinue);
|
||
virtual HRESULT RenderPrint(DWORD dwDrawAspect,
|
||
LONG lindex,
|
||
void FAR* pvAspect,
|
||
DVTARGETDEVICE FAR * ptd,
|
||
HDC hicTargetDev,
|
||
HDC hdcDraw,
|
||
LPCRECTL lprectl,
|
||
LPCRECTL lprcWBounds,
|
||
BOOL (CALLBACK * pfnContinue) (DWORD),
|
||
DWORD dwContinue);
|
||
virtual HRESULT RenderThumbnail(DWORD dwDrawAspect,
|
||
LONG lindex,
|
||
void FAR* pvAspect,
|
||
DVTARGETDEVICE FAR * ptd,
|
||
HDC hicTargetDev,
|
||
HDC hdcDraw,
|
||
LPCRECTL lprectl,
|
||
LPCRECTL lprcWBounds,
|
||
BOOL (CALLBACK * pfnContinue) (DWORD),
|
||
DWORD dwContinue);
|
||
|
||
BOOL IsInNoScrible(void);
|
||
|
||
virtual HRESULT Init(LPCLASSDESCRIPTOR pClass, LPSRVRCTRL pCtrl);
|
||
virtual HRESULT Init(LPCLASSDESCRIPTOR pClass, LPSRVRDV pDV);
|
||
|
||
protected:
|
||
|
||
//
|
||
//DERIVED: The derived class should override these methods to perform
|
||
// persistent serialization and deserialization. These are used in the
|
||
// implementation of IPersistStream/Storage/File
|
||
//
|
||
virtual HRESULT LoadFromStream(LPSTREAM pStrm);
|
||
virtual HRESULT SaveToStream(LPSTREAM pStrm);
|
||
virtual DWORD GetStreamSizeMax(void);
|
||
|
||
virtual HRESULT LoadFromStorage(LPSTORAGE pStg);
|
||
virtual HRESULT SaveToStorage(LPSTORAGE pStg, BOOL fSameAsLoad);
|
||
|
||
//
|
||
// constructors, initializers, and destructors
|
||
//
|
||
SrvrDV(void);
|
||
virtual ~SrvrDV(void);
|
||
|
||
LPCLASSDESCRIPTOR _pClass; // global info about our OLE server
|
||
LPSRVRCTRL _pCtrl; // control of server aggregate or
|
||
// NULL if transfer object
|
||
//
|
||
// IDataObject-related members
|
||
//
|
||
LPMONIKER _pmk; // moniker used for LINKSOURCE
|
||
LPWSTR _lpstrDisplayName; // cached display name of moniker
|
||
SIZEL _sizel; // used for OBJECTDESCRIPTOR and Extent
|
||
LPDATAADVISEHOLDER _pDataAdviseHolder;
|
||
|
||
//
|
||
//DERIVED: The derived class must supply table of Get functions
|
||
// and a table of Set functions parallel to the FORMATETC tables
|
||
// in the class descriptor.
|
||
//
|
||
LPFNGETDATA FAR* _pGetFuncs; // GetData(Here) function table
|
||
LPFNSETDATA FAR* _pSetFuncs; // SetData function table
|
||
|
||
LPVIEWADVISEHOLDER _pViewAdviseHolder;
|
||
|
||
unsigned _fFrozen: 1; // blocked from updating
|
||
unsigned _fDirty: 1; // TRUE iff persistent data has changed
|
||
unsigned _fNoScribble: 1; // between save and save completed
|
||
|
||
// IPersistStorage-related members
|
||
LPSTORAGE _pStg; // our home IStorage instance
|
||
};
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrDV::IsInNoScrible, public
|
||
//
|
||
// Synopsis: Answers wether we are currently in no-scribble mode
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline BOOL
|
||
SrvrDV::IsInNoScrible(void)
|
||
{
|
||
return _fNoScribble;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Class: SrvrInPlace
|
||
//
|
||
// Purpose: Inplace subobject of OLE compound document server
|
||
//
|
||
// Notes: This class supports the IOleInPlaceObject and
|
||
// IOleInPlaceActiveObject interfaces.
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
class SrvrInPlace: public IOleInPlaceObject,
|
||
public IOleInPlaceActiveObject
|
||
{
|
||
public:
|
||
//DERIVED: IUnknown methods are left pure virtual and must be implemented
|
||
// by the derived class
|
||
|
||
// IOleWindow interface methods
|
||
STDMETHOD(GetWindow) (HWND FAR* lphwnd);
|
||
STDMETHOD(ContextSensitiveHelp) (BOOL fEnterMode);
|
||
|
||
// IOleInPlaceObject interface methods
|
||
STDMETHOD(InPlaceDeactivate) (void);
|
||
STDMETHOD(UIDeactivate) (void);
|
||
STDMETHOD(SetObjectRects) (LPCRECT lprcPosRect, LPCRECT lprcClipRect);
|
||
STDMETHOD(ReactivateAndUndo) (void);
|
||
|
||
// IOleInPlaceActiveObject methods
|
||
STDMETHOD(TranslateAccelerator) (LPMSG lpmsg);
|
||
STDMETHOD(OnFrameWindowActivate) (BOOL fActivate);
|
||
STDMETHOD(OnDocWindowActivate) (BOOL fActivate);
|
||
STDMETHOD(ResizeBorder) (LPCRECT lprectBorder,
|
||
LPOLEINPLACEUIWINDOW lpUIWindow,
|
||
BOOL fFrameWindow);
|
||
STDMETHOD(EnableModeless) (BOOL fEnable);
|
||
|
||
// methods and members required by the other subobjects.
|
||
HWND WindowHandle(void);
|
||
void SetChildActivating(BOOL fGoingActive);
|
||
BOOL GetChildActivating(void);
|
||
BOOL IsDeactivating(void);
|
||
void ReflectState(BOOL fUIActive);
|
||
|
||
LPOLEINPLACEFRAME _pFrame; // our in-place active frame
|
||
LPOLEINPLACEUIWINDOW _pDoc; // our in-place active document
|
||
|
||
//DERIVED: These methods are called by the control to effect a
|
||
// state transition. The derived class can override these methods if
|
||
// it requires additional processing.
|
||
virtual HRESULT ActivateInPlace(IOleClientSite *pClientSite);
|
||
virtual HRESULT DeactivateInPlace(void);
|
||
virtual HRESULT ActivateUI(void);
|
||
virtual HRESULT DeactivateUI(void);
|
||
|
||
//DERIVED: These methods are related to U.I. activation. The derived
|
||
// class should override these to perform additional processing for
|
||
// any frame, document, or floating toolbars or palettes.
|
||
virtual void InstallUI(void);
|
||
virtual void RemoveUI(void);
|
||
|
||
LPOLEINPLACESITE _pInPlaceSite; // our in-place client site
|
||
|
||
virtual HRESULT Init(LPCLASSDESCRIPTOR pClass, LPSRVRCTRL pCtrl);
|
||
|
||
protected:
|
||
|
||
//DERIVED: More U.I. activation-related methods.
|
||
virtual void CreateUI(void);
|
||
virtual void DestroyUI(void);
|
||
virtual void InstallFrameUI(void);
|
||
virtual void RemoveFrameUI(void);
|
||
virtual void InstallDocUI(void);
|
||
virtual void RemoveDocUI(void);
|
||
virtual void ClearSelection(void);
|
||
virtual void SetFocus(HWND hwnd);
|
||
|
||
//DERIVED: The derived class must override this function to
|
||
// attach the servers in-place active window.
|
||
virtual HWND AttachWin(HWND hwndParent) = 0;
|
||
virtual void DetachWin(void);
|
||
|
||
SrvrInPlace(void);
|
||
virtual ~SrvrInPlace(void);
|
||
|
||
LPCLASSDESCRIPTOR _pClass; // global info about our class
|
||
|
||
LPSRVRCTRL _pCtrl; // the control we are part of.
|
||
|
||
// IOleInPlaceObject-related members
|
||
unsigned _fUIDown: 1; // menu/tools integrated with container?
|
||
unsigned _fChildActivating: 1; // site going UIActive?
|
||
unsigned _fDeactivating: 1; // being deactivated from the outside?
|
||
unsigned _fCSHelpMode: 1; // in context-sensitive help state?
|
||
|
||
OLEINPLACEFRAMEINFO _frameInfo; // accelerator information from our container
|
||
|
||
InPlaceBorder _IPB; // our In-Place border when UIActive
|
||
RECT _rcFrame; // our frame rect
|
||
|
||
HWND _hwnd; // our InPlace window
|
||
HMENU _hmenu;
|
||
HOLEMENU _hOleMenu; // menu registered w/ OLE
|
||
HMENU _hmenuShared; // the shared menu when we are UI active
|
||
OLEMENUGROUPWIDTHS _mgw; // menu interleaving information
|
||
|
||
BOOL _fClientResize; // TRUE during calls to SetObjectRects
|
||
};
|
||
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrInPlace::IsDeactivating, public
|
||
//
|
||
// Synopsis: Gets value of a flag indicating deactivation
|
||
// (from the outside) in progress
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline BOOL
|
||
SrvrInPlace::IsDeactivating(void)
|
||
{
|
||
return _fDeactivating;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrInPlace::GetChildActivating, public
|
||
//
|
||
// Synopsis: Gets value of a flag indicating that a child is
|
||
// activating to prevent menu flashing
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline BOOL
|
||
SrvrInPlace::GetChildActivating(void)
|
||
{
|
||
return _fChildActivating;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrInPlace::SetChildActivating, public
|
||
//
|
||
// Synopsis: Sets or clears a flag indicating that a child is
|
||
// activating to prevent menu flashing
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline void
|
||
SrvrInPlace::SetChildActivating(BOOL fGoingActive)
|
||
{
|
||
_fChildActivating = fGoingActive;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrInPlace::WindowHandle, public
|
||
//
|
||
// Synopsis: Returns object window handle
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline HWND
|
||
SrvrInPlace::WindowHandle(void)
|
||
{
|
||
return _hwnd;
|
||
}
|
||
|
||
//+---------------------------------------------------------------
|
||
//
|
||
// Member: SrvrInPlace::ReflectState, public
|
||
//
|
||
// Synopsis: TBD
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
inline void
|
||
SrvrInPlace::ReflectState(BOOL fActive)
|
||
{
|
||
if(_pCtrl->IsIPBEnabled())
|
||
{
|
||
_IPB.SetUIActive(fActive);
|
||
}
|
||
}
|
||
|
||
#endif // !RC_INVOKED
|
||
|
||
|
||
#endif //_O2BASE_HXX_
|
||
|