/**************************************************************************
File: crossref.txt
Name: Steven A. Lyons
Date: August 4, 1993
Description:
Cross reference between the member functions of classes and the MFC
source code files (contained in msvc\mfc\src). The souce code file name
is listed first (without the associated .cpp extension) then the
functions contained by the file are listed.
This cross reference was created simply by searching on "::". If a
function header was found, then the line was copied. Therefore, the
argument list is often incomplete, and the return value (which sometimes
is listed in the source code on the line just prior to the function
header) is occasionally missing. For these details, see afxwin.h
There are 100 files of MFC source code. However, only 85 files are
listed here. The other 15 files do not contain class member function
definitions.

Revisions/Rev.Date:

************************************************************************/

afxmem
void* CObject::operator new(size_t nSize)
CObject::operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
void CObject::operator delete(void* pbData)
CMemoryState::CMemoryState()
BOOL CMemoryState::Difference(const CMemoryState& oldState,
void CMemoryState::DumpStatistics() const
void CMemoryState::Checkpoint()
void CMemoryState::DumpAllObjectsSince() const
AFX_EXITDUMP::~AFX_EXITDUMP()

appdlg
BOOL CNewTypeDlg::OnInitDialog()
void CNewTypeDlg::OnOK()
void CWinApp::OnFileNew()
void CWinApp::OnFileOpen()
BOOL CWinApp::DoPromptFileName(CString& fileName, UINT nIDSTitle, DWORD

apphlp
void CWinApp::WinHelp(DWORD dwData, UINT nCmd /* = HELP_CONTEXT */)

appprnt
BOOL CWinApp::GetPrinterDeviceDefaults(PRINTDLG FAR* pPrintDlg)
void CWinApp::UpdatePrinterSelection(BOOL bForceDefaults)
int CWinApp::DoPrintDialog(CPrintDialog* pPD)
void CWinApp::OnFilePrintSetup()

arccore
CRuntimeClass* PASCAL CRuntimeClass::Load(CArchive& ar, UINT* pwSchemaNum)
CRuntimeClass::Store(CArchive& ar)
CArchive::CArchive(CFile* pFile,
CArchive::~CArchive()
CArchive::Close()
CArchive::Read(void FAR* lpBuf, UINT nMax)
CArchive::Write(const void FAR* lpBuf, UINT nMax)
CArchive::Flush()
CArchive::FillBuffer(UINT nBytesNeeded)

arcobj
void CArchive::WriteObject(const CObject* pOb)
CObject* CArchive::ReadObject(const CRuntimeClass* pClassRefRequested)

array_d
CDWordArray::CDWordArray()
CDWordArray::~CDWordArray()
void CDWordArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CDWordArray::FreeExtra()
void CDWordArray::SetAtGrow(int nIndex, DWORD newElement)
void CDWordArray::InsertAt(int nIndex, DWORD newElement, int nCount /*=1*/)
void CDWordArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CDWordArray::InsertAt(int nStartIndex, CDWordArray* pNewArray)
void CDWordArray::Serialize(CArchive& ar)
void CDWordArray::Dump(CDumpContext& dc) const
void CDWordArray::AssertValid() const

array_p
CPtrArray::CPtrArray()
CPtrArray::~CPtrArray()
void CPtrArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CPtrArray::FreeExtra()
void CPtrArray::SetAtGrow(int nIndex, void* newElement)
void CPtrArray::InsertAt(int nIndex, void* newElement, int nCount /*=1*/)
void CPtrArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CPtrArray::InsertAt(int nStartIndex, CPtrArray* pNewArray)
void CPtrArray::Dump(CDumpContext& dc) const
void CPtrArray::AssertValid() const

array_u
CUIntArray::CUIntArray()
CUIntArray::~CUIntArray()
void CUIntArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CUIntArray::FreeExtra()
void CUIntArray::SetAtGrow(int nIndex, UINT newElement)
void CUIntArray::InsertAt(int nIndex, UINT newElement, int nCount /*=1*/)
void CUIntArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CUIntArray::InsertAt(int nStartIndex, CUIntArray* pNewArray)
void CUIntArray::Dump(CDumpContext& dc) const
void CUIntArray::AssertValid() const

auxdata
AUX_DATA::AUX_DATA()
AUX_DATA::~AUX_DATA()
void AUX_DATA::UpdateSysColors()


appcore
void CWinApp::AssertValid() const
void CWinApp::Dump(CDumpContext& dc) const
void CWinApp::SetCurrentHandles()
CWinApp::CWinApp(const char* pszAppName)
BOOL CWinApp::InitApplication()
BOOL CWinApp::InitInstance()
CWinApp::~CWinApp()
int CWinApp::ExitInstance()
BOOL CWinApp::PumpMessage()
int CWinApp::Run()
BOOL CWinApp::PreTranslateMessage(MSG* pMsg)
BOOL CWinApp::ProcessMessageFilter(int code, LPMSG lpMsg)
LRESULT CWinApp::ProcessWndProcException(CException* e, const MSG* pMsg)
BOOL CWinApp::OnIdle(LONG lCount)

appgray
void CWinApp::SetDialogBkColor(COLORREF clrCtlBk, COLORREF clrCtlText)

apphelpx
void CWinApp::OnHelp() // use context to derive help context
void CWinApp::OnHelpIndex()
void CWinApp::OnHelpUsing()
void CWinApp::OnContextHelp()
HWND CWinApp::SetHelpCapture(POINT ptCursor)
BOOL CWinApp::ProcessHelpMsg(MSG& msg, DWORD* pContext)

appui
void CWinApp::OnAppExit()
CDocument* CWinApp::OpenDocumentFile(LPCSTR lpszFileName)
int CWinApp::GetOpenDocumentCount()
void CWinApp::EnableShellOpen()
void CWinApp::RegisterShellFileTypes()
BOOL CWinApp::OnDDECommand(char* pszCommand)
void CWinApp::AddDocTemplate(CDocTemplate* pTemplate)
BOOL CWinApp::SaveAllModified()
void CWinApp::DoWaitCursor(int nCode)
int CWinApp::DoMessageBox(LPCSTR lpszPrompt, UINT nType, UINT nIDPrompt)
int CWnd::MessageBox(LPCSTR lpszText, LPCSTR lpszCaption /* = NULL */,
BOOL CWinApp::OnOpenRecentFile(UINT nID)
void CWinApp::AddToRecentFileList(const char* pszPathName)
void CWinApp::OnUpdateRecentFileMenu(CCmdUI* pCmdUI)
void CWinApp::SaveStdProfileSettings()
void CWinApp::LoadStdProfileSettings()
UINT CWinApp::GetProfileInt(LPCSTR lpszSection, LPCSTR lpszEntry, int nDefault)
BOOL CWinApp::WriteProfileInt(LPCSTR lpszSection, LPCSTR lpszEntry, int nValue)
CString CWinApp::GetProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
BOOL CWinApp::WriteProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,

arcex
CArchiveException::Dump(CDumpContext& dc) const

array_b
CByteArray::CByteArray()
CByteArray::~CByteArray()
void CByteArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CByteArray::FreeExtra()
void CByteArray::SetAtGrow(int nIndex, BYTE newElement)
void CByteArray::InsertAt(int nIndex, BYTE newElement, int nCount /*=1*/)
void CByteArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CByteArray::InsertAt(int nStartIndex, CByteArray* pNewArray)
void CByteArray::Serialize(CArchive& ar)
void CByteArray::Dump(CDumpContext& dc) const
void CByteArray::AssertValid() const

array_o
CObArray::CObArray()
CObArray::~CObArray()
void CObArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CObArray::FreeExtra()
void CObArray::SetAtGrow(int nIndex, CObject* newElement)
void CObArray::InsertAt(int nIndex, CObject* newElement, int nCount /*=1*/)
void CObArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CObArray::InsertAt(int nStartIndex, CObArray* pNewArray)
void CObArray::Serialize(CArchive& ar)
void CObArray::Dump(CDumpContext& dc) const
void CObArray::AssertValid() const

array_s
CStringArray::CStringArray()
CStringArray::~CStringArray()
void CStringArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CStringArray::FreeExtra()
void CStringArray::SetAtGrow(int nIndex, const char* newElement)
void CStringArray::InsertAt(int nIndex, const char* newElement, int nCount /*=1*/)
void CStringArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CStringArray::InsertAt(int nStartIndex, CStringArray* pNewArray)
void CStringArray::Serialize(CArchive& ar)
void CStringArray::Dump(CDumpContext& dc) const
void CStringArray::AssertValid() const

array_w
CWordArray::CWordArray()
CWordArray::~CWordArray()
void CWordArray::SetSize(int nNewSize, int nGrowBy /* = -1 */)
void CWordArray::FreeExtra()
void CWordArray::SetAtGrow(int nIndex, WORD newElement)
void CWordArray::InsertAt(int nIndex, WORD newElement, int nCount /*=1*/)
void CWordArray::RemoveAt(int nIndex, int nCount /* = 1 */)
void CWordArray::InsertAt(int nStartIndex, CWordArray* pNewArray)
void CWordArray::Serialize(CArchive& ar)
void CWordArray::Dump(CDumpContext& dc) const
void CWordArray::AssertValid() const

bardlg
CDialogBar::CDialogBar()
CDialogBar::~CDialogBar()
BOOL CDialogBar::Create(CWnd* pParentWnd, LPCSTR lpszTemplateName,
WNDPROC* CDialogBar::GetSuperWndProcAddr()
void CDialogBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
void CDialogBar::AssertValid() const
void CDialogBar::Dump(CDumpContext& dc) const

bartool
void CToolBar::CreateMask(int iImage, CPoint ptOffset,
BOOL CToolBar::DrawButton(HDC hDC, int x, int y, int iImage, UINT nStyle)
BOOL CToolBar::PrepareDrawButton(DrawState& ds)
void CToolBar::EndDrawButton(DrawState& ds)
inline AFX_TBBUTTON* CToolBar::_GetButtonPtr(int nIndex) const
CToolBar::CToolBar()
CToolBar::~CToolBar()
BOOL CToolBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
void CToolBar::SetSizes(SIZE sizeButton, SIZE sizeImage)
BOOL CToolBar::LoadBitmap(LPCSTR lpszResourceName)
BOOL CToolBar::SetButtons(const UINT FAR* lpIDArray, int nIDCount)
int CToolBar::CommandToIndex(UINT nIDFind) const
UINT CToolBar::GetItemID(int nIndex) const
void CToolBar::GetItemRect(int nIndex, LPRECT lpRect) const
inline UINT CToolBar::_GetButtonStyle(int nIndex) const
void CToolBar::_SetButtonStyle(int nIndex, UINT nStyle)
void CToolBar::GetButtonInfo(int nIndex, UINT& nID, UINT& nStyle, int& iImage) const
void CToolBar::SetButtonInfo(int nIndex, UINT nID, UINT nStyle, int iImage)
void CToolBar::DoPaint(CDC* pDC)
void CToolBar::InvalidateButton(int nIndex)
int CToolBar::HitTest(CPoint point) // in window relative coords
void CToolBar::OnLButtonDown(UINT, CPoint point)
LRESULT CToolBar::OnHelpHitTest(WPARAM wParam, LPARAM lParam)
void CToolBar::OnMouseMove(UINT, CPoint point)
void CToolBar::OnLButtonUp(UINT, CPoint point)
void CToolBar::OnCancelMode()
void CToolBar::OnSysColorChange()
void CToolCmdUI::Enable(BOOL bOn)
void CToolCmdUI::SetCheck(int nCheck)
void CToolCmdUI::SetText(LPCSTR)
void CToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
void CToolBar::AssertValid() const
void CToolBar::Dump(CDumpContext& dc) const

cmdtarg
BOOL CCmdTarget::OnCmdMsg(UINT nID, int nCode, void* pExtra,
void CCmdTarget::BeginWaitCursor()
void CCmdTarget::EndWaitCursor()
void CCmdTarget::RestoreWaitCursor()
AFX_MSGMAP AFXAPI_DATA CCmdTarget::messageMap =
AFX_MSGMAP* CCmdTarget::GetMessageMap() const
AFX_MSGMAP_ENTRY BASED_CODE CCmdTarget::_messageEntries[] =
CView* CCmdTarget::pRoutingView = NULL;
CView* CCmdTarget::GetRoutingView()
CCmdUI::CCmdUI()
void CCmdUI::Enable(BOOL bOn)
void CCmdUI::SetCheck(int nCheck)
void CCmdUI::SetRadio(BOOL bOn)
void CCmdUI::SetText(LPCSTR lpszText)
void CCmdUI::DoUpdate(CCmdTarget* pTarget, BOOL bDisableIfNoHndler)

dcmeta
CMetaFileDC::CMetaFileDC()
BOOL CMetaFileDC::Create(LPCSTR lpszFilename)
HMETAFILE CMetaFileDC::Close()
void CMetaFileDC::SetOutputDC(HDC)
void CMetaFileDC::SetAttribDC(HDC hDC) // Set the Attribute DC
CMetaFileDC::~CMetaFileDC()
void CMetaFileDC::AssertValid() const
void CMetaFileDC::Dump(CDumpContext& dc) const
int CMetaFileDC::GetClipBox(LPRECT lpRect) const
BOOL CMetaFileDC::PtVisible(int x, int y) const
BOOL CMetaFileDC::RectVisible(LPRECT lpRect) const
BOOL CMetaFileDC::TextOut(int x, int y, LPCSTR lpszString, int nCount)
BOOL CMetaFileDC::ExtTextOut(int x, int y, UINT nOptions, LPRECT lpRect,
CSize CMetaFileDC::TabbedTextOut(int, int, LPCSTR, int, int, LPINT, int)
int CMetaFileDC::DrawText(LPCSTR lpszString, int nCount, LPRECT lpRect,
int CMetaFileDC::Escape(int nEscape, int nCount, LPCSTR lpszInData, LPVOID

dcprev
CPreviewDC::CPreviewDC()
void CPreviewDC::SetOutputDC(HDC hDC)
void CPreviewDC::ReleaseOutputDC()
void CPreviewDC::SetAttribDC(HDC hDC)
CPreviewDC::~CPreviewDC()
void CPreviewDC::SetScaleRatio(int nNumerator, int nDenominator)
void CPreviewDC::Dump(CDumpContext& dc) const
int CPreviewDC::SaveDC()
BOOL CPreviewDC::RestoreDC(int nSavedDC)
void CPreviewDC::MirrorAttributes()
CGdiObject* CPreviewDC::SelectStockObject(int nIndex)
void CPreviewDC::MirrorFont()
CFont* CPreviewDC::SelectObject(CFont* pFont)
COLORREF CPreviewDC::SetBkColor(COLORREF crColor)
COLORREF CPreviewDC::SetTextColor(COLORREF crColor)
int CPreviewDC::SetMapMode(int nMapMode)
CPoint CPreviewDC::SetViewportOrg(int x, int y)
CPoint CPreviewDC::OffsetViewportOrg(int nWidth, int nHeight)
CSize CPreviewDC::SetViewportExt(int x, int y)
CSize CPreviewDC::ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom)
CSize CPreviewDC::SetWindowExt(int x, int y)
CSize CPreviewDC::ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom)
CSize CPreviewDC::ComputeDeltas(int& x, LPCSTR lpszString, UINT &nCount,
BOOL CPreviewDC::TextOut(int x, int y, LPCSTR lpszString, int nCount)
BOOL CPreviewDC::ExtTextOut(int x, int y, UINT nOptions, LPRECT lpRect,
CSize CPreviewDC::TabbedTextOut(int x, int y, LPCSTR lpszString, int nCount,
int CPreviewDC::DrawText(LPCSTR lpszString, int nCount, LPRECT lpRect,
BOOL CPreviewDC::GrayString(CBrush*,
int CPreviewDC::Escape(int nEscape, int nCount, LPCSTR lpszInData, void FAR*
void CPreviewDC::MirrorMappingMode(BOOL bCompute)
void CPreviewDC::MirrorViewportOrg()
void CPreviewDC::SetTopLeftOffset(CSize sizeTopLeft)
void CPreviewDC::ClipToPage()
void CPreviewDC::PrinterDPtoScreenDP(LPPOINT lpPoint) const

dlgclr
COLORREF AFXAPI_DATA CColorDialog::clrSavedCustom[16] = { RGB(255, 255, 255),
CColorDialog::CColorDialog(COLORREF clrInit /* = 0 */,
int CColorDialog::DoModal()
BOOL CColorDialog::OnColorOK()
void CColorDialog::SetCurrentColor(COLORREF clr)
void CColorDialog::OnOK()
void CColorDialog::OnCancel()
HBRUSH CColorDialog::OnCtlColor(CDC*, CWnd*, UINT)
void CColorDialog::Dump(CDumpContext& dc) const

dlgcore
CDialog::PreTranslateMessage(MSG* pMsg)
CDialog::GetSuperWndProcAddr()
BOOL CDialog::OnCmdMsg(UINT nID, int nCode, void* pExtra,
CDialog::CDialog()
CDialog::~CDialog()
BOOL CDialog::Create(LPCSTR lpszTemplateName, CWnd* pParentWnd)
BOOL CDialog::CreateIndirect(const void FAR* lpDialogTemplate, CWnd* pParentWnd)
CDialog::CDialog(LPCSTR lpszTemplateName, CWnd* pParentWnd)
CDialog::CDialog(UINT nIDTemplate, CWnd* pParentWnd)
BOOL CDialog::InitModalIndirect(HGLOBAL hDialogTemplate)
int CDialog::DoModal()
void CDialog::OnSetFont(CFont*)
BOOL CDialog::OnInitDialog()
void CDialog::OnOK()
void CDialog::OnCancel()
HBRUSH CDialog::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
BOOL PASCAL CWnd::GrayCtlColor(HDC hDC, HWND hWnd, UINT nCtlColor,
void CWnd::CenterWindow(CWnd* pAlternateOwner /*= NULL*/)
LRESULT CDialog::OnCommandHelp(WPARAM, LPARAM lParam)
LRESULT CDialog::OnHelpHitTest(WPARAM, LPARAM)
CDialog::AssertValid() const
CDialog::Dump(CDumpContext& dc) const

dlgdata
HWND CDataExchange::PrepareEditCtrl(int nIDC)
HWND CDataExchange::PrepareCtrl(int nIDC)
void CDataExchange::Fail()

dlgfile
CFileDialog::CFileDialog(BOOL bOpenFileDialog,
int CFileDialog::DoModal()
CString CFileDialog::GetFileName() const
UINT CFileDialog::OnShareViolation(LPCSTR)
BOOL CFileDialog::OnFileNameOK()
void CFileDialog::OnLBSelChangedNotify(UINT, UINT, UINT)
void CFileDialog::OnOK()
void CFileDialog::OnCancel()
void CFileDialog::Dump(CDumpContext& dc) const

dlgfnt
CFontDialog::CFontDialog(LPLOGFONT lplfInitial /* = NULL */,
BOOL CFontDialog::DoModal()
void CFontDialog::OnOK()
void CFontDialog::OnCancel()
void CFontDialog::Dump(CDumpContext& dc) const

dlgfr
CFindReplaceDialog::CFindReplaceDialog()
void CFindReplaceDialog::PostNcDestroy()
BOOL CFindReplaceDialog::Create(BOOL bFindDialogOnly,
void CFindReplaceDialog::OnOK()
void CFindReplaceDialog::OnCancel()
CFindReplaceDialog* PASCAL CFindReplaceDialog::GetNotifier(LPARAM lParam)
void CFindReplaceDialog::Dump(CDumpContext& dc) const

dlgprnt
CPrintDialog::CPrintDialog(BOOL bPrintSetupOnly,
CPrintDialog::CPrintDialog(PRINTDLG FAR& pdInit)
CPrintDialog::CPrintDialog(PRINTDLG& pdInit)
CPrintDialog* CPrintDialog::AttachOnSetup()
void CPrintDialog::OnPrintSetup()
int CPrintDialog::DoModal()
HDC CPrintDialog::CreatePrinterDC()
HDC CPrintDialog::GetPrinterDC() const
int CPrintDialog::GetCopies() const
void CPrintDialog::OnOK()
void CPrintDialog::OnCancel()
void CPrintDialog::Dump(CDumpContext& dc) const

dllinit
CDynLinkLibrary::CDynLinkLibrary(AFX_EXTENSION_MODULE& state)
CDynLinkLibrary::~CDynLinkLibrary()
void CDynLinkLibrary::AssertValid() const
void CDynLinkLibrary::Dump(CDumpContext& dc) const
void CWinApp::_ForceLinkage()
void* CObject::operator new(size_t nSize)
void* CObject::operator new(size_t nSize, LPCSTR pFileName, int nLine)
void CObject::operator delete(void* pbData)

doccore
CDocument::CDocument()
CDocument::~CDocument()
void CDocument::SetTitle(const char* pszTitle)
void CDocument::DeleteContents()
void CDocument::OnChangedViewList()
void CDocument::UpdateFrameCounts()
BOOL CDocument::CanCloseFrame(CFrameWnd* pFrameArg)
void CDocument::SetPathName(const char* pszPathName)
void CDocument::OnFileClose()
void CDocument::OnFileSave()
void CDocument::OnFileSaveAs()
BOOL CDocument::DoSave(const char* pszPathName, BOOL bReplace /*=TRUE*/)
BOOL CDocument::SaveModified()
void CDocument::ReportSaveLoadException(const char* pszPathName, CException* e,
BOOL CDocument::OnNewDocument()
BOOL CDocument::OnOpenDocument(const char* pszPathName)
BOOL CDocument::OnSaveDocument(const char* pszPathName)
void CDocument::OnCloseDocument()
void CDocument::AddView(CView* pView)
void CDocument::RemoveView(CView* pView)
POSITION CDocument::GetFirstViewPosition() const
CView* CDocument::GetNextView(POSITION& rPosition) const
void CDocument::UpdateAllViews(CView* pSender, LPARAM lHint, CObject* pHint)
BOOL CDocument::OnCmdMsg(UINT nID, int nCode, void* pExtra,
void CDocument::Dump(CDumpContext& dc) const
void CDocument::AssertValid() const

docmulti
CMultiDocTemplate::CMultiDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
CMultiDocTemplate::~CMultiDocTemplate()
CDocument* CMultiDocTemplate::GetNextDoc(POSITION& rPos) const
void CMultiDocTemplate::AddDocument(CDocument* pDoc)
void CMultiDocTemplate::RemoveDocument(CDocument* pDoc)
CDocument* CMultiDocTemplate::OpenDocumentFile(const char* pszPathName)
void CMultiDocTemplate::Dump(CDumpContext& dc) const
void CMultiDocTemplate::AssertValid() const

docsingl
CSingleDocTemplate::CSingleDocTemplate(UINT nIDResource,
CSingleDocTemplate::~CSingleDocTemplate()
POSITION CSingleDocTemplate::GetFirstDocPosition() const
CDocument* CSingleDocTemplate::GetNextDoc(POSITION& rPos) const
void CSingleDocTemplate::AddDocument(CDocument* pDoc)
void CSingleDocTemplate::RemoveDocument(CDocument* pDoc)
CDocument* CSingleDocTemplate::OpenDocumentFile(const char* pszPathName)
void CSingleDocTemplate::Dump(CDumpContext& dc) const
void CSingleDocTemplate::AssertValid() const

doctempl
CDocTemplate::CDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
CDocTemplate::~CDocTemplate()
BOOL CDocTemplate::GetDocString(CString& rString, enum DocStringIndex i) const
void CDocTemplate::AddDocument(CDocument* pDoc)
void CDocTemplate::RemoveDocument(CDocument* pDoc)
CDocTemplate::Confidence CDocTemplate::MatchDocType(const char* pszPathName,
CDocument* CDocTemplate::CreateNewDocument()
CFrameWnd* CDocTemplate::CreateNewFrame(CDocument* pDoc, CFrameWnd* pOther)
void CDocTemplate::InitialUpdateFrame(CFrameWnd* pFrame, CDocument* pDoc)
BOOL CDocTemplate::SaveAllModified()
void CDocTemplate::Dump(CDumpContext& dc) const
void CDocTemplate::AssertValid() const

dumpcont
CDumpContext::OutputString(LPCSTR lpsz)
CDumpContext::CDumpContext(CFile* pFile)
void CDumpContext::Flush()
CDumpContext::operator<<(LPCSTR lpsz)
CDumpContext::operator<<(BYTE by)
CDumpContext::operator<<(WORD w)
CDumpContext::operator<<(UINT u)
CDumpContext::operator<<(LONG l)
CDumpContext::operator<<(DWORD dw)
CDumpContext::operator<<(int n)
CDumpContext::operator<<(const CObject* pOb)
CDumpContext::operator<<(const CObject& ob)
CDumpContext::operator<<(const void NEAR* np)
CDumpContext::operator<<(const void FAR* lp)
void CDumpContext::HexDump(const char* pszLine, BYTE* pby,

dumpflt
CDumpContext::operator<<(float f)
CDumpContext::operator<<(double d)

except
void AFX_EXCEPTION_CONTEXT::Throw(CException* pNewException)
void AFX_EXCEPTION_CONTEXT::ThrowLast()
void AFX_EXCEPTION_CONTEXT::Throw(CException* pNewException, BOOL bShared)
void AFX_EXCEPTION_CONTEXT::Cleanup()
AFX_EXCEPTION_LINK::AFX_EXCEPTION_LINK()
AFX_EXCEPTION_LINK::~AFX_EXCEPTION_LINK()

filecore
CFile::CFile()
CFile::CFile(int hFile)
CFile::CFile(const char* pszFileName, UINT nOpenFlags)
CFile::~CFile()
CFile::Duplicate() const
CFile::Open(const char* pszFileName, UINT nOpenFlags,
CFile::Read(void FAR* lpBuf, UINT nCount)
CFile::Write(const void FAR* lpBuf, UINT nCount)
CFile::Seek(LONG lOff, UINT nFrom)
CFile::GetPosition() const
CFile::Flush()
CFile::Close()
CFile::Abort()
CFile::LockRange(DWORD dwPos, DWORD dwCount)
CFile::UnlockRange(DWORD dwPos, DWORD dwCount)
CFile::SetLength(DWORD dwNewLen)
CFile::GetLength() const
CFile::Rename(const char* pszOldName, const char* pszNewName)
CFile::Remove(const char* pszFileName)
CFile::AssertValid() const
CFile::Dump(CDumpContext& dc) const

filemem
CMemFile::CMemFile(UINT nGrowBytes /* = 1024 */)
CMemFile::~CMemFile()
BYTE FAR* CMemFile::Alloc(UINT nBytes)
BYTE FAR* CMemFile::Realloc(BYTE FAR* lpMem, UINT nBytes)
BYTE FAR* CMemFile::Memcpy(BYTE FAR* lpMemTarget, const BYTE FAR*
void CMemFile::Free(BYTE FAR* lpMem)
DWORD CMemFile::GetPosition() const
void CMemFile::GrowFile(DWORD dwNewLen)
void CMemFile::SetLength(DWORD dwNewLen)
UINT CMemFile::Read(void FAR* lpBuf, UINT nCount)
void CMemFile::Write(const void FAR* lpBuf, UINT nCount)
LONG CMemFile::Seek(LONG lOff, UINT nFrom)
void CMemFile::Flush()
void CMemFile::Close()
void CMemFile::Abort()
void CMemFile::LockRange(DWORD /* dwPos */, DWORD /* dwCount */)
void CMemFile::UnlockRange(DWORD /* dwPos */, DWORD /* dwCount */)
CFile* CMemFile::Duplicate() const
void CMemFile::Dump(CDumpContext& dc) const
void CMemFile::AssertValid() const

filest
CFileStatus::Dump(CDumpContext& dc) const
CFile::GetStatus(CFileStatus& rStatus) const
CFile::GetStatus(const char* pszFileName, CFileStatus& rStatus)
CFile::SetStatus(const char* pszFileName, const CFileStatus& status)
CMemFile::GetStatus(CFileStatus& rStatus) const

filetxt
CStdioFile::CStdioFile()
CStdioFile::CStdioFile(FILE* pOpenStream) : CFile(hFileNull)
CStdioFile::CStdioFile(const char* pszFileName, UINT nOpenFlags)
CStdioFile::~CStdioFile()
CStdioFile::Open(const char* pszFileName, UINT nOpenFlags, CFileException* pException)
CStdioFile::Read(void FAR* lpBuf, UINT nCount)
CStdioFile::Write(const void FAR* lpBuf, UINT nCount)
CStdioFile::WriteString(LPCSTR lpsz)
LPSTR CStdioFile::ReadString(LPSTR lpsz, UINT nMax)
CStdioFile::Seek(LONG lOff, UINT nFrom)
CStdioFile::GetPosition() const
CStdioFile::Flush()
CStdioFile::Close()
CStdioFile::Abort()
CStdioFile::Duplicate() const
CStdioFile::LockRange(DWORD /* dwPos */, DWORD /* dwCount */)
CStdioFile::UnlockRange(DWORD /* dwPos */, DWORD /* dwCount */)
CStdioFile::Dump(CDumpContext& dc) const

filex
CFile::ReadHuge(void FAR* lpBuffer, DWORD dwCount)
CFile::WriteHuge(const void FAR* lpBuffer, DWORD dwCount)
CFileException::ThrowOsError(LONG lOsError)
CFileException::ThrowErrno(int nErrno)
CFileException::Dump(CDumpContext& dc) const
CFileException::ErrnoToException(int nErrno)
int PASCAL CFileException::OsErrorToException(LONG lOsErr)

list_o
CObList::CObList(int nBlockSize)
void CObList::RemoveAll()
CObList::~CObList()
CObList::CNode*
CObList::NewNode(CObList::CNode* pPrev, CObList::CNode* pNext)
void CObList::FreeNode(CObList::CNode* pNode)
POSITION CObList::AddHead(CObject* newElement)
POSITION CObList::AddTail(CObject* newElement)
void CObList::AddHead(CObList* pNewList)
void CObList::AddTail(CObList* pNewList)
CObject* CObList::RemoveHead()
CObject* CObList::RemoveTail()
POSITION CObList::InsertBefore(POSITION position, CObject* newElement)
POSITION CObList::InsertAfter(POSITION position, CObject* newElement)
void CObList::RemoveAt(POSITION position)
POSITION CObList::FindIndex(int nIndex) const
POSITION CObList::Find(CObject* searchValue, POSITION startAfter) const
void CObList::Serialize(CArchive& ar)
void CObList::Dump(CDumpContext& dc) const
void CObList::AssertValid() const

list_p
CPtrList::CPtrList(int nBlockSize)
void CPtrList::RemoveAll()
CPtrList::~CPtrList()
CPtrList::CNode*
CPtrList::NewNode(CPtrList::CNode* pPrev, CPtrList::CNode* pNext)
void CPtrList::FreeNode(CPtrList::CNode* pNode)
POSITION CPtrList::AddHead(void* newElement)
POSITION CPtrList::AddTail(void* newElement)
void CPtrList::AddHead(CPtrList* pNewList)
void CPtrList::AddTail(CPtrList* pNewList)
void* CPtrList::RemoveHead()
void* CPtrList::RemoveTail()
POSITION CPtrList::InsertBefore(POSITION position, void* newElement)
POSITION CPtrList::InsertAfter(POSITION position, void* newElement)
void CPtrList::RemoveAt(POSITION position)
POSITION CPtrList::FindIndex(int nIndex) const
POSITION CPtrList::Find(void* searchValue, POSITION startAfter) const
void CPtrList::Dump(CDumpContext& dc) const
void CPtrList::AssertValid() const

list_s
CStringList::CStringList(int nBlockSize)
void CStringList::RemoveAll()
CStringList::~CStringList()
CStringList::CNode*
CStringList::NewNode(CStringList::CNode* pPrev, CStringList::CNode* pNext)
void CStringList::FreeNode(CStringList::CNode* pNode)
POSITION CStringList::AddHead(const char* newElement)
POSITION CStringList::AddTail(const char* newElement)
void CStringList::AddHead(CStringList* pNewList)
void CStringList::AddTail(CStringList* pNewList)
CString CStringList::RemoveHead()
CString CStringList::RemoveTail()
POSITION CStringList::InsertBefore(POSITION position, const char* newElement)
POSITION CStringList::InsertAfter(POSITION position, const char* newElement)
void CStringList::RemoveAt(POSITION position)
POSITION CStringList::FindIndex(int nIndex) const
POSITION CStringList::Find(const char* searchValue, POSITION startAfter) const
void CStringList::Serialize(CArchive& ar)
void CStringList::Dump(CDumpContext& dc) const
void CStringList::AssertValid() const

map_pp
CMapPtrToPtr::CMapPtrToPtr(int nBlockSize)
inline UINT CMapPtrToPtr::HashKey(void* key) const
void CMapPtrToPtr::InitHashTable(UINT nHashSize)
void CMapPtrToPtr::RemoveAll()
CMapPtrToPtr::~CMapPtrToPtr()
CMapPtrToPtr::CAssoc* CMapPtrToPtr::NewAssoc()
void CMapPtrToPtr::FreeAssoc(CMapPtrToPtr::CAssoc* pAssoc)
CMapPtrToPtr::GetAssocAt(void* key, UINT& nHash) const
BOOL CMapPtrToPtr::Lookup(void* key, void*& rValue) const
void*& CMapPtrToPtr::operator[](void* key)
BOOL CMapPtrToPtr::RemoveKey(void* key)
void CMapPtrToPtr::GetNextAssoc(POSITION& rNextPosition,
void CMapPtrToPtr::Dump(CDumpContext& dc) const
void CMapPtrToPtr::AssertValid() const

map_pw
CMapPtrToWord::CMapPtrToWord(int nBlockSize)
inline UINT CMapPtrToWord::HashKey(void* key) const
void CMapPtrToWord::InitHashTable(UINT nHashSize)
void CMapPtrToWord::RemoveAll()
CMapPtrToWord::~CMapPtrToWord()
CMapPtrToWord::CAssoc* CMapPtrToWord::NewAssoc()
void CMapPtrToWord::FreeAssoc(CMapPtrToWord::CAssoc* pAssoc)
CMapPtrToWord::GetAssocAt(void* key, UINT& nHash) const
BOOL CMapPtrToWord::Lookup(void* key, WORD& rValue) const
WORD& CMapPtrToWord::operator[](void* key)
BOOL CMapPtrToWord::RemoveKey(void* key)
void CMapPtrToWord::GetNextAssoc(POSITION& rNextPosition,
void CMapPtrToWord::Dump(CDumpContext& dc) const
void CMapPtrToWord::AssertValid() const

map_so
CMapStringToOb::CMapStringToOb(int nBlockSize)
inline UINT CMapStringToOb::HashKey(const char* key) const
void CMapStringToOb::InitHashTable(UINT nHashSize)
void CMapStringToOb::RemoveAll()
CMapStringToOb::~CMapStringToOb()
CMapStringToOb::CAssoc* CMapStringToOb::NewAssoc()
void CMapStringToOb::FreeAssoc(CMapStringToOb::CAssoc* pAssoc)
CMapStringToOb::GetAssocAt(const char* key, UINT& nHash) const
BOOL CMapStringToOb::Lookup(const char* key, CObject*& rValue) const
CObject*& CMapStringToOb::operator[](const char* key)
BOOL CMapStringToOb::RemoveKey(const char* key)
void CMapStringToOb::GetNextAssoc(POSITION& rNextPosition,
void CMapStringToOb::Serialize(CArchive& ar)
void CMapStringToOb::Dump(CDumpContext& dc) const
void CMapStringToOb::AssertValid() const

map_sp
CMapStringToPtr::CMapStringToPtr(int nBlockSize)
inline UINT CMapStringToPtr::HashKey(const char* key) const
void CMapStringToPtr::InitHashTable(UINT nHashSize)
void CMapStringToPtr::RemoveAll()
CMapStringToPtr::~CMapStringToPtr()
CMapStringToPtr::CAssoc* CMapStringToPtr::NewAssoc()
void CMapStringToPtr::FreeAssoc(CMapStringToPtr::CAssoc* pAssoc)
CMapStringToPtr::GetAssocAt(const char* key, UINT& nHash) const
BOOL CMapStringToPtr::Lookup(const char* key, void*& rValue) const
void*& CMapStringToPtr::operator[](const char* key)
BOOL CMapStringToPtr::RemoveKey(const char* key)
void CMapStringToPtr::GetNextAssoc(POSITION& rNextPosition,
void CMapStringToPtr::Dump(CDumpContext& dc) const
void CMapStringToPtr::AssertValid() const

map_ss
CMapStringToString::CMapStringToString(int nBlockSize)
inline UINT CMapStringToString::HashKey(const char* key) const
void CMapStringToString::InitHashTable(UINT nHashSize)
void CMapStringToString::RemoveAll()
CMapStringToString::~CMapStringToString()
CMapStringToString::CAssoc* CMapStringToString::NewAssoc()
void CMapStringToString::FreeAssoc(CMapStringToString::CAssoc* pAssoc)
CMapStringToString::GetAssocAt(const char* key, UINT& nHash) const
BOOL CMapStringToString::Lookup(const char* key, CString& rValue) const
CString& CMapStringToString::operator[](const char* key)
BOOL CMapStringToString::RemoveKey(const char* key)
void CMapStringToString::GetNextAssoc(POSITION& rNextPosition,
void CMapStringToString::Serialize(CArchive& ar)
void CMapStringToString::Dump(CDumpContext& dc) const
void CMapStringToString::AssertValid() const

map_wo
CMapWordToOb::CMapWordToOb(int nBlockSize)
inline UINT CMapWordToOb::HashKey(WORD key) const
void CMapWordToOb::InitHashTable(UINT nHashSize)
void CMapWordToOb::RemoveAll()
CMapWordToOb::~CMapWordToOb()
CMapWordToOb::CAssoc* CMapWordToOb::NewAssoc()
void CMapWordToOb::FreeAssoc(CMapWordToOb::CAssoc* pAssoc)
CMapWordToOb::CAssoc*
CMapWordToOb::GetAssocAt(WORD key, UINT& nHash) const
BOOL CMapWordToOb::Lookup(WORD key, CObject*& rValue) const
CObject*& CMapWordToOb::operator[](WORD key)
BOOL CMapWordToOb::RemoveKey(WORD key)
void CMapWordToOb::GetNextAssoc(POSITION& rNextPosition,
void CMapWordToOb::Serialize(CArchive& ar)
void CMapWordToOb::Dump(CDumpContext& dc) const
void CMapWordToOb::AssertValid() const

map_wp
CMapWordToPtr::CMapWordToPtr(int nBlockSize)
inline UINT CMapWordToPtr::HashKey(WORD key) const
void CMapWordToPtr::InitHashTable(UINT nHashSize)
void CMapWordToPtr::RemoveAll()
CMapWordToPtr::~CMapWordToPtr()
CMapWordToPtr::CAssoc* CMapWordToPtr::NewAssoc()
void CMapWordToPtr::FreeAssoc(CMapWordToPtr::CAssoc* pAssoc)
CMapWordToPtr::GetAssocAt(WORD key, UINT& nHash) const
BOOL CMapWordToPtr::Lookup(WORD key, void*& rValue) const
void*& CMapWordToPtr::operator[](WORD key)
BOOL CMapWordToPtr::RemoveKey(WORD key)
void CMapWordToPtr::GetNextAssoc(POSITION& rNextPosition,
void CMapWordToPtr::Dump(CDumpContext& dc) const
void CMapWordToPtr::AssertValid() const

objcore
CRuntimeClass* CObject::GetRuntimeClass() const
BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
void CObject::AssertValid() const
CObject::Dump(CDumpContext& dc) const
CObject* CRuntimeClass::CreateObject()
BOOL CRuntimeClass::ConstructObject(void* pThis)
CObject::IsSerializable() const
AFX_CLASSINIT::AFX_CLASSINIT(register CRuntimeClass* pNewClass)

olecli
COleClientItem::FromLp(LPOLECLIENT lpClient)
int OLEEXPORT _afxOleCliImpl::Client_CallBack(LPOLECLIENT lpClient,
COleClientItem::COleClientItem(COleClientDoc* pContainerDoc)
COleClientItem::~COleClientItem()
void COleClientItem::Release()
void COleClientItem::Delete()
BOOL COleClientItem::CheckCreate(OLESTATUS status)
void COleClientItem::CheckAsync(OLESTATUS status)
void COleClientItem::CheckGeneral(OLESTATUS status)
BOOL PASCAL COleClientItem::CanPaste(OLEOPT_RENDER renderopt,
BOOL PASCAL COleClientItem::CanPasteLink(OLEOPT_RENDER renderopt,
BOOL COleClientItem::CreateFromClipboard(LPCSTR lpszItemName,
BOOL COleClientItem::CreateStaticFromClipboard(LPCSTR lpszItemName,
BOOL COleClientItem::CreateLinkFromClipboard(LPCSTR lpszItemName,
BOOL COleClientItem::CreateNewObject(LPCSTR lpszTypeName, LPCSTR lpszItemName,
BOOL COleClientItem::CreateInvisibleObject(LPCSTR lpszTypeName,
BOOL COleClientItem::CreateCloneFrom(COleClientItem* pSrcItem,
int COleClientItem::ClientCallBack(OLE_NOTIFICATION wNotification)
void COleClientItem::OnRenamed()
void COleClientItem::OnRelease()
UINT COleClientItem::GetType()
CString COleClientItem::GetName()
DWORD COleClientItem::GetSize()
BOOL COleClientItem::GetBounds(LPRECT lpBounds)
BOOL COleClientItem::IsOpen()
HANDLE COleClientItem::GetData(OLECLIPFORMAT nFormat, BOOL& bMustDelete)
void COleClientItem::SetData(OLECLIPFORMAT nFormat, HANDLE hData)
void COleClientItem::RequestData(OLECLIPFORMAT nFormat)
BOOL COleClientItem::IsEqual(COleClientItem* pOtherItem)
HGLOBAL COleClientItem::GetLinkFormatData()
OLEOPT_UPDATE COleClientItem::GetLinkUpdateOptions()
void COleClientItem::SetLinkUpdateOptions(OLEOPT_UPDATE updateOpt)
BOOL COleClientItem::Draw(CDC* pDC, LPCRECT lpBounds, LPCRECT lpWBounds,
void COleClientItem::Activate(UINT nVerb, BOOL bShow, BOOL bTakeFocus,
void COleClientItem::Rename(LPCSTR lpszNewname)
void COleClientItem::CopyToClipboard()
void COleClientItem::SetTargetDevice(HGLOBAL hData)
void COleClientItem::SetHostNames(LPCSTR lpszHost, LPCSTR lpszHostObj)
void COleClientItem::SetBounds(LPCRECT lpRect)
void COleClientItem::SetColorScheme(const LOGPALETTE FAR* lpLogPalette)
void COleClientItem::UpdateLink()
void COleClientItem::CloseLink()
void COleClientItem::ReconnectLink()
BOOL COleClientItem::FreezeLink(LPCSTR lpszFrozenName)
_afxOleStreamImpl::Get(LPOLESTREAM lpStream,
_afxOleStreamImpl::Put(LPOLESTREAM lpStream,
_COleStream::_COleStream(CArchive& ar)
void COleClientItem::Serialize(CArchive& ar)
COleClientDoc::COleClientDoc()
void COleClientDoc::Revoke()
COleClientDoc::~COleClientDoc()
void COleClientDoc::CheckGeneral(OLESTATUS status) const
BOOL COleClientDoc::RegisterClientDoc(LPCSTR lpszTypeName, LPCSTR lpszDoc)
void COleClientDoc::NotifyRename(LPCSTR lpszNewName)
void COleClientDoc::NotifyRevert()
void COleClientDoc::NotifySaved()
BOOL COleClientDoc::OnNewDocument()
BOOL COleClientDoc::OnOpenDocument(const char* pszPathName)
BOOL COleClientDoc::OnSaveDocument(const char* pszPathName)
void COleClientDoc::OnCloseDocument()
BOOL COleClientDoc::CanCloseFrame(CFrameWnd* pFrame)
void COleClientItem::AssertValid() const
void COleClientItem::Dump(CDumpContext& dc) const
void COleClientDoc::AssertValid() const
void COleClientDoc::Dump(CDumpContext& dc) const

oledoc
COleDocument::COleDocument()
COleDocument::~COleDocument()
void COleDocument::AddItem(CDocItem* pItem)
void COleDocument::RemoveItem(CDocItem* pItem)
POSITION COleDocument::GetStartPosition() const
CDocItem* COleDocument::GetNextItem(POSITION& rPosition)
void COleDocument::DeleteContents()
void COleDocument::AssertValid() const
void COleDocument::Dump(CDumpContext& dc) const
CDocItem::CDocItem()
CDocItem::~CDocItem()
void CDocItem::AssertValid() const
void CDocItem::Dump(CDumpContext& dc) const

olefile
CSharedFile::CSharedFile(UINT nAllocFlags, UINT nGrowBytes /* = 1024 */)
CSharedFile::~CSharedFile()
CSharedFile::SetHandle(HGLOBAL hGlobalMemory)
CSharedFile::Alloc(UINT nBytes)
CSharedFile::Realloc(BYTE FAR*, UINT nBytes)
CSharedFile::Free(BYTE FAR*)
CSharedFile::Detach()

olemisc
COleException::COleException(OLESTATUS status)
OLESTATUS PASCAL COleException::Process(CException* pAnyException)

olesvr
inline COleServerItem* PASCAL COleServerItem::FromLp(LPOLEOBJECT lpObject)
LPVOID OLEEXPORT _afxOleSvrItemImpl::QueryProtocol(LPOLEOBJECT lpObject,
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::Release(LPOLEOBJECT lpObject)
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::Show(LPOLEOBJECT lpObject,
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::DoVerb(LPOLEOBJECT lpObject,
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::GetData(LPOLEOBJECT lpObject,
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::SetData(LPOLEOBJECT lpObject,
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::SetTargetDevice(LPOLEOBJECT
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::SetBounds(LPOLEOBJECT lpObject,
OLECLIPFORMAT OLEEXPORT _afxOleSvrItemImpl::EnumFormats(LPOLEOBJECT
OLESTATUS OLEEXPORT _afxOleSvrItemImpl::SetColorScheme(LPOLEOBJECT
COleServerItem::COleServerItem(COleServerDoc* pContainerDoc)
COleServerItem::~COleServerItem()
void COleServerItem::BeginRevoke() // Start revoking the client connection
void COleServerItem::Revoke() // revoke - wait if necessary
int COleServerItem::NotifyClient(OLE_NOTIFICATION wNotify)
OLESTATUS COleServerItem::OnRelease()
COleServerItem::OnSetTargetDevice(LPOLETARGETDEVICE /*lpTargetDevice*/)
BOOL COleServerItem::OnGetTextData(CString& /*rStringReturn*/) const
OLESTATUS COleServerItem::OnExtraVerb(UINT /*nVerb*/)
LPVOID COleServerItem::OnQueryProtocol(LPCSTR lpszProtocol) const
OLESTATUS COleServerItem::OnSetColorScheme(const LOGPALETTE FAR*)
OLESTATUS COleServerItem::OnSetBounds(LPCRECT lpRect)
OLESTATUS COleServerItem::OnDoVerb(UINT nVerb, BOOL bShow, BOOL bTakeFocus)
OLESTATUS COleServerItem::OnShow(BOOL bTakeFocus)
OLECLIPFORMAT COleServerItem::OnEnumFormats(OLECLIPFORMAT nFormat)
HGLOBAL COleServerItem::GetNativeData()
HGLOBAL COleServerItem::GetMetafileData()
OLESTATUS COleServerItem::OnGetData(OLECLIPFORMAT nFormat, LPHANDLE
OLESTATUS COleServerItem::OnSetData(OLECLIPFORMAT nFormat, HANDLE hData)
BOOL COleServerItem::CopyToClipboard(BOOL bIncludeNative, BOOL bIncludeLink)
HGLOBAL COleServerItem::GetLinkFormatData(BOOL bObjectLink)
inline COleServerDoc* PASCAL COleServerDoc::FromLp(LPOLESERVERDOC
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::Save(LPOLESERVERDOC lpServerDoc)
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::Close(LPOLESERVERDOC lpServerDoc)
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::SetHostNames(LPOLESERVERDOC
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::SetDocDimensions(
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::Release(LPOLESERVERDOC
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::SetColorScheme(
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::Execute(LPOLESERVERDOC
OLESTATUS OLEEXPORT _afxOleSvrDocImpl::GetObject(LPOLESERVERDOC
COleServerDoc::COleServerDoc()
COleServerDoc::~COleServerDoc()
void COleServerDoc::CheckAsync(OLESTATUS status)
OLESTATUS COleServerDoc::BeginRevoke()
void COleServerDoc::Revoke()
BOOL COleServerDoc::RegisterServerDoc(COleServer* pServer, LPCSTR lpszDoc)
void COleServerDoc::NotifyRename(LPCSTR lpszNewName)
void COleServerDoc::NotifyRevert()
void COleServerDoc::NotifySaved()
void COleServerDoc::NotifyAllClients(OLE_NOTIFICATION wNotify)
OLESTATUS COleServerDoc::OnRelease()
OLESTATUS COleServerDoc::OnSave()
OLESTATUS COleServerDoc::OnClose()
OLESTATUS COleServerDoc::OnExecute(LPVOID /*lpCommands*/) // DDE commands
OLESTATUS COleServerDoc::OnSetDocDimensions(LPCRECT /*lpRect*/)
COleServerDoc::OnSetHostNames(LPCSTR /*lpszHost*/, LPCSTR /*lpszHostObj*/)
OLESTATUS COleServerDoc::OnSetColorScheme(const LOGPALETTE FAR*)
COleServerItem* COleServerDoc::OnGetLinkedItem(LPCSTR lpszItemName)
BOOL COleServerDoc::OnNewDocument()
BOOL COleServerDoc::OnOpenDocument(const char* pszPathName)
void COleServerDoc::RegisterIfServerAttached(const char* pszPathName)
BOOL COleServerDoc::OnSaveDocument(const char* pszPathName)
void COleServerDoc::OnCloseDocument()
void COleServerDoc::OnUpdateFileSaveMenu(CCmdUI* pCmdUI)
void COleServerDoc::OnFileSaveOrUpdate()
BOOL COleServerDoc::SaveModified()
BOOL COleServerDoc::OnUpdateDocument()
void COleServerDoc::OnFileSaveAs()
inline COleServer* PASCAL COleServer::FromLp(LPOLESERVER lpServer)
OLESTATUS OLEEXPORT _afxSvrImpl:: Exit(LPOLESERVER lpServer)
OLESTATUS OLEEXPORT _afxSvrImpl:: Release(LPOLESERVER lpServer)
OLESTATUS OLEEXPORT _afxSvrImpl:: Execute(LPOLESERVER lpServer, HGLOBAL
OLESTATUS OLEEXPORT _afxSvrImpl:: Open(LPOLESERVER lpServer,
OLESTATUS OLEEXPORT _afxSvrImpl::Create(LPOLESERVER lpServer,
OLESTATUS OLEEXPORT _afxSvrImpl:: CreateFromTemplateFile(LPOLESERVER
OLESTATUS OLEEXPORT _afxSvrImpl::Edit(LPOLESERVER lpServer,
COleServer::COleServer(BOOL bLaunchEmbedded)
COleServer::~COleServer()
void COleServer::BeginRevoke()
COleServer::Register(LPCSTR lpszTypeName, BOOL bMultiInstance)
void COleServer::AddDocument(COleServerDoc* pDoc, LHSERVERDOC lhServerDoc)
void COleServer::RemoveDocument(COleServerDoc* pDoc)
COleServerDoc* COleServer::OnOpenDoc(LPCSTR /*lpszDoc*/)
COleServerDoc* COleServer::OnCreateDocFromTemplateFile(LPCSTR /*lpszTypeName*/,
OLESTATUS COleServer::OnExecute(LPVOID /*lpCommands*/) // DDE commands
OLESTATUS COleServer::OnExit()
OLESTATUS COleServer::OnRelease()
void COleServerItem::AssertValid() const
void COleServerItem::Dump(CDumpContext& dc) const
void COleServerDoc::AssertValid() const
void COleServerDoc::Dump(CDumpContext& dc) const
void COleServer::AssertValid() const
void COleServer::Dump(CDumpContext& dc) const

oletsvr
COleTemplateServer::COleTemplateServer()
BOOL COleTemplateServer::RunEmbedded(CDocTemplate* pDocTemplate,
COleServerDoc* COleTemplateServer::OnOpenDoc(LPCSTR lpszDocName)
COleServerDoc* COleTemplateServer::OnCreateDoc(LPCSTR /*lpszTypeName*/,
COleServerDoc* COleTemplateServer::OnEditDoc(LPCSTR lpszTypeName,

oleui
BOOL PASCAL COleClientItem::InWaitForRelease()
void COleClientItem::WaitForServer()
BOOL COleClientItem::ReportOleError(OLESTATUS status)
BOOL CInsertNewObjectDlg::OnInitDialog()
void CInsertNewObjectDlg::OnOK()
BOOL COleClientItem::DoVerb(UINT nVerb)
BOOL COleClientDoc::OnCmdMsg(UINT nID, int nCode, void* pExtra,
void COleClientDoc::OnUpdatePasteMenu(CCmdUI* pCmdUI)
void COleClientDoc::OnUpdatePasteLinkMenu(CCmdUI* pCmdUI)
void COleClientDoc::OnUpdateEditLinksMenu(CCmdUI* pCmdUI)
void COleClientDoc::OnEditLinks()
void COleClientDoc::OnUpdateObjectVerbMenu(CCmdUI* pCmdUI)
COleClientItem* COleClientDoc::GetPrimarySelectedItem(CView* pView)

oleui2
BOOL COleLinksDlg::OnInitDialog()
void COleLinksDlg::OnSelectionChange()
void COleLinksDlg::SetVerbButtons(COleClientItem* pSel)
void COleLinksDlg::DoVerb(UINT iVerb)
void COleLinksDlg::OnVerb1()
void COleLinksDlg::OnVerb2()
void COleLinksDlg::OnAuto()
void COleLinksDlg::OnManual()
void COleLinksDlg::OnUpdate()
void COleLinksDlg::OnFreeze()
void COleLinksDlg::OnChange()

penctrl
WNDPROC* CHEdit::GetSuperWndProcAddr()
BOOL CHEdit::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT
CHEdit::~CHEdit()
WNDPROC* CBEdit::GetSuperWndProcAddr()
BOOL CBEdit::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT
CBEdit::~CBEdit()

plex
CPlex* PASCAL CPlex::Create(CPlex*& pHead, UINT nMax, UINT cbElement)
void CPlex::FreeDataChain() // free this one and links

strcore
void CString::Init()
CString::CString()
CString::CString(const CString& stringSrc)
void CString::AllocBuffer(int nLen)
void CString::Empty()
CString::~CString()
void CString::AllocCopy(CString& dest, int nCopyLen, int nCopyIndex,
CString::CString(const char* psz)
void CString::AssignCopy(int nSrcLen, const char* pszSrcData)
CString::operator =(const CString& stringSrc)
CString::operator =(const char* psz)
CString::ConcatCopy(int nSrc1Len, const char* pszSrc1Data,
CString::ConcatInPlace(int nSrcLen, const char* pszSrcData)
CString::operator +=(const char* psz)
CString::operator +=(char ch)
CString::operator +=(const CString& string)
char* CString::GetBuffer(int nMinBufLength)
void CString::ReleaseBuffer(int nNewLength)
char* CString::GetBufferSetLength(int nNewLength)
int CString::Find(char ch) const
int CString::FindOneOf(const char* pszCharSet) const
CString::CString(LPCSTR lpsz)

strex
CString::CString(char ch, int nLength)
CString::CString(const char* pch, int nLength)
CString::CString(LPCSTR lpch, int nLen)
const CString& CString::operator =(char ch)
CString CString::Mid(int nFirst) const
CString CString::Mid(int nFirst, int nCount) const
CString CString::Right(int nCount) const
CString CString::Left(int nCount) const
CString CString::SpanIncluding(const char* pszCharSet) const
CString CString::SpanExcluding(const char* pszCharSet) const
int CString::ReverseFind(char ch) const
int CString::Find(const char* pszSub) const

timecore
CTime::CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec)
CTime::CTime(WORD wDosDate, WORD wDosTime)
CTime::GetCurrentTime()
CTime::GetGmtTm(struct tm* ptm /* = NULL */) const
CTime::GetLocalTm(struct tm* ptm /* = NULL */) const
CTimeSpan::Format(const char* pFormat) const
CTime::Format(const char* pFormat) const
CTime::FormatGmt(const char* pFormat) const

vbctrl
CVBControl::CVBControl()
BOOL CVBControl::ParseWindowText(LPCSTR lpszWindowName, CString& strFileName,
BOOL CVBControl::Create(LPCSTR lpszWindowName,
void CVBControl::PostNcDestroy()
CVBControl::~CVBControl()
void CVBControl::OpenChannel(CFile* pFile, WORD wChannel)
BOOL CVBControl::CloseChannel(WORD wChannel)
CFile* CVBControl::GetChannel(WORD wChannel)
int CVBControl::ConvertFontSizeToTwips(LONG lFontSize)
long CVBControl::ConvertTwipsToFontSize(int nTwips)
void CVBControl::AssertValid() const
void CVBControl::Dump(CDumpContext& dc) const
void CDECL CVBControl::Trace(BOOL bFatal, UINT nFormatIndex, ...)
BOOL CVBControl::EnableMemoryTracking(BOOL bTracking)
CVBControl* CVBControl::NEW()
void CVBControl::DELETE()

vbddx
CVBControl* CDataExchange::PrepareVBCtrl(int nIDC)

vbfloat
void CVBControl::EnableVBXFloat()
float CVBControl::GetFloatProperty(int nPropIndex, int index)
BOOL CVBControl::SetFloatProperty(int nPropIndex, float value, int index)

viewcore
CView::CView()
CView::~CView()
BOOL CView::PreCreateWindow(CREATESTRUCT& cs)
int CView::OnCreate(LPCREATESTRUCT lpcs)
void CView::OnDestroy()
void CView::PostNcDestroy()
BOOL CView::OnCmdMsg(UINT nID, int nCode, void* pExtra,
void CView::OnPaint()
void CView::OnInitialUpdate()
void CView::OnUpdate(CView* pSender, LPARAM /*lHint*/, CObject* /*pHint*/)
void CView::OnPrint(CDC* pDC, CPrintInfo*)
BOOL CView::IsSelected(const CObject* pDocItem) const
void CView::OnActivateView(BOOL bActivate, CView* pActivateView, CView*)
int CView::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
CScrollBar* CView::GetScrollBarCtrl(int nBar) const
void CView::OnUpdateSplitCmd(CCmdUI* pCmdUI)
BOOL CView::OnSplitCmd(UINT)
void CView::OnUpdateNextPaneMenu(CCmdUI* pCmdUI)
BOOL CView::OnNextPaneCmd(UINT nID)
void CView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
BOOL CView::OnPreparePrinting(CPrintInfo*)
void CView::OnBeginPrinting(CDC* pDC, CPrintInfo*)
void CView::OnEndPrinting(CDC* pDC, CPrintInfo*)
void CView::OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo,
void CView::Dump(CDumpContext& dc) const
void CView::AssertValid() const

viewedit
AFX_FRSTATE::AFX_FRSTATE()
const DWORD CEditView::dwStyleDefault =
CEditView::CEditView()
CEditView::~CEditView()
WNDPROC* CEditView::GetSuperWndProcAddr()
BOOL CEditView::PreCreateWindow(CREATESTRUCT& cs)
int CEditView::OnCreate(LPCREATESTRUCT lpcs)
void CEditView::CalcWindowRect(LPRECT lpClientRect)
void CEditView::DeleteContents()
void CEditView::Serialize(CArchive& ar)
void CEditView::ReadFromArchive(CArchive& ar, UINT nLen)
void CEditView::WriteToArchive(CArchive& ar)
void CEditView::SerializeRaw(CArchive& ar)
void CEditView::OnPaint()
void CEditView::OnDraw(CDC*)
BOOL CEditView::OnPreparePrinting(CPrintInfo* pInfo)
void CEditView::OnBeginPrinting(CDC* pDC, CPrintInfo*)
CEditView::PaginateTo(CDC* pDC, CPrintInfo* pInfo)
void CEditView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
UINT CEditView::PrintInsideRect(CDC* pDC, RECT& rectLayout,
void CEditView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
void CEditView::OnEndPrinting(CDC*, CPrintInfo*)
void CEditView::OnUpdateNeedSel(CCmdUI* pCmdUI)
void CEditView::OnUpdateNeedClip(CCmdUI* pCmdUI)
void CEditView::OnUpdateNeedText(CCmdUI* pCmdUI)
void CEditView::OnUpdateNeedFind(CCmdUI* pCmdUI)
void CEditView::OnUpdateEditUndo(CCmdUI* pCmdUI)
void CEditView::OnEditChange()
void CEditView::OnEditCut()
void CEditView::OnEditCopy()
void CEditView::OnEditPaste()
void CEditView::OnEditClear()
void CEditView::OnEditUndo()
void CEditView::OnEditSelectAll()
LRESULT CEditView::OnSetFont(WPARAM, LPARAM)
void CEditView::SetPrinterFont(CFont* pFont)
CFont* CEditView::GetPrinterFont() const
LPCSTR CEditView::LockBuffer() const
void CEditView::UnlockBuffer() const
UINT CEditView::GetBufferLength() const
void CEditView::GetSelectedText(CString& strResult) const
void CEditView::OnEditFind()
void CEditView::OnEditReplace()
void CEditView::OnEditRepeat()
void CEditView::OnEditFindReplace(BOOL bFindOnly)
void CEditView::OnFindNext(LPCSTR lpszFind, BOOL bNext, BOOL bCase)
CEditView::OnReplaceSel(LPCSTR lpszFind, BOOL bNext, BOOL bCase,
CEditView::OnReplaceAll(LPCSTR lpszFind, LPCSTR lpszReplace, BOOL bCase)
BOOL CEditView::InitializeReplace()
LRESULT CEditView::OnFindReplaceCmd(WPARAM, LPARAM lParam)
BOOL CEditView::SameAsSelected(LPCSTR lpszCompare, BOOL bCase)
BOOL CEditView::FindText(LPCSTR lpszFind, BOOL bNext, BOOL bCase)
void CEditView::OnTextNotFound(LPCSTR)
void CEditView::SetTabStops(int nTabStops)
void CEditView::AssertValid() const
void CEditView::Dump(CDumpContext& dc) const

viewform
CFormView::CFormView(LPCSTR lpszTemplateName)
CFormView::CFormView(UINT nIDTemplate)
BOOL CFormView::Create(LPCSTR /*lpszClassName ignored*/,
void CFormView::OnInitialUpdate()
int CFormView::OnCreate(LPCREATESTRUCT lpcs)
BOOL CFormView::PreTranslateMessage(MSG* pMsg)
void CFormView::OnDraw(CDC* pDC)
WNDPROC* CFormView::GetSuperWndProcAddr()
void CFormView::Dump(CDumpContext& dc) const
void CFormView::AssertValid() const

viewprev
CPrintPreviewState::CPrintPreviewState()
void CView::OnFilePrintPreview()
BOOL CView::DoPrintPreview(UINT nIDResource, CView* pPrintView,
CPreviewView::CPreviewView()
CPreviewView::~CPreviewView()
int CPreviewView::OnCreate(LPCREATESTRUCT lpCreateStruct)
BOOL CPreviewView::SetPrintView(CView* pPrintView)
void CPreviewView::OnSize(UINT nType, int cx, int cy)
void CPreviewView::OnActivateView(BOOL bActivate,
void CPreviewView::OnPreviewClose()
CSize CPreviewView::CalcScaleRatio(CSize screenSize, CSize actualSize)
void CPreviewView::PositionPage(UINT nPage)
CSize CPreviewView::CalcPageDisplaySize()
void CPreviewView::SetScaledSize(UINT nPage)
void CPreviewView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
BOOL CPreviewView::OnEraseBkgnd(CDC* pDC)
void CPreviewView::OnDraw(CDC* pDC)
void CPreviewView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
void CPreviewView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
void CPreviewView::OnNumPageChange()
void CPreviewView::OnNextPage()
void CPreviewView::OnPrevPage()
void CPreviewView::OnPreviewPrint()
BOOL CPreviewView::FindPageRect(CPoint& point, UINT& nPage)
void CPreviewView::OnLButtonDown(UINT, CPoint point)
void CPreviewView::SetZoomState(UINT nNewState, UINT nPage, CPoint point)
void CPreviewView::OnZoomIn()
void CPreviewView::OnZoomOut()
void CPreviewView::DoZoom(UINT nPage, CPoint point)
void CPreviewView::SetCurrentPage(UINT nPage, BOOL bClearRatios)
void CPreviewView::OnDisplayPageNumber(UINT nPage, UINT nPagesDisplayed)
void CPreviewView::OnUpdateNumPageChange(CCmdUI* pCmdUI)
void CPreviewView::OnUpdateNextPage(CCmdUI* pCmdUI)
void CPreviewView::OnUpdatePrevPage(CCmdUI* pCmdUI)
void CPreviewView::OnUpdateZoomIn(CCmdUI* pCmdUI)
void CPreviewView::OnUpdateZoomOut(CCmdUI* pCmdUI)
BOOL CPreviewView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
void CPreviewView::AssertValid() const
void CPreviewView::Dump(CDumpContext& dc) const

viewprnt
BOOL CPrintingDialog::OnInitDialog()
void CPrintingDialog::OnCancel()
BOOL CView::DoPreparePrinting(CPrintInfo* pInfo)
void CView::OnFilePrint()
CPrintInfo::CPrintInfo()
CPrintInfo::~CPrintInfo()

viewscrl
CScrollView::CScrollView()
CScrollView::~CScrollView()
void CScrollView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
void CScrollView::SetScaleToFitSize(SIZE sizeTotal)
const SIZE AFXAPI_DATA CScrollView::sizeDefault = {0,0};
void CScrollView::SetScrollSizes(int nMapMode, SIZE sizeTotal,
CPoint CScrollView::GetScrollPosition() const // logical coordinates
void CScrollView::ScrollToPosition(POINT pt) // logical coordinates
CPoint CScrollView::GetDeviceScrollPosition() const
void CScrollView::GetDeviceScrollSizes(int& nMapMode, SIZE& sizeTotal,
void CScrollView::ScrollToDevicePosition(POINT ptDev)
void CScrollView::FillOutsideRect(CDC* pDC, CBrush* pBrush)
void CScrollView::ResizeParentToFit(BOOL bShrinkOnly)
void CScrollView::OnSize(UINT nType, int cx, int cy)
void CScrollView::CenterOnPoint(CPoint ptCenter) // center in device coords
BOOL CScrollView::GetTrueClientSize(CSize& size, CSize& sizeSb)
void CScrollView::UpdateBars()
void CScrollView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
void CScrollView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
void CScrollView::OnScroll(int nBar, UINT nSBCode, UINT nPos)
void CScrollView::Dump(CDumpContext& dc) const
void CScrollView::AssertValid() const

winbtn
BOOL CBitmapButton::LoadBitmaps(LPCSTR lpszBitmapResource,
void CBitmapButton::SizeToContent()
BOOL CBitmapButton::AutoLoad(UINT nID, CWnd* pParent)
void CBitmapButton::DrawItem(LPDRAWITEMSTRUCT lpDIS)
void CBitmapButton::AssertValid() const
void CBitmapButton::Dump(CDumpContext& dc) const

wincore
const MSG* PASCAL CWnd::GetCurrentMessage()
LRESULT CWnd::Default()
void PASCAL CWnd::DeleteTempMap()
CWnd* PASCAL CWnd::FromHandle(HWND hWnd)
CWnd* PASCAL CWnd::FromHandlePermanent(HWND hWnd)
BOOL CWnd::Attach(HWND hWndNew)
HWND CWnd::Detach()
BOOL CWnd::CreateEx(DWORD dwExStyle, LPCSTR lpszClassName,
BOOL CWnd::PreCreateWindow(CREATESTRUCT& cs)
BOOL CWnd::Create(LPCSTR lpszClassName,
CWnd::~CWnd()
void CWnd::OnNcDestroy()
void CWnd::PostNcDestroy()
void CWnd::AssertValid() const
void CWnd::Dump(CDumpContext& dc) const
CWnd::DestroyWindow()
LRESULT CWnd::DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
WNDPROC* CWnd::GetSuperWndProcAddr()
BOOL CWnd::PreTranslateMessage(MSG*)
void CWnd::OnDrawItem(int /*nIDCtl*/, LPDRAWITEMSTRUCT lpDrawItemStruct)
int CWnd::OnCompareItem(int /*nIDCtl*/, LPCOMPAREITEMSTRUCT
lpCompareItemStruct)
void CWnd::OnDeleteItem(int /*nIDCtl*/, LPDELETEITEMSTRUCT lpDeleteItemStruct)
BOOL CMenu::TrackPopupMenu(UINT nFlags, int x, int y,
void CWnd::OnMeasureItem(int /*nIDCtl*/, LPMEASUREITEMSTRUCT
lpMeasureItemStruct)
LRESULT CWnd::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
BOOL CWnd::OnCommand(WPARAM wParam, LPARAM lParam)
CFrameWnd* CWnd::GetParentFrame() const
CWnd* CWnd::GetDescendantWindow(int nID) const
void CWnd::SendMessageToDescendants(UINT message,
CWnd::GetScrollBarCtrl(int) const
int CWnd::SetScrollPos(int nBar, int nPos, BOOL bRedraw)
int CWnd::GetScrollPos(int nBar) const
void CWnd::SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw)
void CWnd::GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const
void CWnd::EnableScrollBarCtrl(int nBar, BOOL bEnable)
void CWnd::RepositionBars(UINT nIDFirst, UINT nIDLast, UINT nIDLeftOver)
void CWnd::CalcWindowRect(LPRECT lpClientRect)
LRESULT CWnd::OnVBXEvent(WPARAM wParam, LPARAM lParam)
BOOL CWnd::SendChildNotifyLastMsg(LRESULT* pLResult /*= NULL*/)
BOOL CWnd::OnChildNotify(UINT, WPARAM, LPARAM, LRESULT*)
void CWnd::OnParentNotify(UINT message, LPARAM lParam)
void CWnd::OnHScroll(UINT, UINT, CScrollBar* pScrollBar)
void CWnd::OnVScroll(UINT, UINT, CScrollBar* pScrollBar)
HBRUSH CWnd::OnCtlColor(CDC*, CWnd* pWnd, UINT)
BOOL CWnd::UpdateData(BOOL bSaveAndValidate)
CDataExchange::CDataExchange(CWnd* pDlgWnd, BOOL bSaveAndValidate)
BOOL CWnd::ExecuteDlgInit(LPCSTR lpszResourceName)
void CWnd::UpdateDialogControls(CCmdTarget* pTarget, BOOL bDisableIfNoHndler)

winctrl
WNDPROC* CStatic::GetSuperWndProcAddr()
BOOL CStatic::Create(LPCSTR lpszText, DWORD dwStyle,
CStatic::~CStatic()
WNDPROC* CButton::GetSuperWndProcAddr()
BOOL CButton::Create(LPCSTR lpszCaption, DWORD dwStyle,
CButton::~CButton()
int CWnd::GetCheckedRadioButton(int nIDFirstButton, int nIDLastButton)
void CButton::DrawItem(LPDRAWITEMSTRUCT)
BOOL CButton::OnChildNotify(UINT message, WPARAM, LPARAM lParam,
WNDPROC* CListBox::GetSuperWndProcAddr()
BOOL CListBox::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd,
CListBox::~CListBox()
void CListBox::DrawItem(LPDRAWITEMSTRUCT)
void CListBox::MeasureItem(LPMEASUREITEMSTRUCT)
int CListBox::CompareItem(LPCOMPAREITEMSTRUCT)
void CListBox::DeleteItem(LPDELETEITEMSTRUCT)
BOOL CListBox::OnChildNotify(UINT message, WPARAM, LPARAM lParam,
WNDPROC* CComboBox::GetSuperWndProcAddr()
BOOL CComboBox::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd,
CComboBox::~CComboBox()
void CComboBox::DrawItem(LPDRAWITEMSTRUCT)
void CComboBox::MeasureItem(LPMEASUREITEMSTRUCT)
int CComboBox::CompareItem(LPCOMPAREITEMSTRUCT)
void CComboBox::DeleteItem(LPDELETEITEMSTRUCT)
BOOL CComboBox::OnChildNotify(UINT message, WPARAM, LPARAM lParam,
WNDPROC* CEdit::GetSuperWndProcAddr()
BOOL CEdit::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT
CEdit::~CEdit()
WNDPROC* CScrollBar::GetSuperWndProcAddr()
BOOL CScrollBar::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd,
CScrollBar::~CScrollBar()
BOOL CWnd::SubclassWindow(HWND hWnd)
BOOL CWnd::SubclassDlgItem(UINT nID, CWnd* pParent)

winfrm
CFrameWnd::CFrameWnd()
BOOL CFrameWnd::LoadAccelTable(LPCSTR lpszResourceName)
BOOL CFrameWnd::PreTranslateMessage(MSG* pMsg)
void CFrameWnd::PostNcDestroy()
BOOL CFrameWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
BOOL CFrameWnd::IsTracking() const
LRESULT CFrameWnd::OnCommandHelp(WPARAM, LPARAM lParam)
LRESULT CFrameWnd::OnHelpHitTest(WPARAM, LPARAM)
BOOL CFrameWnd::OnCommand(WPARAM wParam, LPARAM lParam)
BOOL CFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
BOOL CFrameWnd::Create(LPCSTR lpszClassName,
BOOL CFrameWnd::OnCreateClient(LPCREATESTRUCT, CCreateContext* pContext)
int CFrameWnd::OnCreate(LPCREATESTRUCT lpcs)
int CFrameWnd::OnCreateHelper(LPCREATESTRUCT lpcs, CCreateContext* pContext)
LPCSTR CFrameWnd::GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource)
BOOL CFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
void CFrameWnd::OnClose()
void CFrameWnd::OnDestroy()
void CFrameWnd::OnNcDestroy()
BOOL CFrameWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra,
void CFrameWnd::OnHScroll(UINT, UINT, CScrollBar*)
void CFrameWnd::OnVScroll(UINT, UINT, CScrollBar*)
void CFrameWnd::OnActivate(UINT nState, CWnd*, BOOL bMinimized)
void CFrameWnd::OnActivateApp(BOOL bActive, HTASK hTask)
void CFrameWnd::OnSysCommand(UINT nID, LONG lParam)
void CFrameWnd::OnDropFiles(HDROP hDropInfo)
BOOL CFrameWnd::OnQueryEndSession()
LRESULT CFrameWnd::OnDDEInitiate(WPARAM wParam, LPARAM lParam)
LRESULT CFrameWnd::OnDDEExecute(WPARAM wParam, LPARAM lParam)
LRESULT CFrameWnd::OnDDETerminate(WPARAM wParam, LPARAM lParam)
CView* CFrameWnd::GetActiveView() const
void CFrameWnd::OnSetFocus(CWnd* pOldWnd)
CDocument* CFrameWnd::GetActiveDocument()
void CFrameWnd::OnInitMenuPopup(CMenu* pMenu, UINT, BOOL bSysMenu)
void CFrameWnd::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU /*hSysMenu*/)
LRESULT CFrameWnd::OnSetMessageString(WPARAM wParam, LPARAM lParam)
CWnd* CFrameWnd::GetMessageBar()
void CFrameWnd::OnEnterIdle(UINT nWhy, CWnd* /*pWho*/)
void CFrameWnd::OnSysColorChange()
void CFrameWnd::OnUpdateControlBarMenu(CCmdUI* pCmdUI)
BOOL CFrameWnd::OnBarCheck(UINT nID)
void CFrameWnd::OnUpdateKeyIndicator(CCmdUI* pCmdUI)
void CFrameWnd::OnUpdateFrameTitle(BOOL bAddToTitle)
void CFrameWnd::UpdateFrameTitleForDocument(const char* pszDocName)
void CFrameWnd::OnSetPreviewMode(BOOL bPreview, CPrintPreviewState* pState)
void CFrameWnd::RecalcLayout()
void CFrameWnd::OnSize(UINT nType, int cx, int cy)
BOOL CFrameWnd::OnEraseBkgnd(CDC* pDC)
void CFrameWnd::ActivateFrame(int nCmdShow)
void CFrameWnd::AssertValid() const
void CFrameWnd::Dump(CDumpContext& dc) const

wingdi
CDC::CDC()
void CDC::AssertValid() const
void CDC::Dump(CDumpContext& dc) const
void PASCAL CDC::DeleteTempMap()
CDC* PASCAL CDC::FromHandle(HDC hDC)
BOOL CDC::Attach(HDC hDC)
HDC CDC::Detach()
BOOL CDC::DeleteDC()
CDC::~CDC()
void CDC::SetAttribDC(HDC hDC) // Set the Attribute DC
void CDC::SetOutputDC(HDC hDC) // Set the Output DC
void CDC::ReleaseAttribDC() // Release the Attribute DC
void CDC::ReleaseOutputDC() // Release the Output DC
int CDC::StartDoc(LPCSTR lpszDocName)
int CDC::StartDoc(LPDOCINFO lpDocInfo)
int CDC::StartPage()
int CDC::EndPage()
int CDC::SetAbortProc(BOOL (CALLBACK EXPORT* lpfn)(HDC, int))
int CDC::AbortDoc()
int CDC::EndDoc()
int CDC::SaveDC()
BOOL CDC::RestoreDC(int nSavedDC)
CGdiObject* PASCAL CDC::SelectGdiObject(HDC hDC, HGDIOBJ h)
CGdiObject* CDC::SelectStockObject(int nIndex)
CPen* CDC::SelectObject(CPen* pPen)
CBrush* CDC::SelectObject(CBrush* pBrush)
CFont* CDC::SelectObject(CFont* pFont)
int CDC::SelectObject(CRgn* pRgn)
CPalette* CDC::SelectPalette(CPalette* pPalette, BOOL bForceBackground)
COLORREF CDC::SetBkColor(COLORREF crColor)
int CDC::SetBkMode(int nBkMode)
int CDC::SetPolyFillMode(int nPolyFillMode)
int CDC::SetROP2(int nDrawMode)
int CDC::SetStretchBltMode(int nStretchMode)
COLORREF CDC::SetTextColor(COLORREF crColor)
int CDC::SetMapMode(int nMapMode)
CPoint CDC::SetViewportOrg(int x, int y)
CPoint CDC::OffsetViewportOrg(int nWidth, int nHeight)
CSize CDC::SetViewportExt(int x, int y)
CSize CDC::ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom)
CPoint CDC::SetWindowOrg(int x, int y)
CPoint CDC::OffsetWindowOrg(int nWidth, int nHeight)
CSize CDC::ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom)
CSize CDC::SetWindowExt(int x, int y)
int CDC::GetClipBox(LPRECT lpRect) const
int CDC::SelectClipRgn(CRgn* pRgn)
int CDC::ExcludeClipRect(int x1, int y1, int x2, int y2)
int CDC::ExcludeClipRect(LPCRECT lpRect)
int CDC::IntersectClipRect(int x1, int y1, int x2, int y2)
int CDC::IntersectClipRect(LPCRECT lpRect)
int CDC::OffsetClipRgn(int x, int y)
int CDC::OffsetClipRgn(SIZE size)
CPoint CDC::MoveTo(int x, int y)
BOOL CDC::LineTo(int x, int y)
UINT CDC::SetTextAlign(UINT nFlags)
int CDC::SetTextJustification(int nBreakExtra, int nBreakCount)
int CDC::SetTextCharacterExtra(int nCharExtra)
DWORD CDC::SetMapperFlags(DWORD dwFlag)
void CClientDC::AssertValid() const
void CClientDC::Dump(CDumpContext& dc) const
CClientDC::CClientDC(CWnd* pWnd)
CClientDC::~CClientDC()
void CWindowDC::AssertValid() const
void CWindowDC::Dump(CDumpContext& dc) const
CWindowDC::CWindowDC(CWnd* pWnd)
CWindowDC::~CWindowDC()
void CPaintDC::AssertValid() const
void CPaintDC::Dump(CDumpContext& dc) const
CPaintDC::CPaintDC(CWnd* pWnd)
CPaintDC::~CPaintDC()
void CGdiObject::Dump(CDumpContext& dc) const
void CGdiObject::AssertValid() const
void PASCAL CGdiObject::DeleteTempMap()
CGdiObject* PASCAL CGdiObject::FromHandle(HGDIOBJ h)
BOOL CGdiObject::Attach(HGDIOBJ hObject)
HGDIOBJ CGdiObject::Detach()
BOOL CGdiObject::DeleteObject()
CGdiObject::~CGdiObject()
CPen::CPen(int nPenStyle, int nWidth, COLORREF crColor)
void CPen::Dump(CDumpContext& dc) const
CBrush::CBrush(COLORREF crColor)
CBrush::CBrush(int nIndex, COLORREF crColor)
CBrush::CBrush(CBitmap* pBitmap)
void CBrush::Dump(CDumpContext& dc) const
void CFont::Dump(CDumpContext& dc) const
void CBitmap::Dump(CDumpContext& dc) const

winhand
CHandleMap::CHandleMap(CRuntimeClass* pClass, int nHandles /*= 1*/)
CObject* CHandleMap::FromHandle(HANDLE h)
void CHandleMap::SetPermanent(HANDLE h, CObject* permOb)
void CHandleMap::RemoveHandle(HANDLE h)
void CHandleMap::DeleteTemp()

winmdi
CMDIFrameWnd::CMDIFrameWnd()
BOOL CMDIFrameWnd::OnCommand(WPARAM wParam, LPARAM lParam)
BOOL CMDIFrameWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra,
LRESULT CMDIFrameWnd::OnCommandHelp(WPARAM wParam, LPARAM lParam)
BOOL CMDIFrameWnd::OnCreateClient(LPCREATESTRUCT lpcs,
BOOL CMDIFrameWnd::CreateClient(LPCREATESTRUCT lpCreateStruct,
CMDIFrameWnd::DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
CMDIFrameWnd::PreTranslateMessage(MSG* pMsg)
BOOL CMDIFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
BOOL CMDIFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
void CMDIFrameWnd::OnDestroy()
void CMDIFrameWnd::OnSize(UINT nType, int, int)
void CMDIFrameWnd::OnActivate(UINT nState, CWnd*, BOOL bMinimized)
CMDIChildWnd* CMDIFrameWnd::MDIGetActive(BOOL* pbMaximized /*= NULL*/)
void CMDIFrameWnd::AssertValid() const
void CMDIFrameWnd::Dump(CDumpContext& dc) const
CMDIChildWnd::CMDIChildWnd()
CMDIChildWnd::DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
CMDIChildWnd::DestroyWindow()
CMDIChildWnd::PreTranslateMessage(MSG* pMsg)
BOOL CMDIChildWnd::PreCreateWindow(CREATESTRUCT& cs)
BOOL CMDIChildWnd::Create(LPCSTR lpszClassName,
BOOL CMDIChildWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
void CMDIChildWnd::OnSize(UINT nType, int cx, int cy)
void CMDIChildWnd::ActivateFrame(int nCmdShow)
CMDIChildWnd::AssertValid() const
CMDIChildWnd::Dump(CDumpContext& dc) const
HMENU CMDIFrameWnd::GetWindowMenuPopup(HMENU hMenuBar)
CMDIFrameWnd* CMDIChildWnd::GetMDIFrame()
CWnd* CMDIChildWnd::GetMessageBar()
void CMDIChildWnd::OnUpdateFrameTitle(BOOL bAddToTitle)
void CMDIChildWnd::OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd*)
int CMDIChildWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
void CMDIFrameWnd::OnUpdateFrameTitle(BOOL bAddToTitle)
void CMDIFrameWnd::OnUpdateMDIWindowCmd(CCmdUI* pCmdUI)
BOOL CMDIFrameWnd::OnMDIWindowCmd(UINT nID)
void CMDIFrameWnd::OnWindowNew()

winmenu
void PASCAL CMenu::DeleteTempMap()
CMenu* PASCAL CMenu::FromHandle(HMENU hMenu)
void CMenu::AssertValid() const
void CMenu::Dump(CDumpContext& dc) const
CMenu::Attach(HMENU hMenu)
CMenu::Detach()
CMenu::~CMenu()
CMenu::DestroyMenu()
void CMenu::DrawItem(LPDRAWITEMSTRUCT /* lpDrawItemStruct */)
void CMenu::MeasureItem(LPMEASUREITEMSTRUCT /* lpMeasureItemStruct */)

winsplit
CSplitterWnd::CSplitterWnd()
CSplitterWnd::~CSplitterWnd()
BOOL CSplitterWnd::Create(CWnd* pParentWnd,
BOOL CSplitterWnd::CreateStatic(CWnd* pParentWnd,
BOOL CSplitterWnd::CreateCommon(CWnd* pParentWnd,
BOOL CSplitterWnd::CreateView(int row, int col,
BOOL CSplitterWnd::CreateScrollBarCtrl(DWORD dwStyle, UINT nID)
int CSplitterWnd::IdFromRowCol(int row, int col) const
CWnd* CSplitterWnd::GetPane(int row, int col) const
BOOL CSplitterWnd::IsChildPane(CWnd* pWnd, int& row, int& col)
void CSplitterWnd::GetRowInfo(int row, int& cyCur, int& cyMin) const
void CSplitterWnd::SetRowInfo(int row, int cyIdeal, int cyMin)
void CSplitterWnd::GetColumnInfo(int col, int& cxCur, int& cxMin) const
void CSplitterWnd::SetColumnInfo(int col, int cxIdeal, int cxMin)
void CSplitterWnd::DeleteView(int row, int col)
void CSplitterWnd::OnDrawSplitter(CDC* pDC, ESplitType nType,
static int NEAR PASCAL CanSplitRowCol(CSplitterWnd::CRowColInfo* pInfoBefore,
BOOL CSplitterWnd::SplitRow(int cyBefore)
BOOL CSplitterWnd::SplitColumn(int cxBefore)
void CSplitterWnd::DeleteRow(int row)
void CSplitterWnd::DeleteColumn(int col)
void CSplitterWnd::GetInsideRect(CRect& rect) const
void CSplitterWnd::StartTracking(int ht)
void CSplitterWnd::TrackRowSize(int y, int row)
void CSplitterWnd::TrackColumnSize(int x, int col)
void CSplitterWnd::StopTracking(BOOL bAccept)
void CSplitterWnd::GetHitRect(int ht, CRect& rectHit)
int CSplitterWnd::HitTest(CPoint pt) const
void CSplitterWnd::OnInvertTracker(const CRect& rect)
BOOL CSplitterWnd::DoKeyboardSplit()
void CSplitterWnd::OnSize(UINT nType, int cx, int cy)
static void NEAR PASCAL LayoutRowCol(CSplitterWnd::CRowColInfo* pInfoArray,
void CSplitterWnd::RecalcLayout()
void CSplitterWnd::DrawAllSplitBars(CDC* pDC, int cxInside, int cyInside)
void CSplitterWnd::OnPaint()
BOOL CSplitterWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
void CSplitterWnd::OnMouseMove(UINT /*nFlags*/, CPoint pt)
void CSplitterWnd::OnLButtonDown(UINT /*nFlags*/, CPoint pt)
void CSplitterWnd::OnLButtonDblClk(UINT /*nFlags*/, CPoint pt)
void CSplitterWnd::OnLButtonUp(UINT /*nFlags*/, CPoint /*pt*/)
void CSplitterWnd::OnCancelMode()
void CSplitterWnd::OnKeyDown(UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
void CSplitterWnd::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
void CSplitterWnd::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
BOOL CSplitterWnd::CanActivateNext(BOOL)
void CSplitterWnd::ActivateNext(BOOL bPrev)
void CSplitterWnd::AssertValid() const
void CSplitterWnd::Dump(CDumpContext& dc) const

winstr
BOOL CString::LoadString(UINT nID)
void CString::AnsiToOem()
void CString::OemToAnsi()