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