home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / todo.pak / TODOLIST.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-24  |  9.1 KB  |  333 lines
  1. #if !defined( __TODOLIST_H )
  2. #define __TODOLIST_H
  3.  
  4. //---------------------------------------------------------------------
  5. //
  6. //  TODOLIST.H
  7. //
  8. //      Copyright (c) 1991, 1993 by Borland International
  9. //      All Rights Reserved.
  10. //
  11. //  Defines the following classes, used in implementing the Todo list:
  12. //
  13. //      TodoEntry   - holds the data for an entry in the Todo list.
  14. //
  15. //      TodoList    - container for holding Todo entries
  16. //
  17. //      ListBox     - wrapper around the Windows listbox, providing
  18. //                    an interface that fits with the Todo list.
  19. //
  20. //      TodoWindow  - the main window for this application.  There's
  21. //                    nothing displayed in the window except for the
  22. //                    list box.
  23. //
  24. //---------------------------------------------------------------------
  25.  
  26. #if !defined( STRICT )
  27. #define STRICT
  28. #endif
  29.  
  30. #include <windows.h>
  31. #include <iostream.h>
  32. #include <except.h>
  33. #include <string.h>
  34. #include <cstring.h>
  35. #include <dir.h>
  36.  
  37. #include "classlib\date.h"
  38. #include "classlib\vectimp.h"
  39. #include "classlib\objstrm.h"
  40. #include "classlib\stdtempl.h"
  41. #include "todowin.h"
  42.  
  43. //---------------------------------------------------------------------
  44. //
  45. //  class TodoEntry
  46. //
  47. //      holds the data for an entry in the Todo list.
  48. //
  49. //---------------------------------------------------------------------
  50.  
  51. class TodoEntry
  52. {
  53.  
  54.     friend class EditBox;
  55.  
  56. public:
  57.  
  58.     TodoEntry();                // constructor.
  59.  
  60.     BOOL Modified() const;      // indicates whether the entry has
  61.                                 // been modified.  Used in determining
  62.                                 // whether the list should be saved.
  63.  
  64.     void Clear();               // marks the entry as saved.
  65.  
  66.     friend int operator == ( const TodoEntry&, const TodoEntry& );
  67.     friend int operator <  ( const TodoEntry&, const TodoEntry& );
  68.  
  69.     friend ipstream& operator >> ( ipstream& is, TodoEntry& td );
  70.     friend opstream& operator << ( opstream& os, const TodoEntry& td );
  71.  
  72.     friend ostream& operator << ( ostream& os, const TodoEntry& tde );
  73.  
  74. private:
  75.  
  76.     BOOL Dirty;                 // indicates whether this entry has
  77.                                 // been modified.
  78.  
  79.     TDate DateCreated;
  80.     TDate DateDue;
  81.     string Text;                // the note associated with this entry
  82.     int Priority;
  83.  
  84. };
  85.  
  86. //---------------------------------------------------------------------
  87. //
  88. //  class TodoList
  89. //
  90. //      container for holding Todo entries.  Currently implemented as
  91. //      a SortedArray, so we don't have to explicitly sort the entries
  92. //      when a new one is added.  The sorting is done according to the
  93. //      operator < defined for a TodoEntry, which sorts according
  94. //      to the due date.
  95. //
  96. //---------------------------------------------------------------------
  97.  
  98. class TodoList
  99. {
  100.  
  101.     friend class ListBox;
  102.  
  103. public:
  104.  
  105.     TodoList();
  106.  
  107.     void Add( const TodoEntry& );
  108.                                 // adds an entry to the Todo list.
  109.  
  110.     void Detach( unsigned idx );
  111.                                 // removes an entry from the Todo list.
  112.  
  113.     TodoEntry& operator [] ( unsigned idx );
  114.  
  115.     int IndexOf( const TodoEntry& );
  116.                                 // returns the index of the specified entry.
  117.  
  118.     BOOL Modified() const;      // indicates whether the list has
  119.                                 // been modified by adding or deleting an
  120.                                 // entry.  Used in determining
  121.                                 // whether the list should be saved.
  122.  
  123.     void MarkSaved() const;     // marks that the list has been saved.
  124.  
  125.     void Clear();               // removes all entries from the list.
  126.  
  127.     friend ipstream& operator >> ( ipstream& is, TodoList& td );
  128.     friend opstream& operator << ( opstream& os, const TodoList& td );
  129.  
  130. private:
  131.  
  132.     TSVectorImp<TodoEntry> Vect;// sorted vector that holds the entries
  133.  
  134.     BOOL Dirty;                 // indicates whether this list has been
  135.                                 // modified.
  136.  
  137. };
  138.  
  139. //---------------------------------------------------------------------
  140. //
  141. //  class ListBox
  142. //
  143. //      wrapper around the Windows listbox, providing an interface
  144. //      that fits with the Todo list.  This is used to display the
  145. //      Todo list in a window.
  146. //
  147. //---------------------------------------------------------------------
  148.  
  149. class ListBox
  150. {
  151.  
  152. public:
  153.  
  154.     ListBox();
  155.  
  156.     const ListBox& operator = ( const TodoList& );
  157.                                 // copies the entries in the TodoList
  158.                                 // into the list box.
  159.  
  160.     void Focus();               // sets focus to the list box.
  161.     void Move( const RECT& );   // moves and resizes the list box.
  162.     int Current();              // returns the index of the current
  163.                                 // selection.
  164.     void Remove( int );         // removes the specified entry from
  165.                                 // the list box.
  166.     void Insert( int, const TodoEntry& );
  167.                                 // adds an entry to the list box.
  168.     void Replace( int, const TodoEntry& );
  169.                                 // replaces an entry in the list box
  170.                                 // with another entry.
  171.     void Select( int );         // selects the specified entry.
  172.     void Clear();               // removes all entries.
  173.  
  174.     void Create( HWND, HWND, const RECT& );
  175.                                 // builds the list box.  This can't be
  176.                                 // done in the constructor because we
  177.                                 // don't have enough information at the
  178.                                 // time of construction.
  179.  
  180. private:
  181.  
  182.     HWND hListBox;              // handle of the list box.
  183.  
  184. };
  185.  
  186. //---------------------------------------------------------------------
  187. //
  188. //  class TodoWindow
  189. //
  190. //      the main window for this application.  There's nothing displayed
  191. //      in the window except for the list box.
  192. //---------------------------------------------------------------------
  193.  
  194. class TodoWindow : public Window
  195. {
  196.  
  197. public:
  198.  
  199.     TodoWindow() { *TitleName = '\0'; *FileName = '\0'; }
  200.  
  201. protected:
  202.  
  203.     virtual LONG Dispatch( WPARAM, WPARAM, LPARAM );
  204.  
  205.     virtual BOOL RegisterClass();
  206.     virtual BOOL CreateNewWindow();
  207.  
  208. private:
  209.  
  210.     ListBox LB;                 // the list box used by this window.
  211.     TodoList Tdl;               // the Todo list being displayed in this
  212.                                 // window.  There's a lot of parallelism
  213.                                 // between the operations of these two
  214.                                 // objects, and it might be worthwhile
  215.                                 // to add a class derived from both
  216.                                 // ListBox and TodoList for use here.
  217.  
  218.     char TitleName[MAXFILE+MAXEXT];
  219.     char FileName[MAXPATH];     // path to the file currently being
  220.                                 // used.  "" if there is no file.
  221.  
  222.     void NewList();
  223.     void OpenFile();
  224.     void SaveFile();
  225.     void SaveFileAs();
  226.     void ShowEditBox();
  227.     void NewEntry();
  228.     void DelEntry();
  229.     void ShowAboutBox();
  230.  
  231.     BOOL ShowSaveBox();
  232.  
  233.     void MoveListBox();
  234.  
  235.     void ReadFile();
  236.     void WriteFile();
  237.     void CheckSave();
  238.  
  239.     BOOL ProcessCommand( WPARAM, LPARAM );
  240.  
  241. };
  242.  
  243. //---------------------------------------------------------------------
  244. //
  245. //  inline functions.
  246. //
  247. //---------------------------------------------------------------------
  248.  
  249. inline TodoEntry::TodoEntry() : Dirty( FALSE ), Priority( 1 )
  250. {
  251. }
  252.  
  253. inline void TodoEntry::Clear()
  254. {
  255.     Dirty = 0;
  256. }
  257.  
  258. inline BOOL TodoEntry::Modified() const
  259. {
  260.     return Dirty;
  261. }
  262.  
  263. inline int operator == ( const TodoEntry& e1, const TodoEntry& e2 )
  264. {
  265.     return e1.DateDue == e2.DateDue;
  266. }
  267.  
  268. inline int operator <  ( const TodoEntry& e1, const TodoEntry& e2 )
  269. {
  270.     return e1.DateDue < e2.DateDue;
  271. }
  272.  
  273. inline TodoList::TodoList() : Vect( 20, 5 )
  274. {
  275. }
  276.  
  277. inline TodoEntry& TodoList::operator [] ( unsigned idx )
  278. {
  279.     return Vect[idx];
  280. }
  281.  
  282. inline ListBox::ListBox() : hListBox( 0 )
  283. {
  284. }
  285.  
  286. inline void ListBox::Focus()
  287. {
  288.     if( IsWindow( hListBox ) )
  289.         SetFocus( hListBox );
  290. }
  291.  
  292. inline void ListBox::Move( const RECT& wrect )
  293. {
  294.     MoveWindow( hListBox,
  295.                 wrect.left,
  296.                 wrect.top,
  297.                 wrect.right - wrect.left,
  298.                 wrect.bottom - wrect.top,
  299.                 TRUE
  300.               );
  301. }
  302.  
  303. inline int ListBox::Current()
  304. {
  305.     return (int)SendMessage( hListBox, LB_GETCURSEL, 0, 0 );
  306. }
  307.  
  308. inline void ListBox::Remove( int i )
  309. {
  310.     SendMessage( hListBox, LB_DELETESTRING, i, 0 );
  311.     Select( i );
  312. }
  313.  
  314. inline void ListBox::Replace( int i, const TodoEntry& tde )
  315. {
  316.     Remove( i );
  317.     Insert( i, tde );
  318. }
  319.  
  320. inline void ListBox::Select( int i )
  321. {
  322.     i = min( i, (int)SendMessage( hListBox, LB_GETCOUNT, 0, 0 ) - 1 );
  323.     SendMessage( hListBox, LB_SETCURSEL, i, 0 );
  324. }
  325.  
  326. inline void ListBox::Clear()
  327. {
  328.     SendMessage( hListBox, LB_RESETCONTENT, 0, 0 );
  329. }
  330.  
  331. #endif  // __TODOLIST_H
  332.  
  333.