resourcesymbolmanager.cpp

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

	return false;
}


CString CResourceSymbolManager::GetDisplayedStatus(CResourceSymbol* pSymbol) const
{
	CString sStatus;

	if (!IsUnique( pSymbol->GetName() ) )
	{
		sStatus.LoadString(IDS_SYM_NAME_CONFLICT);
	}
	else if (!IsUnique( pSymbol->GetValue() ) )
	{
		CString sConflictList;

		CResourceSymbolList listSymbols;
		GetConflicts(pSymbol, listSymbols);

		POSITION pos = listSymbols.GetHeadPosition();
		while (pos != NULL)
		{
			CResourceSymbol* pConflictSymbol = listSymbols.GetNext(pos);
			if ( (NULL != pConflictSymbol) && (pConflictSymbol != pSymbol) )
			{
				sConflictList += pConflictSymbol->GetName() + _T(", ");
			}
		}
		sConflictList.TrimRight( _T(", ") );

		sStatus.Format(IDS_SYM_CONFLICTS, sConflictList);
	}
	else if (IsOutOfRange(pSymbol) )
	{
		sStatus.LoadString(IDS_SYM_OUT_OF_RANGE);
	}
	else if (pSymbol->IsModified())
	{
		sStatus.LoadString(IDS_SYM_MODIFIED);
	}
	else if (pSymbol->IsReadOnly())
	{
		sStatus.LoadString(IDS_SYM_READONLY);
	}
	else
	{
		sStatus.LoadString(IDS_SYM_OK);
	}
	return sStatus;
}


bool CResourceSymbolManager::CheckForOutOfRangeSymbols(bool bCheck)
{
	if (m_bCheckForOutOfRangeSymbols != bCheck)
	{
		m_bCheckForOutOfRangeSymbols = bCheck;

		CountConflicts();

		return true;
	}
	return false;
}


bool CResourceSymbolManager::IsOutOfRange(CResourceSymbol* pSymbol) const
{
	ASSERT(NULL != pSymbol);
	if (NULL != pSymbol)
	{
		return IsOutOfRange(pSymbol->GetType(), pSymbol->GetValue() );
	}
	return false;
}


bool CResourceSymbolManager::IsOutOfRange(int eSymbolType, UINT uValue) const
{
	if (!m_bCheckForOutOfRangeSymbols)
	{
		return false;
	}

	bool bValueOutOfRange = false;

	int nRange = GetSymbolCount();
	if (GetSymbolCount() < 100)
	{
		nRange = 100;
	}

	UINT uMaxResourceValue = GetBaseResourceValue() + nRange;
	UINT uMaxControlValue = GetBaseControlValue() + nRange;
	UINT uMaxCommandValue = GetBaseCommandValue() + nRange;

	switch (eSymbolType)
	{
		case SYM_RESOURCE:
		case SYM_BITMAP:
		case SYM_DIALOG:
		case SYM_MENU:
		case SYM_ICON:
		case SYM_TOOLBAR:
		case SYM_ACCELERATOR:
		case SYM_PROMPT:
		case SYM_STRING:
			bValueOutOfRange = ( (uValue < GetBaseResourceValue() ) || (uValue >= uMaxResourceValue) );
			break;

		case SYM_CONTROL:
			bValueOutOfRange = ( (uValue < GetBaseControlValue() ) || (uValue >= uMaxControlValue) );
			break;

		case SYM_COMMAND:
			bValueOutOfRange = ( (uValue < GetBaseCommandValue() ) || (uValue >= uMaxCommandValue) );
			break;

		default:
			ASSERT(FALSE);
			break;
	}
	return bValueOutOfRange;
}


UINT CResourceSymbolManager::GetBaseValue(int eSymbolType) const
{
	UINT uBaseValue = 0;
	switch (eSymbolType)
	{
		case SYM_RESOURCE:
		case SYM_BITMAP:
		case SYM_DIALOG:
		case SYM_MENU:
		case SYM_ICON:
		case SYM_TOOLBAR:
		case SYM_ACCELERATOR:
		case SYM_PROMPT:
		case SYM_STRING:
			uBaseValue = GetBaseResourceValue();
			break;

		case SYM_CONTROL:
			uBaseValue = GetBaseControlValue();
			break;

		case SYM_COMMAND:
			uBaseValue = GetBaseCommandValue();
			break;

		default:
			uBaseValue = GetBaseResourceValue();
			ASSERT(FALSE);
			break;
	}

	return uBaseValue;
}


bool CResourceSymbolManager::IsUnique(const CString& sName) const
{
	int nCount = m_mapNames.GetCount(sName);

	return (nCount <= 1);
}


bool CResourceSymbolManager::IsUnique(UINT uValue) const
{
	int nCount = m_mapValues.GetCount(uValue);

	return (nCount <= 1);
}


bool CResourceSymbolManager::IsInUse(const CString& sName) const
{
	int nCount = m_mapNames.GetCount(sName);

	return (nCount > 0);
}


bool CResourceSymbolManager::IsInUse(UINT uValue) const
{
	int nCount = m_mapValues.GetCount(uValue);

	return (nCount > 0);
}


int CResourceSymbolManager::GetSymbols(CResourceSymbolList& rlistSymbols) const
{
	rlistSymbols.RemoveAll();

	rlistSymbols.AddTail( (CResourceSymbolList*)&m_listSymbols);

	return rlistSymbols.GetCount();
}


int CResourceSymbolManager::GetSymbols(UINT uValue, CResourceSymbolList& rlistSymbols) const
{
	rlistSymbols.RemoveAll();

	m_mapValues.GetSymbols(uValue, rlistSymbols);

	return rlistSymbols.GetCount();
}


int CResourceSymbolManager::GetSymbols(const CString& sName, CResourceSymbolList& rlistSymbols) const
{
	rlistSymbols.RemoveAll();

	m_mapNames.GetSymbols(sName, rlistSymbols);

	return rlistSymbols.GetCount();
}



bool CResourceSymbolManager::Set(CResourceSymbol* pSymbol,
								 const CString& sName,
								 UINT uValue,
								 bool bReadOnly /*= false*/)
{
	if (uValue != pSymbol->GetValue() )
	{
		CSymbolConflictList& listSymbols = pSymbol->GetConflicts();

		CResourceSymbolList listSymbols2;
		POSITION pos = listSymbols.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pConflict = listSymbols.GetNext(pos);
			if (pSymbol->GetValue() == pConflict->GetValue() )
			{
				pConflict->RemoveConflict(pSymbol);
				listSymbols2.AddTail(pConflict);
			}
		}
		
		pos = listSymbols2.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pConflict = listSymbols2.GetNext(pos);
			pSymbol->RemoveConflict(pConflict);
		}
		m_mapValues.Remove(pSymbol);

		if (pSymbol->SetValue(uValue))
		{
			m_mapValues.Add(pSymbol);
		}
		m_bModified = true;
	}
	if (sName != pSymbol->GetName())
	{
		CSymbolConflictList& listSymbols = pSymbol->GetConflicts();

		CResourceSymbolList listSymbols2;
		POSITION pos = listSymbols.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pConflict = listSymbols.GetNext(pos);
			if (pSymbol->GetName() == pConflict->GetName() )
			{
				pConflict->RemoveConflict(pSymbol);
				listSymbols2.AddTail(pConflict);
			}
		}
		
		pos = listSymbols2.GetHeadPosition();
		while (NULL != pos)
		{
			CResourceSymbol* pConflict = listSymbols2.GetNext(pos);
			pSymbol->RemoveConflict(pConflict);
		}
		m_mapNames.Remove(pSymbol);

		if (pSymbol->SetName(sName))
		{
			m_mapNames.Add(pSymbol);
		}
		m_bModified = true;
	}
	if (bReadOnly != pSymbol->IsReadOnly())
	{
		pSymbol->SetReadOnly(bReadOnly);
		m_bModified = true;
	}
	CountConflicts();

	return m_bModified;
}


CResourceSymbol* CResourceSymbolManager::Add(	const CString& sSymbolName,
												UINT uSymbolValue,
												int nLineNo,
												bool bUpdateMetrics /*= true*/)
{
	if (sSymbolName == _T("_APS_3D_CONTROLS") )
	{
		Set3dControlsValue( (uSymbolValue > 0) );
	}
	else if (sSymbolName == _T("_APS_NEXT_RESOURCE_VALUE") )
	{
		SetNextResourceValue(uSymbolValue);
	}
	else if (sSymbolName == _T("_APS_NEXT_CONTROL_VALUE") )
	{
		SetNextControlValue(uSymbolValue);
	}
	else if (sSymbolName == _T("_APS_NEXT_SYMED_VALUE") )
	{
		SetNextSymedValue(uSymbolValue);
	}
	else if (sSymbolName == _T("_APS_NEXT_COMMAND_VALUE") )
	{
		SetNextCommandValue(uSymbolValue);
	}
	else
	{
		CResourceSymbol* pSymbol = new CResourceSymbol;

		pSymbol->SetUserData( (INT_PTR)this );
		pSymbol->SetName(sSymbolName);
		pSymbol->SetValue(uSymbolValue);
		pSymbol->SetFileName(m_sPathName);
		pSymbol->SetLineNo(nLineNo);
		pSymbol->SetModifiedFlag(false);

		if (Add(pSymbol, bUpdateMetrics) )
		{
			return pSymbol;
		}
		delete pSymbol;
	}
	return NULL;
}


bool CResourceSymbolManager::Add(CResourceSymbol* pSymbol,
								 bool bUpdateMetrics /*= true*/)
{
	m_listSymbols.AddTail(pSymbol);

	m_mapNames.Add(pSymbol);
	m_mapValues.Add(pSymbol);

	if (bUpdateMetrics)
	{
		SortByValue();

		CountConflicts();
	}
	return true;
}


bool CResourceSymbolManager::Remove(CResourceSymbol* pSymbol,
								    bool bUpdateMetrics /*= true */)
{
	POSITION pos = m_listSymbols.Find(pSymbol);
	if (pos != NULL)
	{
		m_listSymbols.RemoveAt(pos);

		m_mapNames.Remove(pSymbol);
		m_mapValues.Remove(pSymbol);

		if (bUpdateMetrics)
		{
			CountConflicts();

			m_bModified = true;
		}
		return true;
	}
	return false;
}


void CResourceSymbolManager::RemoveAll(void)
{
	POSITION pos = m_listSymbols.GetHeadPosition();
	while (pos != NULL)
	{
		CResourceSymbol* pSymbol = m_listSymbols.GetNext(pos);
		if (pSymbol != NULL)
		{
			delete pSymbol;
		}
	}
	m_listSymbols.RemoveAll();
	m_mapNames.RemoveAll();
	m_mapValues.RemoveAll();

	m_nConflicts			= 0;
	m_nOutOfRangeSymbols	= 0;
	m_nProblemSymbols		= 0;

	m_bModified = true;
}


int CResourceSymbolManager::GetSymbolCount(CResourceSymbolCounts& rInfo) const
{
	UINT uMinResource	= 0;
	UINT uMaxResource	= 0;
	UINT uMinCommand	= 0;
	UINT uMaxCommand	= 0;

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

		UINT uValue = pSymbol->GetValue();

		// First check the min/max values
		switch (pSymbol->GetType())
		{
			case SYM_COMMAND:
				uMinCommand = ( (uValue < uMinCommand) || (0 == uMinCommand) ) ? uValue : uMinCommand;
				uMaxCommand = (uValue > uMaxCommand) ? uValue : uMaxCommand;
				break;

			default:
				uMinResource = ( (uValue < uMinResource) || (0 == uMinResource) ) ? uValue : uMinResource;
				uMaxResource = (uValue > uMaxResource) ? uValue : uMaxResource;
				break;

		}
		// Now update the counts
		switch (pSymbol->GetType())
		{
			case SYM_RESOURCE:
			default:
				rInfo.m_nOtherResources++;
				rInfo.m_nResources++;
				break;

			case SYM_ACCELERATOR:
				rInfo.m_nAccelerators++;
				rInfo.m_nResources++;
				break;

			case SYM_BITMAP:
				rInfo.m_nBitmaps++;
				rInfo.m_nResources++;
				break;

			case SYM_DIALOG:
				rInfo.m_nDialogs++;
				rInfo.m_nResources++;
				break;

			case SYM_MENU:
				rInfo.m_nMenus++;
				rInfo.m_nResources++;
				break;

			case SYM_ICON:
				rInfo.m_nIcons++;
				rInfo.m_nResources++;
				break;

			case SYM_PROMPT:
				rInfo.m_nPrompts++;
				rInfo.m_nResources++;
				break;

			case SYM_STRING:
				rInfo.m_nStrings++;
				rInfo.m_nResources++;
				break;

			case SYM_TOOLBAR:
				rInfo.m_nToolbars++;
				rInfo.m_nResources++;
				break;

			case SYM_CONTROL:
				rInfo.m_nControls++;
				break;

			case SYM_COMMAND:
				rInfo.m_nCommands++;
				break;
		}
	}

	rInfo.m_uMinResource	= uMinResource;
	rInfo.m_uMaxResource	= uMaxResource;
	rInfo.m_uMinCommand		= uMinCommand;
	rInfo.m_uMaxCommand		= uMaxCommand;

	return rInfo.m_nResources +	rInfo.m_nControls + rInfo.m_nCommands;
}


bool CResourceSymbolManager::CalculateBaseValues(UINT& ruBaseResource,
												 UINT& ruBaseCommand,
												 UINT& ruBaseControl) const
{
	int nLowSum = 0;
	int nHighSum = 0;
	int nLowSymCount = 0;
	int nHighSymCount = 0;

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

		UINT uValue = pSymbol->GetValue();
		if (uValue >= 32767)	// high range
		{
			nHighSum += uValue;
			nHighSymCount++;
		}
		else
		{
			nLowSum += uValue;
			nLowSymCount++;
		}
	}
	if (nLowSum > 0)
	{
		int nLowAvg = (nLowSum / nLowSymCount);

		ruBaseResource	= ::GetBaseRangeFromValue(nLowAvg);
	}
	if (nHighSum > 0)
	{
		int nHighAvg = (nHighSum / nHighSymCount);

		ruBaseCommand	= ::GetBaseRangeFromValue(nHighAvg);
	}
	bool bResult = ((nLowSum > 0) && (nHighSum > 0));

	// Validate against defined ranges, just to be sure....
	// This is friggy code, but it'll do for now
	if (ruBaseResource < SYM_RESOURCE_VALUE_MIN)
	{
		ruBaseResource = SYM_RESOURCE_VALUE_MIN;
	}
	else if (ruBaseResource > SYM_RESOURCE_VALUE_MAX)
	{
		ruBaseResource	= ::GetBaseRangeFromValue(SYM_RESOURCE_VALUE_MAX);
	}

	if (ruBaseCommand < SYM_COMMAND_VALUE_MIN)
	{
		ruBaseCommand	= SYM_COMMAND_VALUE_MIN;
	}
	else if (ruBaseCommand > SYM_COMMAND_VALUE_MAX)
	{
		ruBaseCommand	= ::GetBaseRangeFromValue(SYM_COMMAND_VALUE_MAX);
	}

	CResourceSymbolCounts Info;
	GetSymbolCount(Info);

	int nControlOffset	= (int)(100 * ::ceil( (double)Info.m_nResources / 100.0) );

	ruBaseControl	= ruBaseResource + nControlOffset;

	return bResult;
}


bool CResourceSymbolManager::Renumber(	CResourceSymbolList* plistSymbols,
										UINT uBaseResource,
										UINT uBaseCommand,
										UINT uBaseControl,
										bool bIgnoreFixedStatus /*= false*/,
										bool bSortByName /*= true*/)
{
	bool bResult = false;

	SetBaseResourceValue(uBaseResource);
	SetBaseControlValue(uBaseControl);
	SetBaseCommandValue(uBaseCommand);

	UINT uNextResourceValue		= uBaseResource;
	UINT uNextControlValue		= uBaseControl;
	UINT uNextCommandValue		= uBaseCommand;