//----------------------------------------------------------------------------------
bool PropertyUndo::apply()
{
CBaseEditor *object = OgitorsRoot::getSingletonPtr()->FindObject(mObjectID);
if(!object)
return false;
if(mValue.propType == PROP_UNSIGNED_LONG && mPropertyName == "parent")
{
CBaseEditor *parent = OgitorsRoot::getSingletonPtr()->FindObject(Ogre::any_cast<unsigned long>(mValue.val));
if(!parent)
return false;
mValue.val = Ogre::Any((unsigned long)parent);
}
OgitorsPropertyValueMap map;
map.insert(OgitorsPropertyValueMap::value_type(mPropertyName, mValue));
if(mSetType == PROPSET_OBJECT)
{
object->getProperties()->setValueMap(map);
return true;
}
else if(mSetType == PROPSET_CUSTOM)
{
object->getCustomProperties()->setValueMap(map);
return true;
}
return false;
}
//----------------------------------------------------------------------------------
CBaseEditor *OgitorsClipboardManager::paste(CBaseEditor *parent, int index)
{
ObjectCopyData *data = 0;
assert(index < (int)mBuffer.size());
if(index == -1)
data = mBuffer[mBuffer.size() - 1];
else
data = mBuffer[index];
CBaseEditor* object = OgitorsRoot::getSingletonPtr()->FindObject(data->mObjectName);
OgitorsPropertyValueMap properties = data->mProperties;
if(object)
{
Ogre::String newname = data->mObjectName + "Copy";
newname += OgitorsRoot::getSingletonPtr()->CreateUniqueID(newname, "", 0);
properties["name"].val = Ogre::Any(newname);
}
object = OgitorsRoot::getSingletonPtr()->CreateEditorObject(parent, data->mObjectTypeName, properties, true, false);
if(!object)
return 0;
object->getCustomProperties()->initFromSet(data->mCustomProperties);
object->load();
OgitorsRoot::getSingletonPtr()->GetSelection()->setSelection(object);
return object;
}
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
CustomSetRebuiltUndo::CustomSetRebuiltUndo(OgitorsCustomPropertySet *set)
{
assert(set->getOwnerData().mOwnerType == PROPSETOWNER_EDITOR);
CBaseEditor *object = static_cast<CBaseEditor*>(set->getOwnerData().mOwnerPtr);
mObjectID = object->getObjectID();
mCustomProperties = OGRE_NEW OgitorsCustomPropertySet();
object->getCustomProperties()->cloneSet(*mCustomProperties);
mDescription = object->getName() + " Custom Property Set Change";
}
//----------------------------------------------------------------------------------
bool CustomSetRebuiltUndo::apply()
{
CBaseEditor *object = OgitorsRoot::getSingletonPtr()->FindObject(mObjectID);
if(object)
{
object->getCustomProperties()->initFromSet(*mCustomProperties);
return true;
}
return false;
}
//----------------------------------------------------------------------------------
bool ObjectDeletionUndo::apply()
{
CBaseEditor *object;
CBaseEditor *parent = OgitorsRoot::getSingletonPtr()->FindObject(mParentObjectID);
object = OgitorsRoot::getSingletonPtr()->CreateEditorObject(parent, mTypeName, mObjectProperties, true, true);
if(object)
{
object->getCustomProperties()->initFromSet(*mCustomProperties);
return true;
}
return false;
}
int COFSSceneSerializer::Import(Ogre::String importfile)
{
OgitorsRoot *ogRoot = OgitorsRoot::getSingletonPtr();
OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr();
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
if(importfile == "")
{
UTFStringVector extlist;
extlist.push_back(OTR("Ogitor File System File"));
extlist.push_back("*.ofs");
extlist.push_back(OTR("Ogitor Scene File"));
extlist.push_back("*" + Globals::OGSCENE_FORMAT_EXTENSION);
importfile = mSystem->GetSetting("system", "oldOpenPath", "");
importfile = mSystem->DisplayOpenDialog(OTR("Open"), extlist, importfile);
if(importfile == "")
return SCF_CANCEL;
mSystem->SetSetting("system", "oldOpenPath", importfile);
}
importfile = OgitorsUtils::QualifyPath(importfile);
Ogre::String filePath = OgitorsUtils::ExtractFilePath(importfile);
Ogre::String fileName = OgitorsUtils::ExtractFileName(importfile);
bool testpassed = false;
try
{
std::ofstream test((filePath + "test.dat").c_str());
if(test.is_open())
testpassed = true;
test.close();
mSystem->DeleteFile(filePath + "test.dat");
}
catch(...)
{
testpassed = false;
}
if(!testpassed)
{
mSystem->DisplayMessageDialog("The path is read-only. Ogitor can not work with read-only project paths!", DLGTYPE_OK);
return SCF_CANCEL;
}
Ogre::UTFString loadmsg = "";
int typepos = importfile.find_last_of(".");
if(typepos != -1 && (importfile.substr(typepos, 4) != ".ofs"))
importfile = filePath;
OFS::OfsResult oRet;
if((oRet = mFile.mount(importfile.c_str(), OFS::OFS_MOUNT_OPEN | OFS::OFS_MOUNT_RECOVER)) != OFS::OFS_OK)
{
if(oRet == OFS::OFS_PREVIOUS_VERSION)
{
mSystem->DisplayMessageDialog("The OFS file is a previous version, please use qtOFS to upgrade it to new file version.", DLGTYPE_OK);
}
loadmsg = mSystem->Translate("Please load a Scene File...");
mSystem->UpdateLoadProgress(-1, loadmsg);
return SCF_ERRPARSE;
}
OFS::FileSystemStats fsStats;
mFile->getFileSystemStats(fsStats);
PROJECTOPTIONS *pOpt = ogRoot->GetProjectOptions();
pOpt->CreatedIn = "";
pOpt->ProjectDir = filePath;
typepos = fileName.find_last_of(".");
if(typepos != -1)
fileName.erase(typepos, fileName.length() - typepos);
pOpt->ProjectName = fileName;
fileName += Globals::OGSCENE_FORMAT_EXTENSION;
OFS::ofs64 file_size = 0;
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
{
// OGSCENE file name needs to match OFS container file name. If the later was renamed, we
// need to automatically adapt the OGSCENE file name now.
OFS::FileList files = mFile->listFiles("/", OFS::OFS_FILE);
unsigned int ogsceneFileExtensionLength = strlen(Globals::OGSCENE_FORMAT_EXTENSION.c_str());
for(OFS::FileList::iterator iter = files.begin(); iter != files.end(); iter++)
{
// Filter out too short names
if(iter->name.size() <= ogsceneFileExtensionLength)
continue;
if(stricmp(iter->name.c_str() + (iter->name.size() - (ogsceneFileExtensionLength)), Globals::OGSCENE_FORMAT_EXTENSION.c_str()) == 0)
{
mFile->renameFile(iter->name.c_str(), fileName.c_str());
break;
}
}
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
return SCF_ERRFILE;
}
char *file_data = new char[(unsigned int)file_size + 1];
OFS::OFSHANDLE projHandle;
if(mFile->openFile(projHandle, fileName.c_str(), OFS::OFS_READ) != OFS::OFS_OK)
{
delete [] file_data;
return SCF_ERRFILE;
}
mFile->read(projHandle, file_data, file_size);
mFile->closeFile(projHandle);
TiXmlDocument docImport;
if(!docImport.LoadFromMemory(file_data, file_size))
{
delete [] file_data;
return SCF_ERRFILE;
}
delete [] file_data;
loadmsg = mSystem->Translate("Parsing Scene File");
mSystem->UpdateLoadProgress(1, loadmsg);
TiXmlNode* ogitorSceneNode = 0;
TiXmlNode* projectNode;
TiXmlElement* element = 0;
bool upgradeExecuted = false;
ogitorSceneNode = docImport.FirstChild("OGITORSCENE");
if(!ogitorSceneNode)
return SCF_ERRPARSE;
element = ogitorSceneNode->ToElement();
// Old OGSCENE version check and attempt to fix/update
int version = Ogre::StringConverter::parseInt(ValidAttr(element->Attribute("version"), "0"));
if(Ogre::StringConverter::toString(version) < Globals::OGSCENE_FORMAT_VERSION)
{
mSystem->DisplayMessageDialog(mSystem->Translate("Old OGSCENE file version detected. Ogitor will now attempt to upgrade the format and will also create a backup version of your OFS file."), DLGTYPE_OK);
loadmsg = mSystem->Translate("Upgrading OGSCENE file.");
mSystem->UpdateLoadProgress(10, loadmsg);
if(version == 0)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files contains no version number set and therefore cannot be loaded."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
else if(version == 1)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files with version 1 cannot be upgraded automatically. Please contact the Ogitor team for further details."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
if(version > 1)
{
if((mFile->getFileSystemType() == OFS::OFS_PACKED) && (!mSystem->CopyFile(importfile, importfile + ".backup")))
mSystem->DisplayMessageDialog(mSystem->Translate("Error while trying to create backup file."), DLGTYPE_OK);
}
switch(version)
{
case 2:
_upgradeOgsceneFileFrom2To3(ogitorSceneNode);
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
case 3:
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
}
upgradeExecuted = true;
}
projectNode = ogitorSceneNode->FirstChild("PROJECT");
if(projectNode)
{
loadmsg = mSystem->Translate("Parsing project options");
mSystem->UpdateLoadProgress(5, loadmsg);
ogRoot->LoadProjectOptions(projectNode->ToElement());
ogRoot->PrepareProjectResources();
}
element = ogitorSceneNode->FirstChildElement();
loadmsg = mSystem->Translate("Creating scene objects");
mSystem->UpdateLoadProgress(10, loadmsg);
unsigned int obj_count = 0;
Ogre::String objecttype;
OgitorsPropertyValueMap params;
OgitorsPropertyValue tmpPropVal;
Ogre::String objAttValue;
Ogre::String elementName;
TiXmlElement* properties = 0;
Ogre::String attID;
Ogre::String attValue;
CBaseEditor* result = 0;
TiXmlElement* customprop = 0;
Ogre::StringVector invalidEditorTypes;
do
{
// Make sure its NON-ZERO
if(pOpt->ObjectCount)
{
++obj_count;
mSystem->UpdateLoadProgress(10 + ((obj_count * 70) / pOpt->ObjectCount), loadmsg);
}
params.clear();
objAttValue = ValidAttr(element->Attribute("object_id"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_UNSIGNED_INT;
tmpPropVal.val = Ogre::Any(Ogre::StringConverter::parseUnsignedInt(objAttValue));
params.insert(OgitorsPropertyValueMap::value_type("object_id", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("parentnode"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("parentnode", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("name"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("name", tmpPropVal));
}
else
continue;
objAttValue = ValidAttr(element->Attribute("typename"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("typename", tmpPropVal));
}
else
continue;
properties = element->FirstChildElement();
if(properties)
{
do
{
elementName = properties->Value();
if(elementName != "PROPERTY")
continue;
attID = ValidAttr(properties->Attribute("id"), "");
int attType = Ogre::StringConverter::parseInt(ValidAttr(properties->Attribute("type"), ""));
attValue = ValidAttr(properties->Attribute("value"), "");
params.insert(OgitorsPropertyValueMap::value_type(attID, OgitorsPropertyValue::createFromString((OgitorsPropertyType)attType, attValue)));
} while(properties = properties->NextSiblingElement());
}
objecttype = Ogre::any_cast<Ogre::String>(params["typename"].val);
result = ogRoot->CreateEditorObject(0, objecttype, params, false, false);
if(result)
{
customprop = element->FirstChildElement("CUSTOMPROPERTIES");
if(customprop)
{
OgitorsUtils::ReadCustomPropertySet(customprop, result->getCustomProperties());
}
}
else
invalidEditorTypes.push_back(objecttype);
} while(element = element->NextSiblingElement());
// Print out invalid/unsupported editor types (= types where no factory could be found)
if(invalidEditorTypes.size() > 0)
{
std::sort(invalidEditorTypes.begin(), invalidEditorTypes.end());
invalidEditorTypes.erase(std::unique(invalidEditorTypes.begin(), invalidEditorTypes.end()), invalidEditorTypes.end());
Ogre::String invalidTypesResultString;
for(unsigned int i = 0; i < invalidEditorTypes.size(); i++)
{
invalidTypesResultString += invalidEditorTypes.at(i) + "\n";
}
mSystem->DisplayMessageDialog(mSystem->Translate("Could not create objects of types:\n" + invalidTypesResultString), DLGTYPE_OK);
}
//// Save directly after upgrade
//if(upgradeExecuted)
// Export(false, importfile);
ogRoot->AfterLoadScene();
return SCF_OK;
}
//----------------------------------------------------------------------------------
CBaseEditor *OgitorsClipboardManager::instantiateTemplate(const Ogre::String& templatename)
{
CBaseEditor *retObject = OgitorsRoot::getSingletonPtr()->GetSelection();
CBaseEditor *item = 0;
ObjectTemplateMap::const_iterator it;
it = mGeneralTemplates.find(templatename);
if(it == mGeneralTemplates.end())
{
it = mProjectTemplates.find(templatename);
if(it == mProjectTemplates.end())
return 0;
}
ObjectTemplate objTemplate = it->second;
OgitorsPropertyValueMap::iterator pit;
NameObjectPairList list;
NameObjectPairList objlist;
std::vector<CBaseEditor*> objlist2;
NameObjectPairList::iterator nit;
Ogre::String parentname;
int numParentObjects = 0;
for(unsigned int i = 0;i < objTemplate.size();i++)
{
OgitorsPropertyValueMap objMap = objTemplate[i].mObjectProperties;
if((pit = objMap.find("parentnode")) != objMap.end())
{
parentname = Ogre::any_cast<Ogre::String>(pit->second.val);
if((nit = list.find(parentname)) != list.end())
{
pit->second.val = Ogre::Any(nit->second->getName());
}
else
{
objMap.erase(pit);
++numParentObjects;
}
}
else
++numParentObjects;
parentname = Ogre::any_cast<Ogre::String>(objMap["name"].val);
objMap["name"].val = Ogre::Any(parentname + OgitorsRoot::getSingletonPtr()->CreateUniqueID(parentname,"",0));
item = OgitorsRoot::getSingletonPtr()->CreateEditorObject(0, objTemplate[i].mTypeName, objMap, true, false);
if(item)
{
item->load();
item->getCustomProperties()->initFromSet(*(objTemplate[i].mCustomProperties));
list.insert(NameObjectPairList::value_type(parentname, item));
objlist.insert(NameObjectPairList::value_type(item->getName(), item));
objlist2.push_back(item);
}
}
Ogre::Vector3 pos(999999, 999999, 999999);
if(numParentObjects == 0)
return 0;
else if(numParentObjects == 1)
{
retObject = objlist2[0];
OgitorsRoot::getSingletonPtr()->GetSelection()->setSelection(retObject);
}
else
static_cast<CMultiSelEditor*>(retObject)->setSelection(objlist);
if(retObject->getProperties()->hasProperty("position"))
retObject->getProperties()->setValue("position", pos);
return retObject;
}
//----------------------------------------------------------------------------------
bool OgitorsClipboardManager::copyToTemplateMulti(CMultiSelEditor *object, const Ogre::String& templatename, bool isGeneralScope)
{
if(templatename.empty())
return false;
NameObjectPairList list = object->getSelection();
NameObjectPairList::iterator oit = list.begin();
if(oit == list.end())
return false;
Ogre::String filename;
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
if(isGeneralScope)
{
filename = OgitorsSystem::getSingletonPtr()->getProjectsDirectory() + "/Templates";
filename = OgitorsUtils::QualifyPath(filename) + "/";
OgitorsSystem::getSingletonPtr()->MakeDirectory(filename);
}
else
{
filename = "/Templates";
mFile->createDirectory(filename.c_str());
}
filename += "/" + templatename + ".otl";
std::stringstream outfile;
outfile << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
outfile << "<TEMPLATES>\n";
outfile << " <OBJECTTEMPLATE name=\"";
outfile << templatename.c_str();
outfile << "\">\n";
ObjectTemplateMap::iterator rit;
if(isGeneralScope)
rit = mGeneralTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate())).first;
else
rit = mProjectTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate())).first;
std::vector<CBaseEditor*> objList;
while(oit != list.end())
{
CBaseEditor *item = oit->second;
if(!item->supports(CAN_ACCEPTCOPY))
{
list.erase(oit);
oit = list.begin();
}
else
{
CBaseEditor *itemParent = item->getParent();
Ogre::String parentName = "";
if(itemParent)
parentName = itemParent->getName();
if(list.find(parentName) == list.end())
{
list.erase(oit);
oit = list.begin();
objList.push_back(item);
}
else
oit++;
}
}
for(unsigned int objn = 0;objn < objList.size();objn++)
{
CBaseEditor *item = objList[objn];
outfile << OgitorsUtils::GetObjectSaveStringV2(item, 2, false, true).c_str();
rit->second.push_back(ObjectTemplateData());
int itempos = rit->second.size() - 1;
item->getPropertyMap(rit->second[itempos].mObjectProperties);
rit->second[itempos].mObjectProperties.erase(rit->second[itempos].mObjectProperties.find("object_id"));
OgitorsPropertyValue parentnodevalue;
parentnodevalue.propType = PROP_STRING;
parentnodevalue.val = Ogre::Any(item->getParent()->getName());
rit->second[itempos].mObjectProperties.insert(OgitorsPropertyValueMap::value_type("parentnode", parentnodevalue));
OgitorsCustomPropertySet *tmpset = OGRE_NEW OgitorsCustomPropertySet();
item->getCustomProperties()->cloneSet(*tmpset);
rit->second[itempos].mCustomProperties = tmpset;
rit->second[itempos].mTypeName = item->getTypeName();
}
outfile << " </OBJECTTEMPLATE>\n";
outfile << "</TEMPLATES>\n";
if(isGeneralScope)
{
std::ofstream out_general(filename.c_str());
out_general << outfile.str();
out_general.close();
}
else
{
OgitorsUtils::SaveStreamOfs(outfile, filename);
}
return true;
}
//----------------------------------------------------------------------------------
bool OgitorsClipboardManager::copyToTemplateWithChildren(CBaseEditor *object, const Ogre::String& templatename, bool isGeneralScope)
{
if(templatename.empty())
return false;
Ogre::String filename;
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
if(isGeneralScope)
{
filename = OgitorsSystem::getSingletonPtr()->getProjectsDirectory() + "/Templates";
filename = OgitorsUtils::QualifyPath(filename);
OgitorsSystem::getSingletonPtr()->MakeDirectory(filename);
}
else
{
filename = "/Templates";
mFile->createDirectory(filename.c_str());
}
filename += "/" + templatename + ".otl";
std::stringstream outfile;
outfile << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
outfile << "<TEMPLATES>\n";
outfile << " <OBJECTTEMPLATE name=\"";
outfile << templatename.c_str();
outfile << "\">\n";
Ogre::StringVector list;
object->getNameList(list);
outfile << OgitorsUtils::GetObjectSaveStringV2(object, 4, false, false).c_str();
ObjectTemplateMap::iterator rit;
if(isGeneralScope)
rit = mGeneralTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate())).first;
else
rit = mProjectTemplates.insert(ObjectTemplateMap::value_type(templatename, ObjectTemplate())).first;
rit->second.push_back(ObjectTemplateData());
object->getPropertyMap(rit->second[0].mObjectProperties);
rit->second[0].mObjectProperties.erase(rit->second[0].mObjectProperties.find("object_id"));
OgitorsCustomPropertySet *tmpset = OGRE_NEW OgitorsCustomPropertySet();
object->getCustomProperties()->cloneSet(*tmpset);
rit->second[0].mCustomProperties = tmpset;
rit->second[0].mTypeName = object->getTypeName();
for(unsigned int i = 1;i < list.size();i++)
{
CBaseEditor *item = OgitorsRoot::getSingletonPtr()->FindObject(list[i]);
if(item != 0)
{
outfile << OgitorsUtils::GetObjectSaveStringV2(item, 4, false, true).c_str();
rit->second.push_back(ObjectTemplateData());
int itempos = rit->second.size() - 1;
item->getPropertyMap(rit->second[itempos].mObjectProperties);
rit->second[itempos].mObjectProperties.erase(rit->second[itempos].mObjectProperties.find("object_id"));
OgitorsPropertyValue parentnodevalue;
parentnodevalue.propType = PROP_STRING;
parentnodevalue.val = Ogre::Any(item->getParent()->getName());
rit->second[itempos].mObjectProperties.insert(OgitorsPropertyValueMap::value_type("parentnode", parentnodevalue));
OgitorsCustomPropertySet *tmpset = OGRE_NEW OgitorsCustomPropertySet();
item->getCustomProperties()->cloneSet(*tmpset);
rit->second[itempos].mCustomProperties = tmpset;
rit->second[itempos].mTypeName = item->getTypeName();
}
}
outfile << " </OBJECTTEMPLATE>\n";
outfile << "</TEMPLATES>\n";
if(isGeneralScope)
{
std::ofstream out_general(filename.c_str());
out_general << outfile.str();
out_general.close();
}
else
{
OgitorsUtils::SaveStreamOfs(outfile, filename);
}
return true;
}