769 lines
20 KiB
C++
769 lines
20 KiB
C++
//=--------------------------------------------------------------------------=
|
|
// PropPage.Cpp
|
|
//=--------------------------------------------------------------------------=
|
|
// Copyright 1995-1996 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
// PARTICULAR PURPOSE.
|
|
//=--------------------------------------------------------------------------=
|
|
//
|
|
// implementation of CPropertyPage object.
|
|
//
|
|
#include "IPServer.H"
|
|
#include "PropPage.H"
|
|
#include "Util.H"
|
|
#include "Globals.H"
|
|
|
|
// for ASSERT and FAIL
|
|
//
|
|
SZTHISFILE
|
|
|
|
// this variable is used to pass the pointer to the object to the hwnd.
|
|
//
|
|
static CPropertyPage *s_pLastPageCreated;
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::CPropertyPage
|
|
//=--------------------------------------------------------------------------=
|
|
// constructor.
|
|
//
|
|
// Parameters:
|
|
// IUnknown * - [in] controlling unknown
|
|
// int - [in] object type.
|
|
//
|
|
// Notes:
|
|
//
|
|
#pragma warning(disable:4355) // using 'this' in constructor
|
|
CPropertyPage::CPropertyPage
|
|
(
|
|
IUnknown *pUnkOuter,
|
|
int iObjectType
|
|
)
|
|
: CUnknownObject(pUnkOuter, this), m_ObjectType(iObjectType)
|
|
{
|
|
// initialize various dudes.
|
|
//
|
|
m_pPropertyPageSite = NULL;
|
|
m_hwnd = NULL;
|
|
m_fDirty = FALSE;
|
|
m_fActivated = FALSE;
|
|
m_cObjects = 0;
|
|
}
|
|
#pragma warning(default:4355) // using 'this' in constructor
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::~CPropertyPage
|
|
//=--------------------------------------------------------------------------=
|
|
// destructor.
|
|
//
|
|
// Notes:
|
|
//
|
|
CPropertyPage::~CPropertyPage()
|
|
{
|
|
// clean up our window.
|
|
//
|
|
if (m_hwnd) {
|
|
SetWindowLongPtr(m_hwnd, GWLP_USERDATA, (LONG_PTR)0xffffffff);
|
|
DestroyWindow(m_hwnd);
|
|
}
|
|
|
|
// release all the objects we're holding on to.
|
|
//
|
|
m_ReleaseAllObjects();
|
|
|
|
// release the site
|
|
//
|
|
QUICK_RELEASE(m_pPropertyPageSite);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::InternalQueryInterface
|
|
//=--------------------------------------------------------------------------=
|
|
// we support IPP and IPP2.
|
|
//
|
|
// Parameters:
|
|
// REFIID - [in] interface they want
|
|
// void ** - [out] where they want to put the resulting object ptr.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOINTERFACE
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CPropertyPage::InternalQueryInterface
|
|
(
|
|
REFIID riid,
|
|
void **ppvObjOut
|
|
)
|
|
{
|
|
IUnknown *pUnk;
|
|
|
|
*ppvObjOut = NULL;
|
|
|
|
if (DO_GUIDS_MATCH(IID_IPropertyPage, riid)) {
|
|
pUnk = (IUnknown *)this;
|
|
} else if (DO_GUIDS_MATCH(IID_IPropertyPage2, riid)) {
|
|
pUnk = (IUnknown *)this;
|
|
} else {
|
|
return CUnknownObject::InternalQueryInterface(riid, ppvObjOut);
|
|
}
|
|
|
|
pUnk->AddRef();
|
|
*ppvObjOut = (void *)pUnk;
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::SetPageSite [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// the initialization function for a property page through which the page
|
|
// receives an IPropertyPageSite pointer.
|
|
//
|
|
// Parameters:
|
|
// IPropertyPageSite * - [in] new site.
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes;
|
|
//
|
|
STDMETHODIMP CPropertyPage::SetPageSite
|
|
(
|
|
IPropertyPageSite *pPropertyPageSite
|
|
)
|
|
{
|
|
RELEASE_OBJECT(m_pPropertyPageSite);
|
|
m_pPropertyPageSite = pPropertyPageSite;
|
|
ADDREF_OBJECT(pPropertyPageSite);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Activate [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// instructs the page to create it's display window as a child of hwndparent
|
|
// and to position it according to prc.
|
|
//
|
|
// Parameters:
|
|
// HWND - [in] parent window
|
|
// LPCRECT - [in] where to position ourselves
|
|
// BOOL - [in] whether we're modal or not.
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Activate
|
|
(
|
|
HWND hwndParent,
|
|
LPCRECT prcBounds,
|
|
BOOL fModal
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// first make sure the dialog window is loaded and created.
|
|
//
|
|
hr = m_EnsureLoaded();
|
|
RETURN_ON_FAILURE(hr);
|
|
|
|
// set our parent window if we haven't done so yet.
|
|
//
|
|
if (!m_fActivated) {
|
|
SetParent(m_hwnd, hwndParent);
|
|
m_fActivated = TRUE;
|
|
}
|
|
|
|
// now move ourselves to where we're told to be and show ourselves
|
|
//
|
|
Move(prcBounds);
|
|
ShowWindow(m_hwnd, SW_SHOW);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Deactivate [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// instructs the page to destroy the window created in activate
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Deactivate
|
|
(
|
|
void
|
|
)
|
|
{
|
|
// blow away yon window.
|
|
//
|
|
if (m_hwnd)
|
|
DestroyWindow(m_hwnd);
|
|
m_hwnd = NULL;
|
|
m_fActivated = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::GetPageInfo [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// asks the page to fill a PROPPAGEINFO structure
|
|
//
|
|
// Parameters:
|
|
// PROPPAGEINFO * - [out] where to put info.
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::GetPageInfo
|
|
(
|
|
PROPPAGEINFO *pPropPageInfo
|
|
)
|
|
{
|
|
RECT rect;
|
|
|
|
CHECK_POINTER(pPropPageInfo);
|
|
|
|
m_EnsureLoaded();
|
|
|
|
// clear it out first.
|
|
//
|
|
memset(pPropPageInfo, 0, sizeof(PROPPAGEINFO));
|
|
|
|
pPropPageInfo->pszTitle = OLESTRFROMRESID(TITLEIDOFPROPPAGE(m_ObjectType));
|
|
pPropPageInfo->pszDocString = OLESTRFROMRESID(DOCSTRINGIDOFPROPPAGE(m_ObjectType));
|
|
pPropPageInfo->pszHelpFile = OLESTRFROMANSI(HELPFILEOFPROPPAGE(m_ObjectType));
|
|
pPropPageInfo->dwHelpContext = HELPCONTEXTOFPROPPAGE(m_ObjectType);
|
|
|
|
if (!(pPropPageInfo->pszTitle && pPropPageInfo->pszDocString && pPropPageInfo->pszHelpFile))
|
|
goto CleanUp;
|
|
|
|
// if we've got a window yet, go and set up the size information they want.
|
|
//
|
|
if (m_hwnd) {
|
|
GetWindowRect(m_hwnd, &rect);
|
|
|
|
pPropPageInfo->size.cx = rect.right - rect.left;
|
|
pPropPageInfo->size.cy = rect.bottom - rect.top;
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
CleanUp:
|
|
if (pPropPageInfo->pszDocString) CoTaskMemFree(pPropPageInfo->pszDocString);
|
|
if (pPropPageInfo->pszHelpFile) CoTaskMemFree(pPropPageInfo->pszHelpFile);
|
|
if (pPropPageInfo->pszTitle) CoTaskMemFree(pPropPageInfo->pszTitle);
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::SetObjects [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// provides the page with the objects being affected by the changes.
|
|
//
|
|
// Parameters:
|
|
// ULONG - [in] count of objects.
|
|
// IUnknown ** - [in] objects.
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::SetObjects
|
|
(
|
|
ULONG cObjects,
|
|
IUnknown **ppUnkObjects
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
ULONG x;
|
|
|
|
// free up all the old objects first.
|
|
//
|
|
m_ReleaseAllObjects();
|
|
|
|
if (!cObjects)
|
|
return S_OK;
|
|
|
|
// now go and set up the new ones.
|
|
//
|
|
m_ppUnkObjects = (IUnknown **)HeapAlloc(g_hHeap, 0, cObjects * sizeof(IUnknown *));
|
|
RETURN_ON_NULLALLOC(m_ppUnkObjects);
|
|
|
|
// loop through and copy over all the objects.
|
|
//
|
|
for (x = 0; x < cObjects; x++) {
|
|
m_ppUnkObjects[x] = ppUnkObjects[x];
|
|
ADDREF_OBJECT(m_ppUnkObjects[x]);
|
|
}
|
|
|
|
// go and tell the object that there are new objects
|
|
//
|
|
hr = S_OK;
|
|
m_cObjects = cObjects;
|
|
// if we've got a window, go and notify it that we've got new objects.
|
|
//
|
|
if (m_hwnd)
|
|
SendMessage(m_hwnd, PPM_NEWOBJECTS, 0, (LPARAM)&hr);
|
|
if (SUCCEEDED(hr)) m_fDirty = FALSE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Show [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// asks the page to show or hide its window
|
|
//
|
|
// Parameters:
|
|
// UINT - [in] whether to show or hide
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Show
|
|
(
|
|
UINT nCmdShow
|
|
)
|
|
{
|
|
if (m_hwnd)
|
|
ShowWindow(m_hwnd, nCmdShow);
|
|
else
|
|
return E_UNEXPECTED;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Move [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// asks the page to relocate and resize itself to a position other than what
|
|
// was specified through Activate
|
|
//
|
|
// Parameters:
|
|
// LPCRECT - [in] new position and size
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Move
|
|
(
|
|
LPCRECT prcBounds
|
|
)
|
|
{
|
|
// do what they sez
|
|
//
|
|
if (m_hwnd)
|
|
SetWindowPos(m_hwnd, NULL, prcBounds->left, prcBounds->top,
|
|
prcBounds->right - prcBounds->left,
|
|
prcBounds->bottom - prcBounds->top,
|
|
SWP_NOZORDER);
|
|
else
|
|
return E_UNEXPECTED;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::IsPageDirty [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// asks the page whether it has changed its state
|
|
//
|
|
// Output
|
|
// S_OK - yep
|
|
// S_FALSE - nope
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::IsPageDirty
|
|
(
|
|
void
|
|
)
|
|
{
|
|
return m_fDirty ? S_OK : S_FALSE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Apply [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// instructs the page to send its changes to all the objects passed through
|
|
// SetObjects()
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Apply
|
|
(
|
|
void
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_hwnd) {
|
|
SendMessage(m_hwnd, PPM_APPLY, 0, (LPARAM)&hr);
|
|
RETURN_ON_FAILURE(hr);
|
|
|
|
if (m_fDirty) {
|
|
m_fDirty = FALSE;
|
|
if (m_pPropertyPageSite)
|
|
m_pPropertyPageSite->OnStatusChange(PROPPAGESTATUS_DIRTY);
|
|
}
|
|
} else
|
|
return E_UNEXPECTED;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::Help [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// instructs the page that the help button was clicked.
|
|
//
|
|
// Parameters:
|
|
// LPCOLESTR - [in] help directory
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::Help
|
|
(
|
|
LPCOLESTR pszHelpDir
|
|
)
|
|
{
|
|
BOOL f;
|
|
|
|
ASSERT(m_hwnd, "How can somebody have clicked Help, but we don't have an hwnd?");
|
|
|
|
// oblige them and show the help.
|
|
//
|
|
MAKE_ANSIPTR_FROMWIDE(psz, pszHelpDir);
|
|
f = WinHelp(m_hwnd, psz, HELP_CONTEXT, HELPCONTEXTOFPROPPAGE(m_ObjectType));
|
|
|
|
return f ? S_OK : E_FAIL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::TranslateAccelerator [IPropertyPage]
|
|
//=--------------------------------------------------------------------------=
|
|
// informs the page of keyboard events, allowing it to implement it's own
|
|
// keyboard interface.
|
|
//
|
|
// Parameters:
|
|
// LPMSG - [in] message that triggered this
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::TranslateAccelerator
|
|
(
|
|
LPMSG pmsg
|
|
)
|
|
{
|
|
ASSERT(m_hwnd, "How can we get a TranslateAccelerator call if we're not visible?");
|
|
|
|
// just pass this message on to the dialog proc and see if they want it.
|
|
//
|
|
return IsDialogMessage(m_hwnd, pmsg) ? S_OK : S_FALSE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::EditProperty [IPropertyPage2]
|
|
//=--------------------------------------------------------------------------=
|
|
// instructs the page to set the focus to the property matching the dispid.
|
|
//
|
|
// Parameters:
|
|
// DISPID - [in] dispid of property to set focus to.
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CPropertyPage::EditProperty
|
|
(
|
|
DISPID dispid
|
|
)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
// send the message on to the control, and see what they want to do with it.
|
|
//
|
|
SendMessage(m_hwnd, PPM_EDITPROPERTY, (WPARAM)dispid, (LPARAM)&hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::m_EnsureLoaded
|
|
//=--------------------------------------------------------------------------=
|
|
// makes sure the dialog is actually loaded
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CPropertyPage::m_EnsureLoaded
|
|
(
|
|
void
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// duh
|
|
//
|
|
if (m_hwnd)
|
|
return S_OK;
|
|
|
|
// set up the global variable so that when we're in the dialog proc, we can
|
|
// stuff this in the hwnd
|
|
//
|
|
// crit sect this whole creation process for apartment threading support.
|
|
//
|
|
EnterCriticalSection(&g_CriticalSection);
|
|
s_pLastPageCreated = this;
|
|
|
|
// create the dialog window
|
|
//
|
|
CreateDialog(GetResourceHandle(), TEMPLATENAMEOFPROPPAGE(m_ObjectType), GetParkingWindow(),
|
|
CPropertyPage::PropPageDlgProc);
|
|
ASSERT(m_hwnd, "Couldn't load Dialog Resource!!!");
|
|
if (!m_hwnd) {
|
|
LeaveCriticalSection(&g_CriticalSection);
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
// clean up variables and leave the critical section
|
|
//
|
|
s_pLastPageCreated = NULL;
|
|
LeaveCriticalSection(&g_CriticalSection);
|
|
|
|
// go and notify the window that it should pick up any objects that are
|
|
// available
|
|
//
|
|
SendMessage(m_hwnd, PPM_NEWOBJECTS, 0, (LPARAM)&hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::m_ReleaseAllObjects
|
|
//=--------------------------------------------------------------------------=
|
|
// releases all the objects that we're working with
|
|
//
|
|
// Notes:
|
|
//
|
|
void CPropertyPage::m_ReleaseAllObjects
|
|
(
|
|
void
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
UINT x;
|
|
|
|
if (!m_cObjects)
|
|
return;
|
|
|
|
// some people will want to stash pointers in the PPM_INITOBJECTS case, so
|
|
// we want to tell them to release them now.
|
|
//
|
|
SendMessage(m_hwnd, PPM_FREEOBJECTS, 0, (LPARAM)&hr);
|
|
|
|
// loop through and blow them all away.
|
|
//
|
|
for (x = 0; x < m_cObjects; x++)
|
|
QUICK_RELEASE(m_ppUnkObjects[x]);
|
|
|
|
HeapFree(g_hHeap, 0, m_ppUnkObjects);
|
|
m_ppUnkObjects = NULL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::PropPageDlgProc
|
|
//=--------------------------------------------------------------------------=
|
|
// static global helper dialog proc that gets called before we pass the message
|
|
// on to anybody ..
|
|
//
|
|
// Parameters:
|
|
// - see win32sdk docs on DialogProc
|
|
//
|
|
// Notes:
|
|
//
|
|
INT_PTR CALLBACK CPropertyPage::PropPageDlgProc
|
|
(
|
|
HWND hwnd,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
CPropertyPage *pPropertyPage;
|
|
|
|
// get the window long, and see if it's been set to the object this hwnd
|
|
// is operating against. if not, go and set it now.
|
|
//
|
|
pPropertyPage = (CPropertyPage *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
if (pPropertyPage == (CPropertyPage *)-1)
|
|
return FALSE;
|
|
if (!pPropertyPage) {
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)s_pLastPageCreated);
|
|
pPropertyPage = s_pLastPageCreated;
|
|
pPropertyPage->m_hwnd = hwnd;
|
|
}
|
|
|
|
ASSERT(pPropertyPage, "Uh oh. Got a window, but no CpropertyPage for it!");
|
|
|
|
// just call the user dialog proc and see if they want to do anything.
|
|
//
|
|
return pPropertyPage->DialogProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::FirstControl
|
|
//=--------------------------------------------------------------------------=
|
|
// returns the first controlish object that we are showing ourselves for.
|
|
// returns a cookie that must be passed in for Next ...
|
|
//
|
|
// Parameters:
|
|
// DWORD * - [out] cookie to be used for Next
|
|
//
|
|
// Output:
|
|
// IUnknown *
|
|
//
|
|
// Notes:
|
|
//
|
|
IUnknown *CPropertyPage::FirstControl
|
|
(
|
|
DWORD *pdwCookie
|
|
)
|
|
{
|
|
// just use the implementation of NEXT.
|
|
//
|
|
*pdwCookie = 0;
|
|
return NextControl(pdwCookie);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::NextControl
|
|
//=--------------------------------------------------------------------------=
|
|
// returns the next control in the chain of people to work with given a cookie
|
|
//
|
|
// Parameters:
|
|
// DWORD * - [in/out] cookie to get next from, and new cookie.
|
|
//
|
|
// Output:
|
|
// IUnknown *
|
|
//
|
|
// Notes:
|
|
//
|
|
IUnknown *CPropertyPage::NextControl
|
|
(
|
|
DWORD *pdwCookie
|
|
)
|
|
{
|
|
UINT i;
|
|
|
|
// go looking through all the objects that we've got, and find the
|
|
// first non-null one.
|
|
//
|
|
for (i = *pdwCookie; i < m_cObjects; i++) {
|
|
if (!m_ppUnkObjects[i]) continue;
|
|
|
|
*pdwCookie = i + 1; // + 1 so we start at next item next time
|
|
return m_ppUnkObjects[i];
|
|
}
|
|
|
|
// couldn't find it .
|
|
//
|
|
*pdwCookie = 0xffffffff;
|
|
return NULL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::MakeDirty [helper, callable]
|
|
//=--------------------------------------------------------------------------=
|
|
// marks a page as dirty.
|
|
//
|
|
// Notes:
|
|
//
|
|
void CPropertyPage::MakeDirty
|
|
(
|
|
void
|
|
)
|
|
{
|
|
m_fDirty = TRUE;
|
|
if (m_pPropertyPageSite)
|
|
m_pPropertyPageSite->OnStatusChange(PROPPAGESTATUS_DIRTY|PROPPAGESTATUS_VALIDATE);
|
|
}
|
|
|
|
|
|
// from Globals.C
|
|
//
|
|
extern HINSTANCE g_hInstResources;
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CPropertyPage::GetResourceHandle [helper, callable]
|
|
//=--------------------------------------------------------------------------=
|
|
// returns current resource handle, based on pagesites ambient LCID.
|
|
//
|
|
// Output:
|
|
// HINSTANCE
|
|
//
|
|
// Notes:
|
|
//
|
|
HINSTANCE CPropertyPage::GetResourceHandle
|
|
(
|
|
void
|
|
)
|
|
{
|
|
if (!g_fSatelliteLocalization)
|
|
return g_hInstance;
|
|
|
|
// if we've already got it, then there's not all that much to do.
|
|
// don't need to crit sect this one right here since even if they do fall
|
|
// into the ::GetResourceHandle call, it'll properly deal with things.
|
|
//
|
|
if (g_hInstResources)
|
|
return g_hInstResources;
|
|
|
|
// we'll get the ambient localeid from the host, and pass that on to the
|
|
// automation object.
|
|
//
|
|
// enter a critical section for g_lcidLocale and g_fHavelocale
|
|
//
|
|
EnterCriticalSection(&g_CriticalSection);
|
|
if (!g_fHaveLocale) {
|
|
if (m_pPropertyPageSite) {
|
|
m_pPropertyPageSite->GetLocaleID(&g_lcidLocale);
|
|
g_fHaveLocale = TRUE;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&g_CriticalSection);
|
|
|
|
return ::GetResourceHandle();
|
|
}
|