← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mygui/vivid

« back to all changes in this revision

Viewing changes to MyGUIEngine/src/MyGUI_OverlappedLayer.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Howard, Bret Curtis, Scott Howard
  • Date: 2014-09-18 17:57:48 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20140918175748-dd8va78mvpw1jbes
Tags: 3.2.1-1
[ Bret Curtis ]
* Updated license for majority of files from LGPL to Expat (MIT)

[ Scott Howard ]
* New upstream release
* Updated patch to add build option for system GLEW libraries
* All patches accepted upstream except shared_libraries.patch
* Bumped SONAME due to dropped symbols, updated *.symbols and package
  names
* Updated license of debian/* to Expat with permission of all authors
* Don't install Doxygen autogenerated md5 and map files (thanks
  lintian)

Show diffs side-by-side

added added

removed removed

Lines of Context:
MyGUIEngine/src/MyGUI_OverlappedLayer.cpp
1
 
/*!
2
 
        @file
3
 
        @author         Albert Semenov
4
 
        @date           02/2008
5
 
*/
6
 
/*
7
 
        This file is part of MyGUI.
8
 
 
9
 
        MyGUI is free software: you can redistribute it and/or modify
10
 
        it under the terms of the GNU Lesser General Public License as published by
11
 
        the Free Software Foundation, either version 3 of the License, or
12
 
        (at your option) any later version.
13
 
 
14
 
        MyGUI is distributed in the hope that it will be useful,
15
 
        but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
        GNU Lesser General Public License for more details.
18
 
 
19
 
        You should have received a copy of the GNU Lesser General Public License
20
 
        along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
21
 
*/
22
 
 
23
 
#include "MyGUI_Precompiled.h"
24
 
#include "MyGUI_LayerItem.h"
25
 
#include "MyGUI_OverlappedLayer.h"
26
 
#include "MyGUI_LayerNode.h"
27
 
#include "MyGUI_RenderManager.h"
28
 
 
29
 
namespace MyGUI
30
 
{
31
 
 
32
 
        OverlappedLayer::OverlappedLayer() :
33
 
                mIsPick(false),
34
 
                mOutOfDate(false)
35
 
        {
36
 
                mViewSize = RenderManager::getInstance().getViewSize();
37
 
        }
38
 
 
39
 
        OverlappedLayer::~OverlappedLayer()
40
 
        {
41
 
                MYGUI_ASSERT(mChildItems.empty(), "Layer '" << getName() << "' must be empty before destroy");
42
 
        }
43
 
 
44
 
        void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
45
 
        {
46
 
                mName = _node->findAttribute("name");
47
 
                if (_version >= Version(1, 2))
48
 
                {
49
 
                        MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
50
 
                        while (propert.next("Property"))
51
 
                        {
52
 
                                const std::string& key = propert->findAttribute("key");
53
 
                                const std::string& value = propert->findAttribute("value");
54
 
                                if (key == "Pick")
55
 
                                        mIsPick = utility::parseValue<bool>(value);
56
 
                        }
57
 
                }
58
 
                else if (_version >= Version(1, 0))
59
 
                {
60
 
                        mIsPick = utility::parseBool(_node->findAttribute("pick"));
61
 
                }
62
 
                else
63
 
                {
64
 
                        mIsPick = utility::parseBool(_node->findAttribute("peek"));
65
 
                }
66
 
        }
67
 
 
68
 
        ILayerNode* OverlappedLayer::createChildItemNode()
69
 
        {
70
 
                // создаем рутовый айтем
71
 
                ILayerNode* node = new LayerNode(this);
72
 
                mChildItems.push_back(node);
73
 
 
74
 
                mOutOfDate = true;
75
 
 
76
 
                return node;
77
 
        }
78
 
 
79
 
        void OverlappedLayer::destroyChildItemNode(ILayerNode* _item)
80
 
        {
81
 
                // если есть отец, то русть сам и удаляет
82
 
                ILayerNode* parent = _item->getParent();
83
 
                if (parent)
84
 
                {
85
 
                        parent->destroyChildItemNode(_item);
86
 
 
87
 
                        mOutOfDate = true;
88
 
 
89
 
                        return;
90
 
                }
91
 
 
92
 
                // айтем рутовый, мы удаляем
93
 
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
94
 
                {
95
 
                        if ((*iter) == _item)
96
 
                        {
97
 
                                delete _item;
98
 
                                mChildItems.erase(iter);
99
 
 
100
 
                                mOutOfDate = true;
101
 
 
102
 
                                return;
103
 
                        }
104
 
                }
105
 
 
106
 
                MYGUI_EXCEPT("item node not found");
107
 
        }
108
 
 
109
 
        void OverlappedLayer::upChildItemNode(ILayerNode* _item)
110
 
        {
111
 
                // если есть отец, то пусть сам рулит
112
 
                ILayerNode* parent = _item->getParent();
113
 
                if (parent != nullptr)
114
 
                {
115
 
                        parent->upChildItemNode(_item);
116
 
 
117
 
                        mOutOfDate = true;
118
 
 
119
 
                        return;
120
 
                }
121
 
 
122
 
                if ((2 > mChildItems.size()) || (mChildItems.back() == _item))
123
 
                        return;
124
 
 
125
 
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
126
 
                {
127
 
                        if ((*iter) == _item)
128
 
                        {
129
 
                                mChildItems.erase(iter);
130
 
                                mChildItems.push_back(_item);
131
 
 
132
 
                                mOutOfDate = true;
133
 
 
134
 
                                return;
135
 
                        }
136
 
                }
137
 
 
138
 
                MYGUI_EXCEPT("item node not found");
139
 
        }
140
 
 
141
 
        ILayerItem* OverlappedLayer::getLayerItemByPoint(int _left, int _top) const
142
 
        {
143
 
                if (!mIsPick)
144
 
                        return nullptr;
145
 
 
146
 
                VectorILayerNode::const_reverse_iterator iter = mChildItems.rbegin();
147
 
                while (iter != mChildItems.rend())
148
 
                {
149
 
                        ILayerItem* item = (*iter)->getLayerItemByPoint(_left, _top);
150
 
                        if (item != nullptr)
151
 
                                return item;
152
 
                        ++iter;
153
 
                }
154
 
                return nullptr;
155
 
        }
156
 
 
157
 
        IntPoint OverlappedLayer::getPosition(int _left, int _top) const
158
 
        {
159
 
                return IntPoint(_left, _top);
160
 
        }
161
 
 
162
 
        void OverlappedLayer::renderToTarget(IRenderTarget* _target, bool _update)
163
 
        {
164
 
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
165
 
                        (*iter)->renderToTarget(_target, _update);
166
 
 
167
 
                mOutOfDate = false;
168
 
        }
169
 
 
170
 
        void OverlappedLayer::resizeView(const IntSize& _viewSize)
171
 
        {
172
 
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
173
 
                        (*iter)->resizeView(_viewSize);
174
 
 
175
 
                mViewSize = _viewSize;
176
 
        }
177
 
 
178
 
        EnumeratorILayerNode OverlappedLayer::getEnumerator() const
179
 
        {
180
 
                return EnumeratorILayerNode(mChildItems);
181
 
        }
182
 
 
183
 
        const IntSize& OverlappedLayer::getSize() const
184
 
        {
185
 
                return mViewSize;
186
 
        }
187
 
 
188
 
        bool OverlappedLayer::isOutOfDate() const
189
 
        {
190
 
                for (VectorILayerNode::const_iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
191
 
                {
192
 
                        if (static_cast<const LayerNode*>(*iter)->isOutOfDate())
193
 
                                return true;
194
 
                }
195
 
 
196
 
                return mOutOfDate;
197
 
        }
198
 
 
199
 
} // namespace MyGUI
 
1
/*
 
2
 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
 
3
 * Distributed under the MIT License
 
4
 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
 
5
 */
 
6
 
 
7
#include "MyGUI_Precompiled.h"
 
8
#include "MyGUI_LayerItem.h"
 
9
#include "MyGUI_OverlappedLayer.h"
 
10
#include "MyGUI_LayerNode.h"
 
11
#include "MyGUI_RenderManager.h"
 
12
 
 
13
namespace MyGUI
 
14
{
 
15
 
 
16
        OverlappedLayer::OverlappedLayer() :
 
17
                mIsPick(false),
 
18
                mOutOfDate(false)
 
19
        {
 
20
                mViewSize = RenderManager::getInstance().getViewSize();
 
21
        }
 
22
 
 
23
        OverlappedLayer::~OverlappedLayer()
 
24
        {
 
25
                MYGUI_ASSERT(mChildItems.empty(), "Layer '" << getName() << "' must be empty before destroy");
 
26
        }
 
27
 
 
28
        void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
 
29
        {
 
30
                mName = _node->findAttribute("name");
 
31
                if (_version >= Version(1, 2))
 
32
                {
 
33
                        MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
 
34
                        while (propert.next("Property"))
 
35
                        {
 
36
                                const std::string& key = propert->findAttribute("key");
 
37
                                const std::string& value = propert->findAttribute("value");
 
38
                                if (key == "Pick")
 
39
                                        mIsPick = utility::parseValue<bool>(value);
 
40
                        }
 
41
                }
 
42
                else if (_version >= Version(1, 0))
 
43
                {
 
44
                        mIsPick = utility::parseBool(_node->findAttribute("pick"));
 
45
                }
 
46
                else
 
47
                {
 
48
                        mIsPick = utility::parseBool(_node->findAttribute("peek"));
 
49
                }
 
50
        }
 
51
 
 
52
        ILayerNode* OverlappedLayer::createChildItemNode()
 
53
        {
 
54
                // создаем рутовый айтем
 
55
                ILayerNode* node = new LayerNode(this);
 
56
                mChildItems.push_back(node);
 
57
 
 
58
                mOutOfDate = true;
 
59
 
 
60
                return node;
 
61
        }
 
62
 
 
63
        void OverlappedLayer::destroyChildItemNode(ILayerNode* _item)
 
64
        {
 
65
                // если есть отец, то русть сам и удаляет
 
66
                ILayerNode* parent = _item->getParent();
 
67
                if (parent)
 
68
                {
 
69
                        parent->destroyChildItemNode(_item);
 
70
 
 
71
                        mOutOfDate = true;
 
72
 
 
73
                        return;
 
74
                }
 
75
 
 
76
                // айтем рутовый, мы удаляем
 
77
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
 
78
                {
 
79
                        if ((*iter) == _item)
 
80
                        {
 
81
                                delete _item;
 
82
                                mChildItems.erase(iter);
 
83
 
 
84
                                mOutOfDate = true;
 
85
 
 
86
                                return;
 
87
                        }
 
88
                }
 
89
 
 
90
                MYGUI_EXCEPT("item node not found");
 
91
        }
 
92
 
 
93
        void OverlappedLayer::upChildItemNode(ILayerNode* _item)
 
94
        {
 
95
                // если есть отец, то пусть сам рулит
 
96
                ILayerNode* parent = _item->getParent();
 
97
                if (parent != nullptr)
 
98
                {
 
99
                        parent->upChildItemNode(_item);
 
100
 
 
101
                        mOutOfDate = true;
 
102
 
 
103
                        return;
 
104
                }
 
105
 
 
106
                if ((2 > mChildItems.size()) || (mChildItems.back() == _item))
 
107
                        return;
 
108
 
 
109
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
 
110
                {
 
111
                        if ((*iter) == _item)
 
112
                        {
 
113
                                mChildItems.erase(iter);
 
114
                                mChildItems.push_back(_item);
 
115
 
 
116
                                mOutOfDate = true;
 
117
 
 
118
                                return;
 
119
                        }
 
120
                }
 
121
 
 
122
                MYGUI_EXCEPT("item node not found");
 
123
        }
 
124
 
 
125
        ILayerItem* OverlappedLayer::getLayerItemByPoint(int _left, int _top) const
 
126
        {
 
127
                if (!mIsPick)
 
128
                        return nullptr;
 
129
 
 
130
                VectorILayerNode::const_reverse_iterator iter = mChildItems.rbegin();
 
131
                while (iter != mChildItems.rend())
 
132
                {
 
133
                        ILayerItem* item = (*iter)->getLayerItemByPoint(_left, _top);
 
134
                        if (item != nullptr)
 
135
                                return item;
 
136
                        ++iter;
 
137
                }
 
138
                return nullptr;
 
139
        }
 
140
 
 
141
        IntPoint OverlappedLayer::getPosition(int _left, int _top) const
 
142
        {
 
143
                return IntPoint(_left, _top);
 
144
        }
 
145
 
 
146
        void OverlappedLayer::renderToTarget(IRenderTarget* _target, bool _update)
 
147
        {
 
148
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
 
149
                        (*iter)->renderToTarget(_target, _update);
 
150
 
 
151
                mOutOfDate = false;
 
152
        }
 
153
 
 
154
        void OverlappedLayer::resizeView(const IntSize& _viewSize)
 
155
        {
 
156
                for (VectorILayerNode::iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
 
157
                        (*iter)->resizeView(_viewSize);
 
158
 
 
159
                mViewSize = _viewSize;
 
160
        }
 
161
 
 
162
        EnumeratorILayerNode OverlappedLayer::getEnumerator() const
 
163
        {
 
164
                return EnumeratorILayerNode(mChildItems);
 
165
        }
 
166
 
 
167
        size_t OverlappedLayer::getLayerNodeCount() const
 
168
        {
 
169
                return mChildItems.size();
 
170
        }
 
171
 
 
172
        ILayerNode* OverlappedLayer::getLayerNodeAt(size_t _index) const
 
173
        {
 
174
                MYGUI_ASSERT_RANGE(_index, mChildItems.size(), "OverlappedLayer::getLayerNodeAt");
 
175
 
 
176
                return mChildItems[_index];
 
177
        }
 
178
 
 
179
        const IntSize& OverlappedLayer::getSize() const
 
180
        {
 
181
                return mViewSize;
 
182
        }
 
183
 
 
184
        bool OverlappedLayer::isOutOfDate() const
 
185
        {
 
186
                for (VectorILayerNode::const_iterator iter = mChildItems.begin(); iter != mChildItems.end(); ++iter)
 
187
                {
 
188
                        if (static_cast<const LayerNode*>(*iter)->isOutOfDate())
 
189
                                return true;
 
190
                }
 
191
 
 
192
                return mOutOfDate;
 
193
        }
 
194
 
 
195
} // namespace MyGUI