XTPCalendarEvents.h
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:21k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // XTPCalendarEvents.h: CXTPCalendarEvents template.
  2. //
  3. // This file is a part of the XTREME CALENDAR MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  20. //{{AFX_CODEJOCK_PRIVATE
  21. #if !defined(_XTPCALENDAREVENTS_H__)
  22. #define _XTPCALENDAREVENTS_H__
  23. #if _MSC_VER > 1000
  24. #pragma once
  25. #endif // _MSC_VER > 1000
  26. //}}AFX_CODEJOCK_PRIVATE
  27. //{{AFX_CODEJOCK_PRIVATE
  28. class CXTPCalendarEvent;
  29. //}}AFX_CODEJOCK_PRIVATE
  30. //===========================================================================
  31. // Summary:
  32. //      This class represents a simple array collection of CXTPCalendarEvent
  33. //      objects.
  34. // Remarks:
  35. //      Array indexes always start at position 0.
  36. //
  37. //      As with a C array, the access time for indexed element of this
  38. //      array is constant and is independent of the array size.
  39. //
  40. //      Methods Add(), SetAt(), and Append() call InternalAddRef() for the
  41. //      added event.
  42. //      Methods Get(), and Find() do not call InternalAddRef() for the returned
  43. //      event.
  44. //      Methods RemoveAt(), RemoveBy(), RemoveAll(), and the destructor call
  45. //      InternalRelease() for the removed events.
  46. //
  47. // See Also: CArray overview, CXTPCalendarEvent overview.
  48. //===========================================================================
  49. class _XTP_EXT_CLASS CXTPCalendarEvents : public CXTPCmdTarget
  50. {
  51. //{{AFX_CODEJOCK_PRIVATE
  52. DECLARE_DYNAMIC(CXTPCalendarEvents)
  53. //}}AFX_CODEJOCK_PRIVATE
  54. public:
  55. //-----------------------------------------------------------------------
  56. // Summary:
  57. //     Default collection constructor.
  58. // See Also: ~CXTPCalendarEvents()
  59. //-----------------------------------------------------------------------
  60. CXTPCalendarEvents();
  61. //-----------------------------------------------------------------------
  62. // Summary:
  63. //     Default collection destructor.
  64. // Remarks:
  65. //     Handles member item deallocation. Decreases reference of all
  66. //     stored CXTPCalendarEvent objects.
  67. // See Also: RemoveAll()
  68. //-----------------------------------------------------------------------
  69. virtual ~CXTPCalendarEvents();
  70. //-----------------------------------------------------------------------
  71. // Summary:
  72. //     This member function is used to add a new event element to the
  73. //     end of an array.
  74. // Parameters:
  75. //     pNewEvent   - The event element to add to this array.
  76. //     bWithAddRef - If this parameter is TRUE, then InternalAddRef()
  77. //                   is called for the pNewEvent, otherwise InternalAddRef()
  78. //                   is not called. The default value is TRUE.
  79. // Remarks:
  80. //     Use this method to add the specified event pointer to the end
  81. //     of the events collection. Reference to the new object is
  82. //     increased or decreased depending on the value of the bWithAddRef parameter.
  83. // Example:
  84. // <code>
  85. // // CXTPCalendarEvents - derived class
  86. // CXTPCalendarEvents* pList = new CXTPCalendarEvents();
  87. // CXTPCalendarEventPtr ptrEvent1 = new CXTPCalendarEvent()
  88. //
  89. // // Add() will call InernalAddRef()
  90. // pList->Add(ptrEvent1);
  91. //
  92. // // Add() will not call InernalAddRef()
  93. // pList->Add(new CXTPCalendarEvent(), FALSE);
  94. //
  95. // // GetAt() will call InernalAddRef()
  96. // CXTPCalendarEventPtr ptrEvent0 = pList->GetAt(0, TRUE);
  97. //
  98. // // GetAt() will not call InernalAddRef()
  99. // CXTPCalendarEvent* pEvent1 = pList->GetAt(1);
  100. //
  101. // ASSERT(2 == pList->GetCount());
  102. //
  103. // //RemoveAll() will call InernalRelease() for all objects
  104. // pList->RemoveAll();
  105. //
  106. // ASSERT(0 == pList->GetCount());
  107. // </code>
  108. // See Also: GetAt, RemoveAll, GetCount, CXTPCalendarEvents overview,
  109. //           CXTPCalendarEvent overview.
  110. //-----------------------------------------------------------------------
  111. void Add(CXTPCalendarEvent* pNewEvent, BOOL bWithAddRef = TRUE);
  112. //-----------------------------------------------------------------------
  113. // Summary:
  114. //     Adds a new events element to the end of an array.
  115. // Parameters:
  116. //     pEventsArray - The pointer to the collection of event elements
  117. //     to add to this array.
  118. // Remarks:
  119. //     Use this method to add event elements from the specified
  120. //     array to the end of the events collection. Reference to the
  121. //     new object is increased by default. This depends on the array
  122. //     constructor parameter. See array constructor
  123. //     CXTPCalendarEvents(BOOL bWithAddRefRelease = TRUE);
  124. // Example:
  125. // <code>
  126. // // CXTPCalendarEvents - derived class
  127. // CXTPCalendarEvents arEvents1;
  128. // CXTPCalendarEventsPtr ptrEvents2 = new CXTPCalendarEvents();
  129. // ...
  130. // ptrEvents2->Append(&arEvents1);
  131. // </code>
  132. // See Also: CXTPCalendarEvents overview, GetAt, RemoveAll, GetCount,
  133. //           constructor CXTPCalendarEvents, CXTPCalendarEvents overview,
  134. //           CXTPCalendarEvents overview, CXTPCalendarEvent overview,
  135. //           CXTPCalendarEvent overview
  136. //-----------------------------------------------------------------------
  137. void Append(CXTPCalendarEvents* pEventsArray);
  138. //-----------------------------------------------------------------------
  139. // Summary:
  140. //     Call this method to get an event at the specified numeric index.
  141. // Parameters:
  142. //     nIndex - An integer index that is greater than or equal to 0
  143. //              and less than the value returned by GetCount.
  144. //     bWithAddRef - If this parameter is TRUE the InternalAdRef()
  145. //                   will be called for the returned object,
  146. //                   otherwise it will not be called.
  147. //                   The default value is FALSE.
  148. // Remarks:
  149. //     Reference to the returned object is increased or not depending on
  150. //     bWithAddRef parameter.
  151. //     Returns the array element at the specified index.
  152. // Example: See example for CXTPCalendarEvents::Add method.
  153. // Returns:
  154. //     The pointer to the CXTPCalendarEvent element currently at this
  155. //     index.
  156. //-----------------------------------------------------------------------
  157. CXTPCalendarEvent* GetAt(int nIndex, BOOL bWithAddRef = FALSE) const;
  158. //-----------------------------------------------------------------------
  159. // Summary:
  160. //     This member function is used to set a new event element to the
  161. //     position specified in the nIndex parameter.
  162. // Parameters:
  163. //     nIndex      - An integer index that is greater than or equal
  164. //                   to 0 and less than the value returned by
  165. //                   GetCount.
  166. //     pEvent      - The event element to add to this array.
  167. //     bWithAddRef - If this parameter is TRUE,  then InternalAddRef()
  168. //                   is called for the pEvent object,
  169. //                   otherwise InternalAddRef() is not called.
  170. // Remarks:
  171. //     Use this method to set the specified event pointer to the
  172. //     position specified in the nIndex parameter.
  173. //     Reference to the previous object is decreased by default. This
  174. //     depends on the array constructor parameter. See the array constructor
  175. //     CXTPCalendarEvents(BOOL bWithAddRefRelease = TRUE);
  176. //     Reference to the new object is increased or decreased depending
  177. //     on the bWithAddRef parameter.
  178. // Example:
  179. // <code>
  180. // // CXTPCalendarEvents - derived class
  181. // CXTPCalendarEvents* pList = new CXTPCalendarEvents();
  182. // CXTPCalendarEventPtr ptrEvent1 = new CXTPCalendarEvent()
  183. //
  184. // pList->Add(ptrEvent1);
  185. // pList->SetAt(0, new CXTPCalendarEvent(), FALSE);
  186. // </code>
  187. // See Also: CXTPCalendarEvents overview,
  188. //           constructor CXTPCalendarEvents, CXTPCalendarEvents overview,
  189. //           CXTPCalendarEvents overview, CXTPCalendarEvent overview,
  190. //           CXTPCalendarEvent overview
  191. //-----------------------------------------------------------------------
  192. void SetAt(int nIndex, CXTPCalendarEvent* pEvent, BOOL bWithAddRef = TRUE);
  193. //-----------------------------------------------------------------------
  194. // Summary:
  195. //     Inserts an element at a specified index.
  196. // Parameters:
  197. //     nIndex - An integer index that is greater than or equal to 0
  198. //              and may be greater than the value returned by GetCount.
  199. //     pEvent      - Pointer to the event to insert.
  200. //     bWithAddRef - Set this value to TRUE to increment the reference count of the inserted object,
  201. //                   FALSE to insert object without incrementing reference count.
  202. //                   Default value is TRUE.
  203. // Remarks:
  204. //     Inserts one element at a specified index in an array. In the process,
  205. //     it shifts up (by incrementing the index) the existing element at
  206. //     this index, and it shifts up all the elements above it.
  207. // See Also: CXTPCalendarEvents overview
  208. //-----------------------------------------------------------------------
  209. void InsertAt(int nIndex, CXTPCalendarEvent* pEvent, BOOL bWithAddRef = TRUE);
  210. //-----------------------------------------------------------------------
  211. // Summary:
  212. //     Removes an element of the specified index from this array.
  213. // Parameters:
  214. //     nIndex - An integer index that is greater than or equal to 0
  215. //              and less than the value returned by GetCount.
  216. // Remarks:
  217. //     Removes the pointer from this array. Reference to the removed
  218. //     object is decreased by default.
  219. // See Also: CXTPCalendarEvents overview
  220. //-----------------------------------------------------------------------
  221. void RemoveAt(int nIndex);
  222. //-----------------------------------------------------------------------
  223. // Summary:
  224. //     This member function is used to obtain the number of
  225. //     CXTPCalendarEvent elements in this collection.
  226. // Remarks:
  227. //     Call this method to retrieve the number of elements in the array.
  228. //     Because indexes are zero-based, the size is 1 greater than
  229. //     the largest index.
  230. // Example: See example for CXTPCalendarEvents::Add method.
  231. // Returns:
  232. //     An int that contains the number of items in the collection.
  233. // See Also: CXTPCalendarEvents overview
  234. //-----------------------------------------------------------------------
  235. int GetCount() const;
  236. //-----------------------------------------------------------------------
  237. // Summary:
  238. //     Set size of the array.
  239. // Parameters:
  240. //     nNewSize - A new array size (elements count).
  241. //     nGrowBy  - Amount of elements to grow array when Add and InsertAt
  242. //                methods used. -1 (by default) means using default
  243. //                parameter value.
  244. // See Also:
  245. //     GetCount, RemoveAll
  246. //-----------------------------------------------------------------------
  247. void SetSize(int nNewSize, int nGrowBy = -1);
  248. //-----------------------------------------------------------------------
  249. // Summary:
  250. //     This function is used to remove all of the elements from this array.
  251. // Remarks:
  252. //     Removes all of the pointers from this array. Reference to
  253. //     removed objects are decreased by default.
  254. // Example: See example for CXTPCalendarEvents::Add method.
  255. // See Also: CXTPCalendarEvents overview
  256. //-----------------------------------------------------------------------
  257. void RemoveAll();
  258. //-----------------------------------------------------------------------
  259. // Summary:
  260. //     This method is used to find an event using the EventID in this array.
  261. // Parameters:
  262. //     dwEventID - A DWORD that contains the unique event ID.
  263. //     pFEvent - A pointer to a CXTPCalendarEvent object that
  264. //                 contains the event object.
  265. // Remarks:
  266. // When using dwEventID -
  267. //     This method searches this collection for the first match of
  268. //     an event object with event ID equal to dwEventID.
  269. // When using pFEvent -
  270. //     This method searches this collection for the first match of
  271. //     a event object with identifiers equal to identifiers of
  272. //     the pFEvent. If there are no recurrence events, then these
  273. //     are Event IDs. For recurrence events, then these are
  274. //     RecurrencePatternID, Start/End times, or
  275. //     RException_StartTimeOrig/RException_EndTimeOrig.
  276. //     For details see implementation CXTPCalendarEvent::IsEqualIDs()
  277. // Example:
  278. // <code>
  279. // // CXTPCalendarEvents - derived class
  280. // CXTPCalendarEvents arEvents;
  281. // CXTPCalendarEvent* pEvent;
  282. // ...
  283. // if (arEvents.Find(pEvent->GetEventID()) < 0) {
  284. //     arEvents.Add(pEvent);
  285. // }
  286. // </code>
  287. // Returns:
  288. //     The zero-based index of the first event in the collection
  289. //     that matches the requested dwEventID.
  290. //     -1 if the event is not found.
  291. // See Also: CXTPCalendarEvents overview,
  292. //           constructor CXTPCalendarEvents, CXTPCalendarEvents overview,
  293. //           CXTPCalendarEvents overview, CXTPCalendarEvent overview,
  294. //           CXTPCalendarEvent overview
  295. //-----------------------------------------------------------------------
  296. int Find(CXTPCalendarEvent* pFEvent) const;
  297. int Find(DWORD dwEventID) const; // <combine CXTPCalendarEvents::Find@CXTPCalendarEvent*@const>
  298. //-----------------------------------------------------------------------
  299. // Summary:
  300. //     This member function is used to find an event using the EventID
  301. //     in this array.
  302. // Parameters:
  303. //     dwEventID - A DWORD that contains the unique event ID.
  304. //     pFEvent - A CXTPCalendarEvent pointer that contains the
  305. //                 event object to compare.
  306. // Remarks:
  307. // When using dwEventID -
  308. //     This method searches this collection for the first match of
  309. //     a event object with event ID equal to dwEventID.
  310. //     Reference to the returned object is not increased.
  311. // When using pFEvent -
  312. //     This method searches this collection for the first match of
  313. //     a event object with identifiers equal to identifiers of
  314. //     the pFEvent. In the case of no recurrence events these
  315. //     are EventIDs. In the case of recurrence events these are
  316. //     RecurrencePatternIDs, Start/End times or
  317. //     RException_StartTimeOrig/RException_EndTimeOrig.
  318. //     For details see implementation CXTPCalendarEvent::IsEqualIDs()
  319. //     Reference to the returned object is not increased by default.
  320. // Example:
  321. // <code>
  322. // // CXTPCalendarEvents - derived class
  323. // CXTPCalendarEvents arEvents;
  324. // CXTPCalendarEvent* pEvent;
  325. // ...
  326. // CXTPCalendarEvent* pEvent2;
  327. // pEvent2 = arEvents.Find(pEvent->GetEventID());
  328. // if (pEvent2) {
  329. //     pEvent2.Update(pEvent);
  330. // }
  331. // </code>
  332. // Returns:
  333. //     The pointer to the first event in the collection
  334. //     that matches the requested dwEventID;
  335. //     NULL if the event is not found.
  336. // See Also: CXTPCalendarEvents overview, CXTPCalendarEvent overview,
  337. //-----------------------------------------------------------------------
  338. CXTPCalendarEvent* FindEvent(DWORD dwEventID) const;
  339. CXTPCalendarEvent* FindEvent(CXTPCalendarEvent* pFEvent) const; // <combine CXTPCalendarEvents::FindEvent@DWORD@const>
  340. //-----------------------------------------------------------------------
  341. // Summary:
  342. //     This member function is used to find and remove an event using
  343. //     EventID in this array.
  344. // Parameters:
  345. //     dwEventID - A DWORD containing a unique event ID.
  346. // Remarks:
  347. //     This method searches this collection for the first match of
  348. //     an event object with the event ID equal to dwEventID and removes
  349. //     the object from the collection..
  350. // Example:
  351. // <code>
  352. // // CXTPCalendarEvents - derived class
  353. // CXTPCalendarEvents arEvents;
  354. // DWORD dwEventIDToRemove;
  355. // ...
  356. // if (arEvents.RemoveByID(dwEventIDToRemove) < 0) {
  357. //  ...
  358. // }
  359. // </code>
  360. // Returns:
  361. //     TRUE - if the event is found and removed.
  362. //     FALSE - if the event is not found.
  363. // See Also: CXTPCalendarEvents overview,
  364. //           constructor CXTPCalendarEvents, CXTPCalendarEvents overview,
  365. //           CXTPCalendarEvents overview, CXTPCalendarEvent overview,
  366. //           CXTPCalendarEvent overview
  367. //-----------------------------------------------------------------------
  368. BOOL RemoveByID(DWORD dwEventID);
  369. //-----------------------------------------------------------------------
  370. // Summary:
  371. //     Clone events in the collection.
  372. // Remarks:
  373. //     This function pointer is used to replace events objects to their clones.
  374. //     If there is not enough memory to clone some events  they are
  375. //     removed from the collection.
  376. // See Also: CXTPCalendarEvent::CloneEvent()
  377. //-----------------------------------------------------------------------
  378. void CloneEvents();
  379. //-----------------------------------------------------------------------
  380. // Summary:
  381. //     Define a function pointer for comparing events.
  382. // Remarks:
  383. //     This function pointer is used in the Sort method.
  384. // See Also: Sort method, CompareEvents_ForView function,
  385. //           CompareEvents_ByID function
  386. //-----------------------------------------------------------------------
  387. typedef int (_cdecl* T_CompareFunc)(const CXTPCalendarEvent** ppEv1, const CXTPCalendarEvent** ppEv2);
  388. //-----------------------------------------------------------------------
  389. // Summary:
  390. //     This member function is used to sort events in this array.
  391. // Parameters:
  392. //     pCompareFunc - A T_CompareFunc function pointer that is used
  393. //                    to compare events.
  394. // Remarks:
  395. //     This method sorts events in this collection using specified
  396. //     compare events function. The QuickSort algorithm is used.
  397. // Example:
  398. // <code>
  399. // CXTPCalendarEvents - derived class
  400. // CXTPCalendarEvents arEvents;
  401. // ...
  402. // arEvents.Sort(CompareEvents_ForView);
  403. // ...
  404. // </code>
  405. // See Also: CXTPCalendarEvents overview,
  406. //           CXTPCalendarEvents overview, CXTPCalendarEvents overview,
  407. //           CXTPCalendarEvent overview, CXTPCalendarEvent overview,
  408. //           CompareEvents_ForView function, CompareEvents_ByID function,
  409. //           qsort() function in the stdlib.h
  410. //-----------------------------------------------------------------------
  411. void Sort(T_CompareFunc pCompareFunc);
  412. //-----------------------------------------------------------------------
  413. // Summary:
  414. //     This member function is used to compare specified events so that
  415. //     the events are displayed properly in the event's views.
  416. // Parameters:
  417. //     ppEv1 - Pointer to the first event.
  418. //     ppEv2 - Pointer to the second event.
  419. // Remarks:
  420. //     This function is used as a parameter for the Sort method to sort
  421. //     events in the order needed to display the events in the event's views.
  422. // Example: See example for CXTPCalendarEvents::Sort method.
  423. // See Also: method CXTPCalendarEvents::Sort overview,
  424. //           CompareEvents_ByID function
  425. //-----------------------------------------------------------------------
  426. static int _cdecl CompareEvents_ForView(const CXTPCalendarEvent** ppEv1, const CXTPCalendarEvent** ppEv2);
  427. //-----------------------------------------------------------------------
  428. // Summary:
  429. //     This member function is used to compare specified events by
  430. //     the event's IDs.
  431. // Parameters:
  432. //     ppEv1 - Pointer to the first event pointer.
  433. //     ppEv2 - Pointer to the second event pointer.
  434. // Remarks:
  435. //     This function is used as a parameter for the Sort method to sort
  436. //     events using EventIDs in ascending order.  This is useful for
  437. //     performing a fast search for an event ID.
  438. // Example: See example for CXTPCalendarEvents::Sort method.
  439. // See Also: method CXTPCalendarEvents::Sort overview,
  440. //           CompareEvents_ForView function
  441. //-----------------------------------------------------------------------
  442. static int _cdecl CompareEvents_ByID(const CXTPCalendarEvent** ppEv1, const CXTPCalendarEvent** ppEv2);
  443. protected:
  444. CArray<CXTPCalendarEvent*, CXTPCalendarEvent*> m_arEvents; // An internal storage for CXTPCalendarEvent pointers.
  445. };
  446. /////////////////////////////////////////////////////////////////////////////
  447. AFX_INLINE int CXTPCalendarEvents::GetCount() const {
  448. return (int)m_arEvents.GetSize();
  449. }
  450. AFX_INLINE void CXTPCalendarEvents::SetSize(int nNewSize, int nGrowBy)
  451. {
  452. m_arEvents.SetSize(nNewSize, nGrowBy);
  453. }
  454. AFX_INLINE BOOL CXTPCalendarEvents::RemoveByID(DWORD dwEventID) {
  455. int nFIndex = Find(dwEventID);
  456. if (nFIndex >= 0) {
  457. RemoveAt(nFIndex);
  458. }
  459. return (nFIndex >= 0);
  460. }
  461. #endif // !defined(_XTPCALENDAREVENTS_H__)