Resource ID Organiser Add-In for Visual C++ 5.0/6.0/.NET

/************************************************************************
 *
 *                 Resource ID Organiser Core Library
 *
 * (c) Copyright 2000-2004 by Anna-Jayne Metcalfe (resorg@annasplace.me.uk)
 *                         All rights reserved.
 *
 ************************************************************************
 *                                                                       
 *  Filename    : ResourceSymbolManagerMultiFile.cpp
 *
 *  Description : CResourceSymbolManagerMultiFile - class to manage conflicts between
 *                resource symbol files
 *                
 *  Compiler    : Microsoft Visual C++ 6.0, Service Pack 3 or later
 *                Microsoft Visual C++ .NET 2002
 *                                                                       
 *  Target                                                               
 *  Environment : Windows 98/NT/2000/XP
 *
 *  NOTE:
 *
 *    This software is provided "as is" free for personal use. All
 *    title and copyrights in and to the software, including but not
 *    limited to any images, text, etc. incorporated into it, are
 *    owned by Anna-Jayne Metcalfe, except where acknowledged otherwise.
 *
 *    Your may freely to use this code in your own products, PROVIDED
 *    this notice is not removed or modified.
 *
 *
 *    Visit http://www.annasplace.me.uk/resorg for latest updates
 *
 ************************************************************************
 *
 *   MODIFICATION HISTORY:
 *
 *           This is a controlled document. See project configuration
 *           control tool for latest version and full version history.
 *
 *    $Archive: /Projects/AddIns/ResOrg/ResOrgCore/ResourceSymbolManagerMultiFile.cpp $
 *   $Revision: 12 $
 *       $Date: 11/07/04 16:15 $
 *     $Author: Anna $
 *
 *    $History: ResourceSymbolManagerMultiFile.cpp $
 * 
 * *****************  Version 12  *****************
 * User: Anna         Date: 11/07/04   Time: 16:15
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Added support for detection of out of range symbols
 * 
 * *****************  Version 11  *****************
 * User: Anna         Date: 20/04/03   Time: 15:34
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Added overrides of CResourceSymbolManager::AreNextSymbolValuesInUse()
 * and FixNextSymbolValues()
 * 
 * *****************  Version 10  *****************
 * User: Anna         Date: 26/03/03   Time: 14:08
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Adding of removing a file not sets the modification flag
 * 
 * *****************  Version 9  *****************
 * User: Anna         Date: 3/03/03    Time: 20:10
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Moved XML code to its own class (CResOrgXmlWriter)
 * 
 * *****************  Version 8  *****************
 * User: Anna         Date: 25/02/03   Time: 21:25
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Added CResourceSymbolManagerMultiFile::SaveXml() override
 * 
 * *****************  Version 7  *****************
 * User: Anna         Date: 15/02/03   Time: 20:50
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Changed big BOOLs into little bools
 * 
 * *****************  Version 6  *****************
 * User: Anna         Date: 28/01/03   Time: 21:19
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Improved multi-file support by allowing files to be Added/Removed from
 * a multi-file display via the File Properties Dialog
 * 
 * *****************  Version 5  *****************
 * User: Anna         Date: 19/01/03   Time: 17:25
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * CResourceSymbolManagerMultiFile::Set() should now mark itself as
 * modified correctly
 * 
 * *****************  Version 4  *****************
 * User: Anna         Date: 3/01/03    Time: 15:51
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Added a "Files" tab to the Symbol File Properties dialog. Not fully
 * functional yet
 * 
 * *****************  Version 3  *****************
 * User: Anna         Date: 3/01/03    Time: 7:36
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Added runtime class info support to CResourceSymbolManagerMultiFile
 * 
 * *****************  Version 2  *****************
 * User: Anna         Date: 3/01/03    Time: 0:09
 * Updated in $/Projects/AddIns/ResOrg/ResOrgCore
 * Speeded up multi-file loading slightly
 * 
 * *****************  Version 1  *****************
 * User: Anna         Date: 2/01/03    Time: 0:03
 * Created in $/Projects/AddIns/ResOrg/ResOrgCore
 * 
 * $Nokeywords: $
 *
 ************************************************************************/

#include "stdafx.h"
#include "ResourceSymbolManagerMultiFile.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


IMPLEMENT_DYNAMIC(CResourceSymbolManagerMultiFile, CResourceSymbolManagerMultiFile_BASE)

//////////////////////////////////////////////////////////////////////
// Construction/Destruction

CResourceSymbolManagerMultiFile::CResourceSymbolManagerMultiFile(void)
{

}


CResourceSymbolManagerMultiFile::~CResourceSymbolManagerMultiFile(void)
{
	// Force references to symbols in the managers we contain
	// to be cleared. Note that this will need modifying if we
	// allow new symbols to be added via the UI
	m_listSymbols.RemoveAll();
	m_mapNames.RemoveAll();
	m_mapValues.RemoveAll();

	// Delete all the objects in m_arrayMngrs that we created
	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];
		if ( (NULL != pMngr) && pMngr->AutoDelete() )
		{
			delete pMngr;
		}
	}
}



/////////////////////////////////////////////////////////////////////////////
// CResourceSymbolManagerMultiFile Virtual Overrides

void CResourceSymbolManagerMultiFile::Serialize(CArchive& ar) 
{
	ASSERT_VALID(this);
	
	if (ar.IsLoading())
	{
		ASSERT(false);			// Don't think we need this..
	}
	else
	{
		for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
		{
			CResourceSymbolManager* pMngr = m_arrayMngrs[n];
			if (NULL != pMngr)
			{
				pMngr->Serialize(ar);
			}
		}
	}
}


bool CResourceSymbolManagerMultiFile::Set(	CResourceSymbol* pSymbol,
											const CString& sName,
											UINT uValue,
											bool bReadOnly /*= false*/)
{
	
	CResourceSymbolManager* pMngr = reinterpret_cast<CResourceSymbolManager*>
													( pSymbol->GetUserData() );

	if ( (NULL != pMngr) && (pMngr != this) )
	{
		// This symbol belongs to another Manager, so let it do the work
		// but make sure we update our own symbol name/value metrics
		ASSERT_VALID(pMngr);

		bool bValueChanged	= (uValue != pSymbol->GetValue() );
		bool bNameChanged	= (sName != pSymbol->GetName() );

		if (bValueChanged)
		{
			m_mapValues.Remove(pSymbol);

		}
		if (bNameChanged)
		{
			m_mapNames.Remove(pSymbol);
		}

		bool bResult = pMngr->Set(	pSymbol,
									sName,
									uValue,
									bReadOnly);

		if (bValueChanged)
		{
			m_mapValues.Add(pSymbol);
		}

		if (bNameChanged)
		{
			m_mapNames.Add(pSymbol);
		}

		if (bResult && (bValueChanged || bNameChanged) )
		{
			m_bModified = true;
		}

		CountConflicts();

		return bResult;
	}
	// It's one of our own symbols, so do the default thing...
	return CResourceSymbolManagerMultiFile_BASE::Set(pSymbol,
													sName,
													uValue,
													bReadOnly);
}


bool CResourceSymbolManagerMultiFile::IsOutOfRange(CResourceSymbol* pSymbol) const
{
	ASSERT(NULL != pSymbol);
	if (NULL != pSymbol)
	{
		CResourceSymbolManager* pManager = reinterpret_cast<CResourceSymbolManager*>( pSymbol->GetUserData() );
		ASSERT(NULL != pManager);
		if (NULL != pManager)
		{
			ASSERT_KINDOF(CResourceSymbolManager, pManager);

			return pManager->IsOutOfRange(pSymbol);
		}
	}
	return false;
}


void CResourceSymbolManagerMultiFile::RemoveAll(void)
{
	POSITION pos = m_listSymbols.GetHeadPosition();
	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = m_listSymbols.GetNext(pos);
		if (pSymbol != NULL)
		{
			CResourceSymbolManager* pMngr = reinterpret_cast<CResourceSymbolManager*>
															( pSymbol->GetUserData() );

			if ( (NULL != pMngr) && (pMngr == this) )
			{
				// Only delete symbols we've created locally. I actual fact I can't
				// see a situation in which this makes sense, since saving then might
				// be a bit problematical
				delete pSymbol;
			}
		}
	}
	m_listSymbols.RemoveAll();
	m_mapNames.RemoveAll();
	m_mapValues.RemoveAll();

	m_nConflicts = 0;

	// Delete all the symbol managers in m_arrayMngrs that we created
	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];
		if ( (NULL != pMngr) && pMngr->AutoDelete() )
		{
			delete pMngr;
		}
	}
	m_arrayMngrs.RemoveAll();

	m_bModified = true;
}


bool CResourceSymbolManagerMultiFile::AreNextSymbolValuesInUse(void) const
{
	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];

		if ( (NULL != pMngr) && pMngr->AreNextSymbolValuesInUse() )
		{
			return true;
		}
	}
	return false;
}


bool CResourceSymbolManagerMultiFile::FixNextSymbolValues(void)
{
	bool bResult = false;

	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];

		if ( (NULL != pMngr) && pMngr->AreNextSymbolValuesInUse() )
		{
			bResult = pMngr->FixNextSymbolValues() | bResult;
		}
	}
	return bResult;
}



/////////////////////////////////////////////////////////////////////
// Operations

bool CResourceSymbolManagerMultiFile::IsSymbolFileLoaded(const CString& sPathName) const
{
	int nMngr = GetSymbolFileIndex(sPathName);

	return (nMngr >= 0);
}


CResourceSymbolManager* CResourceSymbolManagerMultiFile::AddSymbolFile(	const CString& sPathName,
																		bool bUpdateMetrics /*= true*/)
{
	ASSERT(!sPathName.IsEmpty() );

	if (!IsSymbolFileLoaded(sPathName) )
	{
		CResourceSymbolManager* pMngr = new CResourceSymbolManager(true);		// The "true" is to remind us to delete it
		ASSERT(NULL != pMngr);

		if (NULL != pMngr)
		{
			if (pMngr->ReadSymbolFile(sPathName) )
			{
				m_arrayMngrs.Add(pMngr);

				AddSymbols(pMngr, bUpdateMetrics);

				SetModifiedFlag(true);
			}
			else
			{
				delete pMngr;
				pMngr = NULL;
			}
		}
		return pMngr;
	}
	return NULL;
}


bool CResourceSymbolManagerMultiFile::RemoveSymbolFile(	const CString& sPathName,
														bool bUpdateMetrics /*= true*/)
{
	ASSERT(!sPathName.IsEmpty() );

	int nMngr = GetSymbolFileIndex(sPathName);

	if (nMngr >= 0)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[nMngr];
		ASSERT(NULL != pMngr);

		if (NULL != pMngr)
		{
			POSITION pos = pMngr->GetFirstSymbolPosition();
			while (NULL != pos)
			{
				CResourceSymbol* pSymbol = pMngr->GetNextSymbol(pos);
				if (NULL != pSymbol)
				{
					//CResourceSymbolList listSymbols;
					//Lookup(pSymbol->GetValue, listSymbols);

					Remove(pSymbol, false);

					SetModifiedFlag(true);
				}
			}

			pMngr->RemoveAll();

			m_arrayMngrs.RemoveAt(nMngr);

			if (pMngr->AutoDelete() )
			{
				delete pMngr;
			}

			if (bUpdateMetrics)
			{
				SortByValue();

				CountConflicts();
			}
			return true;
		}
	}
	return false;
}


int CResourceSymbolManagerMultiFile::AddSymbols(CResourceSymbolManager* pMngr,
												bool bUpdateMetrics /*= true*/)
{
	if (NULL != pMngr)
	{
		CResourceSymbolList listSymbols;

		int nCount = pMngr->GetSymbols(listSymbols);

		POSITION pos = listSymbols.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pSymbol = listSymbols.GetNext(pos);
			if (NULL != pSymbol)
			{
				Add(pSymbol, false);
			}
		}

		if (bUpdateMetrics)
		{
			SortByValue();

			CountConflicts();
		}

		return nCount;
	}
	return 0;
}


int CResourceSymbolManagerMultiFile::GetSymbolFilePathNames(CStringArray& rarrayPathNames) const
{
	rarrayPathNames.RemoveAll();

	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];
		ASSERT_VALID(pMngr);

		if (NULL != pMngr)
		{
			rarrayPathNames.Add( pMngr->GetPathName() );
		}
	}
	return rarrayPathNames.GetSize();
}


CResourceSymbolManager*	CResourceSymbolManagerMultiFile::GetSymbolManager(const CString& sPathName) const
{
	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];
		ASSERT_VALID(pMngr);

		if (NULL != pMngr)
		{
			if (0 == sPathName.CompareNoCase( pMngr->GetPathName() ) )
			{
				return pMngr;
			}
		}
	}
	return NULL;
}


// Return the total conflict count (internal & external) for the given manager
// TO DO: Check that the given manager object is actually one of ours
//
int CResourceSymbolManagerMultiFile::GetTotalConflictCount(CResourceSymbolManager* pMngr) const
{
	int nConflicts = 0;

	ASSERT(NULL != pMngr);
	if (NULL != pMngr)
	{
		CResourceSymbolList listSymbols;
		pMngr->GetSymbols(listSymbols);

		POSITION pos = listSymbols.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pSymbol = listSymbols.GetNext(pos);

			if (!IsUnique( pSymbol->GetName() ) || !IsUnique( pSymbol->GetValue() ) )
			{
				nConflicts++;
			}
		}
	}
	return nConflicts;
}


int CResourceSymbolManagerMultiFile::GetSymbols(const CSymbolManagerPtrArray& arraySymbolMngrs,
												UINT uValue,
												CResourceSymbolList& rlistSymbols) const
{
	for (int n = 0; n < arraySymbolMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = arraySymbolMngrs[n];
		ASSERT(NULL != pMngr);

		if (NULL != pMngr)
		{
			CResourceSymbolList listLocalSymbols;
			pMngr->GetSymbols(uValue, listLocalSymbols);

			if (listLocalSymbols.GetCount() > 0)
			{
				rlistSymbols.AddTail(&listLocalSymbols);
			}
		}
	}
	return rlistSymbols.GetCount();
}


int CResourceSymbolManagerMultiFile::GetSymbols(const CSymbolManagerPtrArray& arraySymbolMngrs,
												const CString& sName,
												CResourceSymbolList& rlistSymbols) const
{
	for (int n = 0; n < arraySymbolMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = arraySymbolMngrs[n];
		ASSERT(NULL != pMngr);

		if (NULL != pMngr)
		{
			CResourceSymbolList listLocalSymbols;
			pMngr->GetSymbols(sName, listLocalSymbols);

			if (listLocalSymbols.GetCount() > 0)
			{
				rlistSymbols.AddTail(&listLocalSymbols);
			}
		}
	}
	return rlistSymbols.GetCount();
}


//////////////////////////////////////////////////////////////////////
// Implementation

int CResourceSymbolManagerMultiFile::GetSymbolFileIndex(const CString& sPathName) const
{
	ASSERT(!sPathName.IsEmpty() );

	int nMngr = -1;

	for (int n = 0; n < m_arrayMngrs.GetSize(); n++)
	{
		CResourceSymbolManager* pMngr = m_arrayMngrs[n];

		if ( (NULL != pMngr) && (sPathName == pMngr->GetPathName() ) )
		{
			nMngr = n;

			break;
		}
	}
	return nMngr;
}