← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mygui/vivid

« back to all changes in this revision

Viewing changes to Tools/ImageEditor/ImageExportSerializer.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Howard, Bret Curtis, Scott Howard
  • Date: 2014-09-18 17:57:48 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20140918175748-dd8va78mvpw1jbes
Tags: 3.2.1-1
[ Bret Curtis ]
* Updated license for majority of files from LGPL to Expat (MIT)

[ Scott Howard ]
* New upstream release
* Updated patch to add build option for system GLEW libraries
* All patches accepted upstream except shared_libraries.patch
* Bumped SONAME due to dropped symbols, updated *.symbols and package
  names
* Updated license of debian/* to Expat with permission of all authors
* Don't install Doxygen autogenerated md5 and map files (thanks
  lintian)

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tools/ImageEditor/ImageExportSerializer.cpp
 
1
/*!
 
2
        @file
 
3
        @author         Albert Semenov
 
4
        @date           07/2012
 
5
*/
 
6
 
 
7
#include "Precompiled.h"
 
8
#include "ImageExportSerializer.h"
 
9
#include "FactoryManager.h"
 
10
#include "DataManager.h"
 
11
#include "DataTypeManager.h"
 
12
#include "PropertyUtility.h"
 
13
 
 
14
namespace tools
 
15
{
 
16
 
 
17
        FACTORY_ITEM_ATTRIBUTE(ImageExportSerializer)
 
18
 
 
19
        ImageExportSerializer::ImageExportSerializer()
 
20
        {
 
21
        }
 
22
 
 
23
        ImageExportSerializer::~ImageExportSerializer()
 
24
        {
 
25
        }
 
26
 
 
27
        void ImageExportSerializer::serialization(pugi::xml_document& _doc)
 
28
        {
 
29
                pugi::xml_node root = _doc.append_child("MyGUI");
 
30
                root.append_attribute("type").set_value("Resource");
 
31
                root.append_attribute("version").set_value("1.1");
 
32
 
 
33
                DataPtr data = DataManager::getInstance().getRoot();
 
34
                for (Data::VectorData::const_iterator child = data->getChilds().begin(); child != data->getChilds().end(); child ++)
 
35
                        writeImage(root, (*child));
 
36
        }
 
37
 
 
38
        bool ImageExportSerializer::deserialization(pugi::xml_document& _doc)
 
39
        {
 
40
                if (_doc.select_single_node("MyGUI[@type=\"Resource\"]").node().empty())
 
41
                        return false;
 
42
 
 
43
                pugi::xpath_node_set nodes = _doc.select_nodes("MyGUI/Resource[@type=\"ResourceImageSet\"]");
 
44
                for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
 
45
                        parseImage((*node).node());
 
46
 
 
47
                updateImageProperty(DataManager::getInstance().getRoot());
 
48
                return true;
 
49
        }
 
50
 
 
51
        void ImageExportSerializer::parseImage(pugi::xml_node _node)
 
52
        {
 
53
                DataPtr data = Data::CreateInstance();
 
54
                data->setType(DataTypeManager::getInstance().getType("Image"));
 
55
                data->setPropertyValue("Name", _node.attribute("name").value());
 
56
 
 
57
                DataManager::getInstance().getRoot()->addChild(data);
 
58
 
 
59
                pugi::xpath_node_set nodes = _node.select_nodes("Group");
 
60
                for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
 
61
                        parseGroup((*node).node(), data);
 
62
        }
 
63
 
 
64
        void ImageExportSerializer::parseGroup(pugi::xml_node _node, DataPtr _parent)
 
65
        {
 
66
                DataPtr data = Data::CreateInstance();
 
67
                data->setType(DataTypeManager::getInstance().getType("Group"));
 
68
                std::string value = _node.attribute("name").value();
 
69
                if (value.empty())
 
70
                        value = "unnamed";
 
71
                data->setPropertyValue("Name", value);
 
72
                data->setPropertyValue("Texture", _node.attribute("texture").value());
 
73
                MyGUI::IntSize size = MyGUI::IntSize::parse(_node.attribute("size").value());
 
74
                data->setPropertyValue("Size", MyGUI::IntCoord(0, 0, size.width, size.height).print());
 
75
 
 
76
                _parent->addChild(data);
 
77
 
 
78
                pugi::xpath_node_set nodes = _node.select_nodes("Index");
 
79
                for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
 
80
                        parseIndex((*node).node(), data);
 
81
        }
 
82
 
 
83
        void ImageExportSerializer::parseIndex(pugi::xml_node _node, DataPtr _parent)
 
84
        {
 
85
                DataPtr data = Data::CreateInstance();
 
86
                data->setType(DataTypeManager::getInstance().getType("Index"));
 
87
                std::string value = _node.attribute("name").value();
 
88
                if (value.empty())
 
89
                        value = "unnamed";
 
90
                data->setPropertyValue("Name", value);
 
91
                data->setPropertyValue("Rate", _node.attribute("rate").value());
 
92
 
 
93
                _parent->addChild(data);
 
94
 
 
95
                pugi::xpath_node_set nodes = _node.select_nodes("Frame");
 
96
                for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
 
97
                        parseFrame((*node).node(), data);
 
98
        }
 
99
 
 
100
        void ImageExportSerializer::parseFrame(pugi::xml_node _node, DataPtr _parent)
 
101
        {
 
102
                DataPtr data = Data::CreateInstance();
 
103
                data->setType(DataTypeManager::getInstance().getType("Frame"));
 
104
                data->setPropertyValue("Point", _node.attribute("point").value());
 
105
                std::string value = _node.attribute("count").value();
 
106
                if (value.empty())
 
107
                        value = "1";
 
108
                data->setPropertyValue("Count", value);
 
109
 
 
110
                _parent->addChild(data);
 
111
        }
 
112
 
 
113
        void ImageExportSerializer::writeImage(pugi::xml_node _parent, DataPtr _data)
 
114
        {
 
115
                pugi::xml_node node = _parent.append_child("Resource");
 
116
                node.append_attribute("type").set_value("ResourceImageSet");
 
117
                node.append_attribute("name").set_value(_data->getPropertyValue("Name").c_str());
 
118
 
 
119
                for (Data::VectorData::const_iterator child = _data->getChilds().begin(); child != _data->getChilds().end(); child ++)
 
120
                        writeGroup(node, (*child));
 
121
        }
 
122
 
 
123
        void ImageExportSerializer::writeGroup(pugi::xml_node _parent, DataPtr _data)
 
124
        {
 
125
                pugi::xml_node node = _parent.append_child("Group");
 
126
                node.append_attribute("name").set_value(_data->getPropertyValue("Name").c_str());
 
127
                node.append_attribute("texture").set_value(_data->getPropertyValue("Texture").c_str());
 
128
                node.append_attribute("size").set_value(MyGUI::IntCoord::parse(_data->getPropertyValue("Size")).size().print().c_str());
 
129
 
 
130
                for (Data::VectorData::const_iterator child = _data->getChilds().begin(); child != _data->getChilds().end(); child ++)
 
131
                        writeIndex(node, (*child));
 
132
        }
 
133
 
 
134
        void ImageExportSerializer::writeIndex(pugi::xml_node _parent, DataPtr _data)
 
135
        {
 
136
                pugi::xml_node node = _parent.append_child("Index");
 
137
                node.append_attribute("name").set_value(_data->getPropertyValue("Name").c_str());
 
138
 
 
139
                std::string value = _data->getPropertyValue("Rate");
 
140
                if (!value.empty())
 
141
                        node.append_attribute("rate").set_value(value.c_str());
 
142
 
 
143
                for (Data::VectorData::const_iterator child = _data->getChilds().begin(); child != _data->getChilds().end(); child ++)
 
144
                        writeFrame(node, (*child));
 
145
        }
 
146
        
 
147
        void ImageExportSerializer::writeFrame(pugi::xml_node _parent, DataPtr _data)
 
148
        {
 
149
                pugi::xml_node node = _parent.append_child("Frame");
 
150
                node.append_attribute("point").set_value(_data->getPropertyValue("Point").c_str());
 
151
 
 
152
                size_t count = MyGUI::utility::parseValue<size_t>(_data->getPropertyValue("Count"));
 
153
                if (count > 1)
 
154
                        node.append_attribute("count").set_value(MyGUI::utility::toString(count).c_str());
 
155
        }
 
156
 
 
157
        void ImageExportSerializer::updateImageProperty(DataPtr _data)
 
158
        {
 
159
                const Data::VectorData& childs = _data->getChilds();
 
160
                for (Data::VectorData::const_iterator child = childs.begin(); child != childs.end(); child++)
 
161
                {
 
162
                        bool unique = PropertyUtility::isUniqueName((*child), "Name");
 
163
                        (*child)->setPropertyValue("UniqueName", unique);
 
164
                        updateGroupProperty(*child);
 
165
                }
 
166
        }
 
167
 
 
168
        void ImageExportSerializer::updateGroupProperty(DataPtr _data)
 
169
        {
 
170
                const Data::VectorData& childs = _data->getChilds();
 
171
                for (Data::VectorData::const_iterator child = childs.begin(); child != childs.end(); child++)
 
172
                {
 
173
                        bool unique = PropertyUtility::isUniqueName((*child), "Name");
 
174
                        (*child)->setPropertyValue("UniqueName", unique);
 
175
                        updateIndexProperty(*child);
 
176
                }
 
177
        }
 
178
 
 
179
        void ImageExportSerializer::updateIndexProperty(DataPtr _data)
 
180
        {
 
181
                const Data::VectorData& childs = _data->getChilds();
 
182
                for (Data::VectorData::const_iterator child = childs.begin(); child != childs.end(); child++)
 
183
                {
 
184
                        bool unique = PropertyUtility::isUniqueName((*child), "Name");
 
185
                        (*child)->setPropertyValue("UniqueName", unique);
 
186
                }
 
187
 
 
188
                MyGUI::IntPoint point = getFirstFramePoint(_data);
 
189
                MyGUI::IntSize size = _data->getPropertyValue<MyGUI::IntCoord>("Size").size();
 
190
                MyGUI::IntCoord coord(point, size);
 
191
                _data->setPropertyValue("Size", coord);
 
192
        }
 
193
 
 
194
        MyGUI::IntPoint ImageExportSerializer::getFirstFramePoint(DataPtr _data)
 
195
        {
 
196
                if (_data->getType()->getName() != "Group")
 
197
                        return MyGUI::IntPoint();
 
198
 
 
199
                if (_data->getChilds().size() != 0)
 
200
                {
 
201
                        DataPtr child = _data->getChildByIndex(0);
 
202
                        if (child->getChilds().size() != 0)
 
203
                        {
 
204
                                return child->getChildByIndex(0)->getPropertyValue<MyGUI::IntPoint>("Point");
 
205
                        }
 
206
                }
 
207
 
 
208
 
 
209
                return MyGUI::IntPoint();
 
210
        }
 
211
 
 
212
}