cbformats.cpp

vc座的资源管理器源代码

		dropfiles.pFiles = sizeof(dropfiles);
		dropfiles.fNC = m_fNC;
		dropfiles.pt = m_pt;
#ifdef _UNICODE
		dropfiles.fWide = TRUE;
#else
		dropfiles.fWide = FALSE;
#endif
		ar.Write(&dropfiles,sizeof(DROPFILES));
		LPCTSTR pszFileName=NULL;
		for(int i=0; i < m_nFiles;i++)
		{
			pszFileName=m_sFileNames[i];
			ar.Write(pszFileName,lstrlen(pszFileName)+sizeof(TCHAR));
		}
		TCHAR rchar=0;
		ar.Write(&rchar,sizeof(TCHAR));
	}
}

////////////////////////////////////////////////
// CCF_ShellIDList
////////////////////////////////////////////////
CCF_ShellIDList::CCF_ShellIDList() 
{
}

CCF_ShellIDList::~CCF_ShellIDList()
{
}

LPCITEMIDLIST CCF_ShellIDList::operator[](UINT nIndex) const
{
	return GetPidl(nIndex);
}

LPCITEMIDLIST CCF_ShellIDList::GetPidl(UINT nIndex) const
{
	if (nIndex > (UINT)m_pidls.GetSize()) 
	{ 
		return NULL; 
	} 
	return(m_pidls[nIndex]); 
}

UINT CCF_ShellIDList::GetCount() const
{
	return m_pidls.GetSize();  
}

void CCF_ShellIDList::AddPidl(LPCITEMIDLIST pidl)
{
	m_pidls.Add(pidl);
}

void CCF_ShellIDList::Serialize(CArchive &ar)
{
	if (ar.IsLoading())
	{
		// read the header
		CIDA cida;
		ar.Read(&cida,sizeof(CIDA));
		LPCITEMIDLIST pidl=NULL;
		UINT nOffset;
		// read the ITEMIDLIST structures
		for(UINT i=0;i < cida.cidl+1;i++)
		{
			nOffset = cida.aoffset[i];
			ar.GetFile()->Seek(CFile::begin,nOffset*sizeof(UINT));
			ar.Read((void*)pidl,sizeof(ITEMIDLIST));
			m_pidls.Add(pidl);
		}
	}
	else
	{
		CShellPidl ShellPidl;
		CIDA cida;
		cida.cidl = m_pidls.GetSize();
		ASSERT(cida.cidl > 1);
		if (cida.cidl <= 1)
			return;
		UINT pidls=cida.cidl-1;
		ar.Write(&pidls,sizeof(pidls));
		const UINT nOffset=sizeof(UINT);
		UINT nElemOffset;
		UINT nPidlSize=0;
		for(UINT i1=0;i1 < cida.cidl;i1++)
		{
			nElemOffset = sizeof(cida.cidl)+(cida.cidl*sizeof(nElemOffset))+nOffset+nPidlSize;
			ar.Write(&nElemOffset,sizeof(nElemOffset));
			nPidlSize += ShellPidl.GetSize(m_pidls[i1]);
		}
		BYTE nZero=0;
		for(int i=0;i < nOffset;i++)
			ar.Write(&nZero,sizeof(nZero));
		TRACE1("Writing %u pidls\n",cida.cidl);
		LPSHELLFOLDER pFolder=ShellPidl.GetFolder((LPITEMIDLIST)m_pidls[0]);
		for(UINT i2=0;i2 < cida.cidl;i2++)
		{
#ifdef _DEBUG
			CString sPath;
			ShellPidl.SHPidlToPathEx((LPITEMIDLIST)m_pidls[i2],sPath,pFolder);
			TRACE3("Writing pidl %s (%u) size(%u)\n",sPath,i2,ShellPidl.GetSize(m_pidls[i2]));
#endif	
			ar.Write(m_pidls[i2],ShellPidl.GetSize(m_pidls[i2]));
		}
		if (pFolder)
			pFolder->Release();
	}
}

///////////////////////////////////////////////////////////////////
// Private clipboard formats for drag and drop
///////////////////////////////////////////////////////////////////
const CCF_WebSite &CCF_WebSite::operator=(const CCF_WebSite &rThat)
{
	if (this != &rThat)
	{
		m_strURL = rThat.m_strURL;
		m_strTitle = rThat.m_strTitle;
	}
	return *this;
}

CCF_WebSite::CCF_WebSite(const CCF_WebSite &WebSite)
{
	*this = WebSite;
}

////////////////////////////////////////////

void CCF_App::Serialize(CArchive &ar)
{
	if (ar.IsLoading())
	{
		long hWnd;
		ar >> hWnd;
		m_hWnd = (HWND)hWnd;
	}
	else
	{
		ar << (long)m_hWnd;
	}
}
/////////////////////////////////////////

void CCF_WebSites::Serialize(CArchive &ar)
{
	m_App.Serialize(ar);
	m_listWebSites.Serialize(ar);
}

/////////////////////////////////////////

CCF_String::CCF_String(LPCTSTR pszText) : m_sText(pszText) 
{
}

CCF_String::~CCF_String()
{
}

LPCTSTR CCF_String::GetString()
{
	return m_sText;
}

void CCF_String::SetString(LPCTSTR pszText)
{
	m_sText = pszText;
}

void CCF_String::Serialize(CArchive &ar)
{
	if (ar.IsLoading())
	{
		TCHAR szText[MAX_PATH+1];
		m_sText.Empty();
		while (1)
		{
			ZeroMemory(szText,sizeof(szText));
			ar.Read(szText,MAX_PATH);
			m_sText += szText;
			if (lstrlen(szText) < MAX_PATH)
				break;
		}
	}
	else
	{
		ar.Write((LPCTSTR)m_sText, m_sText.GetLength()*sizeof(TCHAR));
		int null=0;
		ar.Write(&null,sizeof(null));
	}
}

//
// Private clipboard formats for drag and drop
//
CCF_WebSite::CCF_WebSite(LPCTSTR pszURL,LPCTSTR pszTitle) : 
	m_strURL(pszURL),
		m_strTitle(pszTitle)
{
}

CCF_WebSite::~CCF_WebSite()
{
}

void CCF_WebSite::Serialize(CArchive &ar)
{
	if (ar.IsLoading())
	{
		ar >> m_strURL;
		ar >> m_strTitle;
	}
	else
	{
		ar << m_strURL;
		ar << m_strTitle;
	}
}

//
//////////////////////////////////////////////////////

CCF_FolderType::CCF_FolderType(LPCTSTR pszParentCategory,long nCategory,LPCTSTR pszCategory) :
		m_strParentCategory(pszParentCategory),
		m_nCategory(nCategory),
		m_strCategory(pszCategory)
{
}

CCF_FolderType::~CCF_FolderType()
{
}

const CCF_FolderType &CCF_FolderType::operator=(const CCF_FolderType &rThat)
{
	if (this != &rThat)
	{
		m_nCategory = rThat.m_nCategory;
		m_strCategory = rThat.m_strCategory;
		m_strParentCategory = rThat.m_strParentCategory;
	}
	return *this;
}

CCF_FolderType::CCF_FolderType(const CCF_FolderType &WebSiteCategory)
{
	*this = WebSiteCategory;
}

void CCF_FolderType::Serialize(CArchive &ar)
{
	if (ar.IsLoading())
	{
		ar >> m_nCategory;
		ar >> m_strCategory;
		ar >> m_strParentCategory;
	}
	else
	{
		ar << m_nCategory;
		ar << m_strCategory;
		ar << m_strParentCategory;
	}
}

/////////////////////////////////////////////////

void CCF_DBFolderList::Serialize(CArchive &ar)
{
	m_App.Serialize(ar);
	if (ar.IsLoading())
	{
		ar >> m_strDatabase;
	}
	else
	{
		ar << m_strDatabase;
	}
	CList<CCF_FolderType,CCF_FolderType&>::Serialize(ar);
}

template <> void AFXAPI SerializeElements <CCF_FolderType>(CArchive& ar, CCF_FolderType *pWebSite, int nCount )
{
    for ( int i = 0; i < nCount; i++, pWebSite++ )
    {
		pWebSite->Serialize(ar);
	}
}

template<> void AFXAPI DestructElements<CCF_FolderType> (CCF_FolderType *pElements, int nCount)
{
	for ( int n = 0; n < nCount; n++, pElements++ )
	{
		pElements->CCF_FolderType::~CCF_FolderType();
	}
}

template<> void AFXAPI ConstructElements<CCF_FolderType> (CCF_FolderType *pElements, int nCount)
{
	for ( int n = 0; n < nCount; n++, pElements++ )
	{
		pElements->CCF_FolderType::CCF_FolderType();
	}
}

///////////////////////////////////////////////////	
template <> void AFXAPI SerializeElements <CCF_WebSite>(CArchive& ar, CCF_WebSite *pWebSite, int nCount )
{
    for ( int i = 0; i < nCount; i++, pWebSite++ )
    {
		pWebSite->Serialize(ar);
	}
}

template<> void AFXAPI DestructElements<CCF_WebSite> (CCF_WebSite *pElements, int nCount)
{
	for ( int n = 0; n < nCount; n++, pElements++ )
	{
		pElements->CCF_WebSite::~CCF_WebSite();
	}
}

template<> void AFXAPI ConstructElements<CCF_WebSite> (CCF_WebSite *pElements, int nCount)
{
	for ( int n = 0; n < nCount; n++, pElements++ )
	{
		pElements->CCF_WebSite::CCF_WebSite();
	}
}