//************************************************************************************
void CBCGPCalendarMenuButton::Serialize (CArchive& ar)
{
CBCGPToolbarMenuButton::Serialize (ar);
if (ar.IsLoading ())
{
ar >> m_nColumns;
ar >> m_nVertDockColumns;
ar >> m_nHorzDockRows;
ar >> m_bStdCalendarDlg;
CObList listButtons;
if (CBCGPToolBar::GetCommandButtons (m_nID, listButtons) > 0)
{
for (POSITION pos = listButtons.GetHeadPosition (); pos != NULL;)
{
CBCGPCalendarMenuButton* pOther =
DYNAMIC_DOWNCAST (CBCGPCalendarMenuButton, listButtons.GetNext (pos));
if (pOther != NULL && pOther != this)
{
m_Calendar = pOther->m_Calendar;
}
}
}
}
void CMyFirstDocWindowDoc::Serialize(CArchive& ar)
{
// CEditView contains an edit control which handles all serialization
if (!m_viewList.IsEmpty())
{
reinterpret_cast<CEditView*>(m_viewList.GetHead())->SerializeRaw(ar);
}
#ifdef SHARED_HANDLERS
if (m_viewList.IsEmpty() && ar.IsLoading())
{
CFile* pFile = ar.GetFile();
pFile->Seek(0, FILE_BEGIN);
ULONGLONG nFileSizeBytes = pFile->GetLength();
ULONGLONG nFileSizeChars = nFileSizeBytes/sizeof(TCHAR);
LPTSTR lpszText = (LPTSTR)malloc(((size_t)nFileSizeChars + 1) * sizeof(TCHAR));
if (lpszText != NULL)
{
ar.Read(lpszText, (UINT)nFileSizeBytes);
lpszText[nFileSizeChars] = '\0';
m_strThumbnailContent = lpszText;
m_strSearchContent = lpszText;
}
}
#endif
}
void CDevObjDoc::Serialize(CArchive& ar)
{
ASSERT(ar.IsLoading());
m_objects.Serialize(ar); //对象序列化
COleDocument::Serialize(ar);
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CTorpedoWeapons::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
m_Firearc.Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
ar << m_iTorpedoType;
ar << m_iNumber;
ar << m_iTupeFirerate;
ar << m_iNumberOfTupes;
ar << m_byAccuracy;
ar << m_strTupeName;
ar << m_bOnlyMicroPhoton;
}
// wenn geladen wird
if (ar.IsLoading())
{
ar >> m_iTorpedoType;
ar >> m_iNumber;
ar >> m_iTupeFirerate;
ar >> m_iNumberOfTupes;
ar >> m_byAccuracy;
ar >> m_strTupeName;
ar >> m_bOnlyMicroPhoton;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CHull::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
MYTRACE("shipdetails")(MT::LEVEL_DEBUG, "HULL.CPP: BaseHull:%d, CurrentHull:%d, HullMaterial:%d, MaxHull:%d, DblHull:%s, Ablative:%s, Pola:%s\n",
m_iBaseHull, m_iCurrentHull, m_iHullMaterial, m_iMaxHull,
m_bDoubleHull ? "true" : "false",
m_bAblative ? "true" : "false",
m_bPolarisation ? "true" : "false");
//HULL.CPP: BaseHull:600, CurrentHull:600, HullMaterial:0, MaxHull:600
ar << m_bDoubleHull;
ar << m_bAblative;
ar << m_bPolarisation;
ar << m_iBaseHull;
ar << m_iCurrentHull;
ar << m_iHullMaterial;
ar << m_iMaxHull;
}
// wenn geladen wird
if (ar.IsLoading())
{
ar >> m_bDoubleHull;
ar >> m_bAblative;
ar >> m_bPolarisation;
ar >> m_iBaseHull;
ar >> m_iCurrentHull;
ar >> m_iHullMaterial;
ar >> m_iMaxHull;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CBeamWeapons::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
m_Firearc.Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
ar << m_strBeamName;
ar << m_iBeamPower;
ar << m_iBeamType;
ar << m_iBeamNumber;
ar << m_byShootNumber;
ar << m_byBonus;
ar << m_byBeamLenght;
ar << m_byRechargeTime;
ar << m_bPiercing;
ar << m_bModulating;
}
// wenn geladen wird
if (ar.IsLoading())
{
ar >> m_strBeamName;
ar >> m_iBeamPower;
ar >> m_iBeamType;
ar >> m_iBeamNumber;
ar >> m_byShootNumber;
ar >> m_byBonus;
ar >> m_byBeamLenght;
ar >> m_byRechargeTime;
ar >> m_bPiercing;
ar >> m_bModulating;
}
void CBrowseHostWnd::Serialize(CArchive& ar, int nVersion /* BROWSER_SER_VERSION */)
{
if ( ar.IsStoring() )
{
ar << nVersion;
ar << m_bOnFiles;
}
else
{
ar >> nVersion;
if ( nVersion < 1 || nVersion > BROWSER_SER_VERSION ) AfxThrowUserException();
ar >> m_bOnFiles;
}
CBaseMatchWnd::Serialize( ar );
m_pBrowser->Serialize( ar, nVersion );
m_wndProfile.Serialize( ar, nVersion );
m_wndFrame.Serialize( ar, nVersion );
if ( ar.IsLoading() )
{
m_wndProfile.Update( m_pBrowser );
PostMessage( WM_TIMER, 1 );
SendMessage( WM_TIMER, 2 );
SetAlert( FALSE );
}
}
void CSchemaObject::Serialize(CArchive& ar)
{
CObject::Serialize(ar);
if (ar.IsLoading())
{
int nVersion = ar.GetObjectSchema();
switch(nVersion)
{
case 0:
// read in previous version of
// this object
break;
case 1:
// read in current version of
// this object
break;
default:
// report unknown version of
// this object
break;
}
}
else
{
// Normal storing code goes here
}
}
void CServerData::Serialize( CArchive& ar )
{
const int iObjectVersion = 7;
if ( ar.IsLoading( ) )
{
int iVersion;
ar >> iVersion;
if ( ( iVersion < 1 ) || ( iVersion > iObjectVersion ) )
::AfxThrowArchiveException( CArchiveException::generic );
ar >> m_bIsTemporary;
ar >> m_sServerName;
ar >> m_sServerIP;
ar >> m_iServerPort;
ar >> m_sUserLogin;
ar >> m_sUserPassword;
ar >> m_pUserStatusData;
ar >> m_bOwnData;
if ( iVersion > 1 )
{
ar >> m_bAutoConnect;
if ( iVersion > 2 )
{
ar >> m_sServerIcon;
if ( iVersion > 3 )
{
ar >> m_pServerOptions;
}
//////////////////////////////////////////////////////////////////////
// Serialisierungsfunktion
//////////////////////////////////////////////////////////////////////
void CWorker::Serialize(CArchive &ar)
{
// wenn gespeichert wird
if (ar.IsStoring())
{
ar << m_Workers.size();
for(const_iterator it = m_Workers.begin(); it != m_Workers.end(); ++it)
{
ar << static_cast<int>(it->first);
ar << it->second;
}
ar << m_AllWorkers;
ar << m_FreeWorkers;
}
// wenn geladen wird
if (ar.IsLoading())
{
m_Workers.clear();
unsigned size;
ar >> size;
for(unsigned i = 0; i < size; ++i)
{
int key;
ar >> key;
int value;
ar >> value;
AssertBotE(WORKER::FOOD_WORKER <= key && key <= WORKER::IRIDIUM_WORKER);
m_Workers.insert(std::pair<WORKER::Typ, int>(static_cast<WORKER::Typ>(key), value));
}
ar >> m_AllWorkers;
ar >> m_FreeWorkers;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CIntelReports::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
if (ar.IsStoring())
{
BYTE type = MAXBYTE;
if (m_pAttemptObject)
type = m_pAttemptObject->GetType();
ar << type;
if (m_pAttemptObject)
m_pAttemptObject->Serialize(ar);
}
else if (ar.IsLoading())
{
m_nActiveReport = -1;
RemoveAllReports();
BYTE type;
ar >> type;
if (type != MAXBYTE)
{
switch (type)
{
case 0: m_pAttemptObject = new CEcoIntelObj(); break;
case 1: m_pAttemptObject = new CScienceIntelObj(); break;
case 2: m_pAttemptObject = new CMilitaryIntelObj(); break;
case 3: m_pAttemptObject = new CDiplomacyIntelObj(); break;
}
m_pAttemptObject->Serialize(ar);
}
else
m_pAttemptObject = 0;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CAssemblyList::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
for (int i = 0; i < ALE; i++)
{
ar << m_iEntry[i];
// Variablen geben die noch verbleibenden Kosten der Elemente in der Bauliste an
ar << m_iNeededIndustryInAssemblyList[i];
ar << m_iNeededTitanInAssemblyList[i];
ar << m_iNeededDeuteriumInAssemblyList[i];
ar << m_iNeededDuraniumInAssemblyList[i];
ar << m_iNeededCrystalInAssemblyList[i];
ar << m_iNeededIridiumInAssemblyList[i];
ar << m_iNeededDeritiumInAssemblyList[i];
}
// Variablen, die Angeben, wieviel Industrie und Rohstoffe zum Bau benötigt werden
ar << m_iNeededIndustryForBuild;
ar << m_iNeededTitanForBuild;
ar << m_iNeededDeuteriumForBuild;
ar << m_iNeededDuraniumForBuild;
ar << m_iNeededCrystalForBuild;
ar << m_iNeededIridiumForBuild;
ar << m_iNeededDeritiumForBuild;
// Wurde das Gebäude gekauft in dieser Runde gekauft
ar << m_bWasBuildingBought;
// Die Baukosten eines Auftrages
ar << m_iBuildCosts;
}
// wenn geladen wird
if (ar.IsLoading())
{
for (int i = 0; i < ALE; i++)
{
ar >> m_iEntry[i];
// Variablen geben die noch verbleibenden Kosten der Elemente in der Bauliste an
ar >> m_iNeededIndustryInAssemblyList[i];
ar >> m_iNeededTitanInAssemblyList[i];
ar >> m_iNeededDeuteriumInAssemblyList[i];
ar >> m_iNeededDuraniumInAssemblyList[i];
ar >> m_iNeededCrystalInAssemblyList[i];
ar >> m_iNeededIridiumInAssemblyList[i];
ar >> m_iNeededDeritiumInAssemblyList[i];
}
// Variablen, die Angeben, wieviel Industrie und Rohstoffe zum Bau benötigt werden
ar >> m_iNeededIndustryForBuild;
ar >> m_iNeededTitanForBuild;
ar >> m_iNeededDeuteriumForBuild;
ar >> m_iNeededDuraniumForBuild;
ar >> m_iNeededCrystalForBuild;
ar >> m_iNeededIridiumForBuild;
ar >> m_iNeededDeritiumForBuild;
// Wurde das Gebäude gekauft in dieser Runde gekauft
ar >> m_bWasBuildingBought;
// Die Baukosten eines Auftrages
ar >> m_iBuildCosts;
}
}
void CUserOptions::Serialize( CArchive & ar )
{
if( ar.IsLoading() )
{
ar >> m_bHasTitle >> m_nPoem >> m_nStanzas >> m_nVerses >> m_cbStanza;
ar >> m_nCompiler >> m_strRootWords >> m_strSyntaxPath >> m_strSavePath;
}
//************************************************************************************
void CBCGColorMenuButton::Serialize (CArchive& ar)
{
CBCGToolbarMenuButton::Serialize (ar);
if (ar.IsLoading ())
{
int nColorsCount;
ar >> nColorsCount;
m_Colors.SetSize (nColorsCount);
for (int i = 0; i < nColorsCount; i++)
{
COLORREF color;
ar >> color;
m_Colors [i] = color;
}
ar >> m_nColumns;
if (g_pWorkspace != NULL && g_pWorkspace->GetDataVersion () >= 0x40710)
{
ar >> m_nVertDockColumns;
ar >> m_nHorzDockRows;
}
//*****************************************************************************************
void CBCGPDropDownToolbarButton::Serialize (CArchive& ar)
{
CBCGPToolbarButton::Serialize (ar);
UINT uiToolbarResID = 0;
if (ar.IsLoading ())
{
m_pToolBar = NULL;
ar >> uiToolbarResID;
ar >> m_strName;
ar >> m_iSelectedImage;
// Find toolbar with required resource ID:
for (POSITION pos = gAllToolbars.GetHeadPosition (); pos != NULL;)
{
CBCGPDropDownToolBar* pToolBar = DYNAMIC_DOWNCAST (CBCGPDropDownToolBar,
gAllToolbars.GetNext (pos));
if (pToolBar != NULL &&
CWnd::FromHandlePermanent (pToolBar->m_hWnd) != NULL)
{
ASSERT_VALID (pToolBar);
if (pToolBar->m_uiOriginalResID == uiToolbarResID)
{
m_pToolBar = pToolBar;
break;
}
}
}
SetDefaultCommand (m_nID);
}
void COXChildFrameState::Serialize(CArchive& ar)
{
ASSERT_VALID(this);
// Check the version
// (If version == -1, the version is unknown, this occurs when Serialize() is called directly)
if (ar.IsLoading())
{
m_nSerializeSchemaVersionLoad = (int)ar.GetObjectSchema();
if (m_nSerializeSchemaVersion < m_nSerializeSchemaVersionLoad)
{
TRACE1("COXChildFrameState::Serialize : Unexpected schema version : %i, throwing CArchiveException\n",
m_nSerializeSchemaVersionLoad);
AfxThrowArchiveException(CArchiveException::badSchema);
}
}
// Call base class implementation
CObject::Serialize(ar);
// Serialize all data
if (ar.IsStoring())
StoreProperties(ar);
else
LoadProperties(ar);
ASSERT_VALID(this);
}
//**************************************************************************************
void CBCGPBaseTabbedBar::Serialize (CArchive& ar)
{
CBCGPDockingControlBar::Serialize (ar);
if (ar.IsLoading ())
{
ar >> m_bAutoDestroy;
}
void CUPnpNatMappingKey::Serialize(CArchive& ar)
{
if (ar.IsLoading())
{
ar >> m_strRemoteHost;
ar >> m_usExternalPort;
ar >> m_strProtocol;
}
void CVector::Serialize(CArchive& ar) {
if(ar.IsLoading()) {
int nsize;
ar>>nsize;
init(nsize);
for(int i=0;i<nsize;i++) {
ar>>element[i];
}
}
//********************************************************************************
void CBCGPHotSpot::Serialize(CArchive& ar)
{
CObject::Serialize (ar);
if (ar.IsLoading ())
{
ar >> (ULONG&) m_nID;
ar >> m_rect;
}
BOOL CBCGPRegistry::Read(LPCTSTR pszKey, LPPOINT& lpPoint)
{
ASSERT(m_hKey);
BOOL bSucess = FALSE;
BYTE* pData = NULL;
UINT uDataSize;
Read (pszKey, &pData, &uDataSize);
try
{
if (pData != NULL && m_Info.lMessage == ERROR_SUCCESS && m_Info.dwType == REG_BINARY)
{
CMemFile file (pData, uDataSize);
CArchive ar (&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
CDWordArray dwcArray;
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
if (dwcArray.GetSize() == 2)
{
lpPoint->x = dwcArray.GetAt(0);
lpPoint->y = dwcArray.GetAt(1);
bSucess = TRUE;
}
}
}
catch (CMemoryException* pEx)
{
pEx->Delete ();
TRACE(_T("Memory exception in CBCGPRegistry::Read ()!\n"));
}
catch (CArchiveException* pEx)
{
pEx->Delete ();
TRACE(_T("CArchiveException exception in CBCGPRegistry::Read ()!\n"));
}
m_Info.dwType = REG_POINT;
m_Info.dwSize = sizeof(POINT);
if (pData != NULL)
{
delete [] pData;
pData = NULL;
}
return bSucess;
}
DWORD COleControl::SerializeVersion(CArchive& ar, DWORD dwVersionDefault,
BOOL bConvert)
{
DWORD dwVersion;
if (ar.IsLoading())
{
ar >> m_dwVersionLoaded;
dwVersion = m_dwVersionLoaded;
}
void CDiasAPIChannels::Serialize (CArchive& ar) {
CaImAPICollection<CChannel>::Serialize (ar);
uvar32_64 n, size;
if (ar.IsLoading ()) {
ar.Read (&size, sizeof (uvar32_64));
Add (size);
for (n = 0; n < size; ++n)
(*this)[n].Serialize (ar);
}
}
void CWordPadDoc::Serialize(CArchive& ar)
{
COleMessageFilter* pFilter = AfxOleGetMessageFilter();
ASSERT(pFilter != NULL);
pFilter->EnableBusyDialog(FALSE);
if (ar.IsLoading())
SetDocType(m_nNewDocType);
CRichEditDoc::Serialize(ar);
pFilter->EnableBusyDialog(TRUE);
}
////////////////////////////////////////////////////////////////////////////////////
// Class Vector
//
// Physics as interpreted by me.
//
//
void Vector::Serialize(CArchive& ar)
{
if (ar.IsLoading())
{
ar >> dx;
ar >> dy;
ar >> x;
ar >> y;
ar >> dr;
ar >> r;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CDiplomacyInfo::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
ar << m_sToRace; // an welche Rasse (ID) geht das Angebot
ar << m_sFromRace; // von welcher Rasse (ID) kommt das Angebot
ar << m_sText; // Angebotstext
ar << m_nFlag; // Angebot, Antwort oder irgendwas anderes
ar << m_nType; // Art des Angebots (Krieg, NAP, Geschenk usw.)
ar << m_nSendRound; // in welcher Runde wurde das Angebot abgeschickt
ar << m_nCredits; // wieviele Credits werden als Geschenk angeboten
for (int i = 0; i <= RESOURCES::DERITIUM; i++)
ar << m_nResources[i]; // welche Ressourcen werden mit als Geschenk angeboten
ar << m_ptKO; // aus welchem System stammen die Ressourcen
ar << m_nDuration; // Dauer des Angebots
ar << m_sWarpactEnemy; // der Gegner bei einem Kriegspaktangebot
ar << m_sCorruptedRace; // Hauptrasse, welche bei einer Bestechnung betroffen sein soll
ar << m_nAnswerStatus; // wurde das Angebot angenommen, abgelehnt oder nicht darauf reagiert
ar << m_sHeadline; // Überschrift bei Angebotsantwort
ar << m_sWarPartner; // Krieg aufgrund Diplomatiepartner
}
// wenn geladen wird
else if (ar.IsLoading())
{
ar >> m_sToRace; // an welche Rasse (ID) geht das Angebot
ar >> m_sFromRace; // von welcher Rasse (ID) kommt das Angebot
ar >> m_sText; // Angebotstext
ar >> m_nFlag; // Angebot, Antwort oder irgendwas anderes
int nType;
ar >> nType; // Art des Angebots (Krieg, NAP, Geschenk usw.)
m_nType = (DIPLOMATIC_AGREEMENT::Typ)nType;
ar >> m_nSendRound; // in welcher Runde wurde das Angebot abgeschickt
ar >> m_nCredits; // wieviele Credits werden als Geschenk angeboten
for (int i = 0; i <= RESOURCES::DERITIUM; i++)
ar >> m_nResources[i]; // welche Ressourcen werden mit als Geschenk angeboten
ar >> m_ptKO; // aus welchem System stammen die Ressourcen
ar >> m_nDuration; // Dauer des Angebots
ar >> m_sWarpactEnemy; // der Gegner bei einem Kriegspaktangebot
ar >> m_sCorruptedRace; // Hauptrasse, welche bei einer Bestechnung betroffen sein soll
int nAnswerStatus;
ar >> nAnswerStatus;
m_nAnswerStatus = (ANSWER_STATUS::Typ)nAnswerStatus; // wurde das Angebot angenommen, abgelehnt oder nicht darauf reagiert
ar >> m_sHeadline; // Überschrift bei Angebotsantwort
ar >> m_sWarPartner; // Krieg aufgrund Diplomatiepartner
}
void CDiasAPIDensScales::Serialize (CArchive& ar) {
CaImAPICollection<CDensScale>::Serialize (ar);
uvar32_64 n, size;
if (ar.IsLoading ()) {
ar.Read (&size, sizeof (uvar32_64));
for (n = 0; n < size; ++n) {
CDensScale* scale = new CDensScale;
scale->Serialize (ar);
Add (*scale);
}
ar >> m_nActive;
} else
bool CEditorCondition::Serialize(CArchive &ar, CChronoEventEditor* Ed)
{
CString ExpectedName = "CEditorCondition";
int Version = 2;
if (!SerializeClassHeader(ExpectedName, Version, ar))
return false;
if( ar.IsLoading())
{
m_visible = true;
m_Valid = true;
ar >> mid;
ar >> cndID;
ar >> oid;
if(Ed) Ed->RegisterObjectID(oid, ar);
ar >> m_Negate;
ar >> m_Family >> m_FamilyName;
ar >> m_rect_default;
ar >> m_select_default;
ar >> m_select_default;
ar >> m_Anim.Space;
ar // //m_Text - note: must call EventSheetEditor::ReformatCondition
>> m_Object >> m_Script;
m_Anim.m_bDestroyed = false;
m_Text = "";
int size = 0;
ar >> size;
for (int i = 0; i < size; i++)
{
CEditorParam* Param = new CEditorParam;
Param->Serialize(ar, Ed);
params.push_back(Param);
}
if (oid != -1)
{
CString name = "";
ar >> name;
OINFO* o = GetOINFO(name);
if (!o)
{
CErrorDlg Dlg;
Dlg.Error("Error in condition.", "An invalid object in a condition was referenced.");
return false;
}
DLLIndex = o->oID;
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CTrade::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
m_TradeHistory.Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
ar << m_iQuantity;
ar << m_fTax;
for (int i = 0; i <= RESOURCES::IRIDIUM; i++)
{
ar << m_iRessourcePrice[i];
ar << m_iRessourcePriceAtRoundStart[i];
ar << m_iTaxes[i];
ar << m_dMonopolBuy[i];
}
ar << m_TradeActions.GetSize();
for (int i = 0; i < m_TradeActions.GetSize(); i++)
{
ar << m_TradeActions.GetAt(i).number;
ar << m_TradeActions.GetAt(i).price;
ar << m_TradeActions.GetAt(i).res;
ar << m_TradeActions.GetAt(i).system;
}
}
// wenn geladen wird
if (ar.IsLoading())
{
int number = 0;
ar >> m_iQuantity;
ar >> m_fTax;
for (int i = 0; i <= RESOURCES::IRIDIUM; i++)
{
ar >> m_iRessourcePrice[i];
ar >> m_iRessourcePriceAtRoundStart[i];
ar >> m_iTaxes[i];
ar >> m_dMonopolBuy[i];
}
ar >> number;
TradeStruct ts;
m_TradeActions.RemoveAll();
for (int i = 0; i < number; i++)
{
ar >> ts.number;
ar >> ts.price;
ar >> ts.res;
ar >> ts.system;
m_TradeActions.Add(ts);
}
}
void AnimatorBar::FrameSerialize(CArchive& ar)
{
if(ar.IsLoading())
{
POSITION Pos = film_strip.GetFirstSelectedItemPosition();
int Count;
ar >> Count;
vector<int> ToSelect;
for(int a = 0; a < Count; a ++)
{
application->resources.images.push_back(CImageResource());
application->resources.images_changed = true;
CImageResource* image = &application->resources.images.back();
image->Serialize(ar);
image->m_FixedID = application->m_ImageFixID++;
POSITION pos = film_strip.GetFirstSelectedItemPosition();
if(pos)
{
if(m_pCurrentAnimation->supportsFrames())
{
int nItem = film_strip.GetNextSelectedItem(pos);
m_pCurrentAnimation->m_Images.insert( m_pCurrentAnimation->m_Images.begin() + nItem + a, image->m_FixedID);
ToSelect.push_back(nItem + a);
}
}
else
{
if(m_pCurrentAnimation->supportsFrames())
{
m_pCurrentAnimation->m_Images.push_back( image->m_FixedID);
ToSelect.push_back(m_pCurrentAnimation->m_Images.size());
}
}
int iFrameTime = 0;
ar >> iFrameTime;
if(m_pCurrentAnimation->supportsFrames())
{
m_pCurrentAnimation->m_FrameTimes.push_back(iFrameTime);
}
}
UpdateFilmStrip();
for(int c = 0 ; c < ToSelect.size(); c++)
film_strip.SetItemState (ToSelect[c], LVIS_SELECTED, LVIS_SELECTED);
}
