MyGUI  3.2.0
MyGUI_OverlappedLayer.cpp
Go to the documentation of this file.
00001 
00006 /*
00007     This file is part of MyGUI.
00008 
00009     MyGUI is free software: you can redistribute it and/or modify
00010     it under the terms of the GNU Lesser General Public License as published by
00011     the Free Software Foundation, either version 3 of the License, or
00012     (at your option) any later version.
00013 
00014     MyGUI is distributed in the hope that it will be useful,
00015     but WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017     GNU Lesser General Public License for more details.
00018 
00019     You should have received a copy of the GNU Lesser General Public License
00020     along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
00021 */
00022 
00023 #include "MyGUI_Precompiled.h"
00024 #include "MyGUI_LayerItem.h"
00025 #include "MyGUI_OverlappedLayer.h"
00026 #include "MyGUI_LayerNode.h"
00027 #include "MyGUI_RenderManager.h"
00028 
00029 namespace MyGUI
00030 {
00031 
00032     OverlappedLayer::OverlappedLayer() :
00033         mIsPick(false),
00034         mOutOfDate(false)
00035     {
00036         mViewSize = RenderManager::getInstance().getViewSize();
00037     }
00038 
00039     OverlappedLayer::~OverlappedLayer()
00040     {
00041         MYGUI_ASSERT(mChildItems.empty(), "Layer '" << getName() << "' must be empty before destroy");
00042     }
00043 
00044     void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
00045     {
00046         mName = _node->findAttribute("name");
00047         if (_version >= Version(1, 2))
00048         {
00049             MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
00050             while (propert.next("Property"))
00051             {
00052                 const std::string& key = propert->findAttribute("key");
00053                 const std::string& value = propert->findAttribute("value");
00054                 if (key == "Pick")
00055                     mIsPick = utility::parseValue<bool>(value);
00056             }
00057         }
00058         else if (_version >= Version(1, 0))
00059         {
00060             mIsPick = utility::parseBool(_node->findAttribute("pick"));
00061         }
00062         else
00063         {
00064             mIsPick = utility::parseBool(_node->findAttribute("peek"));
00065         }
00066     }
00067 
00068     ILayerNode* OverlappedLayer::createChildItemNode()
00069     {
00070         // создаем рутовый айтем
00071         ILayerNode* node = new LayerNode(this);
00072         mChildItems.push_back(node);
00073 
00074         mOutOfDate = true;
00075 
00076         return node;
00077     }
00078 
00079     void OverlappedLayer::destroyChildItemNode(ILayerNode* _item)
00080     {
00081         // если есть отец, то русть сам и удаляет
00082         ILayerNode* parent = _item->getParent();
00083         if (parent)
00084         {
00085             parent->destroyChildItemNode(_item);
00086 
00087             mOutOfDate = true;
00088 
00089             return;
00090         }
00091 
00092         // айтем рутовый, мы удаляем
00093         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00094         {
00095             if ((*iter) == _item)
00096             {
00097                 delete _item;
00098                 mChildItems.erase(iter);
00099 
00100                 mOutOfDate = true;
00101 
00102                 return;
00103             }
00104         }
00105 
00106         MYGUI_EXCEPT("item node not found");
00107     }
00108 
00109     void OverlappedLayer::upChildItemNode(ILayerNode* _item)
00110     {
00111         // если есть отец, то пусть сам рулит
00112         ILayerNode* parent = _item->getParent();
00113         if (parent != nullptr)
00114         {
00115             parent->upChildItemNode(_item);
00116 
00117             mOutOfDate = true;
00118 
00119             return;
00120         }
00121 
00122         if ((2 > mChildItems.size()) || (mChildItems.back() == _item))
00123             return;
00124 
00125         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00126         {
00127             if ((*iter) == _item)
00128             {
00129                 mChildItems.erase(iter);
00130                 mChildItems.push_back(_item);
00131 
00132                 mOutOfDate = true;
00133 
00134                 return;
00135             }
00136         }
00137 
00138         MYGUI_EXCEPT("item node not found");
00139     }
00140 
00141     ILayerItem* OverlappedLayer::getLayerItemByPoint(int _left, int _top) const
00142     {
00143         if (!mIsPick)
00144             return nullptr;
00145 
00146         VectorILayerNode::const_reverse_iterator iter = mChildItems.rbegin();
00147         while (iter != mChildItems.rend())
00148         {
00149             ILayerItem* item = (*iter)->getLayerItemByPoint(_left, _top);
00150             if (item != nullptr)
00151                 return item;
00152             ++iter;
00153         }
00154         return nullptr;
00155     }
00156 
00157     IntPoint OverlappedLayer::getPosition(int _left, int _top) const
00158     {
00159         return IntPoint(_left, _top);
00160     }
00161 
00162     void OverlappedLayer::renderToTarget(IRenderTarget* _target, bool _update)
00163     {
00164         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00165             (*iter)->renderToTarget(_target, _update);
00166 
00167         mOutOfDate = false;
00168     }
00169 
00170     void OverlappedLayer::resizeView(const IntSize& _viewSize)
00171     {
00172         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00173             (*iter)->resizeView(_viewSize);
00174 
00175         mViewSize = _viewSize;
00176     }
00177 
00178     EnumeratorILayerNode OverlappedLayer::getEnumerator() const
00179     {
00180         return EnumeratorILayerNode(mChildItems);
00181     }
00182 
00183     const IntSize& OverlappedLayer::getSize() const
00184     {
00185         return mViewSize;
00186     }
00187 
00188     bool OverlappedLayer::isOutOfDate() const
00189     {
00190         for (VectorILayerNode::const_iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00191         {
00192             if (static_cast<const LayerNode*>(*iter)->isOutOfDate())
00193                 return true;
00194         }
00195 
00196         return mOutOfDate;
00197     }
00198 
00199 } // namespace MyGUI