00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "MyGUI_Precompiled.h"
00024 #include "MyGUI_LayerManager.h"
00025 #include "MyGUI_LayerItem.h"
00026 #include "MyGUI_WidgetManager.h"
00027 #include "MyGUI_RenderManager.h"
00028 #include "MyGUI_Widget.h"
00029 #include "MyGUI_FactoryManager.h"
00030
00031 #include "MyGUI_SharedLayer.h"
00032 #include "MyGUI_OverlappedLayer.h"
00033
00034 namespace MyGUI
00035 {
00036
00037 const std::string XML_TYPE("Layer");
00038
00039 MYGUI_INSTANCE_IMPLEMENT( LayerManager )
00040
00041 void LayerManager::initialise()
00042 {
00043 MYGUI_ASSERT(!mIsInitialise, INSTANCE_TYPE_NAME << " initialised twice");
00044 MYGUI_LOG(Info, "* Initialise: " << INSTANCE_TYPE_NAME);
00045
00046 WidgetManager::getInstance().registerUnlinker(this);
00047 ResourceManager::getInstance().registerLoadXmlDelegate(XML_TYPE) = newDelegate(this, &LayerManager::_load);
00048
00049 FactoryManager::getInstance().registerFactory<SharedLayer>(XML_TYPE);
00050 FactoryManager::getInstance().registerFactory<OverlappedLayer>(XML_TYPE);
00051
00052 MYGUI_LOG(Info, INSTANCE_TYPE_NAME << " successfully initialized");
00053 mIsInitialise = true;
00054 }
00055
00056 void LayerManager::shutdown()
00057 {
00058 if (!mIsInitialise) return;
00059 MYGUI_LOG(Info, "* Shutdown: " << INSTANCE_TYPE_NAME);
00060
00061 FactoryManager::getInstance().unregisterFactory<SharedLayer>(XML_TYPE);
00062 FactoryManager::getInstance().unregisterFactory<OverlappedLayer>(XML_TYPE);
00063
00064
00065 clear();
00066
00067 WidgetManager::getInstance().unregisterUnlinker(this);
00068 ResourceManager::getInstance().unregisterLoadXmlDelegate(XML_TYPE);
00069
00070 MYGUI_LOG(Info, INSTANCE_TYPE_NAME << " successfully shutdown");
00071 mIsInitialise = false;
00072 }
00073
00074 void LayerManager::clear()
00075 {
00076 for (VectorLayer::iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00077 {
00078 destroy(*iter);
00079 }
00080 mLayerNodes.clear();
00081 }
00082
00083 bool LayerManager::load(const std::string& _file)
00084 {
00085 return ResourceManager::getInstance()._loadImplement(_file, true, XML_TYPE, INSTANCE_TYPE_NAME);
00086 }
00087
00088 void LayerManager::_load(xml::ElementPtr _node, const std::string& _file, Version _version)
00089 {
00090 VectorLayer layers;
00091
00092 xml::ElementEnumerator layer = _node->getElementEnumerator();
00093 while (layer.next(XML_TYPE))
00094 {
00095
00096 std::string name;
00097
00098 if ( !layer->findAttribute("name", name))
00099 {
00100 MYGUI_LOG(Warning, "Attribute 'name' not found (file : " << _file << ")");
00101 continue;
00102 }
00103
00104 for (VectorLayer::iterator iter=layers.begin(); iter!=layers.end(); ++iter)
00105 {
00106 MYGUI_ASSERT((*iter)->getName() != name, "Layer '" << name << "' already exist (file : " << _file << ")");
00107 }
00108
00109 std::string type = layer->findAttribute("type");
00110 if (type.empty() && _version <= Version(1, 0))
00111 {
00112 bool overlapped = utility::parseBool(layer->findAttribute("overlapped"));
00113 type = overlapped ? "OverlappedLayer" : "SharedLayer";
00114 }
00115
00116 IObject* object = FactoryManager::getInstance().createObject(XML_TYPE, type);
00117 MYGUI_ASSERT(object != nullptr, "factory is '" << type << "' not found");
00118
00119 ILayer* item = object->castType<ILayer>();
00120 item->deserialization(layer.current(), _version);
00121
00122 layers.push_back(item);
00123 }
00124
00125
00126 merge(layers);
00127 }
00128
00129 void LayerManager::_unlinkWidget(Widget* _widget)
00130 {
00131 detachFromLayer(_widget);
00132 }
00133
00134
00135 void LayerManager::attachToLayerNode(const std::string& _name, Widget* _item)
00136 {
00137 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
00138 MYGUI_ASSERT(_item->isRootWidget(), "attached widget must be root");
00139
00140
00141 _item->detachFromLayer();
00142
00143
00144 for (VectorLayer::iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00145 {
00146 if (_name == (*iter)->getName())
00147 {
00148 ILayerNode* node = (*iter)->createChildItemNode();
00149 node->attachLayerItem(_item);
00150
00151 return;
00152 }
00153 }
00154 MYGUI_LOG(Error, "Layer '" << _name << "' is not found");
00155
00156 }
00157
00158 void LayerManager::detachFromLayer(Widget* _item)
00159 {
00160 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
00161 _item->detachFromLayer();
00162 }
00163
00164 void LayerManager::upLayerItem(Widget* _item)
00165 {
00166 MYGUI_ASSERT(nullptr != _item, "pointer must be valid");
00167 _item->upLayerItem();
00168 }
00169
00170 bool LayerManager::isExist(const std::string& _name) const
00171 {
00172 return getByName(_name, false) != nullptr;
00173 }
00174
00175 void LayerManager::merge(VectorLayer& _layers)
00176 {
00177 for (VectorLayer::iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00178 {
00179 if ((*iter) == nullptr) continue;
00180 bool find = false;
00181 std::string name = (*iter)->getName();
00182 for (VectorLayer::iterator iter2=_layers.begin(); iter2!=_layers.end(); ++iter2)
00183 {
00184 if (name == (*iter2)->getName())
00185 {
00186
00187 delete (*iter2);
00188 (*iter2) = (*iter);
00189 (*iter) = nullptr;
00190 find = true;
00191 break;
00192 }
00193 }
00194 if (!find)
00195 {
00196 destroy(*iter);
00197 (*iter) = nullptr;
00198 }
00199 }
00200
00201
00202 mLayerNodes = _layers;
00203 }
00204
00205 void LayerManager::destroy(ILayer* _layer)
00206 {
00207 MYGUI_LOG(Info, "destroy layer '" << _layer->getName() << "'");
00208 delete _layer;
00209 }
00210 Widget* LayerManager::getWidgetFromPoint(int _left, int _top)
00211 {
00212 VectorLayer::reverse_iterator iter = mLayerNodes.rbegin();
00213 while (iter != mLayerNodes.rend())
00214 {
00215 ILayerItem * item = (*iter)->getLayerItemByPoint(_left, _top);
00216 if (item != nullptr) return static_cast<Widget*>(item);
00217 ++iter;
00218 }
00219 return nullptr;
00220 }
00221
00222 void LayerManager::renderToTarget(IRenderTarget* _target, bool _update)
00223 {
00224 for (VectorLayer::iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00225 {
00226 (*iter)->renderToTarget(_target, _update);
00227 }
00228 }
00229
00230 ILayer* LayerManager::getByName(const std::string& _name, bool _throw) const
00231 {
00232 for (VectorLayer::const_iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00233 {
00234 if (_name == (*iter)->getName())
00235 return (*iter);
00236 }
00237 MYGUI_ASSERT(!_throw, "Layer '" << _name << "' not found");
00238 return nullptr;
00239 }
00240
00241 void LayerManager::dumpStatisticToLog()
00242 {
00243 static const char* spacer = " ";
00244 MYGUI_LOG(Info, spacer);
00245 MYGUI_LOG(Info, "---------- Statistic for layers start ----------" << spacer);
00246 for (VectorLayer::iterator iter=mLayerNodes.begin(); iter!=mLayerNodes.end(); ++iter)
00247 {
00248 (*iter)->dumpStatisticToLog();
00249 }
00250 MYGUI_LOG(Info, spacer);
00251 MYGUI_LOG(Info, "---------- Statistic for layers end ----------" << spacer);
00252 MYGUI_LOG(Info, spacer);
00253 }
00254
00255 }