• Main Page
  • Related Pages
  • Namespaces
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

MyGUI_LayerManager.cpp

Go to the documentation of this file.
00001 
00007 /*
00008     This file is part of MyGUI.
00009     
00010     MyGUI is free software: you can redistribute it and/or modify
00011     it under the terms of the GNU Lesser General Public License as published by
00012     the Free Software Foundation, either version 3 of the License, or
00013     (at your option) any later version.
00014     
00015     MyGUI is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018     GNU Lesser General Public License for more details.
00019     
00020     You should have received a copy of the GNU Lesser General Public License
00021     along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
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         //MYGUI_EXCEPT("Layer '" << _name << "' is not found");
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 } // namespace MyGUI

Generated on Sun Jan 30 2011 for MyGUI by  doxygen 1.7.1