resourcesymbolbuffer.cpp

一个vc中管理资源文件ID的插件

		plistSymbols->SortByName();
	}
	else
	{
		plistSymbols->SortByValue();
	}

	// First, remove all values from the values map
	// so that we can reuse their previous values...
	POSITION pos = plistSymbols->GetHeadPosition();
	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = plistSymbols->GetNext(pos);
		if ( (NULL != pSymbol) && !pSymbol->IsReadOnly())
		{
			m_mapValues.Remove(pSymbol);
		}
	}

	// Now renumber them
	pos = plistSymbols->GetHeadPosition();
	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = plistSymbols->GetNext(pos);
		if ( (NULL != pSymbol) && !pSymbol->IsReadOnly())
		{
			switch (pSymbol->GetType())
			{
				case SYM_RESOURCE:
				case SYM_DIALOG:
				case SYM_MENU:
				case SYM_STRING:
				case SYM_PROMPT:
				case SYM_BITMAP:
				case SYM_ICON:
					uNextResourceValue = GetNextFreeValue(uNextResourceValue);
					if (uNextResourceValue != pSymbol->GetValue() )
					{
						Set(pSymbol,
							pSymbol->GetName(),
							uNextResourceValue++);

						bResult = TRUE;
					}
					else
					{
						m_mapValues.Add(pSymbol);
					}
					break;

				case SYM_COMMAND:
					uNextCommandValue = GetNextFreeValue(uNextCommandValue);
					if (uNextCommandValue != pSymbol->GetValue() )
					{
						Set(pSymbol,
							pSymbol->GetName(),
							uNextCommandValue++);

						bResult = TRUE;
					}
					else
					{
						m_mapValues.Add(pSymbol);
					}
					break;

				case SYM_CONTROL:
					uNextControlValue = GetNextFreeValue(uNextControlValue);
					if (uNextControlValue != pSymbol->GetValue() )
					{
						Set(pSymbol,
							pSymbol->GetName(),
							uNextControlValue++);

						bResult = TRUE;
					}
					else
					{
						m_mapValues.Add(pSymbol);
					}
					break;

				default:
					ASSERT(FALSE);
					break;
			}
		}
	}
	if (bResult)
	{
		UpdateNextSymbolValues();
	}
	return bResult;
}


// Renumber all symbols
BOOL CResourceSymbolBuffer::Renumber(	UINT uBaseResource,
										UINT uBaseCommand,
										UINT uBaseControl,
										BOOL bSortByName /*= TRUE*/)
{

	return Renumber(&m_listSymbols,
					uBaseResource,
					uBaseCommand,
					uBaseControl,
					bSortByName);
}


BOOL CResourceSymbolBuffer::UpdateNextSymbolValues(void)
{
	BOOL bResult = FALSE;

	POSITION pos = GetFirstSymbolPosition();

	UINT uNextResourceValue	= 0;
	UINT uNextCommandValue	= 0;
	UINT uNextControlValue	= 0;

	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = GetNextSymbol(pos);
		if (NULL != pSymbol)
		{
			switch (pSymbol->GetType())
			{
				case SYM_RESOURCE:
				case SYM_DIALOG:
				case SYM_MENU:
				case SYM_STRING:
				case SYM_PROMPT:
				case SYM_BITMAP:
				case SYM_ICON:
					if (pSymbol->GetValue() > uNextResourceValue)
					{
						uNextResourceValue = GetNextFreeValue(pSymbol->GetValue());
					}
					break;

				case SYM_COMMAND:
					if (pSymbol->GetValue() > uNextCommandValue)
					{
						uNextCommandValue = GetNextFreeValue(pSymbol->GetValue());
					}
					break;

				case SYM_CONTROL:
					if (pSymbol->GetValue() > uNextControlValue)
					{
						uNextControlValue = GetNextFreeValue(pSymbol->GetValue());
					}
					break;

				default:
					break;
			}
		}
	}
	if (uNextCommandValue != m_uNextCommandValue)
	{
		m_uNextCommandValue = uNextCommandValue;
		bResult = TRUE;
	}
	if (uNextControlValue != m_uNextControlValue)
	{
		m_uNextControlValue = uNextControlValue;
		bResult = TRUE;
	}
	if (uNextResourceValue != m_uNextResourceValue)
	{
		m_uNextResourceValue = uNextResourceValue;

		bResult = TRUE;
	}
	m_uNextSymedValue = max(m_uNextResourceValue + 100,
							m_uNextControlValue + 100);	// Fairly arbitrary, but it should be OK

	return bResult;
}


BOOL CResourceSymbolBuffer::SetModifiedFlag(BOOL bModified)
{
	m_bModified = bModified;

	if (!m_bModified)
	{
		POSITION pos = GetFirstSymbolPosition();

		while (pos != NULL)
		{
			CResourceSymbol* pSymbol = GetNextSymbol(pos);
			if (NULL != pSymbol)
			{
				pSymbol->SetModifiedFlag(FALSE);
			}
		}
	}
	return TRUE;
}


CString CResourceSymbolBuffer::GetUnusedName(int eType) const
{
	CString sName;

	CString sBaseName = SymbolTypes.GetTypePrefix(eType) +
						_T("NEW_SYMBOL");

	int n = 1;
	do
	{
		if (n <= 1)
		{
			sName = sBaseName;
		}
		else
		{
			sName.Format(sBaseName + _T("%d"), n);
		}
		n++;
	} while ( IsInUse(sName) );

	return sName;
}


UINT CResourceSymbolBuffer::GetNextFreeValue(UINT uValue) const
{
	while (IsInUse(uValue) )
	{
		if (IDC_STATIC == uValue)
		{
			ASSERT(FALSE);
			break;
		}
		uValue++;
	}
	return uValue;
}


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

void CResourceSymbolBuffer::CountConflicts(void)
{
	m_nConflicts = 0;

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

		if (NULL != pSymbol)
		{
			if (!IsUnique( pSymbol->GetName() ) || !IsUnique( pSymbol->GetValue() ) )
			{
				m_nConflicts++;
			}
		}
	}
}


int CResourceSymbolBuffer::GetConflicts(CResourceSymbolList& rlistConflicts) const
{
	rlistConflicts.RemoveAll();

	POSITION pos = GetFirstSymbolPosition();
	while (NULL != pos)
	{
		CResourceSymbol* pSymbol = GetNextSymbol(pos);

		if (NULL != pSymbol)
		{
			if (!IsUnique( pSymbol->GetValue() ) )
			{
				rlistConflicts.AddTail(pSymbol);
			}
		}
	}
	return rlistConflicts.GetCount();
}



int CResourceSymbolBuffer::GetConflicts(CResourceSymbol* pSymbol,
										CResourceSymbolList& rlistConflicts) const
{
	rlistConflicts.RemoveAll();

	rlistConflicts.AddTail( (CResourceSymbolList*)&pSymbol->GetConflicts() );

	return rlistConflicts.GetCount();
}


/////////////////////////////////////////////////////////////////////////////
// File Read Implementation


/******************************************************************************
 *	Read from an archive
 *
 ******************************************************************************/

BOOL CResourceSymbolBuffer::Read(CArchive& ar)
{
	return CResourceSymbolBuffer_BASE::Read(ar);
}


/******************************************************************************
 *	Parse the given line
 *
 ******************************************************************************/

BOOL CResourceSymbolBuffer::Parse(const CString& rsLine)
{
	if (!rsLine.IsEmpty())
	{
		CString sLine = rsLine;
		CString sToken = GetToken(sLine);
		if (IsComment(sToken))
		{
			CString sUsedBy = ::After(sLine, _T("Used by") );
			sUsedBy.TrimLeft();
			sUsedBy.TrimRight();

			if (!sUsedBy.IsEmpty())
			{
				m_sResourceFileName = sUsedBy;
			}
		}
		else
		{
			if (IsDefine(sToken))
			{
				CString sSymbolName		= GetToken(sLine);
				CString sSymbolValue	= GetToken(sLine);
				UINT uSymbolValue		= 0;
				BOOL bReadOnly			= FALSE;

				// Hex symbols are assumed to be read only...
				if (sSymbolValue.FindOneOf( _T("Xx") ) >= 0)
				{
					uSymbolValue =_tcstoul(	sSymbolValue,
											NULL,
											16);
					bReadOnly = TRUE;
				}
				else
				{
					uSymbolValue		= _ttoi(sSymbolValue);
				}

				TRACE2("  Symbol: %s, Value: %d\n", sSymbolName, uSymbolValue);

				// Create a CResourceSymbol object to hold the symbol data
				if ( (!sSymbolName.IsEmpty()) && (uSymbolValue > 0) )
				{
					CResourceSymbol* pSymbol =	Add(sSymbolName,
													uSymbolValue,
													0/*m_nLineNo*/,
													FALSE);

					if ( (NULL != pSymbol) && bReadOnly)
					{
						pSymbol->SetReadOnly();
					}
				}

				// Cross reference the symbols by symbol name and ID
				// For a given resource file, a symbol name can only occur once
				// if the file was generated by the IDE. However, an ID value can
				// occur multiple times.
				//
				// For safety, we use a list of symbol objects, sorted by ID, together
				// with a map identifying the number of times each ID value is used.
			}
		}
	}
	return FALSE;
}


BOOL CResourceSymbolBuffer::IsComment(const CString& sToken) const
{
	if (sToken.Left(2) == _T("//"))
	{
		return TRUE;
	}
	return FALSE;
}


BOOL CResourceSymbolBuffer::IsDefine(const CString& sToken) const
{
	if (sToken.Find( _T("#define") ) == 0)
	{
		return TRUE;
	}
	return FALSE;
}


BOOL CResourceSymbolBuffer::IsInteger(const CString& sToken) const
{
	CString s = sToken.SpanExcluding( _T("0123456789") );

	return s.IsEmpty();
}


CString CResourceSymbolBuffer::GetToken(CString& rsLine)
{
	rsLine.TrimLeft(WHITE_SPACE);

	CString sToken;
	int nPos = rsLine.FindOneOf(WHITE_SPACE);
	if (nPos > 0)
	{
		sToken = rsLine.Left(nPos);
		rsLine = rsLine.Mid(nPos);
	}
	else
	{
		sToken = rsLine;
		rsLine = _T("");
	}
	sToken.TrimLeft(WHITE_SPACE);
	sToken.TrimRight(WHITE_SPACE);

	return sToken;
}


/////////////////////////////////////////////////////////////////////////////
// File Write Implementation

/******************************************************************************
 *	Write the buffer to an archive
 *
 ******************************************************************************/

BOOL CResourceSymbolBuffer::Write(CArchive& ar)
{
	// Build a buffer from our data
	Build();

	return CResourceSymbolBuffer_BASE::Write(ar);
}


void CResourceSymbolBuffer::Add(CString sText)
{
	sText.TrimLeft(_T(": ") );
	sText.TrimRight(_T(":; ") );

	m_arrayLines.Add(sText);
}


void CResourceSymbolBuffer::AddComment(const CString& sComment)
{
	m_arrayLines.Add( _T("//") + sComment);
}


void CResourceSymbolBuffer::AddNewline(void)
{
	m_arrayLines.Add( _T("") );
}


BOOL CResourceSymbolBuffer::Build(void)
{
	SortByValue();

	m_arrayLines.RemoveAll();

	AddComment( _T("{{NO_DEPENDENCIES}}") );
	AddComment( _T(" Microsoft Developer Studio generated include file.") );
	AddComment( _T(" Used by ") + m_sResourceFileName );
	AddComment( _T("") );

	AddSymbols();
	AddNewline();

	AddComment( _T(" Next default values for new objects") );
	AddComment( _T("") );
	Add( _T("#ifdef APSTUDIO_INVOKED") );
	Add( _T("#ifndef APSTUDIO_READONLY_SYMBOLS") );

	Add( FormatSymbolDefine(_T("_APS_3D_CONTROLS"),			m_b3dControls) );
	Add( FormatSymbolDefine(_T("_APS_NEXT_RESOURCE_VALUE"), m_uNextResourceValue) );
	Add( FormatSymbolDefine(_T("_APS_NEXT_CONTROL_VALUE"),	m_uNextControlValue) );
	Add( FormatSymbolDefine(_T("_APS_NEXT_SYMED_VALUE"),	m_uNextSymedValue) );
	Add( FormatSymbolDefine(_T("_APS_NEXT_COMMAND_VALUE"),	m_uNextCommandValue) );

	Add( _T("#endif") );
	Add( _T("#endif") );

	return TRUE;
}


BOOL CResourceSymbolBuffer::AddSymbols(void)
{
	POSITION pos = m_listSymbols.GetHeadPosition();
	while (NULL != pos)
	{
		CResourceSymbol* pSymbol = m_listSymbols.GetNext(pos);
		if (NULL != pSymbol)
		{
			if (pSymbol->IsReadOnly())
			{
				Add( FormatHexSymbolDefine(	pSymbol->GetName(),
											pSymbol->GetValue()) );
			}
			else
			{
				Add( FormatSymbolDefine(	pSymbol->GetName(),
											pSymbol->GetValue()) );
			}
		}
	}
	return TRUE;
}


CString CResourceSymbolBuffer::FormatHexSymbolDefine(	const CString& sName,
														UINT uValue)
{
	CString sDefine;
	sDefine.Format( _T("#define %-31s0x%X"),
					sName + _T(" "),
					uValue);

	return sDefine;
}


CString CResourceSymbolBuffer::FormatSymbolDefine(	const CString& sName,
													UINT uValue)
{
	CString sDefine;
	sDefine.Format( _T("#define %-31s%u"),
					sName + _T(" "),
					uValue);

	return sDefine;
}