//////////////////////////////////////////////////////////////////////////////
//文件 ActionBackupItem.cpp
//主要功能: 
//
//程序编写:		2006-12-07
/////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "ActionBackupItem.h"
#include "SigmaDoc.h"
#include "SigmaView.h"
#include ".\actionbackupitem.h"
#include "ItemEditCurveInName.h"
#include "Visitor.h"

NAction::CActionBackupItem::CActionBackupItem()
	: CActionItem(nullptr, 0)
{
}

CActionBackupItem::CActionBackupItem(CSigmaDoc * ppDoc, UINT actionType)
: CActionItem(ppDoc, actionType)
{
}

CActionBackupItem::CActionBackupItem(CSigmaDoc * ppDoc, UINT actionType, const CPositionList& list)
: CActionItem(ppDoc, actionType)
{
	Backup(list);
}

CActionBackupItem::~CActionBackupItem(void)
{
}

void CActionBackupItem::Undo(void)
{
	CActionItem::Undo();
	DoOperation(&BackupEntry::pOldOne);
}

void CActionBackupItem::Redo(void)
{
	CActionItem::Redo();
	DoOperation(&BackupEntry::pNewOne);
}

void CActionBackupItem::DoOperation(std::unique_ptr<COne> BackupEntry::* member)
{
	CRect8 rect(1e300,-1e300,-1e300,1e300);

	for (const BackupEntry& entry : m_entries)
	{
		COne* pOne = GetDoc()->GetDraw()->GetOneById(entry.id);
		const std::unique_ptr<COne>& pActionOne = entry.*member;

		if (pOne != nullptr && pActionOne != nullptr)
		{
			pOne->GetRange(rect);
			pActionOne->GetRange(rect);

			*pOne = *pActionOne;
		}
	}

	Invalidate(rect);
}

void CActionBackupItem::Backup(const CPositionList& list)
{
	Clear(value);

	POSITION pos=list.GetHeadPosition();
	POSITION pt;
	while(pos)
	{
		pt=list.GetNext(pos);
		Backup(pt);
	}
}

void CActionBackupItem::Backup(POSITION pos)
{
	if(pos==NULL) return;
	COne* pOne=GetDoc()->GetDraw()->GetAt(pos);
	Backup(pOne);
}

void NAction::CActionBackupItem::BackupNew()
{
	for (auto& entry : m_entries)
	{
		COne* pOne = GetDoc()->GetDraw()->GetOneById(entry.id);
		if (pOne != nullptr)
		{
			entry.pNewOne = std::make_unique<COne>();
			*entry.pNewOne = *pOne;
		}
	}
}

void NAction::CActionBackupItem::accept(CActionVisitor& visitor)
{
	visitor.visit(*this);
}

void NAction::CActionBackupItem::Backup(COne* pOne)
{
	COne* pBakOne=new COne;
	*pBakOne=*pOne;
	Backup(pBakOne, pOne);
}

void NAction::CActionBackupItem::Backup(COne* pBakOne, COne* pOne)
{
	BackupEntry entry;
	entry.id = pOne->GetId();
	entry.pOldOne.reset(pBakOne);

	m_entries.push_back(std::move(entry));
}

int NAction::CActionBackupItem::BackupAllElements(void)
{
	CPtrList* pl=GetDoc()->GetDraw()->GetValueList();
	POSITION pos=pl->GetHeadPosition();
	while(pos)
	{
		Backup(pos);
		pl->GetNext(pos);
	}
	return (int)GetDoc()->GetDraw()->GetCount();
}

int NAction::CActionBackupItem::GetCount(void)
{
	return static_cast<int>(m_entries.size());
}

void NAction::CActionBackupItem::RemoveBackupTail(void)
{
	if (m_entries.size() > 0)
	{
		m_entries.pop_back();
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////

NAction::CActionBackupProjectionItem::CActionBackupProjectionItem()
	: CActionItem(nullptr, 0)
{
}

CActionBackupProjectionItem::CActionBackupProjectionItem(CSigmaDoc * ppDoc, UINT actionType)
: CActionItem(ppDoc, actionType)
{
	m_strOldProjection=_T("");
	m_strNewProjection=_T("");
}

CActionBackupProjectionItem::CActionBackupProjectionItem(CSigmaDoc * ppDoc, UINT actionType, CString strOldPro, CString strNewPro)
: CActionItem(ppDoc, actionType)
{
	m_strOldProjection=strOldPro;
	m_strNewProjection=strNewPro;
}

CActionBackupProjectionItem::~CActionBackupProjectionItem(void)
{
}

void CActionBackupProjectionItem::Undo()
{
	CActionItem::Undo();

	GetDoc()->GetDraw()->SetProjection(m_strOldProjection);
	GetDoc()->Invalidate();
}

void CActionBackupProjectionItem::Redo()
{
	CActionItem::Redo();

	GetDoc()->GetDraw()->SetProjection(m_strNewProjection);
	GetDoc()->Invalidate();
}

void NAction::CActionBackupProjectionItem::accept(CActionVisitor& visitor)
{
	visitor.visit(*this);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////

NAction::CActionBackupXYItem::CActionBackupXYItem()
	: CActionItem(nullptr, 0)
{
}

CActionBackupXYItem::CActionBackupXYItem(CSigmaDoc * ppDoc, UINT actionType)
: CActionItem(ppDoc, actionType)
{
	m_pPrevXY = NULL;
	//m_pPrevXY=GetDoc()->m_pDraw;
	//GetDoc()->m_pDraw=new CXy;
	//*(GetDoc()->m_pDraw)=*m_pPrevXY;
	//ResetTreeLayerPtr();
}

CActionBackupXYItem::~CActionBackupXYItem()
{
	if(m_pPrevXY) delete m_pPrevXY;
	m_pPrevXY=NULL;
}

void CActionBackupXYItem::Undo()
{
	CActionItem::Undo();
	/*
	CXy* pTempXY=GetDoc()->m_pDraw;
	GetDoc()->m_pDraw=m_pPrevXY;
	m_pPrevXY=pTempXY;
	ResetTreeLayerPtr();
	*/

	GetDoc()->Invalidate();
}

void CActionBackupXYItem::Redo()
{
	CActionItem::Redo();
	/*
	CXy* pTempXY=GetDoc()->m_pDraw;
	GetDoc()->m_pDraw=m_pPrevXY;
	m_pPrevXY=pTempXY;
	ResetTreeLayerPtr();

	GetDoc()->Invalidate();
	*/
}

void NAction::CActionBackupXYItem::ResetTreeLayerPtr(void)
{
	/*
	CMainFrame* pmf = (CMainFrame*)GetDoc()->GetMainFrame();
	if(pmf && pmf->m_pPaneLayerManager!=NULL)
		pmf->m_pPaneLayerManager->LoadTree(GetDoc()->GetDraw(), FALSE);
	*/
}

void NAction::CActionBackupXYItem::accept(CActionVisitor& visitor)
{
	visitor.visit(*this);
}

NAction::CAtionBackupEditCurveInName::CAtionBackupEditCurveInName()
	: CActionBackupItem(nullptr, 0)
{
}

CAtionBackupEditCurveInName::CAtionBackupEditCurveInName(CSigmaDoc * ppDoc, UINT actionType, const CPositionList& list)
	:CActionBackupItem(ppDoc, actionType, list)
{
}

void CAtionBackupEditCurveInName::Undo(void)
{
	CActionBackupItem::Undo();
	CItemEditCurveInName * pItem = dynamic_cast<CItemEditCurveInName *>(GetDoc()->GetItem());
	if (pItem == 0)
		return;
	CDC * pDC = GetDoc()->GetView()->GetScreenDC();
	pItem->BeginEdit(pDC);
}

void CAtionBackupEditCurveInName::Redo(void)
{
	CActionBackupItem::Redo();
	CItemEditCurveInName * pItem = dynamic_cast<CItemEditCurveInName *>(GetDoc()->GetItem());
	if (pItem == 0)
		return;
	CDC * pDC = GetDoc()->GetView()->GetScreenDC();
	pItem->BeginEdit(pDC);
}

void NAction::CAtionBackupEditCurveInName::accept(CActionVisitor& visitor)
{
	visitor.visit(*this);
}