BOOL CWnd::Create(LPCTSTR IpszClassName, LPCTSTR IpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)

{

// can’t use for desktop or pop-up windows // (use CreateEx instead) ASSERT(pParentWnd != NULL); ASSERT((dwStyle & WS_POPUP) == 0); return CreateEx (0,

IpszClassName,

IpszWindowName,

dwStyle I WS_CHILD,

rect.left, rect.top,

rect.right – rect.left,

rect.bottom – rect.top,

pParentWnd->GetSafeHwnd(),

(HMENU)nID,

(LPVOID)pContext);

}

if (!Create(GetlconWndClass(dwDefaultStyle, nIDResource), strTitle, dwDefaultStyle, rectDefault,

(CMDIFrameWnd*) pParentWnd, pContext)) …

BOOL CMDIChildWnd::Create(LPCTSTR IpszClassName,

LPCTSTR IpszWindowName, DWORD dwStyle, const RECT& rect, CMDIFrameWnd* pParentWnd, CCreateContext* pContext)

{

if (pParentWnd == NULL) {

CWnd* pMainWnd = AfxGetThread()->m_pMainWnd; ASSERT(pMainWnd != NULL); ASSERT_KINDOF(CMDIFrameWnd, pMainWnd); pParentWnd = (CMDIFrameWnd*)pMainWnd;

ASSERT(::IsWindow(pParentWnd->m_hWndMDIClient));

// insure correct window positioning pParentWnd->RecalcLayout();

// first copy into a CREATESTRUCT for PreCreate CREATESTRUCT cs; cs.dwExStyle = OL; cs.IpszClass = IpszClassName; cs.lpszName = IpszWindowName; cs.style = dwStyle; cs.x = rect.left; cs.y = rect.top; cs.cx = rect.right – rect.left; cs.cy = rect.bottom – rect.top; cs.hwndParent = pParentWnd->m_hWnd; cs.hMenu = NULL;

cs.hlnstance = AfxGetlnstanceHandle(); cs.lpCreateParams = (LPVOID)pContext;

if (!PreCreateWindow(cs)) {

PostNcDestroy(); return FALSE;

}

// extended style must be zero for MDI Children // (except under Win4)

ASSERT(afxData.bWin4 || cs.dwExStyle == 0);

ASSERT(cs.hwndParent == pParentWnd->m_hWnd); // must not change

// now copy into a MDICREATESTRUCT for real create MDICREATESTRUCT mcs; mcs.szClass = cs :*lpszClass; mcs.szTitle = cs.lpszName; mcs.hOwner = cs.hlnstance;

mcs.x = cs.x; mcs.у = cs.y; mcs.cx = cs.cx; mcs.cy = cs.cy;

mcs.style = cs.style & -(WS_MAXIMIZE | WS_VISIBLE); mcs.lParam = (LONG)cs.lpCreateParams;

// create the window through the MDICLIENT window AfxHookWindowCreate(this); HWND hWnd =

(HWND)::SendMessage(pParentWnd->m_hWndMDIClient, WM_MDICREATE, 0,

(LPARAM)&mcs); if (!AfxUnhookWindowCreate()) PostNcDestroy(); // cleanup if MDICREATE fails too soon

if (hWnd ~ NULL) return FALSE;

// special handling of visibility (always created invisible) if (cs.style & WS_VISIBLE) {

// place the window on top in z-order before showing it ::BringWindowToTop(hWnd);

// show it as specified

if (cs.style & WS_MINIMIZE)

ShowWindow(SW_SHOWMINIMIZED); else if (cs.style & WS_MAXIMIZE)

ShowWindow(SW_SHOWMAXIMIZED) ; else

ShowWindow(SW_SHOWNORMAL);

// make sure it is active (visibility == activation) pParentWnd->MDIActivate(this);

// refresh MDI Window menu

::SendMessage(pParentWnd->m_hWndMDIClient, WM_MDIREFRESHMENU, 0, 0) ; }

ASSERT(hWnd == m_hWnd); return TRUE;

}

fCMDIChJldWnd::OnCreate)

В том случае, если длина буфера, переданного конструктору, окажется менее 128 байтов, конструктор не будет использовать переданный ему буфер и сделает указатель на буфер равным NULL, а длину буфера сделает равной 128 байтам. Длина бу­фера сохраняется в поле m_nBufSize. После этого, в том случае, если указатель на буфер оказался равным NULL (например, при вызове конструктора использовался указатель по умолчанию или указанный при вызове конструктора размер буфера был меньше 128 байтов), то конструктор выделяет новый буфер тре­буемого размера, записывает указатель на буфер в поле mJpBufferStart и… Нам становится понятно назначение еще одного поля! Поле m_bUserBuf является флагом. Значение TRUE этого поля определяет, что объект будет использовать ранее подготовленный буфер, значение FALSE говорит о том, что бу­фер, используемый объектом, был создан во время работы кон­структора. Естественно, в том случае, когда конструктор са­мостоятельно выделяет буфер для работы, значение этого поля делается равным FALSE.

После того как все указатели проинициализированы, определяет­ся указатель на конец буфера. Этот указатель хранится в поле mJpBufMax. Но возникает вопрос – а зачем нам необходимо хра­нить две величины, фактически определяющие размер буфера – поле mjiBufSize и поле mJpBufSize? Вопрос закономерен, то отвечу я на него немного позже, ОК?

А затем происходит одна интересная вещь. Указатель на те­кущую позицию буфера (поле mJpBufCur) в том случае, если происходит чтение из архива, устанавливается на конец буфе­ра. В случае, если происходит запись в архив, указатель уста­навливается на начало буфера. Это, разумеется, не означает, что чтение или запись будут производиться в обратном поряд­ке. Нет, конечно, все гораздо проще. Если при операции чтения из архива в буфер указатель на текущую позицию буфера дос­тигает конца буфера, это означает, что буфер заполнен, читать больше некуда, и необходимо произвести некоторые действия для того, чтобы буфер можно было бы использовать повторно. Аналогично, если при записи из буфера в архив указатель на начало файла и на текущее позицию в буфере совпадают, то это означает, что все данные из буфера уже «сброшены» в ар­хив и что опять-таки необходимо произвести некоторые дейст­вия для того, чтобы заполнить буфер. Другими словами, поло­жение указателя является своеобразным флагом, вынуждающим метод произвести подготовку буфера к считыванию данных из архива или записи данных в архив.

Запись в архив и чтение из архива больших объемов информа­ции производится при помощи перегруженных операторов ««» и «»». В классе CArchive мы можем найти перегруженные опера­ции для чтения из архива и записи в архив переменных типа WORD, DWORD, float, double. Помимо этого предусмотрены операции за­писи в архив и чтения из архива строк. Для того, чтобы понять, как происходит чтение из архива и запись в архив примитивов, рас­смотрим, каким образом осуществляется запись в архив и чтение из архива переменной типа WORD.

Режим работы архива, кстати, может быть получен при помощи методов lsl_oading()

_AFX_INLINE BOOL CArchive::IsLoading() const { return (m_nMode & CArchive::load) != 0; }

и lsStoring()

_AFX_INLINE BOOL CArchive::IsStoring() const { return (m_nMode & CArchive::load) == 0; }

Третий аргумент конструктора – это размер временного буфера, который будет использоваться для промежуточного хранения данных. По умолчанию размер буфера равен 4К (4096 байтов). Четвертым аргументом, как можно уже догадаться, является указатель на вре­менный буфер. По умолчанию указатель на буфер равен NULL, т. е. буфер по умолчанию создается самим конструктором.

CArchive::CArchive(CFile* pFile, UINT nMode, int nBufSize, void* lpBuf) :

m_strFileName(pFile->GetFilePath() )

{

ASSERT_VALID(pFile);

// initialize members not dependent on allocated buffer

m_nMode = nMode; m_pFile = pFile; m_pSchemaMap = NULL; m_pLoadArray = NULL; m_pDocument = NULL; m_bForceFlat = TRUE;

m_nObjectSchema = (UINT)-l; // start with invalid schema

if (IsStoringO )

m_nGrowSize = nBlockSize; else

m_nGrowSize = nGrowSize; m_nHashSize = nHashSize;

// initialize the buffer. minimum size is 128 m_lpBufStart = (BYTE*)lpBuf; m_bUserBuf = TRUE; m_bDirectBuffer = FALSE;

if (nBufSize < nBufSizeMin) {

// force use of private buffer of minimum size m_nBufSize = nBufSizeMin; m_lpBufStart = NULL;

}

else

m_nBufSize = nBufSize;

nBufSize = m_nBufSize; if (m_lpBufStart == NULL) {

// check for CFile providing buffering support m_bDirectBuffer =

m_pPile->GetBufferPtr(CFile::bufferCheck); if (!m_bDirectBuffer) {

// no support for direct buffering, // allocate new buffer m_lpBufStart = new BYTE[m_nBufSize]; m_bUserBuf = FALSE;

}

else {

I/ CFile* supports direct buffering! nBufSize = 0; // will trigger initial FillBuffer

}

}

if (!m_bDirectBuffer) {

ASSERT(m_lpBufStart !=NULL);

ASSERT(AfxIsValidAddress(m_lpBufStart,

nBufSize, IsStoring()));

}

m_lpBufMax = m_lpBufStart + nBufSize;

m_lpBufCur = (IsLoading()) ? m_lpBufMax : m_lpBufStart;
ASSERT (m_pStoreMap == NULL); // same as m_pLoadArray

}

class CArchive {

public:

// Flag values

enum Mode { store = 0, load = 1_Г

bNoFlushOnDelete = 2, bNoByteSwap = 4 };

CArchive(CFile* pFile,

UINT nMode,

int nBufSize = 4096,

void* lpBuf = NULL); -CArchive();

// Attributes

BOOL IsLoadingO const; BOOL IsStoringO const; BOOL IsByteSwapping() const; BOOL IsBufferEmpty() const; CFile* GetFileO const;

UINT GetObjectSchema(); // only valid when reading

// a CObject* void SetObjectSchema(UINT nSchema);

// pointer to document being serialized — must set // to serialize COleClientltems in a document! CDocument* m_pDocument;

// Operations

UINT Read(void* lpBuf, UINT nMax);

void Write(const void* lpBuf, UINT nMax);

void Flush(); void Close();

void Abort(); // close and shutdown without exceptions

// reading and writing strings

void WriteString(LPCTSTR lpsz);

LPTSTR ReadString(LPTSTR lpsz, UINT nMax);

BOOL ReadString(CStringS rString);

public:

// Object I/O is pointer based to avoid added // construction overhead.

// Use the Serialize member function directly for // embedded objects.

friend CArchive& AFXAPI operator«(CArchive& ar,

const CObject* pOb);

friend CArchiveS AFXAPI operator»(CArchive& ar,

CObject*& pOb); friend CArchive& AFXAPI operator>>(CArchive& ar,

const CObject*& pOb);

// insertion operations CArchive& operator« (BYTE by) ; CArchiveS operator« (WORD w) ; CArchiveS operator« (LONG 1) ; CArchive& operator« (DWORD dw) ; CArchiveS operator« (float f) ; CArchive& operator« (double d) ; CArchive& operator<< (int i); CArchive& operator<<(short w); CArchive& operator<< (char ch); CArchive& operator<<(unsigned u);

// extraction operations CArchiveS operator» (BYTE& by) ; CArchive& operator>>(W0RD& w); CArchive& operator» (DWORDS dw) ; CArchive& operator» (L0NG& 1) ; CArchive& operator» (floats f) ; CArchive& operator>>(doubles d);

CArchive& operator>>(int& i);

CArchive& operator>>(short& w); CArchive& operator>>(char& ch); CArchive& operator>>(unsigned& u);

// object read/write

CObject* ReadObject(const CRuntimeClass* pClass); void WriteObject(const CObject* pOb);

// advanced object mapping (used for forced references) void MapObject(const CObject* pOb);

// advanced versioning support

void WriteClass(const CRuntimeClass* pClassRef);

CRuntimeClass* ReadClass(const CRuntimeClass*

pClassRefRequested = NULL, UINT* pSchema = NULL, DWORD* pObTag = NULL);

void SerializeClass(const CRuntimeClass* pClassRef);

// advanced operations (used when storing/loading // many objects)

void SetStoreParams(UINT nHashSize = 2053,

UINT nBlockSize = 128); void SetLoadParams(UINT nGrowBy = 1024);

// Implementation public:

BOOL m_bForceFlat; // for COleClientltem implementation

// (default TRUE) BOOL m_bDirectBuffer; // TRUE if m_pFile supports

// direct buffering void FillBuffer(UINT nBytesNeeded);

void CheckCount(); // throw exception if m_nMapCount

// is too large

// special functions for reading and writing

// (16-bit compatible) counts

DWORD ReadCount();

void WriteCount(DWORD dwCount);

// public for advanced use UINT m_nObjectSchema; CString m_strFileName;

protected:

// archive objects cannot be copied or assigned

CArchive(const CArchive& arSrc);

void operator= (const CArchive& arSrc);

BOOL m_nMode; BOOL m_bUserBuf; int m_nBufSize;

CFile* m_pFile; «’

BYTE* m_lpBufCur; BYTE* m_lpBufMax; BYTE* m_lpBufStart;

// array/map for CObject* and CRuntimeClass* load/store

UINT m_nMapCount;

union

{

CPtrArray* m_pLoadArray; CMapPtrToPtr* m_pStoreMap;

};

// map to keep track of mismatched schemas CMapPtrToPtr* mjpSchemaMap;

// advanced parameters (controls performance with // large archives) UINT m_nGrowSize; UINT m_nHashSize;

};

Давайте попробуем разобраться в принципах работы архива. Для того чтобы создать архив, необходимо, естественно, восполь­зоваться конструктором класса.

Для того чтобы реализовать сериализацию, можно пойти при­вычным путем – в программе создать файл, затем при помощи стан­дартных операций записи в файл «сбросить» в него данные, потом при помощи таких же стандартных операций считать данные. Но де­ло в том, что программе придется работать не с объектами, а с не­которыми блоками памяти или, на худой конец, со строками. Все будет работать нормально, но каждый раз придется считать, какую переменную куда записать, помнить о формате записанной инфор­мации… Ужас!

Можно, конечно, пойти другим путем. В каждой программе раз­работать методы, реализующие сериализацию для каждого кон­кретного класса. Можно при этом использовать уже имеющиеся в языках средства для записи данных в файл.

Но я не зря выше употребил слово «стандартные». Дело в том, что MFC позволяет программистам использовать процедуры се-риализации, которые являются стандартными для MFC. Конечно, процедуру сериализации для всех возможных объектов и органи­зованных в памяти структур данных написать невозможно, но впол­не возможно определить порядок применения процедур сериали-зации, описать интерфейсы и т.д.

Метод работает подобно методу Read(), отличие состоит только в направлении перемещения информации. Кроме этого, метод Write() не возвращает никакого значения.

Перед тем как завершить рассмотрение класса CMemFile, не­обходимо заметить, что методы LockRange(), UnlockRange() и Duplicate(), унаследованные от класса CFile, не поддерживаются. Обращение к ним немедленно приводит к выработке исключения.

void CMemFile::Write(const void* lpBuf, UINT nCount) {

ASSERT_VALID(this);

if (nCount == 0) return;

ASSERT(lpBuf != NULL);

ASSERT(AfxIsValidAddress(lpBuf, nCount, FALSE));

if (m_nPosition + nCount > m_nBufferSize) GrowFile(m_nPosition + nCount);

ASSERT(m_nPosition + nCount <= m_nBufferSize);

Memcpy((BYTE*)m_lpBuffer + m_nPosition, (BYTE*)lpBuf, nCount);

m_nPosition += nCount;

if (m_nPosition > m_nFileSize) m_nFileSize = m_nPosition;

ASSERT_VALID(this);

}