TreeLazyNotificationData.h

//========================================================================================
// 
// $File$
// 
// Owner: Habib Khalfallah
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __LazyTreeMsgCookie__
#define __LazyTreeMsgCookie__

#include "LazyNotificationData.h"
#include "KeyValuePair.h"
#include "ChangeTree.h"

class ITreeViewMgr;

template<class ItemType>
class TreeLazyNotificationData : public LazyNotificationData
{
 typedef typename ChangeTree<ItemType>::Node TreeNode; 
public:
 TreeLazyNotificationData():LazyNotificationData(), fMustRebuildChangeRecords (false)
 {
 }

 virtual ~TreeLazyNotificationData()
 {
 }
 
 virtual void Add (const LazyNotificationData* other);

 virtual LazyNotificationData* Clone (bool16 undoData) const;

 virtual void Validate(IDataBase *)
 {}


 virtual void MarkShouldRebuildAll();

 virtual bool ShouldRebuildAll() const;

 void ItemAdded(const ItemType &item);
 
 void ItemDeleted(const ItemType &item);
 
 void ItemChanged(const ItemType &item);
 
 void ItemRebuilt(const ItemType &item);

 template<typename TAdded, typename TDeleted, typename TChanged, typename TBuild>
 void ProcessChanges(TAdded Added, 
 TDeleted Deleted, 
 TChanged Changed, 
 TBuild Rebuilt);

 struct IgnoreItem : std::function<void (const ItemType &) >
 {
 void operator () (const ItemType &) const {}
 };

#ifdef DEBUG

 virtual void WriteTree(std::ofstream *file);
#endif

 /*
 / ** Used to indicate to external clients what type of change 
 happened to a given item
 * /
 enum ChangeType
 {
 / ** Item was added * /
 kAdd,
 / ** Item was deleted * /
 kDelete,
 / ** Item was changed * /
 kChange,
 / ** Item and its children need to be rebuilt * /
 kRebuild
 };

 / ** Each item in the iterator will be a ChangeRecord * /
 typedef std::pair<ChangeType,ItemType> ChangeRecord;
 / ** Used as a typedef simply to make less typing and easier reading * /
 typedef std::vector<ChangeRecord> ChangeRecordsContainer;
 / ** Used as a typedef simply to make less typing and easier reading * /
 typedef typename ChangeRecordsContainer::const_iterator change_records_iterator;

 / ** This method can be used to ask for an iterator
 which starts at the beginning of the changes.
 NOTE: When using this iterator it is highly 
 recommended that you handle each item change
 in the order that you iterate them, rather than
 skip some and try to handle them later.
 @return - A const iterator for looking at the changes
 * /
 change_records_iterator begin_change_records ();

 / ** The end of the list of changes. Use this in
 conjuction with begin_change_records
 @return - The end of the changes.
 * /
 change_records_iterator end_change_records ();
 */

protected:
 virtual TreeLazyNotificationData *CreateNewCookie() const = 0;

 virtual bool16 GetParent(const ItemType &item, ItemType &parent) const = 0;
 
#ifdef DEBUG
 virtual PMString GetNodeName(const ItemType &item) const
 { 
 return ""; 
 }
#endif

private:
 void AddChange(const ItemType &item, typename TreeNode::ChangeState nodeChange);

 void MergeChildren(typename ChangeTree<ItemType>::Node *whole, const TreeNode *part);

 void InsertSubBranch(TreeNode *myStart, const TreeNode *otherStart);

 void ChangeNode(TreeNode *node, typename ChangeTree<ItemType>::Node::ChangeState newState);

 void SwapAddAndDelete (const ItemType item);

 ChangeTree<ItemType> fTree;

 bool fMustRebuildChangeRecords;

 enum {kMaxSize = 200};
};


#endif