ctlprop.cpp

c语言编程软件vc6.0中文绿色版_vc6.0官方下载

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#include "stdafx.h"

#ifdef AFXCTL_PROP_SEG
#pragma code_seg(AFXCTL_PROP_SEG)
#endif

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#ifndef _DEBUG
#pragma intrinsic(memset)
#endif

#define new DEBUG_NEW

/////////////////////////////////////////////////////////////////////////////
// Stock property mask

#define STOCKPROP_BACKCOLOR     0x00000001
#define STOCKPROP_CAPTION       0x00000002
#define STOCKPROP_FONT          0x00000004
#define STOCKPROP_FORECOLOR     0x00000008
#define STOCKPROP_TEXT          0x00000010
#define STOCKPROP_BORDERSTYLE   0x00000020
#define STOCKPROP_ENABLED       0x00000040
#define STOCKPROP_APPEARANCE    0x00000080

AFX_STATIC_DATA const DWORD _afxStockProps[] =
{
	STOCKPROP_BACKCOLOR,    // -501
	0,                      // -502
	0,                      // -503
	STOCKPROP_BORDERSTYLE,  // -504
	0,                      // -505
	0,                      // -506
	0,                      // -507
	0,                      // -508
	0,                      // -509
	0,                      // -510
	0,                      // -511
	STOCKPROP_FONT,         // -512
	STOCKPROP_FORECOLOR,    // -513
	STOCKPROP_ENABLED,      // -514
	0,                      // -515
	0,                      // -516
	STOCKPROP_TEXT,         // -517
	STOCKPROP_CAPTION,      // -518
	0,                      // -519
	STOCKPROP_APPEARANCE,   // -520
};

void COleControl::InitStockPropMask()
{
	const AFX_DISPMAP* pDispMap = GetDispatchMap();
	const AFX_DISPMAP_ENTRY* pEntry;
	ASSERT(pDispMap != NULL);

	// If stock property mask is already initialized, we're outta here.
	if (*pDispMap->lpStockPropMask != (DWORD)-1)
		return;

	AfxLockGlobals(CRIT_STOCKMASK);

	if (*pDispMap->lpStockPropMask == (DWORD)-1)
	{
		const AFX_DISPMAP* pDispMapTop = pDispMap;
		DWORD dwStockPropMask = 0;

		while (pDispMap != NULL)
		{
			pEntry = pDispMap->lpEntries;
			while (pEntry->nPropOffset != -1)
			{
				int nIndex = DISPID_BACKCOLOR - pEntry->lDispID;
				DWORD dwFlag;
				if (nIndex >= 0 && nIndex < _countof(_afxStockProps) &&
					(dwFlag = _afxStockProps[nIndex]) != 0)
				{
					dwStockPropMask |= dwFlag;
				}

				++pEntry;
			}
			// check base class
#ifdef _AFXDLL
			pDispMap = (*pDispMap->pfnGetBaseMap)();
#else
			pDispMap = pDispMap->pBaseMap;
#endif
		}

		*pDispMapTop->lpStockPropMask = dwStockPropMask;
	}

	AfxUnlockGlobals(CRIT_STOCKMASK);
}

AFX_STATIC void AFXAPI _AfxToggleBorderStyle(CWnd* pWnd)
{
	if (pWnd->m_hWnd != NULL)
	{
		// toggle border style and force redraw of border
		::SetWindowLong(pWnd->m_hWnd, GWL_STYLE, pWnd->GetStyle() ^ WS_BORDER);
		::SetWindowPos(pWnd->m_hWnd, NULL, 0, 0, 0, 0,
			SWP_DRAWFRAME | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
	}
}

AFX_STATIC void AFXAPI _AfxToggleAppearance(CWnd* pWnd)
{
	if (pWnd->m_hWnd != NULL)
	{
		// toggle border style and force redraw of border
		::SetWindowLong(pWnd->m_hWnd, GWL_EXSTYLE, pWnd->GetExStyle() ^
			WS_EX_CLIENTEDGE);
		::SetWindowPos(pWnd->m_hWnd, NULL, 0, 0, 0, 0,
			SWP_DRAWFRAME | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
	}
}

/////////////////////////////////////////////////////////////////////////////
// Property exchange for stock properties

void COleControl::ExchangeStockProps(CPropExchange* pPX)
{
	BOOL bLoading = pPX->IsLoading();
	DWORD dwStockPropMask = GetStockPropMask();
	DWORD dwPersistMask = dwStockPropMask;

	PX_ULong(pPX, _T("_StockProps"), dwPersistMask);

	if (dwStockPropMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
	{
		CString strText;

		if (dwPersistMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
		{
			if (!bLoading)
				strText = InternalGetText();
			if (dwStockPropMask & STOCKPROP_CAPTION)
				PX_String(pPX, _T("Caption"), strText, _T(""));
			if (dwStockPropMask & STOCKPROP_TEXT)
				PX_String(pPX, _T("Text"), strText, _T(""));
		}
		if (bLoading)
		{
			TRY
				SetText(strText);
			END_TRY
		}
	}

	if (dwStockPropMask & STOCKPROP_FORECOLOR)
	{
		if (dwPersistMask & STOCKPROP_FORECOLOR)
			PX_Color(pPX, _T("ForeColor"), m_clrForeColor, AmbientForeColor());
		else if (bLoading)
			m_clrForeColor = AmbientForeColor();
	}

	if (dwStockPropMask & STOCKPROP_BACKCOLOR)
	{
		if (dwPersistMask & STOCKPROP_BACKCOLOR)
			PX_Color(pPX, _T("BackColor"), m_clrBackColor, AmbientBackColor());
		else if (bLoading)
			m_clrBackColor = AmbientBackColor();
	}

	if (dwStockPropMask & STOCKPROP_FONT)
	{
		LPFONTDISP pFontDispAmbient = AmbientFont();
		BOOL bChanged = TRUE;

		if (dwPersistMask & STOCKPROP_FONT)
			bChanged = PX_Font(pPX, _T("Font"), m_font, NULL, pFontDispAmbient);
		else if (bLoading)
			m_font.InitializeFont(NULL, pFontDispAmbient);

		if (bLoading && bChanged)
			OnFontChanged();

		RELEASE(pFontDispAmbient);
	}

	if (dwStockPropMask & STOCKPROP_BORDERSTYLE)
	{
		short sBorderStyle = m_sBorderStyle;

		if (dwPersistMask & STOCKPROP_BORDERSTYLE)
			PX_Short(pPX, _T("BorderStyle"), m_sBorderStyle, 0);
		else if (bLoading)
			m_sBorderStyle = 0;

		if (sBorderStyle != m_sBorderStyle)
			_AfxToggleBorderStyle(this);
	}

	if (dwStockPropMask & STOCKPROP_ENABLED)
	{
		BOOL bEnabled = m_bEnabled;

		if (dwPersistMask & STOCKPROP_ENABLED)
			PX_Bool(pPX, _T("Enabled"), m_bEnabled, TRUE);
		else if (bLoading)
			m_bEnabled = TRUE;

		if ((bEnabled != m_bEnabled) && (m_hWnd != NULL))
			::EnableWindow(m_hWnd, m_bEnabled);
	}

	if (dwStockPropMask & STOCKPROP_APPEARANCE)
	{
		short sAppearance = m_sAppearance;

		if (dwPersistMask & STOCKPROP_APPEARANCE)
			PX_Short(pPX, _T("Appearance"), m_sAppearance, 0);
		else if (bLoading)
			m_sAppearance = AmbientAppearance();

		if (sAppearance != m_sAppearance)
			_AfxToggleAppearance(this);
	}
}

/////////////////////////////////////////////////////////////////////////////
// Serialization for stock properties

void COleControl::SerializeStockProps(CArchive& ar)
{
	BOOL bLoading = ar.IsLoading();
	DWORD dwStockPropMask = GetStockPropMask();
	DWORD dwPersistMask = dwStockPropMask;

	if (bLoading)
	{
		ar >> dwPersistMask;

		if (dwStockPropMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
		{
			if (dwPersistMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
			{
				CString strText;
				ar >> strText;
				TRY
					SetText(strText);
				END_TRY
			}
			else
			{
				TRY
					SetText(_T(""));
				END_TRY
			}
		}

		if (dwStockPropMask & STOCKPROP_FORECOLOR)
		{
			if (dwPersistMask & STOCKPROP_FORECOLOR)
				ar >> m_clrForeColor;
			else
				m_clrForeColor = AmbientForeColor();
		}

		if (dwStockPropMask & STOCKPROP_BACKCOLOR)
		{
			if (dwPersistMask & STOCKPROP_BACKCOLOR)
				ar >> m_clrBackColor;
			else
				m_clrBackColor = AmbientBackColor();
		}

		if (dwStockPropMask & STOCKPROP_FONT)
		{
			BOOL bRead = FALSE;

			if (dwPersistMask & STOCKPROP_FONT)
			{
				BYTE bFlag;
				ar >> bFlag;
				if (bFlag != 0xFF)
				{
					CArchiveStream stm(&ar);
					LPSTREAM pstm = _AfxGetArchiveStream(ar, stm);
					LPFONT pFont = _AfxCreateFontFromStream(pstm);
					if (pFont != NULL)
					{
						m_font.SetFont(pFont);
						bRead = TRUE;
					}
				}
			}

			if (! bRead)
			{
				LPFONTDISP pFontDispAmbient = AmbientFont();
				m_font.InitializeFont(NULL, pFontDispAmbient);
				RELEASE(pFontDispAmbient);
			}

			OnFontChanged();
		}

		if (dwStockPropMask & STOCKPROP_BORDERSTYLE)
		{
			if (dwPersistMask & STOCKPROP_BORDERSTYLE)
			{
				short sBorderStyle = m_sBorderStyle;
				ar >> m_sBorderStyle;
				if (sBorderStyle != m_sBorderStyle)
					_AfxToggleBorderStyle(this);
			}
			else
			{
				m_sBorderStyle = 0;
			}
		}

		if (dwStockPropMask & STOCKPROP_ENABLED)
		{
			if (dwPersistMask & STOCKPROP_ENABLED)
			{
				BOOL bEnabled = m_bEnabled;
				ar >> m_bEnabled;
				if ((bEnabled != m_bEnabled) && (m_hWnd != NULL))
					::EnableWindow(m_hWnd, m_bEnabled);
			}
			else
			{
				m_bEnabled = TRUE;
			}
		}

		if (dwStockPropMask & STOCKPROP_APPEARANCE)
		{
			if (dwPersistMask & STOCKPROP_APPEARANCE)
			{
				short sAppearance = m_sAppearance;
				ar >> m_sAppearance;

				if (sAppearance != m_sAppearance)
					_AfxToggleAppearance(this);
			}
			else
			{
				m_sAppearance = AmbientAppearance();
			}
		}
	}
	else
	{
		ar << dwPersistMask;

		if (dwStockPropMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
			ar << m_strText;

		if (dwStockPropMask & STOCKPROP_FORECOLOR)
			ar << m_clrForeColor;

		if (dwStockPropMask & STOCKPROP_BACKCOLOR)
			ar << m_clrBackColor;

		if (dwStockPropMask & STOCKPROP_FONT)
		{
			BOOL bWrite = FALSE;
			LPFONT pFont = m_font.m_pFont;
			if (pFont != NULL)
			{
				// If same as ambient font (or error), write 0xFF for the flag
				LPFONTDISP pFontDispAmbient = AmbientFont();
				if (!_AfxIsSameFont(m_font, NULL, pFontDispAmbient))
				{
					LPPERSISTSTREAM pps = NULL;
					if (SUCCEEDED(pFont->QueryInterface(IID_IPersistStream,
						(LPVOID*)&pps)))
					{
						ASSERT_POINTER(pps, IPersistStream);
						ar << (BYTE)0x00;
						CArchiveStream stm(&ar);
						LPSTREAM pstm = _AfxGetArchiveStream(ar, stm);
						bWrite = SUCCEEDED(::OleSaveToStream(pps, pstm));
						pps->Release();
						if (!bWrite)
							AfxThrowArchiveException(CArchiveException::generic);
					}
				}
				RELEASE(pFontDispAmbient);
			}
			if (! bWrite)
			{
				ar << (BYTE)0xFF;
			}
		}

		if (dwStockPropMask & STOCKPROP_BORDERSTYLE)
			ar << m_sBorderStyle;

		if (dwStockPropMask & STOCKPROP_ENABLED)
			ar << m_bEnabled;

		if (dwStockPropMask & STOCKPROP_APPEARANCE)
			ar << m_sAppearance;
	}
}

/////////////////////////////////////////////////////////////////////////////
// Initialization for stock properties

void COleControl::ResetStockProps()
{
	DWORD dwStockPropMask = GetStockPropMask();

	if (dwStockPropMask & (STOCKPROP_CAPTION | STOCKPROP_TEXT))
	{
		TRY
			SetText(_T(""));
		END_TRY
	}

	if (dwStockPropMask & STOCKPROP_FORECOLOR)
		m_clrForeColor = AmbientForeColor();

	if (dwStockPropMask & STOCKPROP_BACKCOLOR)
		m_clrBackColor = AmbientBackColor();

	if (dwStockPropMask & STOCKPROP_FONT)
	{
		LPFONTDISP pFontDispAmbient = AmbientFont();
		m_font.InitializeFont(NULL, pFontDispAmbient);
		RELEASE(pFontDispAmbient);
		OnFontChanged();
	}

	if (dwStockPropMask & STOCKPROP_BORDERSTYLE)
		m_sBorderStyle = 0;

	if (dwStockPropMask & STOCKPROP_ENABLED)
		m_bEnabled = TRUE;

	if (dwStockPropMask & STOCKPROP_APPEARANCE)
		m_sAppearance = AmbientAppearance();
}

/////////////////////////////////////////////////////////////////////////////
// Appearance property

short COleControl::GetAppearance()
{
	return m_sAppearance;
}

void COleControl::SetAppearance(short sAppearance)
{
	if (sAppearance != 0 && sAppearance != 1)
		ThrowError(CTL_E_INVALIDPROPERTYVALUE, AFX_IDP_E_INVALIDPROPERTYVALUE);

	// Is the property changing?
	if (m_sAppearance == sAppearance)
		return;

	if (!BoundPropertyRequestEdit(DISPID_APPEARANCE))
		SetNotPermitted();

	ASSERT((m_hWnd == NULL) ||
		((GetExStyle() & WS_EX_CLIENTEDGE) == (DWORD)(m_sAppearance ?
			WS_EX_CLIENTEDGE : 0)));

	m_sAppearance = sAppearance;
	m_bModified = TRUE;

	_AfxToggleAppearance(this);
	OnAppearanceChanged();

	BoundPropertyChanged(DISPID_APPEARANCE);
}

void COleControl::OnAppearanceChanged()
{
	// Can be overridden by subclass

	InvalidateControl();
}

/////////////////////////////////////////////////////////////////////////////
// BackColor property

OLE_COLOR COleControl::GetBackColor()
{
	return m_clrBackColor;
}

void COleControl::SetBackColor(OLE_COLOR clrBackColor)
{
	// Is the property changing?
	if (m_clrBackColor == clrBackColor)
		return;

	if (FAILED(::OleTranslateColor(clrBackColor, NULL, NULL)))
		ThrowError(CTL_E_INVALIDPROPERTYVALUE, AFX_IDP_E_INVALIDPROPERTYVALUE);

	if (!BoundPropertyRequestEdit(DISPID_BACKCOLOR))
		SetNotPermitted();

	m_clrBackColor = clrBackColor;
	m_bModified = TRUE;
	OnBackColorChanged();

	BoundPropertyChanged(DISPID_BACKCOLOR);
}

void COleControl::OnBackColorChanged()