703 lines
16 KiB
C++
703 lines
16 KiB
C++
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
// PARTICULAR PURPOSE.
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "tedmemo.h"
|
|
#include <assert.h>
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedAttributesSerializer::CTedAttributesSerializer(IMFAttributes* pAttributes)
|
|
: m_pAttributes(pAttributes)
|
|
{
|
|
m_pAttributes->AddRef();
|
|
}
|
|
|
|
CTedAttributesSerializer::~CTedAttributesSerializer()
|
|
{
|
|
m_pAttributes->Release();
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr;
|
|
CAtlString converter;
|
|
|
|
IFC( m_pAttributes->LockStore() );
|
|
|
|
UINT32 cItems;
|
|
IFC( m_pAttributes->GetCount(&cItems) );
|
|
|
|
DWORD cUsedItems = 0;
|
|
for(UINT32 i = 0; i < cItems; i++)
|
|
{
|
|
GUID gidKey;
|
|
PROPVARIANT var;
|
|
PropVariantInit(&var);
|
|
|
|
IFC( m_pAttributes->GetItemByIndex(i, &gidKey, &var) );
|
|
|
|
if(VT_LPWSTR == var.vt || VT_UI4 == var.vt || VT_UI8 == var.vt || VT_R8 == var.vt || VT_CLSID == var.vt)
|
|
{
|
|
cUsedItems++;
|
|
}
|
|
|
|
PropVariantClear(&var);
|
|
}
|
|
|
|
converter.Format(L"%d", cUsedItems);
|
|
IFC( pSaver->SaveData(L"ItemCount", converter) );
|
|
|
|
for(UINT32 i = 0; i < cItems; i++)
|
|
{
|
|
GUID gidKey;
|
|
PROPVARIANT var;
|
|
PropVariantInit(&var);
|
|
|
|
IFC( m_pAttributes->GetItemByIndex(i, &gidKey, &var) );
|
|
|
|
if(VT_LPWSTR == var.vt || VT_UI4 == var.vt || VT_UI8 == var.vt || VT_R8 == var.vt || VT_CLSID == var.vt)
|
|
{
|
|
IFC( WriteGUID(pSaver, L"Key", gidKey) );
|
|
IFC( WritePropVar(pSaver, L"Item", var) );
|
|
}
|
|
|
|
PropVariantClear(&var);
|
|
}
|
|
|
|
IFC( m_pAttributes->UnlockStore() );
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr;
|
|
UINT32 cItems;
|
|
LPWSTR szData;
|
|
|
|
IFC( pLoader->LoadData(L"ItemCount", &szData, 0) );
|
|
cItems = wcstoul(szData, NULL, 10);
|
|
CoTaskMemFree(szData);
|
|
|
|
for(UINT32 i = 0; i < cItems; i++)
|
|
{
|
|
GUID gidKey;
|
|
PROPVARIANT var;
|
|
PropVariantInit(&var);
|
|
|
|
IFC( ReadGUID(pLoader, L"Key", i, &gidKey) );
|
|
IFC( ReadPropVar(pLoader, L"Item", i, var) );
|
|
IFC( m_pAttributes->SetItem(gidKey, var) );
|
|
|
|
PropVariantClear(&var);
|
|
}
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::WriteGUID(ITedDataSaver* pSaver, CAtlString strTag, GUID gidToWrite)
|
|
{
|
|
HRESULT hr;
|
|
CAtlString converter;
|
|
LPOLESTR strGuid = NULL;
|
|
|
|
IFC( StringFromCLSID(gidToWrite, &strGuid) );
|
|
|
|
converter.Format(L"%s", strGuid);
|
|
IFC( pSaver->SaveData(strTag, converter) );
|
|
|
|
Cleanup:
|
|
CoTaskMemFree(strGuid);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::WritePropVar(ITedDataSaver* pSaver, CAtlString strTag, PROPVARIANT& varToWrite)
|
|
{
|
|
HRESULT hr;
|
|
CAtlString converter;
|
|
|
|
converter.Format(L"%d", varToWrite.vt);
|
|
IFC( pSaver->SaveData(L"Type", converter) );
|
|
|
|
switch(varToWrite.vt)
|
|
{
|
|
case VT_LPWSTR:
|
|
IFC( pSaver->SaveData(strTag, varToWrite.pwszVal) );
|
|
break;
|
|
case VT_CLSID:
|
|
IFC( WriteGUID(pSaver, strTag, *(varToWrite.puuid) ) );
|
|
break;
|
|
case VT_UI4:
|
|
converter.Format(L"%d", varToWrite.ulVal);
|
|
IFC( pSaver->SaveData(strTag, converter) );
|
|
break;
|
|
case VT_UI8:
|
|
converter.Format(L"%I64d", varToWrite.uhVal.QuadPart);
|
|
IFC( pSaver->SaveData(strTag, converter) );
|
|
break;
|
|
case VT_R8:
|
|
converter.Format(L"%f", varToWrite.dblVal);
|
|
IFC( pSaver->SaveData(strTag, converter) );
|
|
break;
|
|
case VT_VECTOR | VT_UI1:
|
|
case VT_UNKNOWN:
|
|
// Currently topoedit does not allow editing of these
|
|
// types, so they will not be serialized here.
|
|
break;
|
|
}
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::ReadGUID(ITedDataLoader* pLoader, CAtlString strTag, long nIndex, GUID* pgidToRead)
|
|
{
|
|
HRESULT hr;
|
|
LPWSTR szData = NULL;
|
|
|
|
IFC( pLoader->LoadData(strTag, &szData, nIndex) );
|
|
IFC( CLSIDFromString(W2OLE(szData), pgidToRead) );
|
|
|
|
Cleanup:
|
|
CoTaskMemFree(szData);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAttributesSerializer::ReadPropVar(ITedDataLoader* pLoader, CAtlString strTag, long nIndex, PROPVARIANT& varToRead)
|
|
{
|
|
HRESULT hr;
|
|
LPWSTR szData = NULL;
|
|
|
|
IFC( pLoader->LoadData(L"Type", &szData, nIndex) );
|
|
varToRead.vt = (VARTYPE) _wtoi(szData);
|
|
CoTaskMemFree(szData);
|
|
szData = NULL;
|
|
|
|
switch(varToRead.vt)
|
|
{
|
|
case VT_LPWSTR:
|
|
IFC( pLoader->LoadData(strTag, &szData, nIndex) );
|
|
varToRead.pwszVal = szData;
|
|
szData = NULL;
|
|
// String should be freed by PropVariantClear
|
|
break;
|
|
case VT_CLSID:
|
|
varToRead.puuid = (CLSID*) CoTaskMemAlloc(sizeof(CLSID));
|
|
IFC( ReadGUID(pLoader, strTag, nIndex, varToRead.puuid) );
|
|
// GUID should be freed by PropVariantClear
|
|
break;
|
|
case VT_UI4:
|
|
IFC( pLoader->LoadData(strTag, &szData, nIndex) );
|
|
varToRead.ulVal = wcstoul(szData, NULL, 10);
|
|
CoTaskMemFree(szData);
|
|
szData = NULL;
|
|
break;
|
|
case VT_UI8:
|
|
IFC( pLoader->LoadData(strTag, &szData, nIndex) );
|
|
varToRead.uhVal.QuadPart = _wtoi64(szData);
|
|
CoTaskMemFree(szData);
|
|
szData = NULL;
|
|
break;
|
|
case VT_R8:
|
|
IFC( pLoader->LoadData(strTag, &szData, nIndex) );
|
|
varToRead.dblVal = wcstod(szData, NULL);
|
|
CoTaskMemFree(szData);
|
|
szData = NULL;
|
|
break;
|
|
case VT_UNKNOWN:
|
|
case VT_VECTOR | VT_UI1:
|
|
// TopoEdit does not currently handle loading of
|
|
// IUnknown or blob types.
|
|
break;
|
|
}
|
|
|
|
Cleanup:
|
|
CoTaskMemFree(szData);
|
|
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedNodeMemo::CTedNodeMemo()
|
|
{
|
|
}
|
|
|
|
CTedNodeMemo::CTedNodeMemo(double x, double y, const CAtlStringW& strLabel, int nID)
|
|
: m_x(x), m_y(y), m_strLabel(strLabel), m_nID(nID)
|
|
{
|
|
|
|
}
|
|
|
|
CTedNodeMemo::~CTedNodeMemo()
|
|
{
|
|
for(size_t i = 0; i < m_arrNodeAttributes.GetCount(); i++)
|
|
{
|
|
m_arrNodeAttributes.GetAt(i)->Release();
|
|
}
|
|
}
|
|
|
|
HRESULT CTedNodeMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CAtlStringW converter;
|
|
|
|
converter.Format(L"%f", m_x);
|
|
IFC( pSaver->SaveData(L"X", converter) );
|
|
|
|
converter.Format(L"%f", m_y);
|
|
IFC( pSaver->SaveData(L"Y", converter) );
|
|
|
|
converter.Format(L"%d", m_nID);
|
|
IFC( pSaver->SaveData(L"ID", converter) );
|
|
|
|
IFC( pSaver->SaveData(L"Label", m_strLabel) );
|
|
|
|
converter.Format(L"%d", (DWORD) m_arrNodeAttributes.GetCount());
|
|
IFC( pSaver->SaveData(L"NodeAttributesCount", converter) );
|
|
|
|
IFC( pSaver->BeginSaveChildObjects() );
|
|
for(size_t i = 0; i < m_arrNodeAttributes.GetCount(); i++)
|
|
{
|
|
IFC( pSaver->BeginSaveObject(L"NodeAttributes") );
|
|
CTedAttributesSerializer Serializer(m_arrNodeAttributes.GetAt(i));
|
|
IFC( Serializer.Serialize(pSaver) );
|
|
|
|
}
|
|
IFC( pSaver->EndSaveChildObjects() );
|
|
|
|
Cleanup:
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedNodeMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD cNodeAttributes;
|
|
LPWSTR szData = NULL;
|
|
|
|
IFC( pLoader->LoadData(L"X", &szData, 0) );
|
|
m_x = _wtof(szData);
|
|
CoTaskMemFree(szData);
|
|
|
|
IFC( pLoader->LoadData(L"Y", &szData, 0) );
|
|
m_y = _wtof(szData);
|
|
CoTaskMemFree(szData);
|
|
|
|
IFC( pLoader->LoadData(L"ID", &szData, 0) );
|
|
m_nID = _wtoi(szData);
|
|
CoTaskMemFree(szData);
|
|
|
|
IFC( pLoader->LoadData(L"Label", &szData, 0) );
|
|
m_strLabel = szData;
|
|
CoTaskMemFree(szData);
|
|
|
|
IFC( pLoader->LoadData(L"NodeAttributesCount", &szData, 0) );
|
|
cNodeAttributes = wcstoul(szData, NULL, 10);
|
|
CoTaskMemFree(szData);
|
|
|
|
BOOL fHasChildObjects;
|
|
IFC( pLoader->HasChildObjects(&fHasChildObjects) );
|
|
|
|
if(fHasChildObjects)
|
|
{
|
|
IFC( pLoader->BeginLoadChildObjects() );
|
|
for(size_t i = 0; i < cNodeAttributes; i++)
|
|
{
|
|
LPWSTR szNextObject = NULL;
|
|
|
|
IMFAttributes* pAttributes;
|
|
IFC( MFCreateAttributes(&pAttributes, 4) );
|
|
|
|
IFC( pLoader->GetNextObject(&szNextObject) );
|
|
CoTaskMemFree(szNextObject);
|
|
|
|
CTedAttributesSerializer Serializer(pAttributes);
|
|
Serializer.Deserialize(pLoader);
|
|
|
|
m_arrNodeAttributes.Add(pAttributes);
|
|
}
|
|
IFC( pLoader->EndLoadChildObjects() );
|
|
}
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
void CTedNodeMemo::AddNodeAttributes(IMFAttributes* pNodeAttributes)
|
|
{
|
|
m_arrNodeAttributes.Add(pNodeAttributes);
|
|
pNodeAttributes->AddRef();
|
|
}
|
|
|
|
DWORD CTedNodeMemo::GetNodeAttributeCount()
|
|
{
|
|
return (DWORD) m_arrNodeAttributes.GetCount();
|
|
}
|
|
|
|
IMFAttributes* CTedNodeMemo::GetNodeAttributes(DWORD nIndex)
|
|
{
|
|
return m_arrNodeAttributes.GetAt(nIndex);
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedSourceMemo::CTedSourceMemo()
|
|
{
|
|
}
|
|
|
|
CTedSourceMemo::CTedSourceMemo(double x, double y, const CAtlStringW& strLabel, int nID, const CAtlStringW& strSourceURL)
|
|
: CTedNodeMemo(x, y, strLabel, nID), m_strSourceURL(strSourceURL)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedSourceMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedSourceMemo"));
|
|
|
|
IFC(CTedNodeMemo::Serialize(pSaver));
|
|
|
|
IFC(pSaver->SaveData(L"URL", m_strSourceURL));
|
|
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedSourceMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(CTedNodeMemo::Deserialize(pLoader));
|
|
|
|
LPWSTR strData = NULL;
|
|
IFC(pLoader->LoadData(L"URL", &strData, 0));
|
|
m_strSourceURL = strData;
|
|
CoTaskMemFree(strData);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedOutputMemo::CTedOutputMemo()
|
|
{
|
|
}
|
|
|
|
CTedOutputMemo::CTedOutputMemo(double x, double y, const CAtlStringW& strLabel, int nID)
|
|
: CTedNodeMemo(x, y, strLabel, nID)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedOutputMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(CTedNodeMemo::Serialize(pSaver));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedOutputMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(CTedNodeMemo::Deserialize(pLoader));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedAudioOutputMemo::CTedAudioOutputMemo()
|
|
{
|
|
}
|
|
|
|
CTedAudioOutputMemo::CTedAudioOutputMemo(double x, double y, const CAtlStringW& strLabel, int nID)
|
|
: CTedOutputMemo(x, y, strLabel, nID)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedAudioOutputMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedAudioOutputMemo"));
|
|
|
|
IFC(CTedOutputMemo::Serialize(pSaver));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedAudioOutputMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(CTedOutputMemo::Deserialize(pLoader));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedVideoOutputMemo::CTedVideoOutputMemo()
|
|
{
|
|
}
|
|
|
|
CTedVideoOutputMemo::CTedVideoOutputMemo(double x, double y, const CAtlStringW& strLabel, int nID)
|
|
: CTedOutputMemo(x, y, strLabel, nID)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedVideoOutputMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedVideoOutputMemo"));
|
|
|
|
IFC(CTedOutputMemo::Serialize(pSaver));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedVideoOutputMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
IFC(CTedOutputMemo::Deserialize(pLoader));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedCustomOutputMemo::CTedCustomOutputMemo()
|
|
{
|
|
}
|
|
|
|
CTedCustomOutputMemo::CTedCustomOutputMemo(double x, double y, const CAtlStringW& strLabel, int nID, GUID gidCustomSinkID)
|
|
: CTedOutputMemo(x, y, strLabel, nID)
|
|
, m_gidCustomSinkID(gidCustomSinkID)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedCustomOutputMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CAtlStringW converter;
|
|
LPOLESTR guidStr = NULL;
|
|
|
|
IFC( pSaver->BeginSaveObject(L"CTedCustomOutputMemo") );
|
|
IFC( CTedOutputMemo::Serialize(pSaver) );
|
|
|
|
IFC( StringFromCLSID(m_gidCustomSinkID, &guidStr) );
|
|
|
|
converter.Format(L"%s", guidStr);
|
|
IFC( pSaver->SaveData(L"CustomSinkID", converter) );
|
|
|
|
CoTaskMemFree(guidStr);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedCustomOutputMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWSTR converter = NULL;
|
|
|
|
IFC( CTedOutputMemo::Deserialize(pLoader) );
|
|
|
|
IFC( pLoader->LoadData(L"CustomSinkID", &converter, 0) );
|
|
IFC(CLSIDFromString(W2OLE(converter), &m_gidCustomSinkID));
|
|
CoTaskMemFree(converter);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedTransformMemo::CTedTransformMemo()
|
|
{
|
|
}
|
|
|
|
CTedTransformMemo::CTedTransformMemo(double x, double y, const CAtlStringW& strLabel, int nID, const CLSID& clsid)
|
|
: CTedNodeMemo(x, y, strLabel, nID), m_clsid(clsid)
|
|
{
|
|
}
|
|
|
|
HRESULT CTedTransformMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CAtlStringW converter;
|
|
LPOLESTR clsidStr = NULL;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedTransformMemo"));
|
|
IFC(CTedNodeMemo::Serialize(pSaver));
|
|
|
|
IFC(StringFromCLSID(m_clsid, &clsidStr));
|
|
|
|
converter.Format(L"%s", clsidStr);
|
|
IFC(pSaver->SaveData(L"CLSID", converter));
|
|
|
|
CoTaskMemFree(clsidStr);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedTransformMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LPWSTR converter;
|
|
|
|
IFC(CTedNodeMemo::Deserialize(pLoader));
|
|
|
|
IFC(pLoader->LoadData(L"CLSID", &converter, 0));
|
|
IFC(CLSIDFromString(W2OLE(converter), &m_clsid));
|
|
CoTaskMemFree(converter);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedTeeMemo::CTedTeeMemo()
|
|
{
|
|
}
|
|
|
|
CTedTeeMemo::CTedTeeMemo(double x, double y, const CAtlStringW& strLabel, int nID, int nNextOutputIndex)
|
|
: CTedNodeMemo(x, y, strLabel, nID), m_nNextOutputIndex(nNextOutputIndex)
|
|
{
|
|
|
|
}
|
|
|
|
HRESULT CTedTeeMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CAtlStringW converter;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedTeeMemo"));
|
|
IFC(CTedNodeMemo::Serialize(pSaver));
|
|
|
|
converter.Format(L"%d", m_nNextOutputIndex);
|
|
IFC(pSaver->SaveData(L"NextOutputIndex", converter));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedTeeMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LPWSTR converter;
|
|
|
|
IFC(CTedNodeMemo::Deserialize(pLoader));
|
|
|
|
IFC(pLoader->LoadData(L"NextOutputIndex", &converter, 0));
|
|
m_nNextOutputIndex = _wtoi(converter);
|
|
CoTaskMemFree(converter);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////
|
|
//
|
|
|
|
CTedConnectionMemo::CTedConnectionMemo()
|
|
{
|
|
}
|
|
|
|
CTedConnectionMemo::CTedConnectionMemo(int nOutputNodeID, int nOutputPinID, int nInputNodeID, int nInputPinID)
|
|
: m_nOutputNodeID(nOutputNodeID), m_nOutputPinID(nOutputPinID)
|
|
, m_nInputNodeID(nInputNodeID), m_nInputPinID(nInputPinID)
|
|
{
|
|
|
|
}
|
|
|
|
HRESULT CTedConnectionMemo::Serialize(ITedDataSaver* pSaver)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CAtlStringW converter;
|
|
|
|
IFC(pSaver->BeginSaveObject(L"CTedConnectionMemo"));
|
|
|
|
converter.Format(L"%d", m_nOutputNodeID);
|
|
IFC(pSaver->SaveData(L"OutputNodeID", converter));
|
|
|
|
converter.Format(L"%d", m_nOutputPinID);
|
|
IFC(pSaver->SaveData(L"OutputPinID", converter));
|
|
|
|
converter.Format(L"%d", m_nInputNodeID);
|
|
IFC(pSaver->SaveData(L"InputNodeID", converter));
|
|
|
|
converter.Format(L"%d", m_nInputPinID);
|
|
IFC(pSaver->SaveData(L"InputPinID", converter));
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CTedConnectionMemo::Deserialize(ITedDataLoader* pLoader)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LPWSTR converter;
|
|
|
|
IFC(pLoader->LoadData(L"OutputNodeID", &converter, 0));
|
|
m_nOutputNodeID = _wtoi(converter);
|
|
CoTaskMemFree(converter);
|
|
|
|
IFC(pLoader->LoadData(L"OutputPinID", &converter, 0));
|
|
m_nOutputPinID = _wtoi(converter);
|
|
CoTaskMemFree(converter);
|
|
|
|
IFC(pLoader->LoadData(L"InputNodeID", &converter, 0));
|
|
m_nInputNodeID = _wtoi(converter);
|
|
CoTaskMemFree(converter);
|
|
|
|
IFC(pLoader->LoadData(L"InputPinID", &converter, 0));
|
|
m_nInputPinID = _wtoi(converter);
|
|
CoTaskMemFree(converter);
|
|
|
|
Cleanup:
|
|
return hr;
|
|
}
|