开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
cbformats.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：15k
源码类别：

图形图象

开发平台：

Visual C++

cbformats.cpp：源码内容
  1. //*******************************************************************************
  2. // COPYRIGHT NOTES
  3. // ---------------
  4. // You may use this source code, compile or redistribute it as part of your application 
  5. // for free. You cannot redistribute it as a part of a software development 
  6. // library without the agreement of the author. If the sources are 
  7. // distributed along with the application, you should leave the original 
  8. // copyright notes in the source code without any changes.
  9. // This code can be used WITHOUT ANY WARRANTIES at your own risk.
  10. // 
  11. // For the latest updates to this code, check this site:
  12. // http://www.masmex.com 
  13. // after Sept 2000
  14. // 
  15. // Copyright(C) 2000 Philip Oldaker <email: philip@masmex.com>
  16. //*******************************************************************************
  18. #include "stdafx.h"
  19. #include "cbformats.h"
  20. #include "shlobj.h"
  21. #include "ShellPidl.h"
  22. #include <afxpriv.h>
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. //static
  31. CWDClipboardData *CWDClipboardData::Instance()
  32. {
  33. static CWDClipboardData data;
  34. return &data;
  35. }
  37. CWDClipboardData::CWDClipboardData()
  38. {
  39. m_aFormatIDs[e_cfString] = CF_TEXT;
  40. m_aFormatIDs[e_cfHDROP] = CF_HDROP;
  41. m_aFormatIDs[e_cfWebSiteURL] = ::RegisterClipboardFormat(CFSTR_SHELLURL);
  42. #ifdef _UNICODE
  43. m_aFormatIDs[e_cfFileGroupDesc] = ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW);
  44. #else
  45. m_aFormatIDs[e_cfFileGroupDesc] = ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTORA);
  46. #endif
  47. m_aFormatIDs[e_cfHTMLFormat] = ::RegisterClipboardFormat(_T("HTML Format"));
  48. m_aFormatIDs[e_cfWebSite] = ::RegisterClipboardFormat(_T("CF_WD_WEBSITE"));
  49. m_aFormatIDs[e_cfRightMenu] = ::RegisterClipboardFormat(_T("CF_WD_RIGHTMENU"));
  50. m_aFormatIDs[e_cfFolder] = ::RegisterClipboardFormat(_T("CF_WD_WEBSITE_CATEGORY"));
  51. m_aFormatIDs[e_cfShellIDList] = ::RegisterClipboardFormat(CFSTR_SHELLIDLIST);
  52. }
  54. CWDClipboardData::~CWDClipboardData()
  55. {
  56. }
  58. bool CWDClipboardData::IsValidFormat(CLIPFORMAT cfFormat)
  59. {
  60. for(int i=0;i < e_cfMax;i++)
  61. {
  62. if (m_aFormatIDs[i] == cfFormat)
  63. break;
  64. }
  65. return(i != e_cfMax);
  66. }
  68. bool CWDClipboardData::IsDataAvailable(COleDataObject *pDataObject)
  69. {
  70. // Iterate through the clipboard formats
  71. pDataObject->BeginEnumFormats();
  72. FORMATETC FormatEtc;
  73. bool bFound=false;
  74. #ifdef _DEBUG
  75. TCHAR szBuf[128];
  76. #endif
  77. while (pDataObject->GetNextFormat(&FormatEtc))
  78. {
  79. #ifdef _DEBUG
  80. szBuf[0] = 0;
  81. if (FormatEtc.cfFormat > CF_MAX)
  82. {
  83. ::GetClipboardFormatName(FormatEtc.cfFormat,szBuf,sizeof(szBuf)-1);
  84. }
  85. else
  86. {
  87. lstrcpy(szBuf,_T("Predefined Format"));
  88. }
  89. TRACE(_T("Enum formats returned %u(%s) %dn"),FormatEtc.cfFormat,szBuf,FormatEtc.tymed);
  90. #endif
  91. if (IsValidFormat(FormatEtc.cfFormat))
  92. {
  93. #ifdef _DEBUG
  94. TRACE(_T("Clipboard format found %u(%s) tymed(%d), Aspect(%d)n"),FormatEtc.cfFormat,szBuf,FormatEtc.tymed,FormatEtc.dwAspect);
  95. #endif
  96. bFound=true;
  97. }
  98. }
  99. return bFound;
  100. }
  102. CLIPFORMAT CWDClipboardData::GetClipboardFormat(eCBFormats format)
  103. {
  104. return m_aFormatIDs[format]; 
  105. }
  107. void CWDClipboardData::SetData(COleDataSource *pOleDataSource,CObject *pObj,eCBFormats format,LPFORMATETC lpFormatEtc)
  108. {
  109. ASSERT(pOleDataSource);
  110. ASSERT(pObj);
  112. // use serialization
  113. CSharedFile file;
  114. CArchive ar(&file,CArchive::store);
  115. pObj->Serialize(ar);
  116. ar.Close();
  118. // cache into drag drop source
  119. pOleDataSource->CacheGlobalData(CWDClipboardData::Instance()->GetClipboardFormat(format),file.Detach(),lpFormatEtc);
  120. }
  122. bool CWDClipboardData::GetData(COleDataObject *pDataObject,CObject *pObj,eCBFormats format)
  123. {
  124. ASSERT(pDataObject);
  125. ASSERT(pObj);
  126. if (pDataObject == NULL || pObj == NULL)
  127. return false;
  129. if (m_aFormatIDs[format] == CF_HDROP)
  130. {
  131. FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  132. STGMEDIUM medium;
  133. if (pDataObject->GetData(CF_HDROP, &medium, &fmte))
  134. {
  135. HDROP hDropInfo = (HDROP)medium.hGlobal;
  136. UINT wNumFilesDropped = DragQueryFile(hDropInfo, 0XFFFFFFFF, NULL, 0);
  137. TCHAR szFile[MAX_PATH];
  138. ASSERT_KINDOF(CCF_HDROP,pObj);
  139. CCF_HDROP *pHDROP = (CCF_HDROP*)pObj;
  140. UINT nLen;
  141. for(UINT i=0; i < wNumFilesDropped;i++)
  142. {
  143. nLen = DragQueryFile(hDropInfo,i,szFile,sizeof(szFile)/sizeof(TCHAR));
  144. if (nLen)
  145. {
  146. pHDROP->AddFileName(szFile);
  147. }
  148. }
  149. if (medium.pUnkForRelease)
  150. medium.pUnkForRelease->Release();
  151. else
  152. GlobalFree(medium.hGlobal);
  153. }
  154. }
  155. else
  156. {
  157. CFile *pFile = pDataObject->GetFileData(CWDClipboardData::Instance()->GetClipboardFormat(format));
  158. if (pFile)
  159. {
  160. CArchive ar(pFile,CArchive::load);
  161. pObj->Serialize(ar);
  162. ar.Close();
  163. delete pFile;
  164. }
  165. }
  166. return true;
  167. }
  169. ///////////////////////////////////////////
  170. //
  171. // Clipboard objects
  172. //
  173. ///////////////////////////////////////////
  174. IMPLEMENT_SERIAL(CCF_App, CObject, 0 );
  175. IMPLEMENT_SERIAL(CCF_WebSites,CObject,0);
  176. IMPLEMENT_SERIAL(CCF_String, CObject, 0 );
  177. IMPLEMENT_SERIAL(CCF_WebSite, CObject, 0 );
  178. IMPLEMENT_SERIAL(CCF_FolderType, CObject, 0 );
  179. IMPLEMENT_SERIAL(CCF_DBFolderList,CObject,0);
  180. IMPLEMENT_SERIAL(CCF_RightMenu, CObject, 0 );
  181. IMPLEMENT_SERIAL(CCF_FileGroupDescriptor,CObject,0);
  182. IMPLEMENT_SERIAL(CCF_ShellIDList,CObject,0);
  183. IMPLEMENT_SERIAL(CCF_HDROP,CObject,0);
  184. ///////////////////////////////////////////
  185. bool CCF_RightMenu::IsRightDrag()
  186. {
  187. return m_bRightDrag;
  188. }
  190. void CCF_RightMenu::SetRightDrag(bool bRightDrag)
  191. {
  192. m_bRightDrag = bRightDrag;
  193. }
  195. void CCF_RightMenu::Serialize(CArchive &ar)
  196. {
  197. if (ar.IsLoading())
  198. {
  199. int nRightDrag;
  200. ar >> nRightDrag;
  201. m_bRightDrag = nRightDrag == 1;
  202. }
  203. else
  204. {
  205. ar << m_bRightDrag;
  206. }
  207. }
  209. CCF_FileGroupDescriptor::CCF_FileGroupDescriptor() 
  210. {
  211. m_pFileDescrs = NULL;
  212. m_nItems = 0;
  213. }
  215. CCF_FileGroupDescriptor::~CCF_FileGroupDescriptor()
  216. {
  217. delete []m_pFileDescrs;
  218. }
  220. LPFILEDESCRIPTOR CCF_FileGroupDescriptor::GetFileDescriptor(UINT nItem)
  221. {
  222. if (m_pFileDescrs == NULL)
  223. return NULL;
  224. if (nItem >= m_nItems)
  225. {
  226. ASSERT(FALSE);
  227. return NULL;
  228. }
  229. return &m_pFileDescrs[nItem];
  230. }
  232. void CCF_FileGroupDescriptor::SetTitle(const CString &sTitle)
  233. {
  234. m_sTitle = sTitle;
  235. }
  237. CString CCF_FileGroupDescriptor::GetFileName(UINT nItem)
  238. {
  239. if (nItem >= m_nItems || m_pFileDescrs == NULL)
  240. {
  241. ASSERT(FALSE);
  242. return CString();
  243. }
  244. return m_pFileDescrs[nItem].cFileName;
  245. }
  247. CString CCF_FileGroupDescriptor::GetTitle(UINT nItem)
  248. {
  249. if (nItem >= m_nItems || m_pFileDescrs == NULL)
  250. {
  251. ASSERT(FALSE);
  252. return CString();
  253. }
  254. CString strLink(m_pFileDescrs[nItem].cFileName);
  255. int nPos = strLink.Find(_T(".URL"));
  256. if (nPos < 0)
  257. nPos = strLink.Find(_T(".url"));
  258. if (nPos > 0)
  259. {
  260. return strLink.Left(nPos);
  261. }
  262. return strLink;
  263. }
  265. void CCF_FileGroupDescriptor::Serialize(CArchive &ar)
  266. {
  267. if (ar.IsLoading())
  268. {
  269. ar.Read(&m_nItems,sizeof(UINT));
  270. if (m_nItems)
  271. {
  272. m_pFileDescrs = new FILEDESCRIPTOR[m_nItems];
  273. ar.Read(m_pFileDescrs,sizeof(FILEDESCRIPTOR)*m_nItems);
  274. for(UINT i=0;i < m_nItems;i++)
  275. TRACE3("(%u) - cFileName %s, Size=%un",i,m_pFileDescrs[i].cFileName,m_pFileDescrs[i].nFileSizeLow);
  276. }
  277. }
  278. else
  279. {
  280. UINT cItems=1;
  281. ar.Write(&cItems,sizeof(UINT));
  282. FILEDESCRIPTOR FileDesc;
  283. ZeroMemory(&FileDesc,sizeof(FILEDESCRIPTOR));
  284. FileDesc.dwFlags = (FD_LINKUI | FD_FILESIZE);
  285. if (!m_sTitle.IsEmpty())
  286. {
  287. lstrcpy(FileDesc.cFileName,m_sTitle);
  288. lstrcat(FileDesc.cFileName,_T(".url"));
  289. FileDesc.nFileSizeLow = lstrlen(FileDesc.cFileName)+24;
  290. ar.Write(&FileDesc,sizeof(FILEDESCRIPTOR));
  291. }
  292. }
  293. }
  295. ////////////////////////////////////////////////
  296. // CCF_HDROP
  297. ////////////////////////////////////////////////
  298. CCF_HDROP::CCF_HDROP() 
  299. {
  300. m_nFiles = 0;
  301. m_fNC = FALSE;
  302. }
  304. CCF_HDROP::~CCF_HDROP()
  305. {
  306. }
  308. CString CCF_HDROP::GetFileName(UINT nItem)
  309. {
  310. if (m_sFileNames.GetSize() > 0)
  311. return m_sFileNames[nItem];
  312. return _T("");
  313. }
  315. void CCF_HDROP::AddDropPoint(CPoint &pt,BOOL fNC)
  316. {
  317. m_pt = pt;
  318. m_fNC = fNC;
  319. }
  321. void CCF_HDROP::AddFileName(LPCTSTR pszFileName)
  322. {
  323. m_sFileNames.SetAtGrow(m_nFiles++,pszFileName);
  324. }
  326. void CCF_HDROP::Serialize(CArchive &ar)
  327. {
  328. if (ar.IsLoading())
  329. {
  330. // handled in GetData
  331. }
  332. else
  333. {
  334. DROPFILES dropfiles;
  335. dropfiles.pFiles = sizeof(dropfiles);
  336. dropfiles.fNC = m_fNC;
  337. dropfiles.pt = m_pt;
  338. #ifdef _UNICODE
  339. dropfiles.fWide = TRUE;
  340. #else
  341. dropfiles.fWide = FALSE;
  342. #endif
  343. ar.Write(&dropfiles,sizeof(DROPFILES));
  344. LPCTSTR pszFileName=NULL;
  345. for(int i=0; i < m_nFiles;i++)
  346. {
  347. pszFileName=m_sFileNames[i];
  348. ar.Write(pszFileName,lstrlen(pszFileName)+sizeof(TCHAR));
  349. }
  350. TCHAR rchar=0;
  351. ar.Write(&rchar,sizeof(TCHAR));
  352. }
  353. }
  355. ////////////////////////////////////////////////
  356. // CCF_ShellIDList
  357. ////////////////////////////////////////////////
  358. CCF_ShellIDList::CCF_ShellIDList() 
  359. {
  360. }
  362. CCF_ShellIDList::~CCF_ShellIDList()
  363. {
  364. }
  366. LPCITEMIDLIST CCF_ShellIDList::operator[](UINT nIndex) const
  367. {
  368. return GetPidl(nIndex);
  369. }
  371. LPCITEMIDLIST CCF_ShellIDList::GetPidl(UINT nIndex) const
  372. {
  373. if (nIndex > (UINT)m_pidls.GetSize()) 
  374. { 
  375. return NULL; 
  376. } 
  377. return(m_pidls[nIndex]); 
  378. }
  380. UINT CCF_ShellIDList::GetCount() const
  381. {
  382. return m_pidls.GetSize();  
  383. }
  385. void CCF_ShellIDList::AddPidl(LPCITEMIDLIST pidl)
  386. {
  387. m_pidls.Add(pidl);
  388. }
  390. void CCF_ShellIDList::Serialize(CArchive &ar)
  391. {
  392. if (ar.IsLoading())
  393. {
  394. // read the header
  395. CIDA cida;
  396. ar.Read(&cida,sizeof(CIDA));
  397. LPCITEMIDLIST pidl=NULL;
  398. UINT nOffset;
  399. // read the ITEMIDLIST structures
  400. for(UINT i=0;i < cida.cidl+1;i++)
  401. {
  402. nOffset = cida.aoffset[i];
  403. ar.GetFile()->Seek(CFile::begin,nOffset*sizeof(UINT));
  404. ar.Read((void*)pidl,sizeof(ITEMIDLIST));
  405. m_pidls.Add(pidl);
  406. }
  407. }
  408. else
  409. {
  410. CShellPidl ShellPidl;
  411. CIDA cida;
  412. cida.cidl = m_pidls.GetSize();
  413. ASSERT(cida.cidl > 1);
  414. if (cida.cidl <= 1)
  415. return;
  416. UINT pidls=cida.cidl-1;
  417. ar.Write(&pidls,sizeof(pidls));
  418. const UINT nOffset=sizeof(UINT);
  419. UINT nElemOffset;
  420. UINT nPidlSize=0;
  421. for(UINT i1=0;i1 < cida.cidl;i1++)
  422. {
  423. nElemOffset = sizeof(cida.cidl)+(cida.cidl*sizeof(nElemOffset))+nOffset+nPidlSize;
  424. ar.Write(&nElemOffset,sizeof(nElemOffset));
  425. nPidlSize += ShellPidl.GetSize(m_pidls[i1]);
  426. }
  427. BYTE nZero=0;
  428. for(int i=0;i < nOffset;i++)
  429. ar.Write(&nZero,sizeof(nZero));
  430. TRACE1("Writing %u pidlsn",cida.cidl);
  431. LPSHELLFOLDER pFolder=ShellPidl.GetFolder((LPITEMIDLIST)m_pidls[0]);
  432. for(UINT i2=0;i2 < cida.cidl;i2++)
  433. {
  434. #ifdef _DEBUG
  435. CString sPath;
  436. ShellPidl.SHPidlToPathEx((LPITEMIDLIST)m_pidls[i2],sPath,pFolder);
  437. TRACE3("Writing pidl %s (%u) size(%u)n",sPath,i2,ShellPidl.GetSize(m_pidls[i2]));
  438. #endif
  439. ar.Write(m_pidls[i2],ShellPidl.GetSize(m_pidls[i2]));
  440. }
  441. if (pFolder)
  442. pFolder->Release();
  443. }
  444. }
  446. ///////////////////////////////////////////////////////////////////
  447. // Private clipboard formats for drag and drop
  448. ///////////////////////////////////////////////////////////////////
  449. const CCF_WebSite &CCF_WebSite::operator=(const CCF_WebSite &rThat)
  450. {
  451. if (this != &rThat)
  452. {
  453. m_strURL = rThat.m_strURL;
  454. m_strTitle = rThat.m_strTitle;
  455. }
  456. return *this;
  457. }
  459. CCF_WebSite::CCF_WebSite(const CCF_WebSite &WebSite)
  460. {
  461. *this = WebSite;
  462. }
  464. ////////////////////////////////////////////
  466. void CCF_App::Serialize(CArchive &ar)
  467. {
  468. if (ar.IsLoading())
  469. {
  470. long hWnd;
  471. ar >> hWnd;
  472. m_hWnd = (HWND)hWnd;
  473. }
  474. else
  475. {
  476. ar << (long)m_hWnd;
  477. }
  478. }
  479. /////////////////////////////////////////
  481. void CCF_WebSites::Serialize(CArchive &ar)
  482. {
  483. m_App.Serialize(ar);
  484. m_listWebSites.Serialize(ar);
  485. }
  487. /////////////////////////////////////////
  489. CCF_String::CCF_String(LPCTSTR pszText) : m_sText(pszText) 
  490. {
  491. }
  493. CCF_String::~CCF_String()
  494. {
  495. }
  497. LPCTSTR CCF_String::GetString()
  498. {
  499. return m_sText;
  500. }
  502. void CCF_String::SetString(LPCTSTR pszText)
  503. {
  504. m_sText = pszText;
  505. }
  507. void CCF_String::Serialize(CArchive &ar)
  508. {
  509. if (ar.IsLoading())
  510. {
  511. TCHAR szText[MAX_PATH+1];
  512. m_sText.Empty();
  513. while (1)
  514. {
  515. ZeroMemory(szText,sizeof(szText));
  516. ar.Read(szText,MAX_PATH);
  517. m_sText += szText;
  518. if (lstrlen(szText) < MAX_PATH)
  519. break;
  520. }
  521. }
  522. else
  523. {
  524. ar.Write((LPCTSTR)m_sText, m_sText.GetLength()*sizeof(TCHAR));
  525. int null=0;
  526. ar.Write(&null,sizeof(null));
  527. }
  528. }
  530. //
  531. // Private clipboard formats for drag and drop
  532. //
  533. CCF_WebSite::CCF_WebSite(LPCTSTR pszURL,LPCTSTR pszTitle) : 
  534. m_strURL(pszURL),
  535. m_strTitle(pszTitle)
  536. {
  537. }
  539. CCF_WebSite::~CCF_WebSite()
  540. {
  541. }
  543. void CCF_WebSite::Serialize(CArchive &ar)
  544. {
  545. if (ar.IsLoading())
  546. {
  547. ar >> m_strURL;
  548. ar >> m_strTitle;
  549. }
  550. else
  551. {
  552. ar << m_strURL;
  553. ar << m_strTitle;
  554. }
  555. }
  557. //
  558. //////////////////////////////////////////////////////
  560. CCF_FolderType::CCF_FolderType(LPCTSTR pszParentCategory,long nCategory,LPCTSTR pszCategory) :
  561. m_strParentCategory(pszParentCategory),
  562. m_nCategory(nCategory),
  563. m_strCategory(pszCategory)
  564. {
  565. }
  567. CCF_FolderType::~CCF_FolderType()
  568. {
  569. }
  571. const CCF_FolderType &CCF_FolderType::operator=(const CCF_FolderType &rThat)
  572. {
  573. if (this != &rThat)
  574. {
  575. m_nCategory = rThat.m_nCategory;
  576. m_strCategory = rThat.m_strCategory;
  577. m_strParentCategory = rThat.m_strParentCategory;
  578. }
  579. return *this;
  580. }
  582. CCF_FolderType::CCF_FolderType(const CCF_FolderType &WebSiteCategory)
  583. {
  584. *this = WebSiteCategory;
  585. }
  587. void CCF_FolderType::Serialize(CArchive &ar)
  588. {
  589. if (ar.IsLoading())
  590. {
  591. ar >> m_nCategory;
  592. ar >> m_strCategory;
  593. ar >> m_strParentCategory;
  594. }
  595. else
  596. {
  597. ar << m_nCategory;
  598. ar << m_strCategory;
  599. ar << m_strParentCategory;
  600. }
  601. }
  603. /////////////////////////////////////////////////
  605. void CCF_DBFolderList::Serialize(CArchive &ar)
  606. {
  607. m_App.Serialize(ar);
  608. if (ar.IsLoading())
  609. {
  610. ar >> m_strDatabase;
  611. }
  612. else
  613. {
  614. ar << m_strDatabase;
  615. }
  616. CList<CCF_FolderType,CCF_FolderType&>::Serialize(ar);
  617. }
  619. template <> void AFXAPI SerializeElements <CCF_FolderType>(CArchive& ar, CCF_FolderType *pWebSite, int nCount )
  620. {
  621.     for ( int i = 0; i < nCount; i++, pWebSite++ )
  622.     {
  623. pWebSite->Serialize(ar);
  624. }
  625. }
  627. template<> void AFXAPI DestructElements<CCF_FolderType> (CCF_FolderType *pElements, int nCount)
  628. {
  629. for ( int n = 0; n < nCount; n++, pElements++ )
  630. {
  631. pElements->CCF_FolderType::~CCF_FolderType();
  632. }
  633. }
  635. template<> void AFXAPI ConstructElements<CCF_FolderType> (CCF_FolderType *pElements, int nCount)
  636. {
  637. for ( int n = 0; n < nCount; n++, pElements++ )
  638. {
  639. pElements->CCF_FolderType::CCF_FolderType();
  640. }
  641. }
  643. ///////////////////////////////////////////////////
  644. template <> void AFXAPI SerializeElements <CCF_WebSite>(CArchive& ar, CCF_WebSite *pWebSite, int nCount )
  645. {
  646.     for ( int i = 0; i < nCount; i++, pWebSite++ )
  647.     {
  648. pWebSite->Serialize(ar);
  649. }
  650. }
  652. template<> void AFXAPI DestructElements<CCF_WebSite> (CCF_WebSite *pElements, int nCount)
  653. {
  654. for ( int n = 0; n < nCount; n++, pElements++ )
  655. {
  656. pElements->CCF_WebSite::~CCF_WebSite();
  657. }
  658. }
  660. template<> void AFXAPI ConstructElements<CCF_WebSite> (CCF_WebSite *pElements, int nCount)
  661. {
  662. for ( int n = 0; n < nCount; n++, pElements++ )
  663. {
  664. pElements->CCF_WebSite::CCF_WebSite();
  665. }
  666. }