resorgxmlwriter.cpp

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

		int nExternalConflicts	= 0;

		if (NULL != pParentManager)
		{
			nTotalConflicts		= pParentManager->GetTotalConflictCount(pManager);

			nExternalConflicts	= nTotalConflicts - nInternalConflicts;
		}

		ptrConflicts->text = (LPCTSTR)::IntToStr(nTotalConflicts);
		ptrMetrics->appendChild(ptrConflicts);

		MSXML2::IXMLDOMElementPtr ptrInternalConflicts = ptrDOMDoc->createElement( _T("Internal") );

		ptrInternalConflicts->text = (LPCTSTR)::IntToStr(nInternalConflicts);;
		ptrConflicts->appendChild(ptrInternalConflicts);

		MSXML2::IXMLDOMElementPtr ptrExternalConflicts = ptrDOMDoc->createElement(_T("External"));

		ptrExternalConflicts->text = (LPCTSTR)::IntToStr(nExternalConflicts);
		ptrConflicts->appendChild(ptrExternalConflicts);

		MSXML2::IXMLDOMElementPtr ptrOutOfRangeSymbols = ptrDOMDoc->createElement( _T("OutOfRangeSymbols") );
		ptrOutOfRangeSymbols->text = (LPCTSTR)::IntToStr(nOutOfRangeSymbols);
		ptrMetrics->appendChild(ptrOutOfRangeSymbols);

		CResourceSymbolCounts info;
		pManager->GetSymbolCount(info);

		// Dialogs
		MSXML2::IXMLDOMElementPtr ptrDialogs = ptrDOMDoc->createElement( _T("Dialogs") );
		ptrMetrics->appendChild(ptrDialogs);

		MSXML2::IXMLDOMElementPtr ptrDialogCount = ptrDOMDoc->createElement( _T("Count") );
		ptrDialogCount->text = (LPCTSTR)::IntToStr(info.m_nDialogs);
		ptrDialogs->appendChild(ptrDialogCount);

		// General Resources
		MSXML2::IXMLDOMElementPtr ptrResources = ptrDOMDoc->createElement( _T("Resources") );
		ptrMetrics->appendChild(ptrResources);

		MSXML2::IXMLDOMElementPtr ptrResourceCount = ptrDOMDoc->createElement( _T("Count") );
		ptrResourceCount->text = (LPCTSTR)::IntToStr(info.m_nResources);
		ptrResources->appendChild(ptrResourceCount);

		MSXML2::IXMLDOMElementPtr ptrMinResourceValue = ptrDOMDoc->createElement(_T("MinValue"));
		ptrMinResourceValue->text = (LPCTSTR)::UIntToStr(info.m_uMinResource);
		ptrResources->appendChild(ptrMinResourceValue);
		
		MSXML2::IXMLDOMElementPtr ptrMaxResourceValue = ptrDOMDoc->createElement(_T("MaxValue"));
		ptrMaxResourceValue->text = (LPCTSTR)::UIntToStr(info.m_uMaxResource);
		ptrResources->appendChild(ptrMaxResourceValue);
		
		// Accelerators
		MSXML2::IXMLDOMElementPtr ptrAccelerators = ptrDOMDoc->createElement( _T("Accelerators") );
		ptrMetrics->appendChild(ptrAccelerators);

		MSXML2::IXMLDOMElementPtr ptrAcceleratorCount = ptrDOMDoc->createElement( _T("Count") );
		ptrAccelerators->text = (LPCTSTR)::IntToStr(info.m_nAccelerators);
		ptrAccelerators->appendChild(ptrAcceleratorCount);
		
		// Bitmaps
		MSXML2::IXMLDOMElementPtr ptrBitmaps = ptrDOMDoc->createElement( _T("Bitmaps") );
		ptrMetrics->appendChild(ptrBitmaps);

		MSXML2::IXMLDOMElementPtr ptrBitmapCount = ptrDOMDoc->createElement( _T("Count") );
		ptrBitmapCount->text = (LPCTSTR)::IntToStr(info.m_nBitmaps);
		ptrBitmaps->appendChild(ptrBitmapCount);

		// Icons
		MSXML2::IXMLDOMElementPtr ptrIcons = ptrDOMDoc->createElement( _T("Icons") );
		ptrMetrics->appendChild(ptrIcons);

		MSXML2::IXMLDOMElementPtr ptrIconCount = ptrDOMDoc->createElement( _T("Count") );
		ptrIconCount->text = (LPCTSTR)::IntToStr(info.m_nIcons);
		ptrIcons->appendChild(ptrIconCount);

		// Menus
		MSXML2::IXMLDOMElementPtr ptrMenus = ptrDOMDoc->createElement( _T("Menus") );
		ptrMetrics->appendChild(ptrMenus);

		MSXML2::IXMLDOMElementPtr ptrMenuCount = ptrDOMDoc->createElement( _T("Count") );
		ptrMenuCount->text = (LPCTSTR)::IntToStr(info.m_nMenus);
		ptrMenus->appendChild(ptrMenuCount);

		// Prompt Strings
		MSXML2::IXMLDOMElementPtr ptrPrompts = ptrDOMDoc->createElement( _T("Prompts") );
		ptrMetrics->appendChild(ptrPrompts);

		MSXML2::IXMLDOMElementPtr ptrPromptCount = ptrDOMDoc->createElement( _T("Count") );
		ptrPromptCount->text = (LPCTSTR)::IntToStr(info.m_nPrompts);
		ptrPrompts->appendChild(ptrPromptCount);

		// Other Strings
		MSXML2::IXMLDOMElementPtr ptrStrings = ptrDOMDoc->createElement( _T("Strings") );
		ptrMetrics->appendChild(ptrStrings);

		MSXML2::IXMLDOMElementPtr ptrStringCount = ptrDOMDoc->createElement( _T("Count") );
		ptrStringCount->text = (LPCTSTR)::IntToStr(info.m_nStrings);
		ptrStrings->appendChild(ptrStringCount);

		// Toolbars
		MSXML2::IXMLDOMElementPtr ptrToolbars = ptrDOMDoc->createElement( _T("Toolbars") );
		ptrMetrics->appendChild(ptrToolbars);

		MSXML2::IXMLDOMElementPtr ptrToolbarCount = ptrDOMDoc->createElement( _T("Count") );
		ptrToolbars->text = (LPCTSTR)::IntToStr(info.m_nToolbars);
		ptrToolbars->appendChild(ptrToolbarCount);

		// Controls
		MSXML2::IXMLDOMElementPtr ptrControls = ptrDOMDoc->createElement( _T("Controls") );
		ptrMetrics->appendChild(ptrControls);

		MSXML2::IXMLDOMElementPtr ptrControlCount = ptrDOMDoc->createElement( _T("Count") );
		ptrControlCount->text = (LPCTSTR)::IntToStr(info.m_nControls);
		ptrControls->appendChild(ptrControlCount);

		// Commands
		MSXML2::IXMLDOMElementPtr ptrCommands = ptrDOMDoc->createElement( _T("Commands") );
		ptrMetrics->appendChild(ptrCommands);

		MSXML2::IXMLDOMElementPtr ptrCommandCount = ptrDOMDoc->createElement( _T("Count") );
		ptrCommandCount->text = (LPCTSTR)::IntToStr(info.m_nCommands);
		ptrCommands->appendChild(ptrCommandCount);

		MSXML2::IXMLDOMElementPtr ptrMinCommandValue = ptrDOMDoc->createElement(_T("MinValue"));
		ptrMinCommandValue->text = (LPCTSTR)::UIntToStr(info.m_uMinCommand);
		ptrCommands->appendChild(ptrMinCommandValue);
		
		MSXML2::IXMLDOMElementPtr ptrMaxCommandValue = ptrDOMDoc->createElement(_T("MaxValue"));
		ptrMaxCommandValue->text = (LPCTSTR)::UIntToStr(info.m_uMaxCommand);
		ptrCommands->appendChild(ptrMaxCommandValue);
		
		// Next Symbol Values
		MSXML2::IXMLDOMElementPtr ptrNextSymbols = ptrDOMDoc->createElement( _T("NextSymbols") );
		ptrFile->appendChild(ptrNextSymbols);

		MSXML2::IXMLDOMElementPtr ptrNextResourceValue = ptrDOMDoc->createElement( _T("Resources") );
		ptrNextResourceValue->text = (LPCTSTR)::UIntToStr(pManager->GetNextResourceValue() );
		ptrNextSymbols->appendChild(ptrNextResourceValue);

		MSXML2::IXMLDOMElementPtr ptrNextControlValue = ptrDOMDoc->createElement( _T("Controls") );
		ptrNextControlValue->text = (LPCTSTR)::UIntToStr(pManager->GetNextControlValue() );
		ptrNextSymbols->appendChild(ptrNextControlValue);

		MSXML2::IXMLDOMElementPtr ptrNextCommandValue = ptrDOMDoc->createElement( _T("Commands") );
		ptrNextCommandValue->text = (LPCTSTR)::UIntToStr(pManager->GetNextCommandValue() );
		ptrNextSymbols->appendChild(ptrNextCommandValue);

		MSXML2::IXMLDOMElementPtr ptrNextSymedValue = ptrDOMDoc->createElement( _T("EditableSymbols") );
		ptrNextSymedValue->text = (LPCTSTR)::UIntToStr(pManager->GetNextSymedValue() );
		ptrNextSymbols->appendChild(ptrNextSymedValue);

		MSXML2::IXMLDOMElementPtr ptrSymbols = ptrDOMDoc->createElement( _T("Symbols") );
		ptrFile->appendChild(ptrSymbols);

		CResourceSymbolList listSymbols;
		pManager->GetSymbols(listSymbols);

		POSITION pos = listSymbols.GetHeadPosition();

		while (NULL != pos)
		{
			CResourceSymbol* pSymbol = listSymbols.GetNext(pos);
			if (NULL != pSymbol)
			{
				SaveSymbolXml(	pManager,
								pSymbol,
								pDOMDoc,
								(IXMLDOMElement*)ptrSymbols.GetInterfacePtr(),
								psErrorMsg);
			}
		}
	}
	catch(_com_error& e)
	{
		hr = e.Error();

		if (NULL != psErrorMsg)
		{
			psErrorMsg->Format( _T("Exception 0x%08x in CResOrgXmlWriter::SaveXml()"), hr);
		}
	}
	return hr;
}


HRESULT CResOrgXmlWriter::SaveSymbolXml(CResourceSymbolManager* pManager,
										CResourceSymbol* pSymbol,
										IXMLDOMDocument* pDOMDoc,
										IXMLDOMElement* pParent,
										CString* psErrorMsg /*= NULL*/)
{
	if (NULL == pSymbol)
	{
		return E_FAIL;
	}

	MSXML2::IXMLDOMDocumentPtr ptrDOMDoc(pDOMDoc);
	MSXML2::IXMLDOMElementPtr ptrParent(pParent);

	HRESULT hr = S_OK;
	try
	{
		MSXML2::IXMLDOMElementPtr ptrSymbol = ptrDOMDoc->createElement( _T("Symbol") );

		MSXML2::IXMLDOMAttributePtr ptrNameAttr = ptrDOMDoc->createAttribute(_T("name"));
		ptrNameAttr->value = (LPCTSTR)pSymbol->GetName();

		ptrSymbol->setAttributeNode(ptrNameAttr);

		MSXML2::IXMLDOMAttributePtr ptrUidAttr = ptrDOMDoc->createAttribute(_T("uid"));
		CString sValue;
		sValue.Format( _T("%lu"), (INT_PTR)pSymbol);

		ptrUidAttr->value = (LPCTSTR)sValue;
		ptrSymbol->setAttributeNode(ptrUidAttr);

		ptrParent->appendChild(ptrSymbol);

		//MSXML2::IXMLDOMElementPtr ptrName = ptrDOMDoc->createElement( _T("Name") );
		//ptrName->text = (LPCTSTR)m_sName;
		//ptrSymbol->appendChild(ptrName);

		MSXML2::IXMLDOMElementPtr ptrType = ptrDOMDoc->createElement( _T("Type") );
		ptrType->text = (LPCTSTR)pSymbol->GetTypeName();
		ptrSymbol->appendChild(ptrType);

		MSXML2::IXMLDOMElementPtr ptrValue = ptrDOMDoc->createElement( _T("Value") );
		ptrValue->text = (LPCTSTR)::UIntToStr(pSymbol->GetValue() );
		ptrSymbol->appendChild(ptrValue);

		MSXML2::IXMLDOMElementPtr ptrReadOnly = ptrDOMDoc->createElement( _T("ReadOnly") );
		ptrReadOnly->text = pSymbol->IsReadOnly() ? _T("1") : _T("0");
		ptrSymbol->appendChild(ptrReadOnly);

		MSXML2::IXMLDOMElementPtr ptrOutOfRange = ptrDOMDoc->createElement( _T("OutOfRange") );

		if (pManager->CheckForOutOfRangeSymbols() )
		{
			ptrOutOfRange->text = pManager->IsOutOfRange(pSymbol)  ? _T("1") : _T("0");
		}
		else
		{
			ptrOutOfRange->text = _T("n/a");
		}
		ptrSymbol->appendChild(ptrOutOfRange);

		MSXML2::IXMLDOMElementPtr ptrConflicts = ptrDOMDoc->createElement( _T("Conflicts") );
		ptrSymbol->appendChild(ptrConflicts);

		
		POSITION pos = pSymbol->GetConflicts().GetHeadPosition();

		while (NULL != pos)
		{
			CResourceSymbol* pConflictingSymbol = pSymbol->GetConflicts().GetNext(pos);
			if (NULL != pSymbol)
			{
				MSXML2::IXMLDOMElementPtr ptrConflict = ptrDOMDoc->createElement( _T("Symbol") );

				MSXML2::IXMLDOMAttributePtr ptrNameAttr = ptrDOMDoc->createAttribute(_T("name"));
				ptrNameAttr->value = (LPCTSTR)pConflictingSymbol->GetName();

				ptrConflict->setAttributeNode(ptrNameAttr);

				MSXML2::IXMLDOMAttributePtr ptrUidAttr = ptrDOMDoc->createAttribute(_T("uid"));
				CString sValue;
				sValue.Format( _T("%lu"), (INT_PTR)pConflictingSymbol);

				ptrUidAttr->value = (LPCTSTR)sValue;
				ptrConflict->setAttributeNode(ptrUidAttr);

				ptrConflicts->appendChild(ptrConflict);
			}
		}
	}
	catch(_com_error& e)
	{
		hr = e.Error();

		if (NULL != psErrorMsg)
		{
			psErrorMsg->Format( _T("Exception 0x%08x in CResourceSymbol::SaveXml()"), hr);
		}
	}
	return hr;
}


bool CResOrgXmlWriter::LoadSymbolFileConfig(CResourceSymbolManager* pManager,
											const CString& sPathName,
											CString* psErrorMsg /*= NULL*/)
{
	ASSERT(NULL != pManager);
	ASSERT(!sPathName.IsEmpty() );

	bool bResult = false;

	CString sErrorMsg;

	if (!sPathName.IsEmpty() && (NULL != pManager) )
	{
		try
		{
			MSXML2::IXMLDOMDocumentPtr ptrDOMDoc;

			// Create empty DOM
			::CoInitialize(NULL);

			HRESULT hr = ptrDOMDoc.CreateInstance("Msxml2.DOMDocument.4.0");

			if (FAILED(hr) )
			{
				sErrorMsg = _T("Failed to create XML DOM");

				throw new CUserException();
			}

			// Try to load the XML stream
			ptrDOMDoc->load( _variant_t(sPathName) );

			hr = LoadSymbolFileConfig(	pManager,
										(IXMLDOMDocument *)ptrDOMDoc.GetInterfacePtr(),
										&sErrorMsg);

			if (FAILED(hr) )
			{
//				sErrorMsg = _T("Failed to load XML stream");

				throw new CUserException();
			}

			bResult = true;
		}
		catch (CException* pError)
		{
			// Nothing to do here - we already know what's wrong
			pError->Delete();
		}
	}
	if (!bResult)
	{
		if ( (NULL != psErrorMsg) && !sErrorMsg.IsEmpty() )
		{
			*psErrorMsg = sErrorMsg;
		}
		TRACE1("ERROR in CResOrgXmlWriter::LoadSymbolFileConfig(): %s\n", sErrorMsg);
	}

	return bResult;
}


CString CResOrgXmlWriter::GetConfigFilePathName(const CString& sSymbolFilePathName)
{
	CNGSplitPath split(sSymbolFilePathName);

	CString sConfigFilePathName =	split.GetDrive() +
									split.GetDirectory() +
									split.GetFileName() +
									_T(".resorg");

	return sConfigFilePathName;
}


bool CResOrgXmlWriter::SaveSymbolFileConfig(	CResourceSymbolManager* pManager,
												const CString& sPathName,
												CString* psErrorMsg /*= NULL*/)

{
	ASSERT(!sPathName.IsEmpty() );
	ASSERT(NULL != pManager);

	bool bResult = false;

	CString sErrorMsg;

	if (!sPathName.IsEmpty() && (NULL != pManager) )
	{
		try
		{
			MSXML2::IXMLDOMDocumentPtr ptrDOMDoc;

			// Create empty DOM
			::CoInitialize(NULL);

			HRESULT hr = ptrDOMDoc.CreateInstance("Msxml2.DOMDocument.4.0");

			if (FAILED(hr) )
			{
				//sErrorMsg.LoadString(IDP_RESORG_ERR_XML_DOM_CREATE);
				sErrorMsg = _T("Failed to create XML DOM");

				throw new CUserException();
			}

			// Add xml version node
			CString sAttribs = _T("version=\"1.0\" encoding=\"iso-8859-1\"");

			MSXML2::IXMLDOMProcessingInstructionPtr ptrIns;
			ptrIns = ptrDOMDoc->createProcessingInstruction(_T("xml"), (LPCTSTR)sAttribs);
			ptrDOMDoc->appendChild(ptrIns);

			hr = SaveSymbolFileConfig(	pManager,
										(IXMLDOMDocument*)ptrDOMDoc.GetInterfacePtr(),
										&sErrorMsg);

			if (FAILED(hr) )
			{
				sErrorMsg = _T("Failed to save XML stream - ") + sErrorMsg;

				throw new CUserException();
			}

			try
			{
				 _variant_t varPathName = (LPCTSTR)sPathName;

				 ptrDOMDoc->save(varPathName);

				bResult = true;
			}
			catch(_com_error& e)
			{
				sErrorMsg = (LPCTSTR)e.Description();
			}
		}
		catch (CUserException* pError)
		{
			// Nothing to do here - we already know what's wrong
			pError->Delete();
		}
	}
	if (!bResult)
	{
		if ( (NULL != psErrorMsg) && !sErrorMsg.IsEmpty() )
		{
			*psErrorMsg = sErrorMsg;
		}
		TRACE( _T("ERROR in CResOrgXmlWriter::SaveSymbolFileConfig(): %s\n"), sErrorMsg);
	}
	return bResult;
}