MyGUI 3.4.3
MyGUI_LayerManager.cpp
Go to the documentation of this file.
1/*
2 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
3 * Distributed under the MIT License
4 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
5 */
6
7#include "MyGUI_Precompiled.h"
9#include "MyGUI_LayerItem.h"
10#include "MyGUI_WidgetManager.h"
11#include "MyGUI_RenderManager.h"
12#include "MyGUI_Widget.h"
14
15#include "MyGUI_SharedLayer.h"
17
18namespace MyGUI
19{
20
22
24 mCategoryName("Layer"),
25 mSingletonHolder(this)
26 {
27 }
28
30 {
31 MYGUI_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
32 MYGUI_LOG(Info, "* Initialise: " << getClassTypeName());
33
35 ResourceManager::getInstance().registerLoadXmlDelegate(mCategoryName) = newDelegate(this, &LayerManager::_load);
36
39
40 MYGUI_LOG(Info, getClassTypeName() << " successfully initialized");
41 mIsInitialise = true;
42 }
43
45 {
46 MYGUI_ASSERT(mIsInitialise, getClassTypeName() << " is not initialised");
47 MYGUI_LOG(Info, "* Shutdown: " << getClassTypeName());
48
51
52 // удаляем все хранители слоев
53 clear();
54
57
58 MYGUI_LOG(Info, getClassTypeName() << " successfully shutdown");
59 mIsInitialise = false;
60 }
61
62 void LayerManager::clear()
63 {
64 for (auto& layerNode : mLayerNodes)
65 {
66 destroy(layerNode);
67 }
68 mLayerNodes.clear();
69 }
70
71 void LayerManager::_load(xml::ElementPtr _node, std::string_view _file, Version _version)
72 {
73 VectorLayer layers;
74 // берем детей и крутимся, основной цикл
75 xml::ElementEnumerator layer = _node->getElementEnumerator();
76 while (layer.next(mCategoryName))
77 {
78 std::string name;
79
80 if (!layer->findAttribute("name", name))
81 {
82 MYGUI_LOG(Warning, "Attribute 'name' not found (file : " << _file << ")");
83 continue;
84 }
85
86 for (const auto& item : layers)
87 {
88 MYGUI_ASSERT(item->getName() != name, "Layer '" << name << "' already exist (file : " << _file << ")");
89 }
90
91 std::string_view type = layer->findAttribute("type");
92 if (type.empty() && _version <= Version(1, 0))
93 {
94 bool overlapped = utility::parseBool(layer->findAttribute("overlapped"));
95 type = overlapped ? "OverlappedLayer" : "SharedLayer";
96 }
97
98 ILayer* item = _createLayerObject(type);
99 item->deserialization(layer.current(), _version);
100
101 layers.push_back(item);
102 }
103
104 // теперь мержим новые и старые слои
105 merge(layers);
106 }
107
108 ILayer* LayerManager::_createLayerObject(std::string_view _type)
109 {
110 IObject* object = FactoryManager::getInstance().createObject(mCategoryName, _type);
111 MYGUI_ASSERT(object != nullptr, "factory '" << _type << "' is not found");
112
113 return object->castType<ILayer>();
114 }
115
116 void LayerManager::_unlinkWidget(Widget* _widget)
117 {
118 detachFromLayer(_widget);
119 }
120
121 // поправить на виджет и проверять на рутовость
122 void LayerManager::attachToLayerNode(std::string_view _name, Widget* _item)
123 {
124 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
125 MYGUI_ASSERT(_item->isRootWidget(), "attached widget must be root");
126
127 // сначала отсоединяем
128 _item->detachFromLayer();
129
130 // а теперь аттачим
131 for (auto& layerNode : mLayerNodes)
132 {
133 if (_name == layerNode->getName())
134 {
135 ILayerNode* node = layerNode->createChildItemNode();
136 node->attachLayerItem(_item);
137
138 return;
139 }
140 }
141 MYGUI_LOG(Error, "Layer '" << _name << "' is not found");
142 //MYGUI_EXCEPT("Layer '" << _name << "' is not found");
143 }
144
146 {
147 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
148 _item->detachFromLayer();
149 }
150
152 {
153 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
154 _item->upLayerItem();
155 }
156
157 bool LayerManager::isExist(std::string_view _name) const
158 {
159 return getByName(_name, false) != nullptr;
160 }
161
162 void LayerManager::merge(VectorLayer& _layers)
163 {
164 for (auto& layerNode : mLayerNodes)
165 {
166 if (layerNode == nullptr)
167 continue;
168 bool find = false;
169 const std::string& name = layerNode->getName();
170 for (auto& layer : _layers)
171 {
172 if (name == layer->getName())
173 {
174 // заменяем новый слой, на уже существующий
175 delete layer;
176 layer = layerNode;
177 layerNode = nullptr;
178 find = true;
179 break;
180 }
181 }
182 if (!find)
183 {
184 destroy(layerNode);
185 layerNode = nullptr;
186 }
187 }
188
189 // теперь в основной
190 mLayerNodes = _layers;
191 }
192
193 ILayer* LayerManager::createLayerAt(std::string_view _name, std::string_view _type, size_t _index)
194 {
195 MYGUI_ASSERT_RANGE(_index, mLayerNodes.size() + 1, "LayerManager::getLayer");
196
197 ILayer* item = _createLayerObject(_type);
198 item->setName(_name);
199
200 mLayerNodes.insert(mLayerNodes.begin() + _index, item);
201
202 return item;
203 }
204
205 void LayerManager::destroy(ILayer* _layer)
206 {
207 MYGUI_LOG(Info, "destroy layer '" << _layer->getName() << "'");
208 delete _layer;
209 }
210
211 Widget* LayerManager::getWidgetFromPoint(int _left, int _top) const
212 {
213 VectorLayer::const_reverse_iterator iter = mLayerNodes.rbegin();
214 while (iter != mLayerNodes.rend())
215 {
216 ILayerItem* item = (*iter)->getLayerItemByPoint(_left, _top);
217 if (item != nullptr)
218 return static_cast<Widget*>(item);
219 ++iter;
220 }
221 return nullptr;
222 }
223
224 void LayerManager::renderToTarget(IRenderTarget* _target, bool _update)
225 {
226 for (auto& layerNode : mLayerNodes)
227 {
228 layerNode->renderToTarget(_target, _update);
229 }
230 }
231
232 ILayer* LayerManager::getByName(std::string_view _name, bool _throw) const
233 {
234 for (const auto& layerNode : mLayerNodes)
235 {
236 if (_name == layerNode->getName())
237 return layerNode;
238 }
239 MYGUI_ASSERT(!_throw, "Layer '" << _name << "' not found");
240 return nullptr;
241 }
242
247
248 void LayerManager::resizeView(const IntSize& _viewSize)
249 {
250 for (const auto& node : mLayerNodes)
251 node->resizeView(_viewSize);
252 }
253
255 {
256 return mLayerNodes.size();
257 }
258
259 ILayer* LayerManager::getLayer(size_t _index) const
260 {
261 MYGUI_ASSERT_RANGE(_index, mLayerNodes.size(), "LayerManager::getLayer");
262 return mLayerNodes[_index];
263 }
264
265 const std::string& LayerManager::getCategoryName() const
266 {
267 return mCategoryName;
268 }
269
270} // namespace MyGUI
#define MYGUI_ASSERT(exp, dest)
#define MYGUI_ASSERT_RANGE(index, size, owner)
#define MYGUI_LOG(level, text)
#define MYGUI_SINGLETON_DEFINITION(ClassName)
void registerFactory(std::string_view _category, std::string_view _type, Delegate::IDelegate *_delegate)
static FactoryManager & getInstance()
void unregisterFactory(std::string_view _category, std::string_view _type)
IObject * createObject(std::string_view _category, std::string_view _type)
const std::string & getName() const
void setName(std::string_view _name)
virtual ILayerItem * getLayerItemByPoint(int _left, int _top) const =0
virtual void attachLayerItem(ILayerItem *_item)=0
virtual ILayerNode * createChildItemNode()=0
void detachFromLayer() override
void upLayerItem() override
void detachFromLayer(Widget *_item)
void upLayerItem(Widget *_item)
ILayer * getLayer(size_t _index) const
const std::string & getCategoryName() const
static std::string_view getClassTypeName()
EnumeratorLayer getEnumerator() const
ILayer * createLayerAt(std::string_view _name, std::string_view _type, size_t _index)
void renderToTarget(IRenderTarget *_target, bool _update)
std::vector< ILayer * > VectorLayer
ILayer * getByName(std::string_view _name, bool _throw=true) const
void resizeView(const IntSize &_viewSize)
void attachToLayerNode(std::string_view _name, Widget *_item)
Widget * getWidgetFromPoint(int _left, int _top) const
Enumerator< VectorLayer > EnumeratorLayer
bool isExist(std::string_view _name) const
void unregisterLoadXmlDelegate(std::string_view _key)
LoadXmlDelegate & registerLoadXmlDelegate(std::string_view _key)
static ResourceManager & getInstance()
widget description should be here.
bool isRootWidget() const
void unregisterUnlinker(IUnlinkWidget *_unlink)
static WidgetManager & getInstance()
void registerUnlinker(IUnlinkWidget *_unlink)
bool parseBool(std::string_view _value)
Element * ElementPtr
delegates::DelegateFunction< Args... > * newDelegate(void(*_func)(Args... args))