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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
PROPSET.CPP
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：40k
源码类别：

界面编程

开发平台：

Visual C++

PROPSET.CPP：源码内容
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  11. #include "stdafx.h"
  13. #include <malloc.h>
  14. #include <ole2.h>
  15. #include <oleauto.h>
  17. #ifndef __DRAWCLI_PROPSET_H
  18. #include "propset.h"
  19. #endif // __DRAWCLI_PROPSET_H
  21. #ifdef AFXCTL_PROP_SEG
  22. #pragma code_seg(AFXCTL_PROP_SEG)
  23. #endif
  25. #ifdef _DEBUG
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. #define new DEBUG_NEW
  33. static LPVOID CountPrefixedStringA(LPCSTR lpsz)
  34. {
  35. DWORD cb = (lstrlenA( lpsz ) + 1);
  36. LPDWORD lp = (LPDWORD)malloc( (int)cb + sizeof(DWORD) );
  37. if (lp)
  38. {
  39. *lp = cb;
  40. lstrcpyA( (LPSTR)(lp+1), lpsz );
  41. }
  43. return (LPVOID)lp;
  44. }
  47. static LPVOID CountPrefixedStringW(LPCWSTR lpsz)
  48. {
  49. DWORD cb = DWORD( wcslen( lpsz ) + 1 );
  50. LPDWORD lp = (LPDWORD)malloc( (int)cb * sizeof(WCHAR) + sizeof(DWORD) );
  51. if (lp)
  52. {
  53. *lp = cb;
  54. __EXT_MFC_WCSCPY( (LPWSTR)(lp+1), wcslen( (LPWSTR)(lp+1) ), lpsz );
  55. }
  57. return (LPVOID)lp;
  58. }
  61. #ifdef _UNICODE
  62. #define CountPrefixedStringT CountPrefixedStringW
  63. #else
  64. #define CountPrefixedStringT CountPrefixedStringA
  65. #endif
  68. #ifdef _UNICODE
  70. #define MAX_STRLEN 1024
  72. static LPBYTE ConvertStringProp(LPBYTE pbProp, DWORD dwType, ULONG nReps,
  73. size_t cbCharSize)
  74. {
  75. LPBYTE pbResult = NULL; // Return value
  76. ULONG cbResult = 0;     // Number of bytes in pbResult
  77. LPBYTE pbBuffer;        // Temporary holding space
  78. ULONG cchOrig;          // Number of characters in original string
  79. ULONG cchCopy;          // Number of characters to copy
  80. ULONG cbCopy;           // Number of bytes to copy
  81. LPBYTE pbResultNew;     // Used for realloc of pbResult
  83. pbBuffer = (LPBYTE)malloc(MAX_STRLEN * cbCharSize);
  84. if (pbBuffer == NULL)
  85. return NULL;
  87. // If it's a vector, the count goes first.
  88. if (dwType & VT_VECTOR)
  89. {
  90. pbResult = (LPBYTE)malloc(sizeof(DWORD));
  91. if (pbResult == NULL)
  92. {
  93. free(pbBuffer);
  94. return NULL;
  95. }
  96. *(LPDWORD)pbResult = nReps;
  97. cbResult = sizeof(DWORD);
  98. }
  100. while (nReps--)
  101. {
  102. cchOrig = *(LPDWORD)pbProp;
  103. pbProp += sizeof(DWORD);
  105. // Convert multibyte string to Unicode.
  106. if (cbCharSize == sizeof(WCHAR))
  107. {
  108. cchCopy = _mbstowcsz((LPWSTR)pbBuffer, (LPSTR)pbProp,
  109. min(cchOrig, MAX_STRLEN));
  110. }
  111. else
  112. {
  113. cchCopy = _wcstombsz((LPSTR)pbBuffer, (LPWSTR)pbProp,
  114. min(cchOrig, MAX_STRLEN));
  115. }
  117. // Allocate space to append string.
  118. cbCopy = ULONG( cchCopy * cbCharSize );
  119. pbResultNew = (LPBYTE)realloc(pbResult, cbResult + sizeof(DWORD) +
  120. cbCopy);
  122. // If allocation failed, cleanup and return NULL;
  123. if (pbResultNew == NULL)
  124. {
  125. free(pbResult);
  126. free(pbBuffer);
  127. return NULL;
  128. }
  130. pbResult = pbResultNew;
  132. // Copy character count and converted string into place,
  133. // then update the total size.
  134. memcpy(pbResult + cbResult, (LPBYTE)&cchCopy, sizeof(DWORD));
  135. memcpy(pbResult + cbResult + sizeof(DWORD), pbBuffer, cbCopy);
  136. cbResult += sizeof(DWORD) + cbCopy;
  138. // Advance to the next vector element
  139. pbProp += (cchOrig * cbCharSize);
  140. }
  142. free(pbBuffer);
  143. return pbResult;
  144. }
  146. #endif // _UNICODE
  149. /////////////////////////////////////////////////////////////////////////////
  150. //Implementation of the CDrawCliProperty class
  152. CDrawCliProperty::CDrawCliProperty( void )
  153. {
  154. m_dwPropID = 0;
  156. m_dwType = VT_EMPTY;
  157. m_pValue = NULL;       // must init to NULL
  158. }
  160. CDrawCliProperty::CDrawCliProperty( DWORD dwID, const LPVOID pValue, DWORD dwType )
  161. {
  162. m_dwPropID = dwID;
  163. m_dwType = dwType;
  164. m_pValue = NULL;       // must init to NULL
  165. Set( dwID, pValue, dwType );
  166. }
  168. CDrawCliProperty::~CDrawCliProperty()
  169. {
  170. FreeValue();
  171. }
  173. BOOL CDrawCliProperty::Set( DWORD dwID, const LPVOID pValue, DWORD dwType )
  174. {
  175. m_dwType = dwType;
  176. m_dwPropID = dwID;
  178. return Set( pValue );
  179. }
  181. BOOL CDrawCliProperty::Set( const LPVOID pValue, DWORD dwType )
  182. {
  183. m_dwType = dwType;
  184. return Set( pValue );
  185. }
  187. BOOL CDrawCliProperty::Set( const  LPVOID pVal )
  188. {
  189. ULONG           cb;
  190. ULONG           cbItem;
  191. ULONG           cbValue;
  192. ULONG           nReps;
  193. LPBYTE          pCur;
  194. LPVOID          pValue = pVal;
  195. DWORD           dwType = m_dwType;
  196. LPVOID          pValueOrig = NULL;
  198. if (m_pValue != NULL)
  199. {
  200. FreeValue();
  201. }
  203. if (pValue == NULL || m_dwType == 0)
  204. return TRUE;
  206. // Given pValue, determine how big it is
  207. // Then allocate a new buffer for m_pValue and copy...
  208. nReps = 1;
  209. cbValue = 0;
  210. pCur = (LPBYTE)pValue;
  211. if (m_dwType & VT_VECTOR)
  212. {
  213. // The next DWORD is a count of the elements
  214. nReps = *(LPDWORD)pValue;
  215. cb = sizeof( nReps );
  216. pCur += cb;
  217. cbValue += cb;
  218. dwType &= ~VT_VECTOR;
  219. }
  220. else
  221. {
  222. // If we get any of the string-like types,
  223. // and we are not a vector create a count-prefixed
  224. // buffer.
  225. switch (dwType )
  226. {
  227. case VT_LPSTR:          // null terminated string
  228. pValueOrig = pValue;
  229. pValue = CountPrefixedStringA( (LPSTR)pValueOrig );
  230. pCur = (LPBYTE)pValue;
  231. break;
  233. case VT_BSTR:           // binary string
  234. case VT_STREAM:         // Name of the stream follows
  235. case VT_STORAGE:        // Name of the storage follows
  236. case VT_STREAMED_OBJECT:// Stream contains an object
  237. case VT_STORED_OBJECT:  // Storage contains an object
  238. pValueOrig = pValue;
  239. pValue = CountPrefixedStringT( (LPTSTR)pValueOrig );
  240. pCur = (LPBYTE)pValue;
  241. break;
  243. case VT_LPWSTR:         // UNICODE string
  244. pValueOrig = pValue;
  245. pValue = CountPrefixedStringW( (LPWSTR)pValueOrig );
  246. pCur = (LPBYTE)pValue;
  247. break;
  248. }
  249. }
  251. // Since a value can be made up of a vector (VT_VECTOR) of
  252. // items, we first seek through the value, picking out
  253. // each item, getting it's size.
  254. //
  255. cbItem = 0;        // Size of the current item
  256. while (nReps--)
  257. {
  258. switch (dwType)
  259. {
  260. case VT_EMPTY:          // nothing
  261. cbItem = 0;
  262. break;
  264. case VT_I2:             // 2 byte signed int
  265. case VT_BOOL:           // True=-1, False=0
  266. cbItem = 2;
  267. break;
  269. case VT_I4:             // 4 byte signed int
  270. case VT_R4:             // 4 byte real
  271. cbItem = 4;
  272. break;
  274. case VT_R8:             // 8 byte real
  275. case VT_CY:             // currency
  276. case VT_DATE:           // date
  277. case VT_I8:             // signed 64-bit int
  278. case VT_FILETIME:       // FILETIME
  279. cbItem = 8;
  280. break;
  282. case VT_CLSID:          // A Class ID
  283. cbItem = sizeof(CLSID);
  284. break;
  286. #ifndef _UNICODE
  287. case VT_BSTR:           // binary string
  288. case VT_STREAM:         // Name of the stream follows
  289. case VT_STORAGE:        // Name of the storage follows
  290. case VT_STREAMED_OBJECT:// Stream contains an object
  291. case VT_STORED_OBJECT:  // Storage contains an object
  292. case VT_STREAMED_PROPSET:// Stream contains a propset
  293. case VT_STORED_PROPSET: // Storage contains a propset
  294. #endif // _UNICODE
  295. case VT_LPSTR:          // null terminated string
  296. case VT_BLOB_OBJECT:    // Blob contains an object
  297. case VT_BLOB_PROPSET:   // Blob contains a propset
  298. case VT_BLOB:           // Length prefixed bytes
  299. case VT_CF:             // Clipboard format
  300. // Get the DWORD that gives us the size, making
  301. // sure we increment cbValue.
  302. cbItem = *(LPDWORD)pCur;
  303. cb = sizeof(cbItem);
  304. pCur += cb;
  305. cbValue += cb;
  306. break;
  308. #ifdef _UNICODE
  309. case VT_BSTR:           // binary string
  310. case VT_STREAM:         // Name of the stream follows
  311. case VT_STORAGE:        // Name of the storage follows
  312. case VT_STREAMED_OBJECT:// Stream contains an object
  313. case VT_STORED_OBJECT:  // Storage contains an object
  314. case VT_STREAMED_PROPSET:// Stream contains a propset
  315. case VT_STORED_PROPSET: // Storage contains a propset
  316. #endif // _UNICODE
  317. case VT_LPWSTR:         // UNICODE string
  318. cbItem = *(LPDWORD)pCur * sizeof(WCHAR);
  319. cb = sizeof( cbItem );
  320. pCur += cb;
  321. cbValue += cb;
  322. break;
  323. case VT_VARIANT:        // VARIANT*
  324. break;
  326. default:
  327. if (pValueOrig)
  328. free( pValue );
  329. return FALSE;
  330. }
  332. // Add 'cb' to cbItem before seeking...
  333. //
  334. // Seek to the next item
  335. pCur += cbItem;
  336. cbValue += cbItem;
  337. }
  339. if (NULL == AllocValue(cbValue))
  340. {
  341. TRACE0("CDrawCliProperty::AllocValue failed");
  342. return FALSE;
  343. }
  344. memcpy( m_pValue, pValue, (int)cbValue );
  346. if (pValueOrig)
  347. free( pValue );
  349. return TRUE;
  350. }
  352. LPVOID CDrawCliProperty::Get( void )
  353. {   return Get( (DWORD*)NULL );   }
  355. LPVOID CDrawCliProperty::Get( DWORD* pcb )
  356. {
  357. DWORD   cb = 0;
  358. LPBYTE  p = NULL;
  360. p = (LPBYTE)m_pValue;
  362. // m_pValue points to a Property "Value" which may
  363. // have size information included...
  364. switch( m_dwType )
  365. {
  366. case VT_EMPTY:          // nothing
  367. cb = 0;
  368. break;
  370. case VT_I2:             // 2 byte signed int
  371. case VT_BOOL:           // True=-1, False=0
  372. cb = 2;
  373. break;
  375. case VT_I4:             // 4 byte signed int
  376. case VT_R4:             // 4 byte real
  377. cb = 4;
  378. break;
  380. case VT_R8:             // 8 byte real
  381. case VT_CY:             // currency
  382. case VT_DATE:           // date
  383. case VT_I8:             // signed 64-bit int
  384. case VT_FILETIME:       // FILETIME
  385. cb = 8;
  386. break;
  388. #ifndef _UNICODE
  389. case VT_BSTR:           // binary string
  390. case VT_STREAM:         // Name of the stream follows
  391. case VT_STORAGE:        // Name of the storage follows
  392. case VT_STREAMED_OBJECT:// Stream contains an object
  393. case VT_STORED_OBJECT:  // Storage contains an object
  394. case VT_STREAMED_PROPSET:// Stream contains a propset
  395. case VT_STORED_PROPSET: // Storage contains a propset
  396. #endif // UNICODE
  397. case VT_LPSTR:          // null terminated string
  398. case VT_CF:             // Clipboard format
  399. // Read the DWORD that gives us the size, making
  400. // sure we increment cbValue.
  401. cb = *(LPDWORD)p;
  402. p += sizeof( DWORD );
  403. break;
  405. case VT_BLOB:           // Length prefixed bytes
  406. case VT_BLOB_OBJECT:    // Blob contains an object
  407. case VT_BLOB_PROPSET:   // Blob contains a propset
  408. // Read the DWORD that gives us the size.
  409. cb = *(LPDWORD)p;
  410. break;
  412. #ifdef _UNICODE
  413. case VT_BSTR:           // binary string
  414. case VT_STREAM:         // Name of the stream follows
  415. case VT_STORAGE:        // Name of the storage follows
  416. case VT_STREAMED_OBJECT:// Stream contains an object
  417. case VT_STORED_OBJECT:  // Storage contains an object
  418. case VT_STREAMED_PROPSET:// Stream contains a propset
  419. case VT_STORED_PROPSET: // Storage contains a propset
  420. #endif // _UNICODE
  421. case VT_LPWSTR:         // UNICODE string
  422. cb = *(LPDWORD)p * sizeof(WCHAR);
  423. p += sizeof( DWORD );
  424. break;
  426. case VT_CLSID:          // A Class ID
  427. cb = sizeof(CLSID);
  428. break;
  430. case VT_VARIANT:        // VARIANT*
  431. break;
  433. default:
  434. return NULL;
  435. }
  436. if (pcb != NULL)
  437. *pcb = cb;
  439. return p;
  440. }
  442. DWORD  CDrawCliProperty::GetType( void )
  443. {   return m_dwType;  }
  445. void   CDrawCliProperty::SetType( DWORD dwType )
  446. {   m_dwType = dwType; }
  448. DWORD CDrawCliProperty::GetID( void )
  449. {   return m_dwPropID;   }
  451. void CDrawCliProperty::SetID( DWORD dwPropID )
  452. {    m_dwPropID = dwPropID;   }
  454. LPVOID CDrawCliProperty::GetRawValue( void )
  455. {   return m_pValue; }
  457. BOOL CDrawCliProperty::WriteToStream( IStream* pIStream )
  458. {
  459. ULONG           cb = 0;
  460. ULONG           cbTotal; // Total size of the whole value
  461. DWORD           dwType = m_dwType;
  462. DWORD           nReps;
  463. LPBYTE          pValue;
  464. LPBYTE          pCur;
  465. BOOL            bSuccess = FALSE;
  466. BYTE            b = 0;
  468. nReps = 1;
  469. pValue = (LPBYTE)m_pValue;
  470. pCur = pValue;
  471. cbTotal = 0;
  472. if (m_dwType & VT_VECTOR)
  473. {
  474. // Value is a DWORD count of elements followed by
  475. // that many repititions of the value.
  476. //
  477. nReps = *(LPDWORD)pCur;
  478. cbTotal = sizeof(DWORD);
  479. pCur += cbTotal;
  480. dwType &= ~VT_VECTOR;
  481. }
  483. #ifdef _UNICODE
  484. switch (dwType)
  485. {
  486. case VT_BSTR:           // binary string
  487. case VT_STREAM:         // Name of the stream follows
  488. case VT_STORAGE:        // Name of the storage follows
  489. case VT_STREAMED_OBJECT:// Stream contains an object
  490. case VT_STORED_OBJECT:  // Storage contains an object
  491. case VT_STREAMED_PROPSET:// Stream contains a propset
  492. case VT_STORED_PROPSET: // Storage contains a propset
  493. pValue = ConvertStringProp(pCur, m_dwType, nReps, sizeof(char));
  494. if (m_dwType & VT_VECTOR)
  495. pCur = pValue + sizeof(DWORD);
  496. break;
  497. }
  498. #endif // _UNICODE
  500. // Figure out how big the data is.
  501. while (nReps--)
  502. {
  503. switch (dwType)
  504. {
  505. case VT_EMPTY:          // nothing
  506. cb = 0;
  507. break;
  509. case VT_I2:             // 2 byte signed int
  510. case VT_BOOL:           // True=-1, False=0
  511. cb = 2;
  512. break;
  514. case VT_I4:             // 4 byte signed int
  515. case VT_R4:             // 4 byte real
  516. cb = 4;
  517. break;
  519. case VT_R8:             // 8 byte real
  520. case VT_CY:             // currency
  521. case VT_DATE:           // date
  522. case VT_I8:             // signed 64-bit int
  523. case VT_FILETIME:       // FILETIME
  524. cb = 8;
  525. break;
  527. case VT_LPSTR:          // null terminated string
  528. case VT_BSTR:           // binary string
  529. case VT_STREAM:         // Name of the stream follows
  530. case VT_STORAGE:        // Name of the storage follows
  531. case VT_STREAMED_OBJECT:// Stream contains an object
  532. case VT_STORED_OBJECT:  // Storage contains an object
  533. case VT_STREAMED_PROPSET:// Stream contains a propset
  534. case VT_STORED_PROPSET: // Storage contains a propset
  535. case VT_BLOB:           // Length prefixed bytes
  536. case VT_BLOB_OBJECT:    // Blob contains an object
  537. case VT_BLOB_PROPSET:   // Blob contains a propset
  538. case VT_CF:             // Clipboard format
  539. cb = sizeof(DWORD) + *(LPDWORD)pCur;
  540. break;
  542. case VT_LPWSTR:         // UNICODE string
  543. cb = sizeof(DWORD) + (*(LPDWORD)pCur * sizeof(WCHAR));
  544. break;
  546. case VT_CLSID:          // A Class ID
  547. cb = sizeof(CLSID);
  548. break;
  550. case VT_VARIANT:        // VARIANT*
  551. break;
  553. default:
  554. return FALSE;
  555. }
  557. pCur += cb;
  558. cbTotal+= cb;
  559. }
  561. // Write the type
  562. pIStream->Write((LPVOID)&m_dwType, sizeof(m_dwType), &cb);
  563. if (cb != sizeof(m_dwType))
  564. goto Cleanup;
  566. // Write the value
  567. pIStream->Write((LPVOID)pValue, cbTotal, &cb);
  568. if (cb != cbTotal)
  569. goto Cleanup;
  571. // Make sure we are 32 bit aligned
  572. cbTotal = (((cbTotal + 3) >> 2) << 2) - cbTotal;
  573. while (cbTotal--)
  574. {
  575. pIStream->Write((LPVOID)&b, 1, &cb);
  576. if (cb != sizeof(BYTE))
  577. goto Cleanup;
  578. }
  580. bSuccess = TRUE;
  582. Cleanup:
  583. if (pValue != m_pValue)
  584. free(pValue);
  586. return bSuccess;
  587. }
  589. BOOL CDrawCliProperty::ReadFromStream( IStream* pIStream )
  590. {
  591. ULONG           cb;
  592. ULONG           cbItem;
  593. ULONG           cbValue;
  594. DWORD           dwType;
  595. ULONG           nReps;
  596. ULONG           iReps;
  597. LPSTREAM        pIStrItem;
  598. LARGE_INTEGER   li;
  600. // All properties are made up of a type/value pair.
  601. // The obvious first thing to do is to get the type...
  602. pIStream->Read( (LPVOID)&m_dwType, sizeof(m_dwType), &cb );
  603. if (cb != sizeof(m_dwType))
  604. return FALSE;
  606. dwType = m_dwType;
  607. nReps = 1;
  608. cbValue = 0;
  609. if (m_dwType & VT_VECTOR)
  610. {
  611. // The next DWORD in the stream is a count of the
  612. // elements
  613. pIStream->Read( (LPVOID)&nReps, sizeof(nReps), &cb );
  614. if (cb != sizeof(nReps))
  615. return FALSE;
  616. cbValue += cb;
  617. dwType &= ~VT_VECTOR;
  618. }
  620. // Since a value can be made up of a vector (VT_VECTOR) of
  621. // items, we first seek through the value, picking out
  622. // each item, getting it's size.  We use a cloned
  623. // stream for this (pIStrItem).
  624. // We then use our pIStream to read the entire 'blob' into
  625. // the allocated buffer.
  626. //
  627. cbItem = 0;        // Size of the current item
  628. pIStream->Clone( &pIStrItem );
  629. ASSERT(pIStrItem != NULL);
  630. iReps = nReps;
  631. while (iReps--)
  632. {
  633. switch (dwType)
  634. {
  635. case VT_EMPTY:          // nothing
  636. cbItem = 0;
  637. break;
  639. case VT_I2:             // 2 byte signed int
  640. case VT_BOOL:           // True=-1, False=0
  641. cbItem = 2;
  642. break;
  644. case VT_I4:             // 4 byte signed int
  645. case VT_R4:             // 4 byte real
  646. cbItem = 4;
  647. break;
  649. case VT_R8:             // 8 byte real
  650. case VT_CY:             // currency
  651. case VT_DATE:           // date
  652. case VT_I8:             // signed 64-bit int
  653. case VT_FILETIME:       // FILETIME
  654. cbItem = 8;
  655. break;
  657. case VT_LPSTR:          // null terminated string
  658. case VT_BSTR:           // binary string
  659. case VT_STREAM:         // Name of the stream follows
  660. case VT_STORAGE:        // Name of the storage follows
  661. case VT_STREAMED_OBJECT:// Stream contains an object
  662. case VT_STORED_OBJECT:  // Storage contains an object
  663. case VT_STREAMED_PROPSET:// Stream contains a propset
  664. case VT_STORED_PROPSET: // Storage contains a propset
  665. case VT_BLOB:           // Length prefixed bytes
  666. case VT_BLOB_OBJECT:    // Blob contains an object
  667. case VT_BLOB_PROPSET:   // Blob contains a propset
  668. case VT_CF:             // Clipboard format
  669. // Read the DWORD that gives us the size, making
  670. // sure we increment cbValue.
  671. pIStream->Read( (LPVOID)&cbItem, sizeof(cbItem), &cb );
  672. if (cb != sizeof(cbItem))
  673. return FALSE;
  674. LISet32( li, -(LONG)cb );
  675. pIStream->Seek( li, STREAM_SEEK_CUR, NULL );
  676. cbValue += cb;
  677. break;
  679. case VT_LPWSTR:         // UNICODE string
  680. pIStream->Read( (LPVOID)&cbItem, sizeof(cbItem), &cb );
  681. if (cb != sizeof(cbItem))
  682. return FALSE;
  683. LISet32( li, -(LONG)cb );
  684. pIStream->Seek( li, STREAM_SEEK_CUR, NULL );
  685. cbValue += cb;
  686. cbItem *= sizeof(WCHAR);
  687. break;
  689. case VT_CLSID:          // A Class ID
  690. cbItem = sizeof(CLSID);
  691. break;
  693. case VT_VARIANT:        // VARIANT*
  694. break;
  696. default:
  697. pIStrItem->Release();
  698. return FALSE;
  699. }
  701. // Add 'cb' to cbItem before seeking...
  702. //
  703. // Seek to the next item
  704. LISet32( li, cbItem );
  705. pIStrItem->Seek( li, STREAM_SEEK_CUR, NULL);
  706. cbValue += cbItem;
  707. }
  709. pIStrItem->Release();
  711. #ifdef _UNICODE
  712. LPBYTE pTmp;
  714. switch (dwType)
  715. {
  716. case VT_BSTR:           // binary string
  717. case VT_STREAM:         // Name of the stream follows
  718. case VT_STORAGE:        // Name of the storage follows
  719. case VT_STREAMED_OBJECT:// Stream contains an object
  720. case VT_STORED_OBJECT:  // Storage contains an object
  721. case VT_STREAMED_PROPSET:// Stream contains a propset
  722. case VT_STORED_PROPSET: // Storage contains a propset
  723. pTmp = (LPBYTE)malloc((int)cbValue);
  724. pIStream->Read( pTmp, cbValue, &cb );
  725. m_pValue = ConvertStringProp(pTmp, m_dwType, nReps, sizeof(WCHAR));
  726. free(pTmp);
  727. break;
  729. default:
  730. #endif // _UNICODE
  731. // Allocate cbValue bytes
  732. if (NULL == AllocValue(cbValue))
  733. return FALSE;
  735. // Read the buffer from pIStream
  736. pIStream->Read( m_pValue, cbValue, &cb );
  737. if (cb != cbValue)
  738. return FALSE;
  739. #ifdef _UNICODE
  740. break;
  741. }
  742. #endif // _UNICODE
  744. // Done!
  745. return TRUE;
  746. }
  749. LPVOID CDrawCliProperty::AllocValue(ULONG cb)
  750. {
  751. return m_pValue = malloc((int)cb);
  752. }
  755. void CDrawCliProperty::FreeValue()
  756. {
  757. if (m_pValue != NULL)
  758. {
  759. free(m_pValue);
  760. m_pValue = NULL;
  761. }
  762. }
  764. /////////////////////////////////////////////////////////////////////////////
  765. // Implementation of the CDrawCliPropertySection Class
  767. CDrawCliPropertySection::CDrawCliPropertySection( void )
  768. {
  769. m_FormatID = GUID_NULL;
  770. m_SH.cbSection = 0;
  771. m_SH.cProperties = 0;
  772. }
  774. CDrawCliPropertySection::CDrawCliPropertySection( CLSID FormatID )
  775. {
  776. m_FormatID = FormatID;
  777. m_SH.cbSection = 0;
  778. m_SH.cProperties = 0;
  779. }
  781. CDrawCliPropertySection::~CDrawCliPropertySection( void )
  782. {
  783. RemoveAll();
  784. return;
  785. }
  787. CLSID CDrawCliPropertySection::GetFormatID( void )
  788. {   return m_FormatID; }
  790. void CDrawCliPropertySection::SetFormatID( CLSID FormatID )
  791. {   m_FormatID = FormatID; }
  793. BOOL CDrawCliPropertySection::Set( DWORD dwPropID, LPVOID pValue, DWORD dwType )
  794. {
  795. CDrawCliProperty* pProp = GetProperty( dwPropID );
  796. if (pProp == NULL)
  797. {
  798. if ((pProp = new CDrawCliProperty( dwPropID, pValue, dwType )) != NULL)
  799. AddProperty( pProp );
  800. return (pProp != NULL);
  801. }
  803. pProp->Set( dwPropID, pValue, dwType );
  804. return TRUE;
  805. }
  807. BOOL CDrawCliPropertySection::Set( DWORD dwPropID, LPVOID pValue )
  808. {
  809. // Since no dwType was specified, the property is assumed
  810. // to exist.   Fail if it does not.
  811. CDrawCliProperty* pProp = GetProperty( dwPropID );
  812. if (pProp != NULL && pProp->m_dwType)
  813. {
  814. pProp->Set( dwPropID, pValue, pProp->m_dwType );
  815. return TRUE;
  816. }
  817. else
  818. return FALSE;
  819. }
  821. LPVOID CDrawCliPropertySection::Get( DWORD dwPropID )
  822. {   return Get( dwPropID, (DWORD*)NULL );  }
  824. LPVOID CDrawCliPropertySection::Get( DWORD dwPropID, DWORD* pcb )
  825. {
  826. CDrawCliProperty* pProp = GetProperty( dwPropID );
  827. if (pProp)
  828. {
  829. #if (defined _DEBUG)
  830. pProp->AssertValid();
  831. #endif
  832. return pProp->Get( pcb );
  833. }
  834. else
  835. return NULL;
  836. }
  838. void CDrawCliPropertySection::Remove( DWORD dwID )
  839. {
  840. POSITION pos = m_PropList.GetHeadPosition();
  841. CDrawCliProperty*  pProp;
  842. while( pos != NULL )
  843. {
  844. POSITION posRemove = pos;
  845. pProp = (CDrawCliProperty*)m_PropList.GetNext( pos );
  846. if (pProp->m_dwPropID == dwID)
  847. {
  848. m_PropList.RemoveAt( posRemove );
  849. delete pProp;
  850. m_SH.cProperties--;
  851. return;
  852. }
  853. }
  854. }
  856. void CDrawCliPropertySection::RemoveAll( )
  857. {
  858. POSITION pos = m_PropList.GetHeadPosition();
  859. while( pos != NULL )
  860. delete (CDrawCliProperty*)m_PropList.GetNext( pos );
  861. m_PropList.RemoveAll();
  862. m_SH.cProperties = 0;
  863. }
  866. CDrawCliProperty* CDrawCliPropertySection::GetProperty( DWORD dwPropID )
  867. {
  868. POSITION pos = m_PropList.GetHeadPosition();
  869. #if (defined _DEBUG)
  870. m_PropList.AssertValid();
  871. #endif
  872. CDrawCliProperty* pProp;
  873. while (pos != NULL)
  874. {
  875. pProp= (CDrawCliProperty*)m_PropList.GetNext( pos );
  876. #if (defined _DEBUG)
  877. pProp->AssertValid();
  878. #endif
  879. if (pProp->m_dwPropID == dwPropID)
  880. return pProp;
  881. }
  882. return NULL;
  883. }
  885. void CDrawCliPropertySection::AddProperty( CDrawCliProperty* pProp )
  886. {
  887. m_PropList.AddTail( pProp );
  888. m_SH.cProperties++;
  889. }
  891. DWORD CDrawCliPropertySection::GetSize( void )
  892. {   return m_SH.cbSection; }
  894. DWORD CDrawCliPropertySection::GetCount( void )
  895. {   return DWORD( m_PropList.GetCount() );  }
  897. CObList* CDrawCliPropertySection::GetList( void )
  898. {   return &m_PropList;  }
  900. BOOL CDrawCliPropertySection::WriteToStream( IStream* pIStream )
  901. {
  902. // Create a dummy property entry for the name dictionary (ID == 0).
  903. Set(0, NULL, VT_EMPTY);
  905. ULONG           cb;
  906. ULARGE_INTEGER  ulSeekOld;
  907. ULARGE_INTEGER  ulSeek;
  908. LPSTREAM        pIStrPIDO;
  909. PROPERTYIDOFFSET  pido;
  910. LARGE_INTEGER   li;
  912. // The Section header contains the number of bytes in the
  913. // section.  Thus we need  to go back to where we should
  914. // write the count of bytes
  915. // after we write all the property sets..
  916. // We accomplish this by saving the seek pointer to where
  917. // the size should be written in ulSeekOld
  918. m_SH.cbSection = 0;
  919. m_SH.cProperties = DWORD( m_PropList.GetCount() );
  920. LISet32( li, 0 );
  921. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSeekOld);
  923. pIStream->Write((LPVOID)&m_SH, sizeof(m_SH), &cb);
  924. if (sizeof(m_SH) != cb)
  925. {
  926. TRACE0("Write of section header failed (1).n");
  927. return FALSE;
  928. }
  930. if (m_PropList.IsEmpty())
  931. {
  932. TRACE0("Warning: Wrote empty property section.n");
  933. return TRUE;
  934. }
  936. // After the section header is the list of property ID/Offset pairs
  937. // Since there is an ID/Offset pair for each property and we
  938. // need to write the ID/Offset pair as we write each property
  939. // we clone the stream and use the clone to access the
  940. // table of ID/offset pairs (PIDO)...
  941. //
  942. pIStream->Clone( &pIStrPIDO );
  944. // Now seek pIStream past the PIDO list
  945. //
  946. LISet32( li,  m_SH.cProperties * sizeof( PROPERTYIDOFFSET ) );
  947. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSeek);
  949. // Now write each section to pIStream.
  950. CDrawCliProperty* pProp = NULL;
  951. POSITION pos = m_PropList.GetHeadPosition();
  952. while( pos != NULL )
  953. {
  954. // Get next element (note cast)
  955. pProp = (CDrawCliProperty*)m_PropList.GetNext( pos );
  957. if (pProp->m_dwPropID != 0)
  958. {
  959. // Write it
  960. if (!pProp->WriteToStream( pIStream ))
  961. {
  962. pIStrPIDO->Release();
  963. return FALSE;
  964. }
  965. }
  966. else
  967. {
  968. if (!WriteNameDictToStream( pIStream ))
  969. {
  970. pIStrPIDO->Release();
  971. return FALSE;
  972. }
  973. }
  975. // Using our cloned stream write the Format ID / Offset pair
  976. // The offset to this property is the current seek pointer
  977. // minus the pointer to the beginning of the section
  978. pido.dwOffset = ulSeek.LowPart - ulSeekOld.LowPart;
  979. pido.propertyID = pProp->m_dwPropID;
  980. pIStrPIDO->Write((LPVOID)&pido, sizeof(pido), &cb);
  981. if (sizeof(pido) != cb)
  982. {
  983. TRACE0("Write of 'pido' failedn");
  984. pIStrPIDO->Release();
  985. return FALSE;
  986. }
  988. // Get the seek offset after the write
  989. LISet32( li, 0 );
  990. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSeek );
  991. }
  993. pIStrPIDO->Release();
  995. // Now go back to ulSeekOld and write the section header.
  996. // Size of section is current seek point minus old seek point
  997. //
  998. m_SH.cbSection = ulSeek.LowPart - ulSeekOld.LowPart;
  1000. // Seek to beginning of this section and write the section header.
  1001. LISet32( li, ulSeekOld.LowPart );
  1002. pIStream->Seek( li, STREAM_SEEK_SET, NULL );
  1003. pIStream->Write((LPVOID)&m_SH, sizeof(m_SH), &cb);
  1004. if (sizeof(m_SH) != cb)
  1005. {
  1006. TRACE0("Write of section header failed (2).n");
  1007. return FALSE;
  1008. }
  1010. // Now seek to end of of the now written section
  1011. LISet32(li, ulSeek.LowPart);
  1012. pIStream->Seek(li, STREAM_SEEK_SET, NULL);
  1014. return TRUE;
  1015. }
  1017. BOOL CDrawCliPropertySection::ReadFromStream( IStream* pIStream,
  1018. LARGE_INTEGER liPropSet )
  1019. {
  1020. ULONG               cb;
  1021. PROPERTYIDOFFSET    pido;
  1022. ULONG               cProperties;
  1023. LPSTREAM            pIStrPIDO;
  1024. ULARGE_INTEGER      ulSectionStart;
  1025. LARGE_INTEGER       li;
  1026. CDrawCliProperty*          pProp;
  1028. if (m_SH.cProperties || !m_PropList.IsEmpty())
  1029. RemoveAll();
  1031. // pIStream is pointing to the beginning of the section we
  1032. // are to read.  First there is a DWORD that is the count
  1033. // of bytes in this section, then there is a count
  1034. // of properties, followed by a list of propertyID/offset pairs,
  1035. // followed by type/value pairs.
  1036. //
  1037. LISet32( li, 0 );
  1038. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSectionStart );
  1039. pIStream->Read( (LPVOID)&m_SH, sizeof(m_SH), &cb );
  1040. if (cb != sizeof(m_SH))
  1041. return FALSE;
  1043. // Now we're pointing at the first of the PropID/Offset pairs
  1044. // (PIDOs).   To get to each property we use a cloned stream
  1045. // to stay back and point at the PIDOs (pIStrPIDO).  We seek
  1046. // pIStream to each of the Type/Value pairs, creating CProperites
  1047. // and so forth as we go...
  1048. //
  1049. pIStream->Clone( &pIStrPIDO );
  1051. cProperties = m_SH.cProperties;
  1052. while (cProperties--)
  1053. {
  1054. pIStrPIDO->Read( (LPVOID)&pido, sizeof( pido ), &cb );
  1055. if (cb != sizeof(pido))
  1056. {
  1057. pIStrPIDO->Release();
  1058. return FALSE;
  1059. }
  1061. // Do a seek from the beginning of the property set.
  1062. LISet32( li, ulSectionStart.LowPart + pido.dwOffset );
  1063. pIStream->Seek( liPropSet, STREAM_SEEK_SET, NULL );
  1064. pIStream->Seek( li, STREAM_SEEK_CUR, NULL );
  1066. // Now pIStream is at the type/value pair
  1067. if (pido.propertyID != 0)
  1068. {
  1069. pProp = new CDrawCliProperty( pido.propertyID, NULL, 0 );
  1070. pProp->ReadFromStream( pIStream );
  1071. #if (defined _DEBUG)
  1072. pProp->AssertValid();
  1073. #endif
  1074. m_PropList.AddTail( pProp );
  1075. #if (defined _DEBUG)
  1076. m_PropList.AssertValid();
  1077. #endif
  1078. }
  1079. else
  1080. {
  1081. ReadNameDictFromStream( pIStream );
  1082. }
  1083. }
  1085. pIStrPIDO->Release();
  1087. return TRUE;
  1088. }
  1090. BOOL CDrawCliPropertySection::GetID( LPCTSTR pszName, DWORD* pdwPropID )
  1091. {
  1092. CString strName(pszName);
  1093. strName.MakeLower();        // Dictionary stores all names in lowercase
  1095. void* pvID;
  1096. if (m_NameDict.Lookup(strName, pvID))
  1097. {
  1098. *pdwPropID = (DWORD)pvID;
  1099. return TRUE;
  1100. }
  1102. // Failed to find entry in dictionary
  1103. return FALSE;
  1104. }
  1106. BOOL CDrawCliPropertySection::SetName( DWORD dwPropID, LPCTSTR pszName )
  1107. {
  1108. BOOL bSuccess = TRUE;
  1109. CString strName(pszName);
  1110. strName.MakeLower();        // Dictionary stores all names in lowercase
  1112. TRY
  1113. {
  1114. void* pDummy;
  1115. BOOL bNameExists = m_NameDict.Lookup(strName, pDummy);
  1117. ASSERT(! bNameExists);  // Property names must be unique.
  1119. if (bNameExists)
  1120. bSuccess = FALSE;
  1121. else
  1122. m_NameDict.SetAt(strName, (void*)dwPropID);
  1123. }
  1124. CATCH (CException, e)
  1125. {
  1126. TRACE0("Failed to add entry to dictionary.n");
  1127. bSuccess = FALSE;
  1128. }
  1129. END_CATCH
  1131. return bSuccess;
  1132. }
  1134. struct DICTENTRYHEADER
  1135. {
  1136. DWORD dwPropID;
  1137. DWORD cb;
  1138. };
  1140. struct DICTENTRY
  1141. {
  1142. DICTENTRYHEADER hdr;
  1143. char sz[256];
  1144. };
  1146. BOOL CDrawCliPropertySection::ReadNameDictFromStream( IStream* pIStream )
  1147. {
  1148. ULONG cb;
  1149. ULONG cbRead = 0;
  1151. // Read dictionary header (count).
  1152. ULONG cProperties = 0;
  1153. pIStream->Read((LPVOID)&cProperties, sizeof(cProperties), &cb);
  1154. if (sizeof(cProperties) != cb)
  1155. {
  1156. TRACE0("Read of dictionary header failed.n");
  1157. return FALSE;
  1158. }
  1160. ULONG iProp;
  1161. DICTENTRY entry;
  1163. for (iProp = 0; iProp < cProperties; iProp++)
  1164. {
  1165. // Read entry header (dwPropID, cch).
  1166. if (FAILED(pIStream->Read((LPVOID)&entry, sizeof(DICTENTRYHEADER),
  1167. &cbRead)) ||
  1168. (sizeof(DICTENTRYHEADER) != cbRead))
  1169. {
  1170. TRACE0("Read of dictionary entry failed.n");
  1171. return FALSE;
  1172. }
  1174. // Read entry data (name).
  1176. cb = entry.hdr.cb;
  1178. if (FAILED(pIStream->Read((LPVOID)&entry.sz, cb, &cbRead)) ||
  1179. (cbRead != cb))
  1180. {
  1181. TRACE0("Read of dictionary entry failed.n");
  1182. return FALSE;
  1183. }
  1185. LPTSTR pszName;
  1187. #ifdef _UNICODE
  1188. // Persistent form is always ANSI/DBCS.  Convert to Unicode.
  1189. WCHAR wszName[256];
  1190. _mbstowcsz(wszName, entry.sz, 256);
  1191. pszName = wszName;
  1192. #else // _UNICODE
  1193. pszName = entry.sz;
  1194. #endif // _UNICODE
  1196. // Section's "name" appears first in list and has dwPropID == 0.
  1197. if ((iProp == 0) && (entry.hdr.dwPropID == 0))
  1198. m_strSectionName = pszName;             // Section name
  1199. else
  1200. SetName(entry.hdr.dwPropID, pszName);   // Some other property
  1201. }
  1203. return TRUE;
  1204. }
  1206. static BOOL WriteNameDictEntry(IStream* pIStream, DWORD dwPropID, CString& strName)
  1207. {
  1208. ULONG cb;
  1209. ULONG cbWritten = 0;
  1210. DICTENTRY entry;
  1212. entry.hdr.dwPropID = dwPropID;
  1213. entry.hdr.cb = min(strName.GetLength() + 1, 255);
  1214. #ifdef _UNICODE
  1215. // Persistent form is always ANSI/DBCS.  Convert from Unicode.
  1216. _wcstombsz(entry.sz, (LPCWSTR)strName, 256);
  1217. #else // _UNICODE
  1218. memcpy(entry.sz, (LPCSTR)strName, (size_t)entry.hdr.cb);
  1219. #endif // _UNICODE
  1221. cb = sizeof(DICTENTRYHEADER) + entry.hdr.cb;
  1223. if (FAILED(pIStream->Write((LPVOID)&entry, cb, &cbWritten)) ||
  1224. (cbWritten != cb))
  1225. {
  1226. TRACE0("Write of dictionary entry failed.n");
  1227. return FALSE;
  1228. }
  1230. return TRUE;
  1231. }
  1233. BOOL CDrawCliPropertySection::WriteNameDictToStream( IStream* pIStream )
  1234. {
  1235. ULONG cb;
  1237. // Write dictionary header (count).
  1238. ULONG cProperties = ULONG( m_NameDict.GetCount() + 1 );
  1239. pIStream->Write((LPVOID)&cProperties, sizeof(cProperties), &cb);
  1240. if (sizeof(cProperties) != cb)
  1241. {
  1242. TRACE0("Write of dictionary header failed.n");
  1243. return FALSE;
  1244. }
  1246. POSITION pos;
  1247. CString strName;
  1248. void* pvID;
  1250. // Write out section's "name" with dwPropID == 0 first
  1251. if (! WriteNameDictEntry(pIStream, 0, m_strSectionName))
  1252. return FALSE;
  1254. // Enumerate contents of dictionary and write out (dwPropID, cb, name).
  1255. pos = m_NameDict.GetStartPosition();
  1256. while (pos != NULL)
  1257. {
  1258. m_NameDict.GetNextAssoc( pos, strName, pvID );
  1259. if (! WriteNameDictEntry(pIStream, (DWORD)pvID, strName))
  1260. return FALSE;
  1261. }
  1263. return TRUE;
  1264. }
  1266. BOOL CDrawCliPropertySection::SetSectionName( LPCTSTR pszName )
  1267. {
  1268. m_strSectionName = pszName;
  1269. return TRUE;
  1270. }
  1272. LPCTSTR CDrawCliPropertySection::GetSectionName( void )
  1273. {
  1274. return (LPCTSTR)m_strSectionName;
  1275. }
  1278. /////////////////////////////////////////////////////////////////////////////
  1279. // Implementation of the CDrawCliPropertySet class
  1281. CDrawCliPropertySet::CDrawCliPropertySet( void )
  1282. {
  1283. m_PH.wByteOrder = 0xFFFE;
  1284. m_PH.wFormat = 0;
  1285. m_PH.dwOSVer = (DWORD)MAKELONG( LOWORD(GetVersion()), 2 );
  1286. m_PH.clsID =  GUID_NULL;
  1287. m_PH.cSections = 0;
  1289. }
  1291. CDrawCliPropertySet::CDrawCliPropertySet( CLSID clsID )
  1292. {
  1293. m_PH.wByteOrder = 0xFFFE;
  1294. m_PH.wFormat = 0;
  1295. m_PH.dwOSVer = (DWORD)MAKELONG( LOWORD(GetVersion()), 2 );
  1296. m_PH.clsID = clsID;
  1297. m_PH.cSections = 0;
  1298. }
  1300. CDrawCliPropertySet::~CDrawCliPropertySet()
  1301. {   RemoveAll();  }
  1303. BOOL CDrawCliPropertySet::Set( CLSID FormatID, DWORD dwPropID, LPVOID pValue, DWORD dwType )
  1304. {
  1305. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1306. if (pSect == NULL)
  1307. {
  1308. if ((pSect = new CDrawCliPropertySection( FormatID )) != NULL)
  1309. AddSection( pSect );
  1310. }
  1311. pSect->Set( dwPropID, pValue, dwType );
  1312. return TRUE;
  1313. }
  1315. BOOL CDrawCliPropertySet::Set( CLSID FormatID, DWORD dwPropID, LPVOID pValue )
  1316. {
  1317. // Since there is no dwType, we have to assume that the property
  1318. // already exists.  If it doesn't, fail.
  1319. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1320. if (pSect != NULL)
  1321. return pSect->Set( dwPropID, pValue );
  1322. else
  1323. return FALSE;
  1324. }
  1326. LPVOID CDrawCliPropertySet::Get( CLSID FormatID, DWORD dwPropID, DWORD* pcb )
  1327. {
  1328. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1329. if (pSect)
  1330. return pSect->Get( dwPropID, pcb );
  1331. else
  1332. return NULL;
  1333. }
  1335. LPVOID CDrawCliPropertySet::Get( CLSID FormatID, DWORD dwPropID )
  1336. {   return Get( FormatID, dwPropID, (DWORD*)NULL ); }
  1338. void CDrawCliPropertySet::Remove( CLSID FormatID, DWORD dwPropID )
  1339. {
  1340. CDrawCliPropertySection*  pSect = GetSection( FormatID );
  1341. if (pSect)
  1342. pSect->Remove( dwPropID );
  1343. }
  1345. void CDrawCliPropertySet::Remove( CLSID FormatID )
  1346. {
  1347. CDrawCliPropertySection* pSect;
  1348. POSITION posRemove = m_SectionList.GetHeadPosition();
  1349. POSITION pos = posRemove;
  1350. while( posRemove != NULL )
  1351. {
  1352. pSect = (CDrawCliPropertySection*)m_SectionList.GetNext( pos );
  1353. if (IsEqualCLSID( pSect->m_FormatID, FormatID ))
  1354. {
  1355. m_SectionList.RemoveAt( posRemove );
  1356. delete pSect;
  1357. m_PH.cSections--;
  1358. return;
  1359. }
  1360. posRemove = pos;
  1361. }
  1362. }
  1364. void CDrawCliPropertySet::RemoveAll( )
  1365. {
  1366. POSITION pos = m_SectionList.GetHeadPosition();
  1367. while( pos != NULL )
  1368. {
  1369. delete (CDrawCliPropertySection*)m_SectionList.GetNext( pos );
  1370. }
  1371. m_SectionList.RemoveAll();
  1372. m_PH.cSections = 0;
  1373. }
  1375. CDrawCliPropertySection* CDrawCliPropertySet::GetSection( CLSID FormatID )
  1376. {
  1377. POSITION pos = m_SectionList.GetHeadPosition();
  1378. CDrawCliPropertySection* pSect;
  1379. while (pos != NULL)
  1380. {
  1381. pSect = (CDrawCliPropertySection*)m_SectionList.GetNext( pos );
  1382. if (IsEqualCLSID( pSect->m_FormatID, FormatID ))
  1383. return pSect;
  1384. }
  1385. return NULL;
  1386. }
  1388. CDrawCliPropertySection* CDrawCliPropertySet::AddSection( CLSID FormatID )
  1389. {
  1390. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1391. if (pSect)
  1392. return pSect;
  1394. pSect = new CDrawCliPropertySection( FormatID ) ;
  1395. if (pSect)
  1396. AddSection( pSect );
  1397. return pSect;
  1398. }
  1400. void CDrawCliPropertySet::AddSection( CDrawCliPropertySection* pSect )
  1401. {
  1402. m_SectionList.AddTail( pSect );
  1403. m_PH.cSections++;
  1404. }
  1406. CDrawCliProperty* CDrawCliPropertySet::GetProperty( CLSID FormatID, DWORD dwPropID )
  1407. {
  1408. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1409. if (pSect)
  1410. return pSect->GetProperty( dwPropID );
  1411. else
  1412. return NULL;
  1413. }
  1415. void CDrawCliPropertySet::AddProperty( CLSID FormatID, CDrawCliProperty* pProp )
  1416. {
  1417. CDrawCliPropertySection* pSect = GetSection( FormatID );
  1418. if (pSect)
  1419. pSect->AddProperty( pProp );
  1420. }
  1422. WORD CDrawCliPropertySet::GetByteOrder( void )
  1423. {   return m_PH.wByteOrder;  }
  1425. WORD CDrawCliPropertySet::GetFormatVersion( void )
  1426. {   return m_PH.wFormat;  }
  1428. void CDrawCliPropertySet::SetFormatVersion( WORD wFmtVersion )
  1429. {   m_PH.wFormat = wFmtVersion;  }
  1431. DWORD CDrawCliPropertySet::GetOSVersion( void )
  1432. {   return m_PH.dwOSVer;  }
  1434. void CDrawCliPropertySet::SetOSVersion( DWORD dwOSVer )
  1435. {   m_PH.dwOSVer = dwOSVer;  }
  1437. CLSID CDrawCliPropertySet::GetClassID( void )
  1438. {   return m_PH.clsID;  }
  1440. void CDrawCliPropertySet::SetClassID( CLSID clsID )
  1441. {   m_PH.clsID = clsID;  }
  1443. DWORD CDrawCliPropertySet::GetCount( void )
  1444. {   return WORD( m_SectionList.GetCount() ); }
  1446. CObList* CDrawCliPropertySet::GetList( void )
  1447. {   return &m_SectionList;  }
  1450. BOOL CDrawCliPropertySet::WriteToStream( IStream* pIStream )
  1451. {
  1452. LPSTREAM        pIStrFIDO;
  1453. FORMATIDOFFSET  fido;
  1454. ULONG           cb;
  1455. ULARGE_INTEGER  ulSeek;
  1456. LARGE_INTEGER   li;
  1458. // Write the Property List Header
  1459. m_PH.cSections = DWORD( m_SectionList.GetCount() );
  1460. pIStream->Write((LPVOID)&m_PH, sizeof(m_PH), &cb);
  1461. if (sizeof(m_PH) != cb)
  1462. {
  1463. TRACE0("Write of Property Set Header failed.n");
  1464. return FALSE;
  1465. }
  1467. if (m_SectionList.IsEmpty())
  1468. {
  1469. TRACE0("Warning: Wrote empty property set.n");
  1470. return TRUE;
  1471. }
  1473. // After the header is the list of Format ID/Offset pairs
  1474. // Since there is an ID/Offset pair for each section and we
  1475. // need to write the ID/Offset pair as we write each section
  1476. // we clone the stream and use the clone to access the
  1477. // table of ID/offset pairs (FIDO)...
  1478. //
  1479. pIStream->Clone( &pIStrFIDO );
  1481. // Now seek pIStream past the FIDO list
  1482. //
  1483. LISet32( li, m_PH.cSections * sizeof( FORMATIDOFFSET ) );
  1484. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSeek);
  1486. // Write each section.
  1487. CDrawCliPropertySection*   pSect = NULL;
  1488. POSITION            pos = m_SectionList.GetHeadPosition();
  1489. while( pos != NULL )
  1490. {
  1491. // Get next element (note cast)
  1492. pSect = (CDrawCliPropertySection*)m_SectionList.GetNext( pos );
  1494. // Write it
  1495. if (!pSect->WriteToStream( pIStream ))
  1496. {
  1497. pIStrFIDO->Release();
  1498. return FALSE;
  1499. }
  1501. // Using our cloned stream write the Format ID / Offset pair
  1502. fido.formatID = pSect->m_FormatID;
  1503. fido.dwOffset = ulSeek.LowPart;
  1504. pIStrFIDO->Write((LPVOID)&fido, sizeof(fido), &cb);
  1505. if (sizeof(fido) != cb)
  1506. {
  1507. TRACE0("Write of 'fido' failed.n");
  1508. pIStrFIDO->Release();
  1509. return FALSE;
  1510. }
  1512. // Get the seek offset (for pIStream) after the write
  1513. LISet32( li, 0 );
  1514. pIStream->Seek( li, STREAM_SEEK_CUR, &ulSeek );
  1515. }
  1517. pIStrFIDO->Release();
  1519. return TRUE;
  1520. }
  1522. BOOL CDrawCliPropertySet::ReadFromStream( IStream* pIStream )
  1523. {
  1524. ULONG               cb;
  1525. FORMATIDOFFSET      fido;
  1526. ULONG               cSections;
  1527. LPSTREAM            pIStrFIDO;
  1528. CDrawCliPropertySection*   pSect;
  1529. LARGE_INTEGER       li;
  1530. LARGE_INTEGER       liPropSet;
  1532. // Save the stream position at which the property set starts.
  1533. LARGE_INTEGER liZero = {0,0};
  1534. pIStream->Seek( liZero, STREAM_SEEK_CUR, (ULARGE_INTEGER*)&liPropSet );
  1536. if (m_PH.cSections || !m_SectionList.IsEmpty())
  1537.  RemoveAll();
  1539. // The stream starts like this:
  1540. //  wByteOrder   wFmtVer   dwOSVer   clsID  cSections
  1541. // Which is nice, because our PROPHEADER is the same!
  1542. pIStream->Read( (LPVOID)&m_PH, sizeof( m_PH ), &cb );
  1543. if (cb != sizeof(m_PH))
  1544. return FALSE;
  1546. // Now we're pointing at the first of the FormatID/Offset pairs
  1547. // (FIDOs).   To get to each section we use a cloned stream
  1548. // to stay back and point at the FIDOs (pIStrFIDO).  We seek
  1549. // pIStream to each of the sections, creating CProperitySection
  1550. // and so forth as we go...
  1551. //
  1552. pIStream->Clone( &pIStrFIDO );
  1554. cSections = m_PH.cSections;
  1555. while (cSections--)
  1556. {
  1557. pIStrFIDO->Read( (LPVOID)&fido, sizeof( fido ), &cb );
  1558. if (cb != sizeof(fido))
  1559. {
  1560. pIStrFIDO->Release();
  1561. return FALSE;
  1562. }
  1564. // Do a seek from the beginning of the property set.
  1565. LISet32( li, fido.dwOffset );
  1566. pIStream->Seek( liPropSet, STREAM_SEEK_SET, NULL );
  1567. pIStream->Seek( li, STREAM_SEEK_CUR, NULL );
  1569. // Now pIStream is at the type/value pair
  1570. pSect = new CDrawCliPropertySection;
  1571. pSect->SetFormatID( fido.formatID );
  1572. pSect->ReadFromStream( pIStream, liPropSet );
  1573. m_SectionList.AddTail( pSect );
  1574. }
  1576. pIStrFIDO->Release();
  1577. return TRUE;
  1578. }
  1581. /////////////////////////////////////////////////////////////////////////////
  1582. // Force any extra compiler-generated code into AFX_INIT_SEG
  1584. #ifdef AFX_INIT_SEG
  1585. #pragma code_seg(AFX_INIT_SEG)
  1586. #endif