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