dali/internal/event/actors/layer-list.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/actors/layer-list.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm> // for std::swap
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/internal/event/actors/layer-impl.h>
  27 #include <dali/internal/update/manager/update-manager.h>
  28
  29 namespace Dali
  30 {
  31 namespace Internal
  32 {
  33 namespace // unnamed namespace
  34 {
  35 typedef std::vector<Layer*> LayerContainer;
  36 using LayerIter        = LayerContainer::iterator;
  37 using ReverseLayerIter = LayerContainer::reverse_iterator;
  38
  39 /**
  40  * A private helper template to return an iterator to the layer passed in.
  41  * @param[in] first position to start searching from
  42  * @param[in] last position to search to
  43  * @param[in] layer to search for
  44  * @return iterator to layer if found
  45  */
  46 template<class InputIterator>
  47 InputIterator Find(InputIterator first, InputIterator last, const Layer& layer)
  48 {
  49   for(; first != last; ++first)
  50   {
  51     if(*first == &layer)
  52     {
  53       break;
  54     }
  55   }
  56   return first;
  57 }
  58
  59 } // unnamed namespace
  60
  61 LayerList* LayerList::New(SceneGraph::UpdateManager& updateManager)
  62 {
  63   return new LayerList(updateManager);
  64 }
  65
  66 LayerList::~LayerList() = default;
  67
  68 uint32_t LayerList::GetLayerCount() const
  69 {
  70   return static_cast<uint32_t>(mLayers.size()); //  // only 4,294,967,295 layers supported
  71 }
  72
  73 Layer* LayerList::GetLayer(uint32_t depth) const
  74 {
  75   DALI_ASSERT_ALWAYS(depth < mLayers.size());
  76
  77   return mLayers[depth];
  78 }
  79
  80 uint32_t LayerList::GetDepth(const Layer* layer) const
  81 {
  82   for(uint32_t count = 0; count < mLayers.size(); ++count)
  83   {
  84     if(layer == mLayers[count])
  85     {
  86       return count;
  87     }
  88   }
  89   return 0;
  90 }
  91
  92 void LayerList::RegisterLayer(Layer& layer)
  93 {
  94   DALI_ASSERT_DEBUG(mLayers.end() == Find(mLayers.begin(), mLayers.end(), layer));
  95   mLayers.push_back(&layer);
  96
  97   SetLayerDepths();
  98 }
  99
 100 void LayerList::UnregisterLayer(Layer& layer)
 101 {
 102   // Find the layer...
 103   LayerIter iter = Find(mLayers.begin(), mLayers.end(), layer);
 104   DALI_ASSERT_DEBUG(iter != mLayers.end());
 105
 106   // ...and remove it
 107   mLayers.erase(iter);
 108
 109   SetLayerDepths();
 110 }
 111
 112 void LayerList::RaiseLayer(Layer& raiseLayer)
 113 {
 114   LayerIter iter = Find(mLayers.begin(), mLayers.end(), raiseLayer);
 115
 116   if(iter != mLayers.end() &&
 117      iter + 1 != mLayers.end())
 118   {
 119     LayerIter nextIter = iter + 1;
 120
 121     // Swap the pointers
 122     std::swap(*iter, *nextIter);
 123
 124     SetLayerDepths();
 125   }
 126 }
 127
 128 void LayerList::LowerLayer(Layer& lowerLayer)
 129 {
 130   ReverseLayerIter iter = Find(mLayers.rbegin(), mLayers.rend(), lowerLayer);
 131
 132   if(iter != mLayers.rend() &&
 133      iter + 1 != mLayers.rend())
 134   {
 135     ReverseLayerIter nextIter = iter + 1;
 136
 137     // Swap the pointers
 138     std::swap(*iter, *nextIter);
 139
 140     SetLayerDepths();
 141   }
 142 }
 143
 144 void LayerList::RaiseLayerToTop(const Layer& layer)
 145 {
 146   LayerIter iter = Find(mLayers.begin(), mLayers.end(), layer);
 147
 148   if(iter != mLayers.end() &&
 149      iter + 1 != mLayers.end())
 150   {
 151     Layer* raised = *iter;
 152
 153     copy(iter + 1, mLayers.end(), iter);
 154     mLayers.back() = raised;
 155
 156     SetLayerDepths();
 157   }
 158 }
 159
 160 void LayerList::LowerLayerToBottom(const Layer& layer)
 161 {
 162   ReverseLayerIter iter = Find(mLayers.rbegin(), mLayers.rend(), layer);
 163
 164   if(iter != mLayers.rend() &&
 165      iter + 1 != mLayers.rend())
 166   {
 167     Layer* lowered = *iter;
 168
 169     copy(iter + 1, mLayers.rend(), iter);
 170     mLayers.front() = lowered;
 171
 172     SetLayerDepths();
 173   }
 174 }
 175
 176 void LayerList::MoveLayerAbove(const Layer& layer, const Layer& target)
 177 {
 178   // check if it already is
 179   if(layer.GetDepth() == (target.GetDepth() + 1))
 180   {
 181     return;
 182   }
 183
 184   // find the layer to move
 185   LayerIter iter = Find(mLayers.begin(), mLayers.end(), layer);
 186
 187   if(iter != mLayers.end())
 188   {
 189     Layer* moved = *iter;
 190     mLayers.erase(iter);
 191     // find target
 192     LayerIter iterT = Find(mLayers.begin(), mLayers.end(), target);
 193     // if target is not found there's a programming error somewhere
 194     DALI_ASSERT_DEBUG(iterT != mLayers.end());
 195     // iterT might be the last
 196     if((iterT + 1) == mLayers.end())
 197     {
 198       mLayers.push_back(moved);
 199     }
 200     else
 201     {
 202       mLayers.insert(iterT + 1, moved);
 203     }
 204
 205     SetLayerDepths();
 206   }
 207 }
 208
 209 void LayerList::MoveLayerBelow(const Layer& layer, const Layer& target)
 210 {
 211   // check if it already is in correct order
 212   if(layer.GetDepth() == (target.GetDepth() - 1))
 213   {
 214     return;
 215   }
 216
 217   // find the layer to move
 218   LayerIter iter = Find(mLayers.begin(), mLayers.end(), layer);
 219   if(iter != mLayers.end())
 220   {
 221     Layer* moved = *iter;
 222     mLayers.erase(iter);
 223     // find target
 224     LayerIter iterT = Find(mLayers.begin(), mLayers.end(), target);
 225     // if target is not found there's a programming error somewhere
 226     DALI_ASSERT_DEBUG(iterT != mLayers.end());
 227     mLayers.insert(iterT, moved);
 228
 229     SetLayerDepths();
 230   }
 231 }
 232
 233 LayerList::LayerList(SceneGraph::UpdateManager& updateManager)
 234 : mUpdateManager(updateManager),
 235   mRoot(nullptr)
 236 {
 237 }
 238
 239 void LayerList::SetLayerDepths()
 240 {
 241   // we've got a list of on-stage layers on actor side, need to get their stage
 242   // pointers so we can send them to the update manager
 243   std::vector<SceneGraph::Layer*> layers;
 244   layers.reserve(mLayers.size());
 245
 246   // Set the layers (possibly) new depth
 247   for(LayerIter iter = mLayers.begin(); iter != mLayers.end(); ++iter)
 248   {
 249     SceneGraph::Layer* layerPtr = const_cast<SceneGraph::Layer*>(&((*iter)->GetSceneGraphLayer()));
 250     layers.push_back(layerPtr);
 251   }
 252
 253   // Layers are being used in a separate thread; queue a message to set order
 254   SetLayerDepthsMessage(mUpdateManager, layers, &(mRoot->GetSceneGraphLayer()));
 255 }
 256
 257 void LayerList::SetRootLayer(Layer* rootLayer)
 258 {
 259   mRoot = rootLayer;
 260
 261   SetLayerDepths();
 262 }
 263
 264 } // namespace Internal
 265
 266 } // namespace Dali