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