resourcesymbolmanager.cpp

ResOrg 图形化管理Vc项目的资源ID的工具的源代码。 ResOrg - Manage and Renumber Resource Symbol IDs Introduction The

	if (bSortByName)
	{
		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() &&
			(bIgnoreFixedStatus || !Options.IsFixedSymbol(pSymbol->GetName() ) ) )
		{
			m_mapValues.Remove(pSymbol);
		}
	}

	// Now renumber them
	pos = plistSymbols->GetHeadPosition();
	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = plistSymbols->GetNext(pos);
		if ( (NULL != pSymbol) && !pSymbol->IsReadOnly() &&
			(bIgnoreFixedStatus || !Options.IsFixedSymbol(pSymbol->GetName() ) ) )
		{
			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 CResourceSymbolManager::Renumber(	UINT uBaseResource,
										UINT uBaseCommand,
										UINT uBaseControl,
										bool bIgnoreFixedStatus /*= false*/,
										bool bSortByName /*= true*/)
{
	return Renumber(&m_listSymbols,
					uBaseResource,
					uBaseCommand,
					uBaseControl,
					bIgnoreFixedStatus,
					bSortByName);
}


bool CResourceSymbolManager::UpdateNextSymbolValues(void)
{
	bool bResult = false;

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

	CalculateNextSymbolValues(	uNextResourceValue,
								uNextControlValue,
								uNextCommandValue,
								uNextSymedValue);

	bResult = SetNextResourceValue(uNextResourceValue);

	if (!SetNextCommandValue(uNextCommandValue) )
	{
		bResult = false;
	}
	if (!SetNextControlValue(uNextControlValue) )
	{
		bResult = false;
	}
	if (!SetNextSymedValue(uNextSymedValue))
	{
		bResult = false;
	}

	return bResult;
}


bool CResourceSymbolManager::AreNextSymbolValuesInUse(void) const
{
	bool bResult = false;

	bool bNextResourceIDUsed	= IsInUse(m_uNextResourceValue);
	bool bNextControlIDUsed		= IsInUse(m_uNextControlValue);
	bool bNextCommandIDUsed		= IsInUse(m_uNextCommandValue);
	bool bNextSymedIDUsed		= IsInUse(m_uNextSymedValue);

	bResult = bNextResourceIDUsed ||
				bNextControlIDUsed ||
				bNextCommandIDUsed ||
				bNextSymedIDUsed;

	return bResult;
}


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

	if (AreNextSymbolValuesInUse() )
	{
		UINT uNextResourceValue = 0;
		UINT uNextControlValue = 0;
		UINT uNextCommandValue = 0;
		UINT uNextSymedValue = 0;

		CalculateNextSymbolValues(	uNextResourceValue,
									uNextControlValue,
									uNextCommandValue,
									uNextSymedValue);

		if ( IsInUse(m_uNextResourceValue) )
		{
			bResult = SetNextResourceValue(uNextResourceValue);
		}
		if ( IsInUse(m_uNextControlValue) )
		{
			bResult = SetNextControlValue(uNextControlValue);
		}
		if ( IsInUse(m_uNextCommandValue) )
		{
			bResult = SetNextCommandValue(uNextCommandValue);
		}
		if ( IsInUse(m_uNextSymedValue) )
		{
			bResult = SetNextSymedValue(uNextSymedValue);
		}
		ASSERT( !AreNextSymbolValuesInUse() );

	}
	return bResult;
}


bool CResourceSymbolManager::CalculateNextSymbolValues(	UINT& ruNextResourceValue,
														UINT& ruNextControlValue,
														UINT& ruNextCommandValue,
														UINT& ruNextSymedValue)
{
	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 we didn't calculate a new value for any of the constants,
	// just make sure there are no conflicts
	if (0 == uNextResourceValue)
	{
		uNextResourceValue = GetNextFreeValue(ruNextResourceValue);
	}
	if (0 == uNextControlValue)
	{
		uNextControlValue = GetNextFreeValue(ruNextControlValue);
	}
	if (0 == uNextCommandValue)
	{
		uNextCommandValue = GetNextFreeValue(ruNextCommandValue);
	}

	UINT uNextSymedValue = GetNextFreeValue(max(	uNextResourceValue + 100,
													uNextControlValue + 100) );	// Fairly arbitrary, but it should be OK

	// Finally - see what's changed
	if (ruNextResourceValue != uNextResourceValue)
	{
		ruNextResourceValue = uNextResourceValue;
		bResult = true;
	}

	if (ruNextControlValue != uNextControlValue)
	{
		ruNextControlValue = uNextControlValue;
		bResult = true;
	}

	if (ruNextCommandValue != uNextCommandValue)
	{
		ruNextCommandValue = uNextCommandValue;
		bResult = true;
	}

	if ( (uNextSymedValue > 0) && (ruNextSymedValue != uNextSymedValue) )
	{
		ruNextSymedValue = uNextSymedValue;
		bResult = true;
	}


	return bResult;
}


UINT CResourceSymbolManager::GetBaseSymbolValue(int eSymbolType) const
{
	UINT uBaseValue = 0;
	switch (eSymbolType)
	{
		case SYM_RESOURCE:
		default:
			uBaseValue = GetBaseResourceValue();
			break;

		case SYM_CONTROL:
			uBaseValue = GetBaseControlValue();
			break;

		case SYM_COMMAND:
			uBaseValue = GetBaseCommandValue();
			break;

	}
	ASSERT(uBaseValue > 0);

	return uBaseValue;
}


bool CResourceSymbolManager::SetBaseResourceValue(UINT uValue)
{
	if ( (m_uBaseResourceValue != uValue) && (uValue >= SYM_RESOURCE_VALUE_MIN) && (uValue <= SYM_RESOURCE_VALUE_MAX) )
	{
		m_uBaseResourceValue = uValue;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetBaseControlValue(UINT uValue)
{
	if ( (m_uBaseControlValue != uValue) && (uValue >= SYM_CONTROL_VALUE_MIN) && (uValue <= SYM_CONTROL_VALUE_MAX) )
	{
		m_uBaseControlValue = uValue;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetBaseCommandValue(UINT uValue)
{
	if ( (m_uBaseCommandValue != uValue) && (uValue >= SYM_COMMAND_VALUE_MIN) && (uValue <= SYM_COMMAND_VALUE_MAX) )
	{
		m_uBaseCommandValue = uValue;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::Set3dControlsValue(bool b3dControls)
{
	if (m_b3dControls != b3dControls)
	{
		m_b3dControls	= b3dControls;

		m_bModified		= true;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetNextResourceValue(UINT uValue)
{
	if ( (uValue > 0) && (uValue != IDC_STATIC) && (uValue != m_uNextResourceValue) )
	{
		m_uNextResourceValue = uValue;

		m_bModified			= true;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetNextCommandValue(UINT uValue)
{
	if ( (uValue > 0) && (uValue != IDC_STATIC) && (uValue != m_uNextCommandValue) )
	{
		m_uNextCommandValue = uValue;

		m_bModified			= true;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetNextControlValue(UINT uValue)
{
	if ( (uValue > 0) && (uValue != IDC_STATIC) && (uValue != m_uNextControlValue) )
	{
		m_uNextControlValue = uValue;

		m_bModified			= true;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::SetNextSymedValue(UINT uValue)
{
	if ( (uValue > 0) && (uValue != IDC_STATIC) && (uValue != m_uNextSymedValue) )
	{
		m_uNextSymedValue	= uValue;

		m_bModified			= true;

		return true;
	}
	return false;
}


bool CResourceSymbolManager::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 CResourceSymbolManager::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 CResourceSymbolManager::GetNextFreeValue(UINT uValue) const
{
	while (IsInUse(uValue) )
	{
		if ( ((unsigned short)IDC_STATIC) == uValue)
		{
			ASSERT(false);
			break;
		}
		uValue++;
	}
	return uValue;
}


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


void CResourceSymbolManager::CountConflicts(void)
{
	m_nConflicts			= 0;
	m_nOutOfRangeSymbols	= 0;
	m_nProblemSymbols		= 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++;
				m_nProblemSymbols++;

				if (IsOutOfRange(pSymbol) )
				{
					m_nOutOfRangeSymbols++;
				}
			}
			else if (IsOutOfRange(pSymbol) )
			{
				m_nOutOfRangeSymbols++;
				m_nProblemSymbols++;
			}
		}
	}
}


int CResourceSymbolManager::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 CResourceSymbolManager::GetOutOfRangeSymbols(CResourceSymbolList& rlistSymbols) const
{
	rlistSymbols.RemoveAll();

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

		if (NULL != pSymbol)
		{
			if (IsOutOfRange(pSymbol) )
			{
				rlistSymbols.AddTail(pSymbol);
			}
		}
	}
	return rlistSymbols.GetCount();
}


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

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

	return rlistConflicts.GetCount();
}