void AFXAPI AfxOleUnlockApp() {
AfxGetModuleState()->m_comModule.Unlock();
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
if (AfxOleCanExitApp()) {
AfxOleOnReleaseAllObjects();
}
}
CComClass::CComClass(CComGeneralClass *gc)
: m_pGeneralClass(gc)
, m_pModuleState(AfxGetModuleState())
{
ZeroStruct(m_iid);
if (gc) {
AFX_MODULE_STATE *pMS = AfxGetModuleState();
if (!pMS->m_typeLib.m_iTypeLib)
pMS->m_typeLib.Load();
AfxGetModuleThreadState()->m_classList.push_back(unique_ptr<CComClass>(this));
}
}
void AFXAPI AfxCoreInitModule()
{
ASSERT(AfxGetModuleState() != AfxGetAppModuleState());
// construct new dynlink library in this context for core resources
CDynLinkLibrary* pDLL = new CDynLinkLibrary(coreDLL, TRUE);
ASSERT(pDLL != NULL);
pDLL->m_factoryList.m_pHead = NULL;
// borrow resources from language specific DLL if loaded
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AFX_MODULE_STATE* pAppState = AfxGetAppModuleState();
if (pModuleState->m_appLangDLL == NULL)
pModuleState->m_appLangDLL = pAppState->m_appLangDLL;
}
HRESULT CTRiASToolBar::InsertButton (
int iIndex, const TBBUTTON *pBttn, ITRiASUIOwner *pIOwner)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
// jetzt Owner zusammen mit dem ID speichern
if (!((pBttn -> fsStyle & TBSTYLE_SEP) && 0 == pBttn -> idCommand)) { // Separators not handled here
pair<UIOwners::iterator, bool> p = m_Owners.insert (pBttn -> idCommand, pIOwner);
ASSERT(p.second);
if (!p.second)
return ResultFromScode (E_FAIL);
}
// und zur Toolbar hinzufügen
#if !defined(_USE_SEC_CLASSES)
// wenn dieses der erste Zugriff ist, dann Separator entfernen
if (m_fHasDummySep) {
DeleteItem (0);
m_fHasDummySep = false;
}
CToolBarCtrl &rTB = GetToolBarCtrl();
HRESULT hr = (rTB.InsertButton (iIndex, const_cast<TBBUTTON *>(pBttn))) ? NOERROR : S_FALSE;
#else
HRESULT hr = m_pMainFrm -> InsertButton (this, iIndex, pBttn, pIOwner);
#endif // _USE_SEC_CLASSES
if (S_OK == hr && IsWindowVisible())
m_pMainFrm -> DelayRecalcLayout();
return hr;
}
HRESULT CTRiASToolBar::InitNew (void)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT_VALID(m_pMainFrm);
#if !defined(_USE_SEC_CLASSES)
m_uiID = m_pMainFrm -> GetNextBarID();
if (!Create (m_pMainFrm, WS_CHILD|CBRS_ALIGN_TOP|CBRS_FLOATING, m_uiID))
return E_FAIL;
SetBarStyle(GetBarStyle() | (CBRS_TOOLTIPS|CBRS_SIZE_FIXED));
EnableDocking (CBRS_ALIGN_ANY);
m_pMainFrm -> AddNewBar (m_pIBar); // jetzt hier, damit alle von außen das geleiche tun können
m_pMainFrm -> ShowControlBar (this, false, false);
m_pMainFrm -> DockControlBar (this);
TBBUTTON tb = { 25, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0, };
CToolBarCtrl &rTB = GetToolBarCtrl();
rTB.SetButtonSize (CSize(24, 23));
HRESULT hr = (rTB.InsertButton (0, &tb)) ? NOERROR : S_FALSE;
if (S_OK == hr) // leeres Feld einfügen
m_fHasDummySep = true;
#endif // _USE_SEC_CLASSES
return NOERROR;
}
HRESULT CTRiASToolBar::DeleteItem (int iIndex)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
TBBUTTON button;
_GetButtonEx (iIndex, &button);
if (0 != button.idCommand && !m_Owners.erase (button.idCommand))
return E_FAIL;
#if !defined(_USE_SEC_CLASSES)
CToolBarCtrl &rTB = GetToolBarCtrl();
HRESULT hr = rTB.DeleteButton (iIndex) ? NOERROR : S_FALSE;
#else
HRESULT hr = m_pMainFrm -> DeleteButton (this, iIndex);
#endif // _USE_SEC_CLASSES
if (S_OK == hr && IsWindowVisible())
m_pMainFrm -> DelayRecalcLayout();
return hr;
}
static LRESULT CALLBACK _AfxMsgFilterHook(int code, WPARAM wParam, LPARAM lParam) {
CWinThread* pThread;
if (AfxGetModuleState()->m_bDLL || (code < 0 && code != MSGF_DDEMGR) || !(pThread = AfxGetThread()))
return AfxGetThreadState()->m_hookMsg.CallNext(code, wParam, lParam);
ASSERT(pThread != NULL);
return (LRESULT)pThread->ProcessMessageFilter(code, (LPMSG)lParam);
}
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;
}
BOOL WINAPI RawDllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID)
{
UNUSED_ALWAYS(hInstance);
if (dwReason == DLL_PROCESS_ATTACH)
{
// Prevent the MFC DLL from being unloaded prematurely
LoadLibraryA(MFC42_DLL);
// make sure we have enough memory to attempt to start (8kb)
void* pMinHeap = LocalAlloc(NONZEROLPTR, 0x2000);
if (pMinHeap == NULL)
return FALSE; // fail if memory alloc fails
LocalFree(pMinHeap);
// save critical data pointers before running the constructors
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
pModuleState->m_pClassInit = pModuleState->m_classList;
pModuleState->m_pFactoryInit = pModuleState->m_factoryList;
pModuleState->m_classList.m_pHead = NULL;
pModuleState->m_factoryList.m_pHead = NULL;
}
else if (dwReason == DLL_PROCESS_DETACH)
{
// Now it's OK for the MFC DLL to be unloaded (see LoadLibrary above)
FreeLibrary(GetModuleHandleA(MFC42_DLL));
}
return TRUE; // ok
}
void AFXAPI AfxNetInitModule()
{
ASSERT(AfxGetModuleState() != AfxGetAppModuleState());
CDynLinkLibrary* pDLL = new CDynLinkLibrary(extensionDLL, TRUE);
ASSERT(pDLL != NULL);
}
HRESULT CTRiASToolBar::GetButtonEx (int iIndex, TBBUTTON *pBttn, ITRiASUIOwner **ppIOwner)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
if (NULL == pBttn && NULL == ppIOwner)
return E_POINTER;
if (NULL != pBttn)
_GetButtonEx (iIndex, pBttn);
if (NULL != ppIOwner) {
TBBUTTON tb;
_GetButtonEx (iIndex, &tb);
{
WTRiASUIOwner UIOwner;
HRESULT hr = FindOwner (tb.idCommand, UIOwner.ppi());
if (S_OK != hr)
return E_UNEXPECTED;
*ppIOwner = UIOwner.detach();
}
}
return NOERROR;
}
HRESULT CTRiASToolBar::OnCmdMessage (UINT uiID, int nCode, void *pExtra, AFX_CMDHANDLERINFO *pHandlerInfo)
{
// if (nCode != CN_COMMAND)
// return S_FALSE; // nur WM_COMMAND's bearbeiten
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
// nur bearbeiten, wenn dieses Fenster angezeigt ist
if (!(GetStyle() & WS_VISIBLE))
return S_FALSE; // nicht bearbeitet
// Versuchen diesen Befehl an entsprechenden Handler zu schicken
{
WTRiASUIOwner UIOwner;
HRESULT hr = FindOwner (uiID, UIOwner.ppi());
if (S_OK == hr) {
if (NULL != pHandlerInfo)
return S_OK; // lediglich abfragen
if (S_OK == UIOwner -> OnCommand (m_pIBar, uiID, nCode))
return S_OK; // bearbeitet
}
}
return S_FALSE; // nicht bearbeitet
}
extern "C" BOOL WINAPI TaskAnimateInitialize()
{
if (AfxGetModuleState() != AfxGetAppModuleState())
{
//
// construct new dynlink library in this context for core resources
try
{
CDynLinkLibrary* pDLL = new CDynLinkLibrary(TkAnimatDLL, TRUE);
ASSERT(pDLL != NULL);
if (pDLL)
{
pDLL->m_factoryList.m_pHead = NULL;
TRACE0("TKANIMAT.DLL Initializing (explitly calls to TaskAnimateInitialize()...)!\n");
}
else
return FALSE;
}
catch(...)
{
return FALSE;
}
}
return TRUE;
}
AFX_TERM_PROC AFXAPI AfxSetTerminate(AFX_TERM_PROC pfnNew)
{
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
AFX_TERM_PROC pfnOld = pModuleState->m_pfnTerminate;
pState->m_pfnTerminate = pfnNew;
return pfnOld;
}
CObject* CXMLArchiveNode::CreateObject(const CString& className)
{
CRuntimeClass* pClass = NULL;
// First see if the CRuntimeClass object is cached
if (!m_classMap.Lookup(className, (void*&)pClass))
{
// Search app specific classes
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
for (pClass = pModuleState->m_classList; pClass != NULL; pClass = pClass->m_pNextClass)
{
if (className == pClass->m_lpszClassName)
{
m_classMap[className] = (void*&)pClass;
break;
}
}
}
if (pClass == NULL)
{
TRACE1("You did not declare the class %s DECLARE_XMLSERIAL", (const char *)className);
ASSERT(FALSE);
return NULL;
}
return pClass->CreateObject();
}
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();
}
//---------------------------------------------------------------------------
void TFileZillaIntf::SetResourceModule(void * ResourceHandle)
{
// set afx resource handles, taken from AfxWinInit (mfc/appinit.cpp)
AFX_MODULE_STATE * ModuleState = AfxGetModuleState();
ModuleState->m_hCurrentInstanceHandle = static_cast<HINSTANCE>(ResourceHandle);
ModuleState->m_hCurrentResourceHandle = static_cast<HINSTANCE>(ResourceHandle);
}
BOOL AFXAPI AfxInitExtensionModule(AFX_EXTENSION_MODULE& state, HMODULE hModule)
{
// only initialize once
if (state.bInitialized)
{
AfxInitLocalData(hModule);
return TRUE;
}
state.bInitialized = TRUE;
// save the current HMODULE information for resource loading
ASSERT(hModule != NULL);
state.hModule = hModule;
state.hResource = hModule;
// save the start of the runtime class list
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
state.pFirstSharedClass = pModuleState->m_classList.GetHead();
pModuleState->m_classList.m_pHead = pModuleState->m_pClassInit;
#ifndef _AFX_NO_OLE_SUPPORT
// save the start of the class factory list
state.pFirstSharedFactory = pModuleState->m_factoryList.GetHead();
pModuleState->m_factoryList.m_pHead = pModuleState->m_pFactoryInit;
#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
}
HRESULT _VMD_EXPORT FAR PASCAL DllGetClassObject (REFCLSID rclsid, REFIID riid,
LPVOID FAR *ppv)
{
// zuerst MFC interne Abfragen
AFX_MANAGE_STATE(AfxGetModuleState());
return AfxDllGetClassObject (rclsid, riid, ppv);
}
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_STATE* pModuleState = AfxGetModuleState();
AfxLockGlobals(CRIT_CTLLOCKLIST);
pModuleState->m_lockList.AddHead(pLock);
AfxUnlockGlobals(CRIT_CTLLOCKLIST);
}
}
CATCH_ALL (e)
{
// Note: DELETE_EXCEPTION(e) not necessary
pLock = NULL;
}
END_CATCH_ALL
return pLock != NULL;
}
HRESULT CTRiASToolBar::RemoveBar (void)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT_VALID(m_pMainFrm);
return m_pMainFrm -> RemoveBar (m_pIBar); // deletes this object !
}
STDAPI _VMD_EXPORT DllUnregisterServer (void)
{
// MFC bedienen
AFX_MANAGE_STATE(AfxGetModuleState());
if (!COleObjectFactoryEx::UpdateRegistryAll(FALSE))
return SELFREG_E_CLASS;
return NOERROR;
}
CComObjectRootBase::CComObjectRootBase()
: m_pUnkOuter(0)
{
AFX_MODULE_STATE *pMS = AfxGetModuleState();
if (!pMS->m_pComClass.get())
pMS->m_pComClass.reset(new CComClass);
m_pClass = pMS->m_pComClass.get();
//!!!R pMS->m_comModule.Lock();
}
HRESULT CTRiASToolBar::FloatBar (const POINT &pt, DWORD dwStyle)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
ASSERT_VALID(m_pMainFrm);
m_pMainFrm -> FloatControlBar (this, pt, dwStyle);
return NOERROR;
}
HRESULT CTRiASToolBar::DockBar (UINT uiWhere, LPCRECT pcRc)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
ASSERT_VALID(m_pMainFrm);
m_pMainFrm -> DockControlBar (this, uiWhere, pcRc);
return NOERROR;
}
HRESULT CTRiASToolBar::SetButtonStyle (int iIndex, UINT uiStyle)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
SECCustomToolBar::SetButtonStyle (iIndex, uiStyle);
return NOERROR;
}
LRESULT CRoboEx::QueryInformation(UINT uQueryID, WPARAM wParam, LPARAM lParam)
{
AFX_MANAGE_STATE(AfxGetModuleState());
EXT_MSG_STRUCT msg;
msg.wParam = wParam;
msg.lParam = lParam;
return AfxGetApp()->m_pMainWnd->SendMessage(WM_QAPI, (WPARAM)uQueryID, (LPARAM)&msg);
}
HRESULT CTRiASToolBar::CommandToIndex (UINT uiID, int *piIndex)
{
AFX_MANAGE_STATE(AfxGetModuleState());
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
ASSERT(NULL != piIndex);
*piIndex = SECCustomToolBar::CommandToIndex (uiID);
return NOERROR;
}
CDynLinkLibrary::CDynLinkLibrary( HINSTANCE hModule, HINSTANCE hResource )
/************************************************************************/
{
m_hModule = hModule;
m_hResource = hResource;
m_bSystem = FALSE;
AFX_MODULE_STATE *pState = AfxGetModuleState();
ASSERT( pState != NULL );
pState->m_libraryList.AddHead( this );
}
