void Layer::SerializeTo(SerializerElement& element) const {
element.SetAttribute("name", GetName());
element.SetAttribute("visibility", GetVisibility());
SerializerElement& camerasElement = element.AddChild("cameras");
camerasElement.ConsiderAsArrayOf("camera");
for (std::size_t c = 0; c < GetCameraCount(); ++c) {
SerializerElement& cameraElement = camerasElement.AddChild("camera");
cameraElement.SetAttribute("defaultSize", GetCamera(c).UseDefaultSize());
cameraElement.SetAttribute("width", GetCamera(c).GetWidth());
cameraElement.SetAttribute("height", GetCamera(c).GetHeight());
cameraElement.SetAttribute("defaultViewport",
GetCamera(c).UseDefaultViewport());
cameraElement.SetAttribute("viewportLeft", GetCamera(c).GetViewportX1());
cameraElement.SetAttribute("viewportTop", GetCamera(c).GetViewportY1());
cameraElement.SetAttribute("viewportRight", GetCamera(c).GetViewportX2());
cameraElement.SetAttribute("viewportBottom", GetCamera(c).GetViewportY2());
}
SerializerElement& effectsElement = element.AddChild("effects");
effectsElement.ConsiderAsArrayOf("effect");
for (std::size_t i = 0; i < GetEffectsCount(); ++i) {
SerializerElement& effectElement = effectsElement.AddChild("effect");
GetEffect(i).SerializeTo(effectElement);
}
}
void RepeatEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("repeatExpression").SetValue(repeatNumberExpression.GetPlainString());
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void ForEachEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("object").SetValue(objectsToPick.GetPlainString());
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void WhileEvent::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("infiniteLoopWarning", infiniteLoopWarning);
gd::EventsListSerialization::SaveConditions(whileConditions, element.AddChild("whileConditions"));
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void LinkEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("include")
.SetAttribute("includeAll", IncludeAllEvents())
.SetAttribute("start", (int)GetIncludeStart())
.SetAttribute("end", (int)GetIncludeEnd());
element.AddChild("target").SetValue(GetTarget());
}
void ExternalLayout::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
instances.SerializeTo(element.AddChild("instances"));
#if !defined(GD_NO_WX_GUI)
editionSettings.SerializeTo(element.AddChild("editionSettings"));
element.SetAttribute("associatedLayout", associatedLayout);
#endif
}
void CommentEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("color")
.SetAttribute("r", r)
.SetAttribute("g", v)
.SetAttribute("b", b)
.SetAttribute("textR", textR)
.SetAttribute("textG", textG)
.SetAttribute("textB", textB);
element.AddChild("comment").SetValue(com1);
element.AddChild("comment2").SetValue(com2);
}
void GroupEvent::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
element.SetAttribute("source", source);
element.SetAttribute("creationTime", (int)creationTime);
element.SetAttribute("colorR", (int)colorR);
element.SetAttribute("colorG", (int)colorG);
element.SetAttribute("colorB", (int)colorB);
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
gd::SerializerElement & parametersElement = element.AddChild("parameters");
parametersElement.ConsiderAsArrayOf("parameter");
for ( std::size_t i = 0;i < parameters.size();++i)
parametersElement.AddChild("parameter").SetValue(parameters[i]);
}
void ExternalEvents::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
element.SetAttribute("associatedLayout", associatedScene);
element.SetAttribute("lastChangeTimeStamp", (int)lastChangeTimeStamp);
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void LinkEvent::SerializeTo(SerializerElement & element) const
{
SerializerElement & includeElement = element.AddChild("include")
.SetAttribute("includeConfig", static_cast<int>(GetIncludeConfig()));
if(GetIncludeConfig() == INCLUDE_EVENTS_GROUP)
{
includeElement.SetAttribute("eventsGroup", GetEventsGroupName());
}
else if(GetIncludeConfig() == INCLUDE_BY_INDEX)
{
includeElement.SetAttribute("start", static_cast<int>(GetIncludeStart()));
includeElement.SetAttribute("end", static_cast<int>(GetIncludeEnd()));
}
element.AddChild("target").SetValue(GetTarget());
}
void ClassWithObjects::SerializeObjectsTo(SerializerElement & element) const
{
element.ConsiderAsArrayOf("object");
for ( std::size_t j = 0;j < initialObjects.size();j++ )
{
initialObjects[j]->SerializeTo(element.AddChild("object"));
}
}
void ResourcesManager::SerializeTo(SerializerElement & element) const
{
SerializerElement & resourcesElement = element.AddChild("resources");
resourcesElement.ConsiderAsArrayOf("resource");
for (std::size_t i = 0;i<resources.size();++i)
{
if ( resources[i] == std::shared_ptr<Resource>() ) break;
SerializerElement & resourceElement = resourcesElement.AddChild("resource");
resourceElement.SetAttribute("kind", resources[i]->GetKind());
resourceElement.SetAttribute("name", resources[i]->GetName());
resources[i]->SerializeTo(resourceElement);
}
SerializerElement & resourcesFoldersElement = element.AddChild("resourceFolders");
resourcesFoldersElement.ConsiderAsArrayOf("folder");
for (std::size_t i = 0;i<folders.size();++i)
folders[i].SerializeTo(resourcesFoldersElement.AddChild("folder"));
}
void Object::SerializeTo(SerializerElement & element) const
{
element.SetAttribute( "name", GetName() );
element.SetAttribute( "type", GetType() );
objectVariables.SerializeTo(element.AddChild("variables"));
SerializerElement & behaviorsElement = element.AddChild("behaviors");
behaviorsElement.ConsiderAsArrayOf("behavior");
std::vector < gd::String > allBehaviors = GetAllBehaviorNames();
for (std::size_t i = 0;i<allBehaviors.size();++i)
{
SerializerElement & behaviorElement = behaviorsElement.AddChild("behavior");
behaviorElement.SetAttribute( "type", GetBehavior(allBehaviors[i]).GetTypeName() );
behaviorElement.SetAttribute( "name", GetBehavior(allBehaviors[i]).GetName() );
GetBehavior(allBehaviors[i]).SerializeTo(behaviorElement);
}
DoSerializeTo(element);
}
void ResourceFolder::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
SerializerElement & resourcesElement = element.AddChild("resources");
resourcesElement.ConsiderAsArrayOf("resource");
for (std::size_t i = 0;i<resources.size();++i)
{
if ( resources[i] == std::shared_ptr<Resource>() ) continue;
resourcesElement.AddChild("resource").SetAttribute("name", resources[i]->GetName());
}
}
void EventsListSerialization::SerializeEventsTo(const EventsList & list, SerializerElement & events)
{
events.ConsiderAsArrayOf("event");
for ( unsigned int j = 0;j < list.size();j++ )
{
const gd::BaseEvent & event = list.GetEvent(j);
SerializerElement & eventElem = events.AddChild("event");
eventElem.SetAttribute( "disabled", event.IsDisabled());
eventElem.SetAttribute( "folded", event.folded);
eventElem.AddChild("type").SetValue(event.GetType());
event.SerializeTo(eventElem);
}
}
void EventsFunctionsExtension::SerializeTo(SerializerElement& element) const {
element.SetAttribute("version", version);
element.SetAttribute("extensionNamespace", extensionNamespace);
element.SetAttribute("description", description);
element.SetAttribute("name", name);
element.SetAttribute("fullName", fullName);
gd::SerializerElement& eventsFunctionsElement =
element.AddChild("eventsFunctions");
eventsFunctionsElement.ConsiderAsArrayOf("eventsFunction");
for (const auto& eventsFunction : eventsFunctions) {
eventsFunction->SerializeTo(
eventsFunctionsElement.AddChild("eventsFunction"));
}
}
void Variable::SerializeTo(SerializerElement & element) const
{
if (!isStructure)
element.SetAttribute("value", GetString());
else
{
SerializerElement & childrenElement = element.AddChild("children");
childrenElement.ConsiderAsArrayOf("variable");
for (std::map<std::string, gd::Variable>::iterator i = children.begin(); i != children.end(); ++i)
{
SerializerElement & variableElement = childrenElement.AddChild("variable");
variableElement.SetAttribute("name", i->first);
i->second.SerializeTo(variableElement);
}
}
}
void ObjectGroup::SerializeTo(const std::vector < gd::ObjectGroup > & list, SerializerElement & element)
{
element.ConsiderAsArrayOf("group");
for ( unsigned int j = 0;j < list.size();j++ )
{
SerializerElement & groupElement = element.AddChild("group");
groupElement.SetAttribute("name", list[j].GetName());
SerializerElement & objectsElement = groupElement.AddChild("objects");
objectsElement.ConsiderAsArrayOf("object");
vector < string > allObjects = list[j].GetAllObjectsNames();
for ( unsigned int k = 0;k < allObjects.size();k++ )
objectsElement.AddChild("object").SetAttribute( "name", allObjects[k] );
}
}
void Layout::SerializeTo(SerializerElement & element) const
{
element.SetAttribute( "name", GetName());
element.SetAttribute( "mangledName", GetMangledName());
element.SetAttribute( "r", (int)GetBackgroundColorRed() );
element.SetAttribute( "v", (int)GetBackgroundColorGreen() );
element.SetAttribute( "b", (int)GetBackgroundColorBlue() );
element.SetAttribute( "title", GetWindowDefaultTitle());
element.SetAttribute( "oglFOV", oglFOV );
element.SetAttribute( "oglZNear", oglZNear );
element.SetAttribute( "oglZFar", oglZFar );
element.SetAttribute( "standardSortMethod", standardSortMethod);
element.SetAttribute( "stopSoundsOnStartup", stopSoundsOnStartup);
element.SetAttribute( "disableInputWhenNotFocused", disableInputWhenNotFocused);
#if defined(GD_IDE_ONLY) && !defined(GD_NO_WX_GUI)
GetAssociatedLayoutEditorCanvasOptions().SerializeTo(element.AddChild("uiSettings"));
#endif
ObjectGroup::SerializeTo(GetObjectGroups(), element.AddChild("objectsGroups"));
GetVariables().SerializeTo(element.AddChild("variables"));
GetInitialInstances().SerializeTo(element.AddChild("instances"));
SerializeObjectsTo(element.AddChild("objects"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
SerializerElement & layersElement = element.AddChild("layers");
layersElement.ConsiderAsArrayOf("layer");
for ( std::size_t j = 0;j < GetLayersCount();++j )
GetLayer(j).SerializeTo(layersElement.AddChild("layer"));
SerializerElement & behaviorDatasElement = element.AddChild("behaviorsSharedData");
behaviorDatasElement.ConsiderAsArrayOf("behaviorSharedData");
for (std::map<gd::String, std::shared_ptr<gd::BehaviorsSharedData> >::const_iterator it = behaviorsInitialSharedDatas.begin();
it != behaviorsInitialSharedDatas.end();++it)
{
SerializerElement & dataElement = behaviorDatasElement.AddChild("behaviorSharedData");
dataElement.SetAttribute("type", it->second->GetTypeName());
dataElement.SetAttribute("name", it->second->GetName());
it->second->SerializeTo(dataElement);
}
}
void gd::EventsListSerialization::SaveConditions(const vector < gd::Instruction > & list, SerializerElement & conditions)
{
conditions.ConsiderAsArrayOf("condition");
for ( unsigned int k = 0;k < list.size();k++ )
{
SerializerElement & condition = conditions.AddChild("condition");
condition.AddChild("type")
.SetAttribute("value", list[k].GetType())
.SetAttribute("inverted", list[k].IsInverted());
//Parameters
SerializerElement & parameters = condition.AddChild("parameters");
parameters.ConsiderAsArrayOf("parameter");
for ( unsigned int l = 0;l < list[k].GetParameters().size();l++ )
parameters.AddChild("parameter").SetValue(list[k].GetParameter(l).GetPlainString());
//Sub instructions
SerializerElement & subConditions = condition.AddChild("subConditions");
SaveConditions(list[k].GetSubInstructions(), subConditions);
}
}
void gd::EventsListSerialization::SaveActions(const gd::InstructionsList & list, SerializerElement & actions)
{
actions.ConsiderAsArrayOf("action");
for ( std::size_t k = 0;k < list.size();k++ )
{
SerializerElement & action = actions.AddChild("action");
action.AddChild("type")
.SetAttribute("value", list[k].GetType())
.SetAttribute("inverted", list[k].IsInverted());
//Parameters
SerializerElement & parameters = action.AddChild("parameters");
parameters.ConsiderAsArrayOf("parameter");
for ( std::size_t l = 0;l < list[k].GetParameters().size();l++ )
parameters.AddChild("parameter").SetValue(list[k].GetParameter(l).GetPlainString());
//Sub instructions
SerializerElement & subActions = action.AddChild("subActions");
SaveActions(list[k].GetSubInstructions(), subActions);
}
}
void StandardEvent::SerializeTo(SerializerElement & element) const
{
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
