BOOL PASCAL COleObjectFactory::UpdateRegistryAll(BOOL bRegister)
{
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
for (COleObjectFactory* pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
if (!pFactory->UpdateRegistry(bRegister))
{
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
return FALSE;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
#ifdef _AFXDLL
AfxLockGlobals(CRIT_DYNLINKLIST);
// register extension DLL factories
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (pFactory = pDLL->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
if (!pFactory->UpdateRegistry(bRegister))
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return FALSE;
}
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
return TRUE;
}
void PASCAL COleObjectFactory::RevokeAll()
{
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
for (COleObjectFactory* pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
pFactory->Revoke();
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
#ifdef _AFXDLL
AfxLockGlobals(CRIT_DYNLINKLIST);
// register extension DLL factories
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (pFactory = pDLL->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
pFactory->Revoke();
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
}
SCODE AFXAPI AfxDllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
*ppv = NULL;
DWORD lData1 = rclsid.Data1;
// search factories defined in the application
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
COleObjectFactory* pFactory;
for (pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
if (pFactory->m_bRegistered != 0 &&
lData1 == pFactory->m_clsid.Data1 &&
((DWORD*)&rclsid)[1] == ((DWORD*)&pFactory->m_clsid)[1] &&
((DWORD*)&rclsid)[2] == ((DWORD*)&pFactory->m_clsid)[2] &&
((DWORD*)&rclsid)[3] == ((DWORD*)&pFactory->m_clsid)[3])
{
// found suitable class factory -- query for correct interface
SCODE sc = pFactory->InternalQueryInterface(&riid, ppv);
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
return sc;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
#ifdef _AFXDLL
AfxLockGlobals(CRIT_DYNLINKLIST);
// search factories defined in extension DLLs
CDynLinkLibrary* pDLL;
for (pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (COleObjectFactory* pDLLFactory = pDLL->m_factoryList;
pDLLFactory != NULL; pDLLFactory = pDLLFactory->m_pNextFactory)
{
if (pDLLFactory->m_bRegistered != 0 &&
lData1 == pDLLFactory->m_clsid.Data1 &&
((DWORD*)&rclsid)[1] == ((DWORD*)&pDLLFactory->m_clsid)[1] &&
((DWORD*)&rclsid)[2] == ((DWORD*)&pDLLFactory->m_clsid)[2] &&
((DWORD*)&rclsid)[3] == ((DWORD*)&pDLLFactory->m_clsid)[3])
{
// found suitable class factory -- query for correct interface
SCODE sc = pDLLFactory->InternalQueryInterface(&riid, ppv);
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return sc;
}
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
// factory not registered -- return error
return CLASS_E_CLASSNOTAVAILABLE;
}
COleDropTarget::COleDropTarget()
{
// initialize local state
m_hWnd = NULL;
m_lpDataObject = NULL;
m_nTimerID = 0xffff;
AfxLockGlobals(CRIT_DROPTARGET);
static BOOL bInitialized;
if (!bInitialized)
{
// get scroll metrics from win.ini
static const TCHAR szWindows[] = _T("windows");
static const TCHAR szScrollDelay[] = _T("DragScrollDelay");
static const TCHAR szScrollInset[] = _T("DragScrollInset");
static const TCHAR szScrollInterval[] = _T("DragScrollInterval");
nScrollInset = GetProfileInt(szWindows, szScrollInset, DD_DEFSCROLLINSET);
nScrollDelay = GetProfileInt(szWindows, szScrollDelay, DD_DEFSCROLLDELAY);
nScrollInterval = GetProfileInt(szWindows, szScrollInterval,
DD_DEFSCROLLINTERVAL);
// now initialized, no need to call Initialize any more
bInitialized = TRUE;
}
AfxUnlockGlobals(CRIT_DROPTARGET);
ASSERT_VALID(this);
}
CDynLinkLibrary::~CDynLinkLibrary()
{
// remove this frame window from the list of frame windows
AfxLockGlobals(CRIT_DYNLINKLIST);
m_pModuleState->m_libraryList.Remove(this);
AfxUnlockGlobals(CRIT_DYNLINKLIST);
}
BOOL AFXAPI AfxOleLockControl(REFCLSID clsid)
{
COleControlLock* pLock = NULL;
TRY
{
pLock = new COleControlLock(clsid);
if (pLock->m_pClassFactory == NULL)
{
delete pLock;
pLock = NULL;
}
else
{
AFX_MODULE_PROCESS_STATE* pState = AfxGetModuleProcessState();
AfxLockGlobals(CRIT_CTLLOCKLIST);
pState->m_lockList.AddHead(pLock);
AfxUnlockGlobals(CRIT_CTLLOCKLIST);
}
}
CATCH_ALL (e)
{
// Note: DELETE_EXCEPTION(e) not necessary
pLock = NULL;
}
END_CATCH_ALL
return pLock != NULL;
}
COleObjectFactory::COleObjectFactory(REFCLSID clsid,
CRuntimeClass* pRuntimeClass, BOOL bMultiInstance, LPCTSTR lpszProgID)
{
ASSERT(pRuntimeClass == NULL ||
pRuntimeClass->IsDerivedFrom(RUNTIME_CLASS(CCmdTarget)));
ASSERT(AfxIsValidAddress(&clsid, sizeof(CLSID), FALSE));
ASSERT(lpszProgID == NULL || AfxIsValidString(lpszProgID));
// initialize to unregistered state
m_dwRegister = 0; // not registered yet
m_bRegistered = FALSE;
m_clsid = clsid;
m_pRuntimeClass = pRuntimeClass;
m_bMultiInstance = bMultiInstance;
m_lpszProgID = lpszProgID;
m_bOAT = (BYTE) OAT_UNKNOWN;
// licensing information
m_bLicenseChecked = FALSE;
m_bLicenseValid = FALSE;
// add this factory to the list of factories
m_pNextFactory = NULL;
AFX_MODULE_STATE* pModuleState = _AFX_CMDTARGET_GETSTATE();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
pModuleState->m_factoryList.AddHead(this);
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
ASSERT_VALID(this);
}
BOOL AFXAPI AfxFreeLibrary(HINSTANCE hInstLib)
{
AfxLockGlobals(CRIT_LOCKSHARED);
BOOL bResult = FreeLibrary(hInstLib);
AfxUnlockGlobals(CRIT_LOCKSHARED);
return bResult;
}
void AFXAPI AfxTermExtensionModule(AFX_EXTENSION_MODULE& state, BOOL bAll)
{
// make sure initialized
if (!state.bInitialized)
return;
// search for CDynLinkLibrary matching state.hModule and delete it
ASSERT(state.hModule != NULL);
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL; )
{
CDynLinkLibrary* pNextDLL = pDLL->m_pNextDLL;
if (bAll || pDLL->m_hModule == state.hModule)
delete pDLL; // will unwire itself
pDLL = pNextDLL;
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
// delete any local storage attached to this module
AfxTermLocalData(state.hModule, TRUE);
// remove any entries from the CWnd message map cache
AfxResetMsgCache();
}
HINSTANCE AFXAPI AfxLoadLibrary(LPCTSTR lpszModuleName)
{
ASSERT(lpszModuleName != NULL);
AfxLockGlobals(CRIT_LOCKSHARED);
HINSTANCE hInstLib = LoadLibrary(lpszModuleName);
AfxUnlockGlobals(CRIT_LOCKSHARED);
return hInstLib;
}
CRuntimeClass* CBCGPGlobalUtils::RuntimeClassFromName(LPCSTR lpszClassName)
{
#if (_MSC_VER <= 1200)
CRuntimeClass* pClass = NULL;
// search app specific classes
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_RUNTIMECLASSLIST);
for (pClass = pModuleState->m_classList; pClass != NULL;
pClass = pClass->m_pNextClass)
{
if (lstrcmpA(lpszClassName, pClass->m_lpszClassName) == 0)
{
AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
return pClass;
}
}
AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
#ifdef _AFXDLL
// search classes in shared DLLs
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (pClass = pDLL->m_classList; pClass != NULL;
pClass = pClass->m_pNextClass)
{
if (lstrcmpA(lpszClassName, pClass->m_lpszClassName) == 0)
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return pClass;
}
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
return NULL;
#else
return CRuntimeClass::FromName(lpszClassName);
#endif
}
SCODE AFXAPI AfxDllCanUnloadNow(void)
{
// return S_OK only if no outstanding objects active
if (!AfxOleCanExitApp())
return S_FALSE;
// check if any class factories with >1 reference count
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
COleObjectFactory* pFactory;
for (pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
if (pFactory->m_dwRef > 1)
{
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
return S_FALSE;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
#ifdef _AFXDLL
AfxLockGlobals(CRIT_DYNLINKLIST);
// search factories defined in extension DLLs
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (COleObjectFactory* pDLLFactory = pDLL->m_factoryList;
pDLLFactory != NULL; pDLLFactory = pDLLFactory->m_pNextFactory)
{
if (pDLLFactory->m_dwRef > 1)
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return S_FALSE;
}
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
TRACE(traceOle, 0, "Info: AfxDllCanUnloadNow returning S_OK\n");
return S_OK;
}
HRESULT CCmdTarget::GetTypeInfoOfGuid(LCID lcid, REFGUID guid,
LPTYPEINFO* ppTypeInfo)
{
USES_CONVERSION;
AfxLockGlobals(CRIT_TYPELIBCACHE);
HRESULT hr = TYPE_E_CANTLOADLIBRARY;
CTypeLibCache* pTypeLibCache = GetTypeLibCache();
LPTYPELIB pTypeLib = NULL;
// If type info is already cached, just return it.
if (pTypeLibCache->LookupTypeInfo(lcid, guid, ppTypeInfo))
{
hr = S_OK;
}
else
{
// If type library isn't already cached, try to locate it.
if (!pTypeLibCache->Lookup(lcid, &pTypeLib))
{
// First, try getting the subclass to load the type library
// (normally this goes through LoadRegTypeLib).
if (FAILED(GetTypeLib(lcid, &pTypeLib)))
{
AFX_MANAGE_STATE(m_pModuleState);
// If that failed, try loading the type library from our own
// resources.
TCHAR szPath[_MAX_PATH];
GetModuleFileName(AfxGetInstanceHandle(), szPath, _MAX_PATH);
if (FAILED(LoadTypeLib(T2COLE(szPath), &pTypeLib)))
pTypeLib = NULL;
}
pTypeLibCache->Cache(lcid, pTypeLib);
}
// If we got a type library, extract the requested type info.
if (pTypeLib != NULL)
{
hr = pTypeLib->GetTypeInfoOfGuid(guid, ppTypeInfo);
pTypeLib->Release();
pTypeLibCache->CacheTypeInfo(lcid, guid, *ppTypeInfo);
}
}
AfxUnlockGlobals(CRIT_TYPELIBCACHE);
return hr;
}
void AFXAPI AfxWinTerm(void)
{
#ifdef _MAC
AERemoveEventHandler(kCoreEventClass, kAEOpenApplication, _afxPfnOpenApp, false);
AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, _afxPfnOpenDoc, false);
AERemoveEventHandler(kCoreEventClass, kAEPrintDocuments, _afxPfnPrintDoc, false);
AERemoveEventHandler(kCoreEventClass, kAEQuitApplication, _afxPfnQuit, false);
#endif
// unregister Window classes
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_REGCLASSLIST);
LPTSTR lpsz = pModuleState->m_szUnregisterList;
while (*lpsz != 0)
{
LPTSTR lpszEnd = _tcschr(lpsz, '\n');
ASSERT(lpszEnd != NULL);
*lpszEnd = 0;
UnregisterClass(lpsz, AfxGetInstanceHandle());
lpsz = lpszEnd + 1;
}
pModuleState->m_szUnregisterList[0] = 0;
AfxUnlockGlobals(CRIT_REGCLASSLIST);
// cleanup OLE if required
CWinApp* pApp = AfxGetApp();
if (pApp != NULL && pApp->m_lpfnOleTermOrFreeLib != NULL)
(*pApp->m_lpfnOleTermOrFreeLib)(TRUE, FALSE);
// cleanup thread local tooltip window
_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
if (pThreadState->m_pToolTip != NULL)
{
if (pThreadState->m_pToolTip->DestroyToolTipCtrl())
pThreadState->m_pToolTip = NULL;
}
if (!afxContextIsDLL)
{
// unhook windows hooks
if (pThreadState->m_hHookOldMsgFilter != NULL)
{
::UnhookWindowsHookEx(pThreadState->m_hHookOldMsgFilter);
pThreadState->m_hHookOldMsgFilter = NULL;
}
if (pThreadState->m_hHookOldCbtFilter != NULL)
{
::UnhookWindowsHookEx(pThreadState->m_hHookOldCbtFilter);
pThreadState->m_hHookOldCbtFilter = NULL;
}
}
}
void CCmdTarget::EnableTypeLib()
{
AfxLockGlobals(CRIT_TYPELIBCACHE);
CTypeLibCache* pTypeLibCache = GetTypeLibCache();
ASSERT(pTypeLibCache != NULL); // must override GetTypeLibCache
if (pTypeLibCache != NULL)
pTypeLibCache->Lock(); // will be unlocked in OnFinalRelease
AfxUnlockGlobals(CRIT_TYPELIBCACHE);
}
COleObjectFactory::~COleObjectFactory()
{
ASSERT_VALID(this);
#ifdef _AFXDLL
if (m_pModuleState == NULL)
return;
#endif
// deregister this class factory
Revoke();
// remove this class factory from the list of active class factories
#ifdef _AFXDLL
AFX_MODULE_STATE* pModuleState = m_pModuleState;
#else
AFX_MODULE_STATE* pModuleState = _AFX_CMDTARGET_GETSTATE();
#endif
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
BOOL bResult = pModuleState->m_factoryList.Remove(this);
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
if (bResult)
return;
// check CDynLinkLibrary objects in case it was transfered during init
#ifdef _AFXDLL
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
if (pDLL->m_factoryList.Remove(this))
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return;
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
}
void AFXAPI AfxOleUnlockAllControls()
{
AFX_MODULE_PROCESS_STATE* pState = AfxGetModuleProcessState();
COleControlLock* pLock;
AfxLockGlobals(CRIT_CTLLOCKLIST);
while ((pLock = pState->m_lockList) != NULL)
{
pState->m_lockList.Remove(pLock);
delete pLock;
}
ASSERT(pState->m_lockList.IsEmpty());
AfxUnlockGlobals(CRIT_CTLLOCKLIST);
}
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;
#ifdef _AFXDLL
for (;;)
#else
while (pDispMap != NULL)
#endif
{
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
if (pDispMap->pfnGetBaseMap == NULL)
break;
pDispMap = (*pDispMap->pfnGetBaseMap)();
#else
pDispMap = pDispMap->pBaseMap;
#endif
}
*pDispMapTop->lpStockPropMask = dwStockPropMask;
}
AfxUnlockGlobals(CRIT_STOCKMASK);
}
BOOL PASCAL COleObjectFactory::RegisterAll()
{
BOOL bResult = TRUE;
// register application factories
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
for (COleObjectFactory* pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
// register any non-registered, non-doctemplate factories
if (!pFactory->IsRegistered() &&
pFactory->m_clsid != CLSID_NULL && !pFactory->Register())
{
bResult = FALSE;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
#ifdef _AFXDLL
// register extension DLL factories
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
for (pFactory = pDLL->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
// register any non-registered, non-doctemplate factories
if (!pFactory->IsRegistered() &&
pFactory->m_clsid != CLSID_NULL && !pFactory->Register())
{
bResult = FALSE;
}
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
#endif
return bResult;
}
CBrush* PASCAL CDC::GetHalftoneBrush()
{
AfxLockGlobals(CRIT_HALFTONEBRUSH);
if (halftoneBrush == NULL)
{
WORD grayPattern[8];
for (int i = 0; i < 8; i++)
grayPattern[i] = (WORD)(0x5555 << (i & 1));
HBITMAP grayBitmap = CreateBitmap(8, 8, 1, 1, &grayPattern);
if (grayBitmap != NULL)
{
halftoneBrush = ::CreatePatternBrush(grayBitmap);
DeleteObject(grayBitmap);
}
}
AfxUnlockGlobals(CRIT_HALFTONEBRUSH);
return CBrush::FromHandle(halftoneBrush);
}
BOOL PASCAL COleObjectFactory::UnregisterAll()
{
BOOL bResult = TRUE;
// register application factories
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
for (COleObjectFactory* pFactory = pModuleState->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
// unregister any registered, non-doctemplate factories
if (pFactory->IsRegistered() && !pFactory->Unregister())
{
bResult = FALSE;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
return bResult;
}
BOOL AFXAPI AfxOleUnlockControl(REFCLSID clsid)
{
AFX_MODULE_PROCESS_STATE* pState = AfxGetModuleProcessState();
AfxLockGlobals(CRIT_CTLLOCKLIST);
COleControlLock* pLock = pState->m_lockList;
BOOL bResult = FALSE;
while (pLock != NULL)
{
COleControlLock* pNext = pLock->m_pNextLock;
if (clsid == pLock->m_clsid)
{
// remove lock from list and delete it
pState->m_lockList.Remove(pLock);
delete pLock;
bResult = TRUE;
}
pLock = pNext;
}
AfxUnlockGlobals(CRIT_CTLLOCKLIST);
return bResult;
}
CDynLinkLibrary::CDynLinkLibrary(HINSTANCE hModule, HINSTANCE hResource)
{
#ifndef _AFX_NO_OLE_SUPPORT
m_factoryList.Construct(offsetof(COleObjectFactory, m_pNextFactory));
#endif
m_classList.Construct(offsetof(CRuntimeClass, m_pNextClass));
m_hModule = hModule;
m_hResource = hResource;
m_classList.m_pHead = NULL;
#ifndef _AFX_NO_OLE_SUPPORT
m_factoryList.m_pHead = NULL;
#endif
m_bSystem = FALSE;
// insert at the head of the list (extensions will go in front of core DLL)
DEBUG_ONLY(m_pNextDLL = NULL);
AfxLockGlobals(CRIT_DYNLINKLIST);
m_pModuleState->m_libraryList.AddHead(this);
AfxUnlockGlobals(CRIT_DYNLINKLIST);
}
void CWinApp::DoWaitCursor(int nCode)
{
// 0 => restore, 1=> begin, -1=> end
ASSERT(nCode == 0 || nCode == 1 || nCode == -1);
ASSERT(afxData.hcurWait != NULL);
AfxLockGlobals(CRIT_WAITCURSOR);
m_nWaitCursorCount += nCode;
if (m_nWaitCursorCount > 0)
{
HCURSOR hcurPrev = ::SetCursor(afxData.hcurWait);
if (nCode > 0 && m_nWaitCursorCount == 1)
m_hcurWaitCursorRestore = hcurPrev;
}
else
{
// turn everything off
m_nWaitCursorCount = 0; // prevent underflow
::SetCursor(m_hcurWaitCursorRestore);
}
AfxUnlockGlobals(CRIT_WAITCURSOR);
}
int CEditView::OnCreate(LPCREATESTRUCT lpcs)
{
if (CCtrlView::OnCreate(lpcs) != 0)
return -1;
#ifdef _UNICODE
AfxLockGlobals(CRIT_EDITVIEW);
if (hUnicodeFont == NULL)
{
// get unicode font same size as system font
HFONT hSystemFont = (HFONT)GetStockObject(SYSTEM_FONT);
LOGFONT systemFont;
VERIFY(::GetObject(hSystemFont, sizeof(LOGFONT), (void*)&systemFont));
// default size and facename, but allow customization
LOGFONT logFont; memset(&logFont, 0, sizeof(LOGFONT));
logFont.lfHeight = systemFont.lfHeight;
logFont.lfWeight = systemFont.lfWeight;
logFont.lfCharSet = DEFAULT_CHARSET;
lstrcpy(logFont.lfFaceName, _T("Lucida Sans Unicode"));
AfxCustomLogFont(AFX_IDS_UNICODE_FONT, &logFont);
// attempt to create the font
hUnicodeFont = ::CreateFontIndirect(&logFont);
if (hUnicodeFont == NULL)
TRACE1("Unable to create unicode font '%s'.\n", logFont.lfFaceName);
}
AfxUnlockGlobals(CRIT_EDITVIEW);
// set unicode font instead of using system font
if (hUnicodeFont != NULL)
SendMessage(WM_SETFONT, (WPARAM)hUnicodeFont);
#endif
GetEditCtrl().LimitText(nMaxSize);
#ifndef _MAC
GetEditCtrl().SetTabStops(m_nTabStops);
#endif
return 0;
}
// Constructor - will wire into the current application's list
CDynLinkLibrary::CDynLinkLibrary(AFX_EXTENSION_MODULE& state, BOOL bSystem)
{
#ifndef _AFX_NO_OLE_SUPPORT
m_factoryList.Construct(offsetof(COleObjectFactory, m_pNextFactory));
#endif
m_classList.Construct(offsetof(CRuntimeClass, m_pNextClass));
// copy info from AFX_EXTENSION_MODULE struct
ASSERT(state.hModule != NULL);
m_hModule = state.hModule;
m_hResource = state.hResource;
m_classList.m_pHead = state.pFirstSharedClass;
#ifndef _AFX_NO_OLE_SUPPORT
m_factoryList.m_pHead = state.pFirstSharedFactory;
#endif
m_bSystem = bSystem;
// insert at the head of the list (extensions will go in front of core DLL)
DEBUG_ONLY(m_pNextDLL = NULL);
AfxLockGlobals(CRIT_DYNLINKLIST);
m_pModuleState->m_libraryList.AddHead(this);
AfxUnlockGlobals(CRIT_DYNLINKLIST);
}
void CRectTracker::Construct()
{
// do one-time initialization if necessary
AfxLockGlobals(CRIT_RECTTRACKER);
static BOOL bInitialized;
if (!bInitialized)
{
// sanity checks for assumptions we make in the code
ASSERT(sizeof(((RECT*)NULL)->left) == sizeof(int));
ASSERT(offsetof(RECT, top) > offsetof(RECT, left));
ASSERT(offsetof(RECT, right) > offsetof(RECT, top));
ASSERT(offsetof(RECT, bottom) > offsetof(RECT, right));
if (hatchBrush == NULL)
{
// create the hatch pattern + bitmap
WORD hatchPattern[8];
WORD wPattern = 0x1111;
for (int i = 0; i < 4; i++)
{
hatchPattern[i] = wPattern;
hatchPattern[i+4] = wPattern;
wPattern <<= 1;
}
HBITMAP hatchBitmap = CreateBitmap(8, 8, 1, 1, &hatchPattern);
if (hatchBitmap == NULL)
{
AfxUnlockGlobals(CRIT_RECTTRACKER);
AfxThrowResourceException();
}
// create black hatched brush
hatchBrush = CreatePatternBrush(hatchBitmap);
DeleteObject(hatchBitmap);
if (hatchBrush == NULL)
{
AfxUnlockGlobals(CRIT_RECTTRACKER);
AfxThrowResourceException();
}
}
if (blackDottedPen == NULL)
{
// create black dotted pen
blackDottedPen = CreatePen(PS_DOT, 0, RGB(0, 0, 0));
if (blackDottedPen == NULL)
{
AfxUnlockGlobals(CRIT_RECTTRACKER);
AfxThrowResourceException();
}
}
// Note: all track cursors must live in same module
HINSTANCE hInst = AfxFindResourceHandle(
MAKEINTRESOURCE(AFX_IDC_TRACK4WAY), RT_GROUP_CURSOR);
// initialize the cursor array
rghCursors[0] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_TRACKNWSE));
rghCursors[1] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_TRACKNESW));
rghCursors[2] = rghCursors[0];
rghCursors[3] = rghCursors[1];
rghCursors[4] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_TRACKNS));
rghCursors[5] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_TRACKWE));
rghCursors[6] = rghCursors[4];
rghCursors[7] = rghCursors[5];
rghCursors[8] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_TRACK4WAY));
rghCursors[9] = ::LoadCursor(hInst, MAKEINTRESOURCE(AFX_IDC_MOVE4WAY));
// get default handle size from Windows profile setting
#ifndef _MAC
static const TCHAR szWindows[] = _T("windows");
static const TCHAR szInplaceBorderWidth[] =
_T("oleinplaceborderwidth");
nHandleSize = GetProfileInt(szWindows, szInplaceBorderWidth, 4);
#else
nHandleSize = 4;
#endif
bInitialized = TRUE;
}
AfxUnlockGlobals(CRIT_RECTTRACKER);
m_nStyle = 0;
m_nHandleSize = nHandleSize;
m_sizeMin.cy = m_sizeMin.cx = nHandleSize*2;
m_rectLast.SetRectEmpty();
m_sizeLast.cx = m_sizeLast.cy = 0;
m_bErase = FALSE;
m_bFinalErase = FALSE;
}
extern "C" int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
TRACE0("FILLMODE.VMD Initializing!\n");
bool bRegister = !FillModeDLL.bInitialized;
GetModuleFileName (hInstance, g_pDLLName, _MAX_PATH);
g_hInstance = hInstance;
#if !defined(_NOVERSION)
PreCalcVersion();
#endif // !defined(_NOVERSION)
// Extension DLL one-time initialization
if (!AfxInitExtensionModule(FillModeDLL, hInstance)) {
TRACE1("Could not init ExtensionModule %s\r\n", g_pDLLName);
return false; // failure
}
// Insert this DLL into the resource chain
CDynLinkLibrary *pDLL = new CDynLinkLibrary(FillModeDLL);
if (pDLL == NULL) {
TRACE1("Out of memory in DLLInit of %s\r\n", g_pDLLName);
return false; // failure
}
pDLL -> m_bSystem = true;
// externe Funktionen von Trias abfragen
#if defined(__XT) && defined(__DEXPROCS)
HMODULE hTrias = GetModuleHandle (NULL);
g_pDexExtensionProc = (DEXEXTENSIONPROC)GetProcAddress (hTrias, "DEXEXTENSIONPROC");
#endif // __XT && __DEXPROCS
#if _MSC_VER >= 1000
{
// Register class factories in context of private module state
bool bResult = true;
if (bRegister) {
// register this DLL's factories
AfxLockGlobals(CRIT_OBJECTFACTORYLIST);
for (COleObjectFactory *pFactory = pDLL->m_factoryList;
pFactory != NULL; pFactory = pFactory->m_pNextFactory)
{
// register any non-registered, non-doctemplate factories
if (!pFactory->IsRegistered() &&
pFactory->GetClassID() != CLSID_NULL && !pFactory->Register())
{
TRACE1("Could not init classFactory in %s\r\n", g_pDLLName);
bResult = false;
}
}
AfxUnlockGlobals(CRIT_OBJECTFACTORYLIST);
}
if (!bResult) return false;
}
#endif //_MSC_VER
}
else if (dwReason == DLL_PROCESS_DETACH)
{
TRACE0("FILLMODE.VMD Terminating!\n");
AfxTermExtensionModule(FillModeDLL);
}
return 1; // ok
}
HINSTANCE AFXAPI AfxFindResourceHandle(LPCTSTR lpszName, LPCTSTR lpszType)
{
ASSERT(lpszName != NULL);
ASSERT(lpszType != NULL);
HINSTANCE hInst;
// first check the main module state
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
if (!pModuleState->m_bSystem)
{
hInst = AfxGetResourceHandle();
if (::FindResource(hInst, lpszName, lpszType) != NULL)
return hInst;
}
// check for non-system DLLs in proper order
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
if (!pDLL->m_bSystem && pDLL->m_hResource != NULL &&
::FindResource(pDLL->m_hResource, lpszName, lpszType) != NULL)
{
// found it in a DLL
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return pDLL->m_hResource;
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
// check language specific resource next
hInst = pModuleState->m_appLangDLL;
if (hInst != NULL && ::FindResource(hInst, lpszName, lpszType) != NULL)
return hInst;
// check the main system module state
if (pModuleState->m_bSystem)
{
hInst = AfxGetResourceHandle();
if (::FindResource(hInst, lpszName, lpszType) != NULL)
return hInst;
}
// check for system DLLs in proper order
AfxLockGlobals(CRIT_DYNLINKLIST);
for (pDLL = pModuleState->m_libraryList; pDLL != NULL; pDLL = pDLL->m_pNextDLL)
{
if (pDLL->m_bSystem && pDLL->m_hResource != NULL &&
::FindResource(pDLL->m_hResource, lpszName, lpszType) != NULL)
{
// found it in a DLL
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return pDLL->m_hResource;
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
// if failed to find resource, return application resource
return AfxGetResourceHandle();
}
// AfxLoadString must not only check for the appropriate string segment
// in the resource file, but also that the string is non-zero
int AFXAPI AfxLoadString(UINT nID, LPTSTR lpszBuf, UINT nMaxBuf)
{
ASSERT(AfxIsValidAddress(lpszBuf, nMaxBuf*sizeof(TCHAR)));
LPCTSTR lpszName = MAKEINTRESOURCE((nID>>4)+1);
HINSTANCE hInst;
int nLen;
// first check the main module state
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
if (!pModuleState->m_bSystem)
{
hInst = AfxGetResourceHandle();
if (::FindResource(hInst, lpszName, RT_STRING) != NULL &&
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
{
// found a non-zero string in app
return nLen;
}
}
// check non-system DLLs in proper order
AfxLockGlobals(CRIT_DYNLINKLIST);
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
pDLL = pDLL->m_pNextDLL)
{
if (!pDLL->m_bSystem && (hInst = pDLL->m_hResource) != NULL &&
::FindResource(hInst, lpszName, RT_STRING) != NULL &&
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return nLen;
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
// check language specific DLL next
hInst = pModuleState->m_appLangDLL;
if (hInst != NULL && ::FindResource(hInst, lpszName, RT_STRING) != NULL &&
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
{
// found a non-zero string in language DLL
return nLen;
}
// check the system module state
if (pModuleState->m_bSystem)
{
hInst = AfxGetResourceHandle();
if (::FindResource(hInst, lpszName, RT_STRING) != NULL &&
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
{
// found a non-zero string in app
return nLen;
}
}
// check system DLLs in proper order
AfxLockGlobals(CRIT_DYNLINKLIST);
for (pDLL = pModuleState->m_libraryList; pDLL != NULL; pDLL = pDLL->m_pNextDLL)
{
if (pDLL->m_bSystem && (hInst = pDLL->m_hResource) != NULL &&
::FindResource(hInst, lpszName, RT_STRING) != NULL &&
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
{
AfxUnlockGlobals(CRIT_DYNLINKLIST);
return nLen;
}
}
AfxUnlockGlobals(CRIT_DYNLINKLIST);
// did not find it
lpszBuf[0] = '\0';
return 0;
}
