MyGUI  3.2.1
MyGUI_OverlappedLayer.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_LayerItem.h"
00009 #include "MyGUI_OverlappedLayer.h"
00010 #include "MyGUI_LayerNode.h"
00011 #include "MyGUI_RenderManager.h"
00012 
00013 namespace MyGUI
00014 {
00015 
00016     OverlappedLayer::OverlappedLayer() :
00017         mIsPick(false),
00018         mOutOfDate(false)
00019     {
00020         mViewSize = RenderManager::getInstance().getViewSize();
00021     }
00022 
00023     OverlappedLayer::~OverlappedLayer()
00024     {
00025         MYGUI_ASSERT(mChildItems.empty(), "Layer '" << getName() << "' must be empty before destroy");
00026     }
00027 
00028     void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
00029     {
00030         mName = _node->findAttribute("name");
00031         if (_version >= Version(1, 2))
00032         {
00033             MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
00034             while (propert.next("Property"))
00035             {
00036                 const std::string& key = propert->findAttribute("key");
00037                 const std::string& value = propert->findAttribute("value");
00038                 if (key == "Pick")
00039                     mIsPick = utility::parseValue<bool>(value);
00040             }
00041         }
00042         else if (_version >= Version(1, 0))
00043         {
00044             mIsPick = utility::parseBool(_node->findAttribute("pick"));
00045         }
00046         else
00047         {
00048             mIsPick = utility::parseBool(_node->findAttribute("peek"));
00049         }
00050     }
00051 
00052     ILayerNode* OverlappedLayer::createChildItemNode()
00053     {
00054         // создаем рутовый айтем
00055         ILayerNode* node = new LayerNode(this);
00056         mChildItems.push_back(node);
00057 
00058         mOutOfDate = true;
00059 
00060         return node;
00061     }
00062 
00063     void OverlappedLayer::destroyChildItemNode(ILayerNode* _item)
00064     {
00065         // если есть отец, то русть сам и удаляет
00066         ILayerNode* parent = _item->getParent();
00067         if (parent)
00068         {
00069             parent->destroyChildItemNode(_item);
00070 
00071             mOutOfDate = true;
00072 
00073             return;
00074         }
00075 
00076         // айтем рутовый, мы удаляем
00077         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00078         {
00079             if ((*iter) == _item)
00080             {
00081                 delete _item;
00082                 mChildItems.erase(iter);
00083 
00084                 mOutOfDate = true;
00085 
00086                 return;
00087             }
00088         }
00089 
00090         MYGUI_EXCEPT("item node not found");
00091     }
00092 
00093     void OverlappedLayer::upChildItemNode(ILayerNode* _item)
00094     {
00095         // если есть отец, то пусть сам рулит
00096         ILayerNode* parent = _item->getParent();
00097         if (parent != nullptr)
00098         {
00099             parent->upChildItemNode(_item);
00100 
00101             mOutOfDate = true;
00102 
00103             return;
00104         }
00105 
00106         if ((2 > mChildItems.size()) || (mChildItems.back() == _item))
00107             return;
00108 
00109         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00110         {
00111             if ((*iter) == _item)
00112             {
00113                 mChildItems.erase(iter);
00114                 mChildItems.push_back(_item);
00115 
00116                 mOutOfDate = true;
00117 
00118                 return;
00119             }
00120         }
00121 
00122         MYGUI_EXCEPT("item node not found");
00123     }
00124 
00125     ILayerItem* OverlappedLayer::getLayerItemByPoint(int _left, int _top) const
00126     {
00127         if (!mIsPick)
00128             return nullptr;
00129 
00130         VectorILayerNode::const_reverse_iterator iter = mChildItems.rbegin();
00131         while (iter != mChildItems.rend())
00132         {
00133             ILayerItem* item = (*iter)->getLayerItemByPoint(_left, _top);
00134             if (item != nullptr)
00135                 return item;
00136             ++iter;
00137         }
00138         return nullptr;
00139     }
00140 
00141     IntPoint OverlappedLayer::getPosition(int _left, int _top) const
00142     {
00143         return IntPoint(_left, _top);
00144     }
00145 
00146     void OverlappedLayer::renderToTarget(IRenderTarget* _target, bool _update)
00147     {
00148         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00149             (*iter)->renderToTarget(_target, _update);
00150 
00151         mOutOfDate = false;
00152     }
00153 
00154     void OverlappedLayer::resizeView(const IntSize& _viewSize)
00155     {
00156         for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00157             (*iter)->resizeView(_viewSize);
00158 
00159         mViewSize = _viewSize;
00160     }
00161 
00162     EnumeratorILayerNode OverlappedLayer::getEnumerator() const
00163     {
00164         return EnumeratorILayerNode(mChildItems);
00165     }
00166 
00167     size_t OverlappedLayer::getLayerNodeCount() const
00168     {
00169         return mChildItems.size();
00170     }
00171 
00172     ILayerNode* OverlappedLayer::getLayerNodeAt(size_t _index) const
00173     {
00174         MYGUI_ASSERT_RANGE(_index, mChildItems.size(), "OverlappedLayer::getLayerNodeAt");
00175 
00176         return mChildItems[_index];
00177     }
00178 
00179     const IntSize& OverlappedLayer::getSize() const
00180     {
00181         return mViewSize;
00182     }
00183 
00184     bool OverlappedLayer::isOutOfDate() const
00185     {
00186         for (VectorILayerNode::const_iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
00187         {
00188             if (static_cast<const LayerNode*>(*iter)->isOutOfDate())
00189                 return true;
00190         }
00191 
00192         return mOutOfDate;
00193     }
00194 
00195 } // namespace MyGUI