BOOL COleClientItem::DoVerb(LONG nVerb, CView* pView, LPMSG lpMsg)
{
ASSERT_VALID(this);
if (pView != NULL)
ASSERT_VALID(pView);
if (lpMsg != NULL)
ASSERT(AfxIsValidAddress(lpMsg, sizeof(MSG), FALSE));
TRY
{
Activate(nVerb, pView, lpMsg);
}
CATCH(COleException, e)
{
// catch OLE errors and report them as such
if (!ReportError(e->m_sc))
AfxMessageBox(AFX_IDP_FAILED_TO_LAUNCH);
DELETE_EXCEPTION(e);
return FALSE;
}
AND_CATCH_ALL(e)
{
// otherwise, show generic error
AfxMessageBox(AFX_IDP_FAILED_TO_LAUNCH);
DELETE_EXCEPTION(e);
return FALSE;
}
END_CATCH_ALL
return TRUE;
}
STDMETHODIMP COleUILinkInfo::UpdateLink(
DWORD dwLink, BOOL /*fErrorMessage*/, BOOL /*fErrorAction*/)
{
COleClientItem* pItem = (COleClientItem*)dwLink;
ASSERT_VALID(pItem);
ASSERT_KINDOF(COleClientItem, pItem);
SCODE sc;
TRY
{
// link not up-to-date, attempt to update it
if (!pItem->UpdateLink())
AfxThrowOleException(pItem->GetLastStatus());
pItem->m_bLinkUnavail = FALSE;
sc = S_OK;
}
CATCH_ALL(e)
{
pItem->m_bLinkUnavail = TRUE;
sc = COleException::Process(e);
pItem->ReportError(sc);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return sc;
}
STDMETHODIMP CArchiveStream::Seek(LARGE_INTEGER uliOffset, DWORD dwOrigin,
ULARGE_INTEGER* puliNew)
{
// can't handle offsets with really large magnitude
if ((uliOffset.HighPart != 0) &&
((uliOffset.HighPart != -1) || ((long)uliOffset.LowPart >= 0)))
return E_NOTIMPL;
CFile* pFile = m_pArchive->GetFile();
if (pFile == NULL)
return E_NOTIMPL;
m_pArchive->Flush();
ASSERT(STREAM_SEEK_SET == CFile::begin);
ASSERT(STREAM_SEEK_CUR == CFile::current);
ASSERT(STREAM_SEEK_END == CFile::end);
LONG lNew;
TRY
{
lNew = pFile->Seek((LONG)uliOffset.LowPart, (UINT)dwOrigin);
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
return E_UNEXPECTED;
}
END_CATCH_ALL
if (puliNew != NULL)
ULISet32(*puliNew, lNew);
return NOERROR;
}
STDMETHODIMP COleUILinkInfo::GetLinkUpdateOptions(
DWORD dwLink, DWORD* lpdwUpdateOpt)
{
COleClientItem* pItem = (COleClientItem*)dwLink;
ASSERT_VALID(pItem);
ASSERT_KINDOF(COleClientItem, pItem);
SCODE sc;
TRY
{
if (pItem->GetType() == OT_LINK)
*lpdwUpdateOpt = pItem->GetLinkUpdateOptions();
else
*lpdwUpdateOpt = OLEUPDATE_ALWAYS; // make believe it is auto-link
sc = S_OK;
}
CATCH_ALL(e)
{
sc = COleException::Process(e);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return sc;
}
ConfigMgr::ConfigMgr(void) {
// 读取配置文件
CString& config = GetConfigFile();
if (!config.IsEmpty()) {
// 如果配置文件不存在，创建默认的配置文件
if (0 != _taccess(config, 0)) {
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("配置文件不存存在，创建默认配置文件"));
static char s_default_config[] =
"[system]\r\n"
"access_key_id=\r\n"
"secret_access_key=\r\n"
"host=http://lss.bj.baidubce.com\r\n";
CFile file;
TRY {
if (!file.Open(config, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite)) {
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("创建默认配置文件失败"));
} else {
file.Write(s_default_config, sizeof(s_default_config));
file.Close();
}
}
CATCH_ALL(e) {
DELETE_EXCEPTION(e);
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("创建默认配置文件异常"));
}
END_CATCH_ALL
}
} else {
BOOL CDocument::DoSave(LPCTSTR lpszPathName, BOOL bReplace)
// Save the document data to a file
// lpszPathName = path name where to save document file
// if lpszPathName is NULL then the user will be prompted (SaveAs)
// note: lpszPathName can be different than 'm_strPathName'
// if 'bReplace' is TRUE will change file name if successful (SaveAs)
// if 'bReplace' is FALSE will not change path name (SaveCopyAs)
{
CString newName = lpszPathName;
if (newName.IsEmpty())
{
CDocTemplate* pTemplate = GetDocTemplate();
ASSERT(pTemplate != NULL);
newName = m_strPathName;
if (bReplace && newName.IsEmpty())
{
newName = m_strTitle;
// check for dubious filename
int iBad = newName.FindOneOf(_T(":/\\"));
if (iBad != -1)
newName.ReleaseBuffer(iBad);
// append the default suffix if there is one
CString strExt;
if (pTemplate->GetDocString(strExt, CDocTemplate::filterExt) &&
!strExt.IsEmpty())
{
ASSERT(strExt[0] == '.');
int iStart = 0;
newName += strExt.Tokenize(_T(";"), iStart);
}
}
if (!AfxGetApp()->DoPromptFileName(newName,
bReplace ? AFX_IDS_SAVEFILE : AFX_IDS_SAVEFILECOPY,
OFN_HIDEREADONLY | OFN_PATHMUSTEXIST, FALSE, pTemplate))
return FALSE; // don't even attempt to save
}
CWaitCursor wait;
if (!OnSaveDocument(newName))
{
if (lpszPathName == NULL)
{
// be sure to delete the file
TRY
{
CFile::Remove(newName);
}
CATCH_ALL(e)
{
TRACE(traceAppMsg, 0, "Warning: failed to delete file after failed SaveAs.\n");
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
}
return FALSE;
}
STDMETHODIMP CArchiveStream::Seek(LARGE_INTEGER uliOffset, DWORD dwOrigin,
ULARGE_INTEGER* puliNew)
{
CFile* pFile = m_pArchive->GetFile();
if (pFile == NULL)
return E_NOTIMPL;
m_pArchive->Flush();
ASSERT(STREAM_SEEK_SET == CFile::begin);
ASSERT(STREAM_SEEK_CUR == CFile::current);
ASSERT(STREAM_SEEK_END == CFile::end);
ULONGLONG lNew;
TRY
{
lNew = pFile->Seek(uliOffset.QuadPart, (UINT)dwOrigin);
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
return E_UNEXPECTED;
}
END_CATCH_ALL
if (puliNew != NULL)
puliNew->QuadPart = lNew;
return NOERROR;
}
STDMETHODIMP COleUILinkInfo::CancelLink(DWORD dwLink)
{
COleClientItem* pItem = (COleClientItem*)dwLink;
ASSERT_VALID(pItem);
ASSERT_KINDOF(COleClientItem, pItem);
ASSERT(pItem->GetType() == OT_LINK);
SCODE sc = E_FAIL;
TRY
{
if (pItem->FreezeLink())
sc = S_OK;
}
CATCH_ALL(e)
{
sc = COleException::Process(e);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
// report error
if (sc != S_OK)
pItem->ReportError(sc);
return S_OK;
}
STDMETHODIMP CArchiveStream::Read(void *pv, ULONG cb, ULONG *pcbRead)
{
ASSERT(m_pArchive != NULL);
ASSERT(m_pArchive->IsLoading());
int nRead = 0;
TRY
{
nRead = m_pArchive->Read(pv, cb);
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
return E_UNEXPECTED;
}
END_CATCH_ALL
if (pcbRead != NULL)
*pcbRead = nRead;
return NOERROR;
}
STDMETHODIMP CArchiveStream::Write(const void *pv, ULONG cb, ULONG *pcbWritten)
{
ASSERT(m_pArchive != NULL);
ASSERT(m_pArchive->IsStoring());
int nWrite = 0;
TRY
{
m_pArchive->Write(pv, cb);
nWrite = cb;
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
return E_UNEXPECTED;
}
END_CATCH_ALL
if (pcbWritten != NULL)
*pcbWritten = nWrite;
return NOERROR;
}
STDMETHODIMP COleUILinkInfo::OpenLinkSource(DWORD dwLink)
{
COleClientItem* pItem = (COleClientItem*)dwLink;
ASSERT_VALID(pItem);
ASSERT_KINDOF(COleClientItem, pItem);
ASSERT(pItem->GetType() == OT_LINK);
SCODE sc;
TRY
{
// Note: no need for valid CView* since links don't activate inplace
pItem->DoVerb(OLEIVERB_SHOW, NULL);
sc = S_OK;
}
CATCH_ALL(e)
{
sc = COleException::Process(e);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return sc;
}
STDMETHODIMP COleUILinkInfo::SetLinkUpdateOptions(
DWORD dwLink, DWORD dwUpdateOpt)
{
COleClientItem* pItem = (COleClientItem*)dwLink;
ASSERT_VALID(pItem);
ASSERT_KINDOF(COleClientItem, pItem);
ASSERT(pItem->GetType() == OT_LINK);
SCODE sc;
TRY
{
// item is a link -- get its link options
pItem->SetLinkUpdateOptions((OLEUPDATE)dwUpdateOpt);
sc = S_OK;
}
CATCH_ALL(e)
{
sc = COleException::Process(e);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return sc;
}
BOOL CWnd::CreateDlgIndirect(LPCDLGTEMPLATE lpDialogTemplate,
CWnd* pParentWnd, HINSTANCE hInst)
{
ASSERT(lpDialogTemplate != NULL);
if (pParentWnd != NULL)
ASSERT_VALID(pParentWnd);
if (hInst == NULL)
hInst = AfxGetInstanceHandle();
#ifndef _AFX_NO_OCC_SUPPORT
_AFX_OCC_DIALOG_INFO occDialogInfo;
COccManager* pOccManager = afxOccManager;
#endif
HGLOBAL hTemplate = NULL;
HWND hWnd = NULL;
#ifdef _DEBUG
DWORD dwError = 0;
#endif
TRY
{
VERIFY(AfxDeferRegisterClass(AFX_WNDCOMMCTLS_REG));
AfxDeferRegisterClass(AFX_WNDCOMMCTLSNEW_REG);
#ifndef _AFX_NO_OCC_SUPPORT
// separately create OLE controls in the dialog template
if (pOccManager != NULL)
{
if (!SetOccDialogInfo(&occDialogInfo))
return FALSE;
lpDialogTemplate = pOccManager->PreCreateDialog(&occDialogInfo,
lpDialogTemplate);
}
if (lpDialogTemplate == NULL)
return FALSE;
#endif //!_AFX_NO_OCC_SUPPORT
// If no font specified, set the system font.
CString strFace;
WORD wSize = 0;
BOOL bSetSysFont = !CDialogTemplate::GetFont(lpDialogTemplate, strFace,
wSize);
// On DBCS systems, also change "MS Sans Serif" or "Helv" to system font.
if ((!bSetSysFont) && GetSystemMetrics(SM_DBCSENABLED))
{
bSetSysFont = (strFace == _T("MS Shell Dlg") ||
strFace == _T("MS Sans Serif") || strFace == _T("Helv"));
if (bSetSysFont && (wSize == 8))
wSize = 0;
}
if (bSetSysFont)
{
CDialogTemplate dlgTemp(lpDialogTemplate);
dlgTemp.SetSystemFont(wSize);
hTemplate = dlgTemp.Detach();
}
if (hTemplate != NULL)
lpDialogTemplate = (DLGTEMPLATE*)GlobalLock(hTemplate);
// setup for modal loop and creation
m_nModalResult = -1;
m_nFlags |= WF_CONTINUEMODAL;
// create modeless dialog
AfxHookWindowCreate(this);
hWnd = ::CreateDialogIndirect(hInst, lpDialogTemplate,
pParentWnd->GetSafeHwnd(), AfxDlgProc);
#ifdef _DEBUG
dwError = ::GetLastError();
#endif
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
m_nModalResult = -1;
}
END_CATCH_ALL
#ifndef _AFX_NO_OCC_SUPPORT
if (pOccManager != NULL)
{
pOccManager->PostCreateDialog(&occDialogInfo);
if (hWnd != NULL)
SetOccDialogInfo(NULL);
}
#endif //!_AFX_NO_OCC_SUPPORT
if (!AfxUnhookWindowCreate())
PostNcDestroy(); // cleanup if Create fails too soon
// handle EndDialog calls during OnInitDialog
if (hWnd != NULL && !(m_nFlags & WF_CONTINUEMODAL))
{
::DestroyWindow(hWnd);
hWnd = NULL;
}
if (hTemplate != NULL)
{
GlobalUnlock(hTemplate);
GlobalFree(hTemplate);
}
// help with error diagnosis (only if WM_INITDIALOG didn't EndDialog())
if (hWnd == NULL && (m_nFlags & WF_CONTINUEMODAL))
{
#ifdef _DEBUG
#ifndef _AFX_NO_OCC_SUPPORT
if (afxOccManager == NULL)
{
TRACE0(">>> If this dialog has OLE controls:\n");
TRACE0(">>> AfxEnableControlContainer has not been called yet.\n");
TRACE0(">>> You should call it in your app's InitInstance function.\n");
}
else if (dwError != 0)
{
TRACE1("Warning: Dialog creation failed! GetLastError returns 0x%8.8X\n", dwError);
}
#endif //!_AFX_NO_OCC_SUPPORT
#endif //_DEBUG
return FALSE;
}
ASSERT(hWnd == m_hWnd);
return TRUE;
}
BOOL COleDocument::OnOpenDocument(LPCTSTR lpszPathName)
{
ASSERT(lpszPathName == NULL || AfxIsValidString(lpszPathName));
// just use default implementation if 'docfile' not enabled
if (!m_bCompoundFile && m_lpRootStg == NULL)
{
ASSERT(lpszPathName != NULL);
return CDocument::OnOpenDocument(lpszPathName);
}
if (IsModified())
TRACE(traceOle, 0, "Warning: OnOpenDocument replaces an unsaved document.\n");
// abort changes to current docfile
if (lpszPathName != NULL)
{
DeleteContents();
RELEASE(m_lpRootStg);
}
SetModifiedFlag(); // dirty during de-serialize
BOOL bResult = FALSE;
TRY
{
if (m_lpRootStg == NULL)
{
const CStringW strPathName(lpszPathName);
LPCOLESTR lpsz = lpszPathName ? strPathName.GetString() : NULL;
// use STGM_CONVERT if necessary
SCODE sc;
LPSTORAGE lpStorage = NULL;
if (StgIsStorageFile(lpsz) == S_FALSE)
{
// convert existing storage file
sc = StgCreateDocfile(lpsz, STGM_READWRITE|
STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_CONVERT,
0, &lpStorage);
}
else
{
// open new storage file
sc = StgOpenStorage(lpsz, NULL,
STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE,
0, 0, &lpStorage);
if (FAILED(sc) || lpStorage == NULL)
sc = StgOpenStorage(lpsz, NULL,
STGM_READ|STGM_TRANSACTED, 0, 0, &lpStorage);
}
if (FAILED(sc))
AfxThrowOleException(sc);
ASSERT(lpStorage != NULL);
m_lpRootStg = lpStorage;
}
// use helper to read document from storage
LoadFromStorage();
SetModifiedFlag(FALSE); // start off with unmodified
bResult = TRUE;
}
CATCH_ALL(e)
{
DeleteContents(); // removed failed contents
RELEASE(m_lpRootStg);
// if not file-based load, return exceptions to the caller
if (lpszPathName == NULL)
{
THROW_LAST();
}
TRY
{
ReportSaveLoadException(lpszPathName, e,
FALSE, AFX_IDP_FAILED_TO_OPEN_DOC);
}
END_TRY
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return bResult;
}
BOOL COleDocument::OnSaveDocument(LPCTSTR lpszPathName)
// lpszPathName must be fully qualified
{
ASSERT(lpszPathName == NULL || AfxIsValidString(lpszPathName));
// use default implementation if 'docfile' not enabled
if (!m_bCompoundFile && m_lpRootStg == NULL)
{
ASSERT(lpszPathName != NULL);
return CDocument::OnSaveDocument(lpszPathName);
}
LPSTORAGE lpOrigStg = NULL;
if (lpszPathName != NULL)
m_bSameAsLoad = AfxComparePath(m_strPathName, lpszPathName);
BOOL bResult = FALSE;
TRY
{
// open new root storage if necessary
if (lpszPathName != NULL && !m_bSameAsLoad)
{
// temporarily detach current storage
lpOrigStg = m_lpRootStg;
m_lpRootStg = NULL;
LPSTORAGE lpStorage;
const CStringW strPathName(lpszPathName);
SCODE sc = ::StgCreateDocfile(strPathName.GetString(),
STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_CREATE,
0, &lpStorage);
if (sc != S_OK)
AfxThrowOleException(sc);
ASSERT(lpStorage != NULL);
m_lpRootStg = lpStorage;
}
ASSERT(m_lpRootStg != NULL);
// use helper to save to root storage
SaveToStorage();
if (lpszPathName != NULL)
{
// commit each of the items
CommitItems(m_bRemember && !m_bSameAsLoad);
// mark document as clean if remembering the storage
if (m_bRemember)
SetModifiedFlag(FALSE);
// remember correct storage or release save copy as storage
if (!m_bSameAsLoad)
{
if (m_bRemember)
{
// Save As case -- m_stgRoot is new storage, forget old storage
lpOrigStg->Release();
}
else
{
// Save Copy As case -- m_stgRoot should hook up to m_stgOrig.
m_lpRootStg->Release();
m_lpRootStg = lpOrigStg;
}
}
}
bResult = TRUE;
}
CATCH_ALL(e)
{
if (lpOrigStg != NULL)
{
// save as failed: abort new storage, and re-attach original
RELEASE(m_lpRootStg);
m_lpRootStg = lpOrigStg;
}
if (lpszPathName == NULL)
{
THROW_LAST();
}
TRY
{
ReportSaveLoadException(lpszPathName, e,
TRUE, AFX_IDP_FAILED_TO_SAVE_DOC);
}
END_TRY
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
// cleanup
m_bSameAsLoad = TRUE;
m_bRemember = TRUE;
return bResult;
}
BOOL CCmdTarget::OnEvent(UINT idCtrl, AFX_EVENT* pEvent,
AFX_CMDHANDLERINFO* pHandlerInfo)
{
HRESULT hResult = S_OK;
UINT uArgError = (UINT)-1; // no error yet
const AFX_EVENTSINKMAP_ENTRY* pEntry = GetEventSinkEntry(idCtrl, pEvent);
// no handler for this event
if (pEntry == NULL)
return FALSE;
if (pHandlerInfo != NULL)
{
// just fill in the information, don't do it
pHandlerInfo->pTarget = this;
switch (pEvent->m_eventKind)
{
case AFX_EVENT::event:
case AFX_EVENT::propRequest:
pHandlerInfo->pmf = pEntry->dispEntry.pfn;
break;
case AFX_EVENT::propChanged:
pHandlerInfo->pmf = pEntry->dispEntry.pfnSet;
break;
default:
ASSERT(FALSE); // bogus value for pEvent->m_eventKind
}
return (pHandlerInfo->pmf != NULL);
}
BOOL bRange = (pEntry->nCtrlIDLast != (UINT)-1);
BOOL bHandled = FALSE;
TRY
{
switch (pEvent->m_eventKind)
{
case AFX_EVENT::event:
// do standard method call
VARIANT var;
AfxVariantInit(&var);
DISPPARAMS dispparams;
dispparams.rgvarg = NULL;
if (bRange)
{
memcpy(&dispparams, pEvent->m_pDispParams, sizeof(DISPPARAMS));
dispparams.rgvarg = new VARIANT[++dispparams.cArgs];
memcpy(dispparams.rgvarg, pEvent->m_pDispParams->rgvarg,
sizeof(VARIANT) * (dispparams.cArgs-1));
VARIANT* pvarID = &dispparams.rgvarg[dispparams.cArgs-1];
V_VT(pvarID) = VT_I4;
V_I4(pvarID) = idCtrl;
}
hResult = CallMemberFunc(&pEntry->dispEntry, DISPATCH_METHOD, &var,
(bRange ? &dispparams : pEvent->m_pDispParams), &uArgError);
ASSERT(FAILED(hResult) || (V_VT(&var) == VT_BOOL));
bHandled = V_BOOL(&var);
if (bRange)
delete [] dispparams.rgvarg;
break;
case AFX_EVENT::propChanged:
{
if (bRange)
{
PFN_CHANGED_RANGE pfn = (PFN_CHANGED_RANGE)pEntry->dispEntry.pfnSet;
bHandled = (this->*pfn)(idCtrl);
}
else
{
PFN_CHANGED pfn = (PFN_CHANGED)pEntry->dispEntry.pfnSet;
bHandled = (this->*pfn)();
}
hResult = S_OK;
}
break;
case AFX_EVENT::propRequest:
{
BOOL bAllow = TRUE;
if (bRange)
{
PFN_REQUEST_RANGE pfn = (PFN_REQUEST_RANGE)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(idCtrl, &bAllow);
}
else
{
PFN_REQUEST pfn = (PFN_REQUEST)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(&bAllow);
}
hResult = bAllow ? S_OK : S_FALSE;
}
break;
case AFX_EVENT::propDSCNotify:
{
BOOL bAllow = TRUE;
if (bRange)
{
PFN_DSCNOTIFY_RANGE pfn = (PFN_DSCNOTIFY_RANGE)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(idCtrl, pEvent->m_nDSCState,
pEvent->m_nDSCReason, &bAllow);
}
else
{
PFN_DSCNOTIFY pfn = (PFN_DSCNOTIFY)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(pEvent->m_nDSCState,
pEvent->m_nDSCReason, &bAllow);
}
hResult = bAllow ? S_OK : S_FALSE;
}
break;
default:
ASSERT(FALSE); // bogus value for pEvent->m_eventKind
}
}
CATCH_ALL(e)
{
if (pEvent->m_pExcepInfo != NULL)
{
// fill exception with translation of MFC exception
COleDispatchException::Process(pEvent->m_pExcepInfo, e);
}
DELETE_EXCEPTION(e);
hResult = DISP_E_EXCEPTION;
}
END_CATCH_ALL
// fill error argument if one is available
if (FAILED(hResult) && pEvent->m_puArgError != NULL && uArgError != -1)
*pEvent->m_puArgError = uArgError;
// fill result code
pEvent->m_hResult = hResult;
return bHandled;
}
int CWebInterfaceDlg::DoModal()
{
ASSERT(m_lpszTemplateName != NULL || m_hDialogTemplate != NULL ||
m_lpDialogTemplate != NULL);
LPCDLGTEMPLATE lpDialogTemplate = m_lpDialogTemplate;
HGLOBAL hDialogTemplate = m_hDialogTemplate;
HINSTANCE hInst = AfxGetResourceHandle();
if (m_lpszTemplateName != NULL)
{
hInst = AfxFindResourceHandle(m_lpszTemplateName, RT_DIALOG);
HRSRC hResource = ::FindResource(hInst, m_lpszTemplateName, RT_DIALOG);
hDialogTemplate = LoadResource(hInst, hResource);
}
if (hDialogTemplate != NULL)
lpDialogTemplate = (LPCDLGTEMPLATE)LockResource(hDialogTemplate);
if (lpDialogTemplate == NULL)
return -1;
HWND hWndParent = PreModal();
AfxUnhookWindowCreate();
BOOL bEnableParent = FALSE;
if (hWndParent != NULL && ::IsWindowEnabled(hWndParent))
{
::EnableWindow(hWndParent, FALSE);
bEnableParent = TRUE;
}
TRY
{
AfxHookWindowCreate(this);
if (CreateDlgIndirect(lpDialogTemplate,
CWnd::FromHandle(hWndParent), hInst))
{
if (m_nFlags & WF_CONTINUEMODAL)
{
DWORD dwFlags = 0;
if (GetStyle() & DS_NOIDLEMSG)
dwFlags |= MLF_NOIDLEMSG;
VERIFY(RunModalLoop(dwFlags) == m_nModalResult);
}
if (m_hWnd != NULL)
SetWindowPos(NULL, 0, 0, 0, 0, SWP_HIDEWINDOW|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
}
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
m_nModalResult = -1;
}
END_CATCH_ALL
if (bEnableParent)
::EnableWindow(hWndParent, TRUE);
if (hWndParent != NULL && ::GetActiveWindow() == m_hWnd)
::SetActiveWindow(hWndParent);
DestroyWindow();
PostModal();
if (m_lpszTemplateName != NULL || m_hDialogTemplate != NULL)
UnlockResource(hDialogTemplate);
if (m_lpszTemplateName != NULL)
FreeResource(hDialogTemplate);
return m_nModalResult;
}
BOOL CSocket::PumpMessages(UINT uStopFlag)
{
// The same socket better not be blocking in more than one place.
ASSERT(m_pbBlocking == NULL);
AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
ASSERT(pThreadState->m_hSocketWindow != NULL);
BOOL bBlocking = TRUE;
m_pbBlocking = &bBlocking;
CWinThread* pThread = AfxGetThread();
UINT nTimerID = ::SetTimer(NULL, 0xff00, m_nTimeOut, NULL);
if (nTimerID == 0)
AfxThrowResourceException();
while (bBlocking)
{
TRY
{
MSG msg;
if (::PeekMessage(&msg, pThreadState->m_hSocketWindow,
WM_SOCKET_NOTIFY, WM_SOCKET_DEAD, PM_REMOVE))
{
if (msg.message == WM_SOCKET_NOTIFY && (SOCKET)msg.wParam == m_hSocket)
{
if (WSAGETSELECTEVENT(msg.lParam) == FD_CLOSE)
{
break;
}
if (WSAGETSELECTEVENT(msg.lParam) == uStopFlag)
{
if (uStopFlag == FD_CONNECT)
m_nConnectError = WSAGETSELECTERROR(msg.lParam);
break;
}
}
if (msg.wParam != 0 || msg.lParam != 0)
CSocket::AuxQueueAdd(msg.message, msg.wParam, msg.lParam);
}
else if (::PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE))
{
if (msg.wParam == nTimerID)
{
::PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE);
break;
}
}
else if (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) &&
OnMessagePending())
{
// allow user-interface updates
pThread->OnIdle(-1);
}
else
{
// no work to do -- allow CPU to sleep
WaitMessage();
}
}
CATCH_ALL(e)
{
TRACE0("Error: caught exception in PumpMessage - continuing.\n");
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
}
::KillTimer(NULL, nTimerID);
if (!bBlocking)
{
WSASetLastError(WSAEINTR);
return FALSE;
}
m_pbBlocking = NULL;
::PostMessage(pThreadState->m_hSocketWindow,WM_SOCKET_NOTIFY,0,0);
return TRUE;
}
int CDialog::DoModal()
{
// can be constructed with a resource template or InitModalIndirect
ASSERT(m_lpszTemplateName != NULL || m_hDialogTemplate != NULL ||
m_lpDialogTemplate != NULL);
// load resource as necessary
LPCDLGTEMPLATE lpDialogTemplate = m_lpDialogTemplate;
HGLOBAL hDialogTemplate = m_hDialogTemplate;
HINSTANCE hInst = AfxGetResourceHandle();
if (m_lpszTemplateName != NULL)
{
hInst = AfxFindResourceHandle(m_lpszTemplateName, RT_DIALOG);
HRSRC hResource = ::FindResource(hInst, m_lpszTemplateName, RT_DIALOG);
hDialogTemplate = LoadResource(hInst, hResource);
}
if (hDialogTemplate != NULL)
lpDialogTemplate = (LPCDLGTEMPLATE)LockResource(hDialogTemplate);
// return -1 in case of failure to load the dialog template resource
if (lpDialogTemplate == NULL)
return -1;
// disable parent (before creating dialog)
HWND hWndParent = PreModal();
AfxUnhookWindowCreate();
BOOL bEnableParent = FALSE;
if (hWndParent != NULL && ::IsWindowEnabled(hWndParent))
{
::EnableWindow(hWndParent, FALSE);
bEnableParent = TRUE;
}
TRY
{
// create modeless dialog
AfxHookWindowCreate(this);
if (CreateDlgIndirect(lpDialogTemplate,
CWnd::FromHandle(hWndParent), hInst))
{
if (m_nFlags & WF_CONTINUEMODAL)
{
// enter modal loop
DWORD dwFlags = MLF_SHOWONIDLE;
if (GetStyle() & DS_NOIDLEMSG)
dwFlags |= MLF_NOIDLEMSG;
VERIFY(RunModalLoop(dwFlags) == m_nModalResult);
}
// hide the window before enabling the parent, etc.
if (m_hWnd != NULL)
SetWindowPos(NULL, 0, 0, 0, 0, SWP_HIDEWINDOW|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
}
}
CATCH_ALL(e)
{
DELETE_EXCEPTION(e);
m_nModalResult = -1;
}
END_CATCH_ALL
if (bEnableParent)
::EnableWindow(hWndParent, TRUE);
if (hWndParent != NULL && ::GetActiveWindow() == m_hWnd)
::SetActiveWindow(hWndParent);
// destroy modal window
DestroyWindow();
PostModal();
// unlock/free resources as necessary
if (m_lpszTemplateName != NULL || m_hDialogTemplate != NULL)
UnlockResource(hDialogTemplate);
if (m_lpszTemplateName != NULL)
FreeResource(hDialogTemplate);
return m_nModalResult;
}
CFile* COleDataObject::GetFileData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc)
{
EnsureClipboardObject();
ASSERT(m_bClipboard || m_lpDataObject != NULL);
if (m_lpDataObject == NULL)
return NULL;
ASSERT(lpFormatEtc == NULL ||
AfxIsValidAddress(lpFormatEtc, sizeof(FORMATETC), FALSE));
// fill in FORMATETC struct
FORMATETC formatEtc;
lpFormatEtc = _AfxFillFormatEtc(lpFormatEtc, cfFormat, &formatEtc);
formatEtc.tymed = TYMED_FILE|TYMED_MFPICT|TYMED_HGLOBAL|TYMED_ISTREAM;
// attempt to get the data
STGMEDIUM stgMedium;
SCODE sc = m_lpDataObject->GetData(lpFormatEtc, &stgMedium);
if (FAILED(sc))
return FALSE;
// STGMEDIUMs with pUnkForRelease need to be copied first
if (stgMedium.pUnkForRelease != NULL)
{
STGMEDIUM stgMediumDest;
stgMediumDest.tymed = TYMED_NULL;
stgMediumDest.pUnkForRelease = NULL;
if (!_AfxCopyStgMedium(lpFormatEtc->cfFormat, &stgMediumDest, &stgMedium))
{
::ReleaseStgMedium(&stgMedium);
return FALSE;
}
// release original and replace with new
::ReleaseStgMedium(&stgMedium);
stgMedium = stgMediumDest;
}
// convert it to a file, depending on data
CString strFileName;
CFile* pFile = NULL;
TRY
{
switch (stgMedium.tymed)
{
case TYMED_FILE:
strFileName = stgMedium.lpszFileName;
pFile = new CFile;
if (!pFile->Open(strFileName,
CFile::modeReadWrite|CFile::shareExclusive))
{
delete pFile;
pFile = NULL;
break;
}
// caller is responsible for deleting the actual file,
// but we free the file name.
CoTaskMemFree(stgMedium.lpszFileName);
break;
case TYMED_MFPICT:
case TYMED_HGLOBAL:
pFile = new CSharedFile;
((CSharedFile*)pFile)->SetHandle(stgMedium.hGlobal);
break;
case TYMED_ISTREAM:
pFile = new COleStreamFile(stgMedium.pstm);
break;
default:
// type not supported, so return error
::ReleaseStgMedium(&stgMedium);
break;
}
}
CATCH_ALL(e)
{
delete pFile;
pFile = NULL;
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
// store newly created CFile* and return
return pFile;
}