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

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