D:/Programming/GUI Editor (Source)/AnimationManager.cpp

#include "stdafx.h"
#include "AnimationManager.h"

CAnimationManager::CAnimationManager()
{
        SetEntityType(Entity_AnimationManager);
        CGlobalLogger::GetSingleton().Write("Animation Manager - Instantiated\n");
}

CAnimationManager::~CAnimationManager()
{
        Destroy();
        CGlobalLogger::GetSingleton().Write("Animation Manager - Destroyed\n");
}

int CAnimationManager::LoadXML(TiXmlNode *pDataNode, CString strFilename)
{
        TiXmlElement* pXMLElement = NULL;
        const char *pcValue = NULL;

        int iRetValue = CResourceManager::LoadXML(pDataNode, strFilename);      // LoadXML the data of derivative
        if(iRetValue !=1)
                return iRetValue;

        pXMLElement = m_pXMLElement;

        if(stricmp(pXMLElement->pcValue(), "Animation") == 0)
        {
                CXMLResource *AddedResource = LoadResource(pXMLElement, strFilename);
                if(AddedResource !=NULL)
                {
                        CGlobalLogger::GetSingleton().Write("Animation (Name: %s, ID: %d) has been added successfully.\n", AddedResource->GetName().GetBuffer(), AddedResource->GetID()); 
                        return 1;
                }
                else
                        return 0;
        }
        // LoadXML Animations
        UINT AnimationLoadedCount = 0;
        TiXmlNode *pIterXMLNode = pXMLElement->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "Animation") == 0)  // We have a Animation
                {
                        CXMLResource *AddedResource = LoadResource(pIterXMLNode, "");
                        if(AddedResource !=NULL)
                        {
                                CGlobalLogger::GetSingleton().Write("Animation (Name: %s, ID: %d) has been added successfully.\n", AddedResource->GetName().GetBuffer(), AddedResource->GetID()); 
                                AnimationLoadedCount++;
                        }
                }

                pIterXMLNode = pXMLElement->IterateChildren(pIterXMLNode);
        }

        return AnimationLoadedCount;
}

int CAnimationManager::SaveXML(TiXmlNode *pDataNode, CString strFilename)
{
        // Nowhere to save!                     Nothing to save!
        if(pDataNode == NULL && strFilename == "")
                return -1;

        char Buf[128] = "";
        TiXmlElement *pSaveXMLElement = NULL;

        if(pDataNode != NULL)
                pSaveXMLElement = pDataNode->ToElement();
        else
                pSaveXMLElement = new TiXmlElement("AnimationDatabase");

        CAnimation *pAnimation = (CAnimation *)begin();
        set_ptr(pAnimation);

        while(pAnimation !=NULL)
        {
                TiXmlElement AnimationXMLElement("Animation");
                if(pAnimation->SaveXML(&AnimationXMLElement, ""))
                        pSaveXMLElement->InsertEndChild(AnimationXMLElement);

                pAnimation = (CAnimation *)next();
        }

        if(pDataNode == NULL && strFilename !="")
        {
                TiXmlDocument SaveDoc;
                SaveDoc.InsertEndChild(*pSaveXMLElement);
                int iRetValue = SaveDoc.SaveFile(strFilename);
                SAFEDEL(pSaveXMLElement)

                return iRetValue;
        }

        return 1;
}

CAnimation *CAnimationManager::AddResource(CString strName, UINT uiID, eEntityType ResourceType)
{
        switch(ResourceType)
        {
                case Entity_Default:
                case Entity_Animation:
                case Entity_FrameAnimation:
                case Entity_TextureFrameAnimation:
                        CTextureFrameAnimation *pNewAnimation = new CTextureFrameAnimation;
                        
                        pNewAnimation->SetID(uiID);
                        pNewAnimation->SetName(strName);

                        push_back(pNewAnimation);

                        return pNewAnimation;
                break;
        }

        return NULL;
}

CAnimation *CAnimationManager::LoadResource(TiXmlNode *pDataNode, CString strFilename, UINT uiID, CString strName)
{
        if(pDataNode != NULL)
        {
                const char *pcValue = NULL;
                TiXmlElement *pXMLElement = pDataNode->ToElement();

                pcValue = pXMLElement->Attribute("AnimByID");
                if(pcValue !=NULL)
                {
                        CAnimation *ExistingAnimation = GetResource(-1, atoi(pcValue), "");
                        if(ExistingAnimation !=NULL)
                                return ExistingAnimation;
                        else
                                return NULL;
                }

                pcValue = pXMLElement->Attribute("AnimByName");
                if(pcValue !=NULL)
                {
                        CAnimation *ExistingAnimation = GetResource(-1, -1, pcValue);
                        if(ExistingAnimation !=NULL)
                                return ExistingAnimation;
                        else
                                return NULL;
                }
        }

        if(stricmp(pDataNode->pcValue(), "Animation") == 0)
        {
                CAnimation *NewAnimation = NULL;

                if(stricmp(pDataNode->ToElement()->Attribute("Type"), "Animation") == 0)
                        NewAnimation = new CAnimation;
                else if(stricmp(pDataNode->ToElement()->Attribute("Type"), "Rect") == 0)
                        NewAnimation = new CFrameAnimation<tRect>;
                else if(stricmp(pDataNode->ToElement()->Attribute("Type"), "Texture Frame") == 0)
                        NewAnimation = new CTextureFrameAnimation;

                if(NewAnimation->LoadXML(pDataNode, strFilename))
                {
                        if(NewAnimation->GetID() == 0)
                                NewAnimation->SetID(uiID);

                        if(NewAnimation->GetName() == "")
                                NewAnimation->SetName(strName);

                        if(NewAnimation->GetName() !="")
                        {
                                if(GetResource(-1, -1, NewAnimation->GetName()) == NULL)
                                {
                                        push_back(NewAnimation);
                                        return NewAnimation;
                                }
                                else
                                {
                                        SAFEDEL(NewAnimation)
                                        return NULL;
                                }
                        }
                        else
                        {
                                push_back(NewAnimation);
                                return NewAnimation;
                        }
                }
                else
                        SAFEDEL(NewAnimation)
        }

        return NULL;
}

CAnimation *CAnimationManager::GetResource(int uiIndex, int uiID, CString strName, CString strFilename)
{
        if(uiID !=-1 && uiIndex == -1 && strName == "" && strFilename == "")    // get by uiID
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(ResourcePtr->GetID() == uiID)
                                return (CAnimation *)ResourcePtr;

                        ResourcePtr = next();
                }
        }
        else if(strName !="" && uiIndex == -1 && uiID == -1 && strFilename == "")       // get by name
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(stricmp(ResourcePtr->GetName().GetBuffer(), strName.GetBuffer()) == 0)
                                return (CAnimation *)ResourcePtr;

                        ResourcePtr = next();
                }
        }
        else if(uiIndex !=-1 && uiID == -1 && strName == "" && strFilename == "")       // get by index
        {
                if(uiIndex >=0 && uiIndex < size())
                        return (CAnimation *)at(uiIndex);
        }
        else if(strFilename !="" && uiID == -1 && strName == "" && uiIndex == -1)
        {
                CXMLResource *ResourcePtr = begin();
                set_ptr(ResourcePtr);

                while(ResourcePtr !=NULL)
                {
                        if(ResourcePtr->GetFilename() == strFilename)
                                return (CAnimation *)ResourcePtr;

                        ResourcePtr = next();
                }
        }
        return NULL;
}

int CAnimationManager::RemoveResource(CAnimation *Animation)
{

        return 1;
}

void CAnimationManager::Destroy()
{
        CResourceManager::Destroy();
}

bool CAnimationManager::IsOfType(eEntityType eType)
{
        if(eType == Entity_AnimationManager)
                return true;

        return CResourceManager::IsOfType(eType);
}

---