Show
Ignore:
Timestamp:
07/09/07 10:02:18 (2 years ago)
Author:
daboo
Message:

Some 4.1 changes. Mostly vCard/CardDAV and CalDAV scheduling support.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • Mulberry/branches/v4.1d1/Sources_Common/Mail/AddressBook/CAddressBook.h

    r19 r86  
    2626 
    2727#include "CAdbkACL.h" 
    28 #include "CAdbkList.h" 
    2928#include "CAdbkAddress.h" 
    3029#include "CAddressList.h" 
    … …  
    3534#include "cdstring.h" 
    3635#include "cdmutex.h" 
     36#include "ptrvector.h" 
    3737 
    3838// Classes 
     39namespace xmllib  
     40{ 
     41class XMLDocument; 
     42class XMLNode; 
     43}; 
     44 
     45namespace vCard  
     46{ 
     47class CVCardAddressBook; 
     48}; 
    3949 
    4050class CAdbkProtocol; 
     51 
     52class CAddressBook; 
     53typedef ptrvector<CAddressBook> CAddressBookList; 
    4154 
    4255class CAddressBook 
    … …  
    4760                // Adbk status 
    4861                eNone =                                         0, 
    49                 eReadOnly =                                     1L << 1, 
    50                 eOpen =                                         1L << 2, 
    51                 eLoaded =                                       1L << 3, 
    52                 eOpenOnStart =                          1L << 4, 
    53                 eLookup =                                       1L << 5, 
    54                 eSearch =                                       1L << 6, 
    55                 eAdd =                                          1L << 7, 
    56                 eAutoSync =                                     1L << 8, 
    57                 eDeleteOnClose =                        1L << 9, 
    58                 eLocalAdbk =                            1L << 10, 
    59                 eCachedAdbk =                           1L << 11, 
     62                eIsProtocol =                           1L << 0, 
     63                eIsDirectory =                          1L << 1, 
     64                eIsAdbk =                                       1L << 2, 
     65                eHasExpanded =                          1L << 3, 
     66                eReadOnly =                                     1L << 4, 
     67                eOpen =                                         1L << 5, 
     68                eOpenOnStart =                          1L << 6, 
     69                eLookup =                                       1L << 7, 
     70                eSearch =                                       1L << 8, 
     71                eAdd =                                          1L << 9, 
     72                eAutoSync =                                     1L << 10, 
     73                eIsCached =                                     1L << 11, 
    6074                eSynchronising =                        1L << 12                // Addressbook is being synchronised 
    6175                 
    … …  
    6680        static cdmutex _mutex;                                                                          // Used for locks 
    6781 
    68                 CAddressBook() 
    69                         { InitAddressBook(); } 
    70                 explicit CAddressBook(const char* name) 
    71                         { InitAddressBook(); mAdbkName = name; } 
    72                 CAddressBook(const CAddressBook& copy); 
    73  
     82        // std::sort methods 
     83        static bool sort_by_name(const CAddressBook* s1, const CAddressBook* s2); 
     84 
     85                CAddressBook(); 
     86                CAddressBook(CAdbkProtocol* proto); 
     87                CAddressBook(CAdbkProtocol* proto, CAddressBook* parent, bool is_adbk = true, bool is_dir = false, const cdstring& name = cdstring::null_str); 
    7488        virtual ~CAddressBook(); 
    7589 
    7690        // Getters 
    77         const cdstring& GetName() const 
    78                 { return mAdbkName; } 
    79         void SetName(const char* name); 
    80  
    81         virtual cdstring GetAccountName() const = 0; 
    82         virtual cdstring GetURL(bool full = false) const = 0; 
     91        CAdbkProtocol* GetProtocol() const 
     92        { 
     93                return mProtocol; 
     94        } 
     95 
     96        CAddressBook* GetParent() const 
     97        { 
     98                return mParent; 
     99        } 
     100 
     101        void AddChild(CAddressBook* child, bool sort = false); 
     102        void AddChildHierarchy(CAddressBook* child, bool sort = false); 
     103        void InsertChild(CAddressBook* child, uint32_t index, bool sort = false); 
     104        CAddressBookList* GetChildren() const 
     105        { 
     106                return mChildren; 
     107        } 
     108        void SortChildren(); 
     109 
     110        cdstring GetAccountName(bool multi = true) const; 
     111        cdstring GetURL(bool full = false) const; 
     112 
     113        void SetName(const cdstring& name);                                                     // Set name 
     114        const cdstring& GetName() const                                                         // Get full name 
     115                { return mName; } 
     116        const char*     GetShortName() const                                                    // Get short name 
     117                { return mShortName; } 
     118        void    NewName(const cdstring& name);                                          // Tell this and children to adjust names 
    83119 
    84120        CAddressList* GetAddressList() 
    … …  
    92128                { return (EFlags) mFlags.Get(); } 
    93129 
    94         bool IsOpen() 
     130        bool IsProtocol() const 
     131        { 
     132                return mFlags.IsSet(eIsProtocol); 
     133        } 
     134 
     135        bool IsDirectory() const 
     136        { 
     137                return mFlags.IsSet(eIsDirectory); 
     138        } 
     139 
     140        bool IsAdbk() const 
     141        { 
     142                return mFlags.IsSet(eIsAdbk); 
     143        } 
     144 
     145        bool HasInferiors() const 
     146        { 
     147                return IsDirectory() && (mChildren != NULL) && (mChildren->size() != 0); 
     148        } 
     149 
     150        void SetHasExpanded(bool has_expanded) 
     151        { 
     152                mFlags.Set(eHasExpanded, has_expanded); 
     153        } 
     154        bool HasExpanded() const                                                                        // Has expanded children 
     155        { 
     156                return mFlags.IsSet(eHasExpanded); 
     157        } 
     158 
     159        bool IsOpen() const 
    95160                { return mFlags.IsSet(eOpen); } 
    96         bool IsLoaded() 
    97                 { return mFlags.IsSet(eLoaded); } 
    98161        bool    IsOpenOnStart() const 
    99162                { return mFlags.IsSet(eOpenOnStart); } 
    … …  
    106169        bool    IsAutoSync() const 
    107170                { return mFlags.IsSet(eAutoSync);} 
    108         bool    IsLocalAdbk() const 
    109                 { return mFlags.IsSet(eLocalAdbk);} 
    110171        bool    IsCachedAdbk() const 
    111                 { return mFlags.IsSet(eCachedAdbk);} 
     172                { return mFlags.IsSet(eIsCached);} 
    112173        bool    IsSynchronising() const 
    113174                { return mFlags.IsSet(eSynchronising);} 
    114175 
     176        void SetSize(uint32_t size) 
     177        { 
     178                mSize = size; 
     179        } 
     180        uint32_t GetSize() const 
     181        { 
     182                return mSize; 
     183        } 
     184        void CheckSize(); 
     185 
     186        uint32_t GetLastSync() const 
     187        { 
     188                return mLastSync; 
     189        } 
     190        void SyncNow() const; 
     191 
     192        bool IsCached() const; 
     193        void TestDisconnectCache(); 
     194 
     195        CAddressBook* FindNode(cdstrvect& hierarchy, bool discover = false) const; 
     196        CAddressBook* FindNodeOrCreate(cdstrvect& hierarchy) const 
     197        { 
     198                return FindNode(hierarchy, true); 
     199        } 
     200 
     201        void RemoveFromParent(); 
     202        void Clear(); 
     203 
     204        uint32_t GetRow() const; 
     205        uint32_t CountDescendants() const; 
     206        uint32_t GetParentOffset() const; 
     207        const CAddressBook* GetSibling() const; 
     208        void GetInsertRows(uint32_t& parent_row, uint32_t& sibling_row) const; 
     209 
     210        // VCard stuff 
     211        const vCard::CVCardAddressBook* GetVCardAdbk() const 
     212        { 
     213                return mVCardAdbk; 
     214        } 
     215        vCard::CVCardAddressBook* GetVCardAdbk() 
     216        { 
     217                return mVCardAdbk; 
     218        } 
     219        void SetVCardAdbk(vCard::CVCardAddressBook* adbk) 
     220        { 
     221                mVCardAdbk = adbk; 
     222        } 
     223 
     224        // Operations on address books 
     225        void MoveAddressBook(const CAddressBook* dir, bool sibling); 
     226        void CopyAddressBook(CAddressBook* node); 
     227        void CopyAddressBookContents(CAddressBook* node); 
     228 
    115229        // Opening/closing 
    116         virtual void    New();                                                                  // New visual address book on source 
    117         virtual void    Open();                                                                 // Open visual address book from source 
    118         virtual void    Read();                                                                 // Read in addresses 
    119         virtual void    Save();                                                                 // Save addresses 
    120         virtual void    Close();                                                                // Close visual address book 
    121         virtual void    Clear();                                                                // Clear addresses 
     230        void    Open();                                                                 // Open visual address book from source 
     231        void    Close();                                                                // Close visual address book 
     232        void    ClearContents();                                                // Clear addresses 
    122233 
    123234        // Manipulation 
    124         virtual void    Rename(cdstring& new_name);                             // Rename 
    125         virtual void    Delete();                                                               // Delete 
    126         virtual void    Empty();                                                                // Empty 
    127  
    128         virtual void    CopyAll(CAddressBook* adbk);                    // Copy addresses and groups to another address book 
    129  
    130         virtual void    Synchronise(bool fast);                                 // Synchronise to local 
    131         virtual void    ClearDisconnect();                                              // Clear disconnected cache 
    132         virtual void    SwitchDisconnect(CAdbkProtocol* local); // Switch into disconnected mode 
    133  
    134         virtual CAdbkAddress* FindAddress(const char* name); 
    135         virtual CAdbkAddress* FindAddress(const CAddress* addr); 
    136         virtual CAdbkAddress* FindAddressEntry(const char* name); 
    137         virtual CGroup* FindGroup(const char* name); 
    138         virtual CGroup* FindGroupEntry(const char* name); 
     235        void    Rename(cdstring& new_name);                             // Rename 
     236        void    Delete();                                                               // Delete 
     237        void    Empty();                                                                // Empty 
     238 
     239        void    Synchronise(bool fast);                                 // Synchronise to local 
     240        void    ClearDisconnect();                                              // Clear disconnected cache 
     241 
     242        // Searching 
     243        CAdbkAddress* FindAddress(const char* name); 
     244        CAdbkAddress* FindAddress(const CAddress* addr); 
     245        CAdbkAddress* FindAddressEntry(const char* name); 
     246        CGroup* FindGroup(const char* name); 
     247        CGroup* FindGroupEntry(const char* name); 
    139248 
    140249        // Adding/removing items 
    141         virtual void    AddAddress(CAddress* addr, bool sorted = false); 
    142         virtual void    AddAddress(CAddressList* addrs, bool sorted = false); 
    143         virtual void    AddUniqueAddresses(CAddressList& add);                                                  // Add unique addresses from list 
    144         virtual void    UpdateAddress(CAddress* addr, bool sorted = false);                             // Address changed 
    145         virtual void    UpdateAddress(CAddressList* addrs, bool sorted = false) {}              // Address changed 
    146         virtual void    UpdateAddress(CAddressList* old_addrs, CAddressList* new_addrs, bool sorted = false);           // Address changed 
    147         virtual void    RemoveAddress(CAddress* addr); 
    148         virtual void    RemoveAddress(CAddressList* addrs) 
    149                 { if (IsLoaded()) mAddresses.RemoveAddress(addrs); } 
    150  
    151         virtual void    AddGroup(CGroup* grp, bool sorted = false); 
    152         virtual void    AddGroup(CGroupList* grps, bool sorted = false); 
    153         virtual void    AddUniqueGroups(CGroupList& add);                                                               // Add unique groups from list 
    154         virtual void    UpdateGroup(CGroup* grp, bool sorted = false);                                  // Group changed 
    155         virtual void    UpdateGroup(CGroupList* grps, bool sorted = false) {}                   // Group changed 
    156         virtual void    UpdateGroup(CGroupList* old_grps, CGroupList* new_grps, bool sorted = false);           // Address changed 
    157         virtual void    RemoveGroup(CGroup* grp); 
    158         virtual void    RemoveGroup(CGroupList* grps) 
    159                 { if (IsLoaded()) mGroups.RemoveGroup(grps); } 
    160  
    161         virtual void    MakeUniqueEntry(CAdbkAddress* addr) const;      // Give this address a unique entry 
     250        void    AddAddress(CAddress* addr, bool sorted = false); 
     251        void    AddAddress(CAddressList* addrs, bool sorted = false); 
     252        void    AddUniqueAddresses(CAddressList& add);                                                  // Add unique addresses from list 
     253        void    UpdateAddress(CAddress* addr, bool sorted = false);                             // Address changed 
     254        void    UpdateAddress(CAddressList* addrs, bool sorted = false);                // Address changed 
     255        void    UpdateAddress(CAddressList* old_addrs, CAddressList* new_addrs, bool sorted = false);           // Address changed 
     256        void    RemoveAddress(CAddress* addr); 
     257        void    RemoveAddress(CAddressList* addrs); 
     258 
     259        void    AddGroup(CGroup* grp, bool sorted = false); 
     260        void    AddGroup(CGroupList* grps, bool sorted = false); 
     261        void    AddUniqueGroups(CGroupList& add);                                                               // Add unique groups from list 
     262        void    UpdateGroup(CGroup* grp, bool sorted = false);                                  // Group changed 
     263        void    UpdateGroup(CGroupList* grps, bool sorted = false);                             // Group changed 
     264        void    UpdateGroup(CGroupList* old_grps, CGroupList* new_grps, bool sorted = false);           // Address changed 
     265        void    RemoveGroup(CGroup* grp); 
     266        void    RemoveGroup(CGroupList* grps); 
     267 
     268        void    MakeUniqueEntry(CAdbkAddress* addr) const;      // Give this address a unique entry 
    162269 
    163270        // Reading/writing 
    164         virtual void    ImportAddresses(char* txt); 
    165         virtual void    ImportAddress(char* txt, bool add, 
     271        void    ImportAddresses(char* txt); 
     272        void    ImportAddress(char* txt, bool add, 
    166273                                                                        CAdbkAddress** addr, 
    167274                                                                        CGroup** grp, bool add_entry = false); 
    168         virtual char*   ExportAddress(const CAdbkAddress* addr) const; 
    169         virtual char*   ExportGroup(const CGroup* grp) const; 
     275        char*   ExportAddress(const CAdbkAddress* addr) const; 
     276        char*   ExportGroup(const CGroup* grp) const; 
    170277 
    171278        // Lookup 
    172         virtual bool    FindNickName(const char* nick_name, 
    173                                                                                 CAdbkAddress*& addr);   // Find address from nick-name 
    174  
    175         virtual bool    FindGroupName(const char* grp_name, 
    176                                                                                 CGroup*& grp);                  // Find group from group-name 
    177  
    178         virtual void    SearchAddress(const cdstring& name, 
     279        bool    FindNickName(const char* nick_name, 
     280                                                                                CAdbkAddress*& addr, 
     281                                                                                bool cache_only = false);       // Find address from nick-name 
     282 
     283        bool    FindGroupName(const char* grp_name, 
     284                                                                                CGroup*& grp, 
     285                                                                                bool cache_only = false);                       // Find group from group-name 
     286 
     287        void    SearchAddress(const cdstring& name, 
    179288                                                                        CAdbkAddress::EAddressMatch match, 
    180289                                                                        CAdbkAddress::EAddressField field, 
    … …  
    182291 
    183292        // ACLs 
    184         virtual void    SetMyRights(SACLRight rights)                           // Set user's rights to this mailbox 
     293        void    SetMyRights(SACLRight rights)                           // Set user's rights to this mailbox 
    185294                { mMyRights = rights; } 
    186         virtual SACLRight       GetMyRights() const 
     295        SACLRight       GetMyRights() const 
    187296                { return mMyRights; } 
    188         virtual void    CheckMyRights() = 0;                                    // Get user's rights from server 
    189  
    190         virtual void    AddACL(const CAdbkACL* acl) = 0;                        // Add ACL to list 
    191         virtual void    SetACL(CAdbkACL* acl) = 0;                                      // Set ACL on server 
    192         virtual void    DeleteACL(CAdbkACL* acl) = 0;                           // Delete ACL on server 
    193         virtual CAdbkACLList*   GetACLs() const 
     297        void    CheckMyRights();                                                        // Get user's rights from server 
     298 
     299        void    AddACL(const CAdbkACL* acl);                            // Add ACL to list 
     300        void    SetACL(CAdbkACL* acl);                                          // Set ACL on server 
     301        void    DeleteACL(CAdbkACL* acl);                                       // Delete ACL on server 
     302        CAdbkACLList*   GetACLs() const 
    194303                { return mACLs; } 
    195         virtual void    CheckACLs() = 0;                                                // Get ACLs from server 
     304        void    CheckACLs();                                                            // Get ACLs from server 
     305 
     306        void WriteXML(xmllib::XMLDocument* doc, xmllib::XMLNode* parent, bool is_root = false) const; 
     307        void ReadXML(const xmllib::XMLNode* node, bool is_root = false); 
    196308 
    197309protected: 
    198         cdstring                        mAdbkName;              // Name of adbk 
    199         SBitFlags                       mFlags;                 // Flags state 
     310        CAdbkProtocol*          mProtocol; 
     311        CAddressBook*           mParent; 
     312        CAddressBookList*       mChildren; 
     313        SBitFlags                       mFlags;                                         // Flags state 
     314        cdstring                        mName;                                          // Full path name of item 
     315        const char*                     mShortName;                                     // Pointer to the last part of the path name 
     316        uint32_t                        mSize;                                          // Disk size 
     317        mutable uint32_t        mLastSync;                                      // Last sync time 
    200318        CAddressList            mAddresses; 
    201319        CGroupList                      mGroups; 
    … …  
    203321        CAdbkACLList*           mACLs;                                          // List of ACLs on this address book 
    204322        unsigned long           mRefCount;                                      // Reference count of opens 
     323        vCard::CVCardAddressBook*       mVCardAdbk;                                     // The VCard address book 
    205324 
    206325                        char SkipTerm(char** txt, cdstring& copy); 
    … …  
    209328                        bool CloseCount();                                              // Determine whether to close based on ref cunt 
    210329 
    211 private: 
    212         void    InitAddressBook(); 
     330                        void SetShortName();                                    // Set short name from full name 
     331                        void ParentRenamed();                           // Tell children to adjust names when parent moves 
    213332}; 
    214333