MyGUI  3.0.1
MyGUI_OverlappedLayer.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 
00024 #include "MyGUI_Precompiled.h"
00025 #include "MyGUI_LayerItem.h"
00026 #include "MyGUI_OverlappedLayer.h"
00027 #include "MyGUI_LayerNode.h"
00028 #include "MyGUI_RenderManager.h"
00029 
00030 namespace MyGUI
00031 {
00032 
00033     OverlappedLayer::OverlappedLayer() :
00034         mIsPick(false)
00035     {
00036     }
00037 
00038     OverlappedLayer::~OverlappedLayer()
00039     {
00040         MYGUI_ASSERT(mChildItems.empty(), "Layer '" << getName() << "' must be empty before destroy");
00041     }
00042 
00043     void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
00044     {
00045         mName = _node->findAttribute("name");
00046         if (_version >= Version(1, 2))
00047         {
00048             MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
00049             while (propert.next("Property"))
00050             {
00051                 const std::string& key = propert->findAttribute("key");
00052                 const std::string& value = propert->findAttribute("value");
00053                 if (key == "Pick") mIsPick = utility::parseValue<bool>(value);
00054             }
00055         }
00056         else
00057         {
00058             mIsPick = utility::parseBool(_version < Version(1, 0) ? _node->findAttribute("peek") : _node->findAttribute("pick"));
00059         }
00060     }
00061 
00062     ILayerNode * OverlappedLayer::createChildItemNode()
00063     {
00064         // создаем рутовый айтем
00065         ILayerNode * node = new LayerNode(this);
00066         mChildItems.push_back(node);
00067 
00068         return node;
00069     }
00070 
00071     void OverlappedLayer::destroyChildItemNode(ILayerNode* _item)
00072     {
00073         // если есть отец, то русть сам и удаляет
00074         ILayerNode * parent = _item->getParent();
00075         if (parent)
00076         {
00077             parent->destroyChildItemNode(_item);
00078             return;
00079         }
00080 
00081         // айтем рутовый, мы удаляем
00082         for (VectorILayerNode::iterator iter=mChildItems.begin(); iter!=mChildItems.end(); ++iter)
00083         {
00084             if ((*iter) == _item)
00085             {
00086                 delete _item;
00087                 mChildItems.erase(iter);
00088                 return;
00089             }
00090         }
00091         MYGUI_EXCEPT("item node not found");
00092     }
00093 
00094     void OverlappedLayer::upChildItemNode(ILayerNode* _item)
00095     {
00096         // если есть отец, то пусть сам рулит
00097         ILayerNode* parent = _item->getParent();
00098         if (parent != nullptr)
00099         {
00100             parent->upChildItemNode(_item);
00101             return;
00102         }
00103 
00104         if ((2 > mChildItems.size()) || (mChildItems.back() == _item)) return;
00105         for (VectorILayerNode::iterator iter=mChildItems.begin(); iter!=mChildItems.end(); ++iter)
00106         {
00107             if ((*iter) == _item)
00108             {
00109                 mChildItems.erase(iter);
00110                 mChildItems.push_back(_item);
00111                 return;
00112             }
00113         }
00114 
00115         MYGUI_EXCEPT("item node not found");
00116     }
00117 
00118     ILayerItem * OverlappedLayer::getLayerItemByPoint(int _left, int _top)
00119     {
00120         if (!mIsPick) return nullptr;
00121         VectorILayerNode::reverse_iterator iter = mChildItems.rbegin();
00122         while (iter != mChildItems.rend())
00123         {
00124             ILayerItem * item = (*iter)->getLayerItemByPoint(_left, _top);
00125             if (item != nullptr) return item;
00126             ++iter;
00127         }
00128         return nullptr;
00129     }
00130 
00131     IntPoint OverlappedLayer::getPosition(int _left, int _top) const
00132     {
00133         return IntPoint(_left, _top);
00134     }
00135 
00136     void OverlappedLayer::renderToTarget(IRenderTarget* _target, bool _update)
00137     {
00138         for (VectorILayerNode::iterator iter=mChildItems.begin(); iter!=mChildItems.end(); ++iter)
00139         {
00140             (*iter)->renderToTarget(_target, _update);
00141         }
00142     }
00143 
00144     EnumeratorILayerNode OverlappedLayer::getEnumerator()
00145     {
00146         return EnumeratorILayerNode(mChildItems);
00147     }
00148 
00149     void OverlappedLayer::dumpStatisticToLog()
00150     {
00151         static const char* spacer = "                                                                                                                        ";
00152         MYGUI_LOG(Info, spacer);
00153         MYGUI_LOG(Info, "Layer name='" << getName() << "'" << " type='" << getTypeName() << "'" << spacer);
00154         MYGUI_LOG(Info, "Count root nodes : " << mChildItems.size() << spacer);
00155 
00156         for (VectorILayerNode::iterator iter=mChildItems.begin(); iter!=mChildItems.end(); ++iter)
00157         {
00158             (*iter)->dumpStatisticToLog(0);
00159         }
00160     }
00161 
00162     const IntSize& OverlappedLayer::getSize() const
00163     {
00164         return RenderManager::getInstance().getViewSize();
00165     }
00166 
00167 } // namespace MyGUI