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

#include "StdAfx.h"
#include "AddTextureSettings.h"

CAddTextureSettings::CAddTextureSettings()
{
        m_pCurrentTexture = NULL;
        m_strResourceRawFilename = "";
        m_iTextureIndex = 0;
        m_TextureMask = 0;
        m_iTextureID = 1;
}

CAddTextureSettings::~CAddTextureSettings()
{

}       

bool CAddTextureSettings::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CAddResourceSettings::PropertyChanging(pvProperty, pvNewValue);

        if(CTextureManager::GetSingletonPtr() == NULL)
                return false;

        if(pvProperty == &m_strResourceName)    // strName has been changed, see if there are duplicates
        {
                CTexture *pTexture = CTextureManager::GetSingleton().GetResource(-1, -1, (*(CString *)pvNewValue), "");
                if(pTexture !=NULL)
                        return false;
                else
                {
                        m_strResourceName = *(CString *)pvNewValue;
                        m_pCurrentTexture->SetName(m_strResourceName);

                        for (int i=0; i<CTextureManager::GetSingleton().size(); i++)
                        {
                                CTexture *pTexture = (CTexture *)CTextureManager::GetSingleton().at(i);
                                if(pTexture == m_pCurrentTexture)
                                {
                                        m_iTextureIndex = i;
                                        m_TextureMask = RGB(pTexture->GetMask().R, pTexture->GetMask().G, pTexture->GetMask().B);
                                        m_strResourceRawFilename = pTexture->GetFilename();
                                        break;
                                }
                        }

                        m_bUpdateRequired = true;
                }
        }

        if(pvProperty == &m_strResourceRawFilename)
        {
                if(m_pCurrentTexture == NULL)
                        return false;

                CTexture *pDuplTexture = (CTexture *)CTextureManager::GetSingleton().begin();
                CTextureManager::GetSingleton().set_ptr(pDuplTexture);

                while(pDuplTexture !=NULL)
                {
                        if(pDuplTexture->GetTextureFilename() == (*(CString *)pvNewValue))
                                return false;

                        pDuplTexture = (CTexture *)CTextureManager::GetSingleton().next();
                }

                m_pCurrentTexture->Destroy();
                m_pCurrentTexture->LoadImage((*(CString *)pvNewValue));
                m_pCurrentTexture->Create();

                m_strResourceRawFilename = *(CString *)pvNewValue;

        }

        if(pvProperty == &m_strResourceXMLFilename)
        {
                CTexture *pNewTexture = NULL;
                if(m_pCurrentTexture !=NULL)
                {
                        m_pCurrentTexture->Destroy();

                        m_pCurrentTexture->LoadXML(NULL, (*(CString *)pvNewValue));
                        pNewTexture = m_pCurrentTexture;
                }
                else
                {
                        pNewTexture = CTextureManager::GetSingleton().LoadResource(NULL, (*(CString *)pvNewValue));
                        m_pCurrentTexture = pNewTexture;
                }

                m_strResourceXMLFilename = *(CString *)pvNewValue;
                m_strResourceRawFilename = pNewTexture->GetFilename();
                m_strResourceName = pNewTexture->GetName();
                m_TextureMask = RGB(pNewTexture->GetMask().R, pNewTexture->GetMask().G, pNewTexture->GetMask().B);

                m_bUpdateRequired = true;
                
        }

        if(pvProperty == &m_strResourcesDatabaseFilename)
        {
                int iRetValue = CTextureManager::GetSingleton().LoadXML(NULL, (*(CString *)pvNewValue));
                if(iRetValue > 0)
                        m_bUpdateRequired = true;

                return false;
        }

        if(pvProperty == &m_TextureMask)
        {
                if(m_pCurrentTexture !=NULL)
                {
                        m_TextureMask = *(COLORREF *)pvNewValue;
                        if((m_pCurrentTexture->GetMask().R != (float)GetRValue(m_TextureMask)) || (m_pCurrentTexture->GetMask().G != (float)GetGValue(m_TextureMask)) || (m_pCurrentTexture->GetMask().B != (float)GetBValue(m_TextureMask) ))
                        {
                                m_pCurrentTexture->Release();
                                m_pCurrentTexture->SetMask(tRGBA((float)GetRValue(m_TextureMask), (float)GetGValue(m_TextureMask), (float)GetBValue(m_TextureMask)));
                                m_pCurrentTexture->Create();
                        }
                }
        }

        if(pvProperty == &m_iTextureIndex)
        {
                int iTempTexIndex = *(int *)pvNewValue;
                CTexture *pTexture = CTextureManager::GetSingleton().GetResource(iTempTexIndex);
                if(iTempTexIndex == 1000)
                {
                        CString NewTexName;
                        NewTexName.Format("Texture #%d", m_iTextureID);

                        m_pCurrentTexture = CTextureManager::GetSingleton().AddResource(NewTexName);
                        m_pCurrentTexture->SetName(NewTexName);

                        m_strResourceName = NewTexName;
                        m_strResourceRawFilename = "";
                        m_TextureMask = 0;
                        m_iTextureIndex = CTextureManager::GetSingleton().size() - 1;
                        m_iTextureID++;
                        m_bUpdateRequired = true;
                        return false;
                }
                else
                {
                        m_strResourceName = pTexture->GetName();
                        m_strResourceRawFilename = pTexture->GetTextureFilename();
                        m_TextureMask = RGB(pTexture->GetMask().R, pTexture->GetMask().G, pTexture->GetMask().B);
                        m_iTextureIndex = iTempTexIndex;
                        m_pCurrentTexture = pTexture;
                }
        }

        /*if(pvProperty == &m_bDeleteResource)
        {
                delete CTextureManager::GetSingleton().remove(m_pCurrentTexture);
                m_pCurrentTexture = NULL;

                m_strResourceName = "";
                m_strResourceRawFilename = "";
                m_strResourceXMLFilename = "";
                m_bUpdateRequired = true;
                return false;
        }*/

        return bChangeOK;
}

void CAddTextureSettings::GetProperties( EPropList& PropList )
{
        CAddResourceSettings::GetProperties(PropList);

        if(CTextureManager::GetSingletonPtr() == NULL)
                return;

        PropList.AddTab("Texture(s)");
        PropList.AddPropSeparator(this, "Tools");

        EPropertyCombo *pTextureCombo = PropList.AddPropCombo(this, "Texture", &m_iTextureIndex);
        pTextureCombo->AddString("New Texture", 1000);
        for (int i=0; i<CTextureManager::GetSingleton().size(); i++)
        {
                CTexture *pTexture = (CTexture *)CTextureManager::GetSingleton().at(i);
                pTextureCombo->AddString(pTexture->GetName(), i);
        }

        PropList.AddPropFile(this, "XML File", &m_strResourceXMLFilename, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||")->SetComment("Texture XML File");
        PropList.AddPropFile(this, "XML Database", &m_strResourcesDatabaseFilename, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||")->SetComment("Textures Database XML File");

        PropList.AddPropSeparator(this, "Attributes");
        PropList.AddPropString(this, "strName", &m_strResourceName, true)->SetComment("Texture strName");
        PropList.AddPropColor(this, "Mask", &m_TextureMask, true)->SetComment("Texture' Mask Color");
        PropList.AddPropFile(this, "Image File", &m_strResourceRawFilename, "Image Files (*.jpg;*.bmp;*.png;*.tga)|*.jpg;*.bmp;*.png;*.tga|All Files (*.*)|*.*||")->SetComment("Image strFilename");
}

---