dali/internal/event/size-negotiation/relayout-controller-impl.h

   1 #ifndef DALI_INTERNAL_RELAYOUT_CONTROLLER_IMPL_H
   2 #define DALI_INTERNAL_RELAYOUT_CONTROLLER_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstdint>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/internal/common/memory-pool-object-allocator.h>
  26 #include <dali/internal/event/size-negotiation/memory-pool-relayout-container.h>
  27 #include <dali/public-api/common/vector-wrapper.h>
  28 #include <dali/public-api/object/base-object.h>
  29 #include <dali/public-api/size-negotiation/relayout-container.h>
  30
  31 namespace Dali
  32 {
  33 namespace Integration
  34 {
  35 class RenderController;
  36 }
  37
  38 namespace Internal
  39 {
  40 /**
  41  * @brief The relayout controller is responsible for taking request from actors to relayout their sizes.
  42  * The requests are actioned on at the end of the frame where all actors that have made a request are
  43  * resized.
  44  */
  45 class RelayoutController : public Dali::BaseObject
  46 {
  47 public:
  48   /**
  49    * @brief Constructor.
  50    * We should only create a unique instance.
  51    * @param[in] controller to request a render from the RenderController if core is not processing events.
  52    */
  53   RelayoutController(Integration::RenderController& controller);
  54
  55   /**
  56    * Destructor
  57    */
  58   ~RelayoutController() override;
  59
  60   /**
  61    * @brief Get the singleton of RelayoutController object.
  62    *
  63    * @return A handle to the RelayoutController control.
  64    */
  65   static RelayoutController* Get();
  66
  67   /**
  68    * @brief Request to relayout the given actor and all sub-actors of it.
  69    *
  70    * This flags the actor and all actors dependent on it for relayout. The actual
  71    * relayout is performed at the end of the frame. This means that multiple calls to relayout
  72    * will not cause multiple relayouts to occur.
  73    *
  74    * @param[in] actor The actor to request relayout on
  75    * @param[in] dimension The dimension(s) to request the relayout on. Defaults to all dimensions
  76    */
  77   void RequestRelayout(Dali::Actor& actor, Dimension::Type dimension = Dimension::ALL_DIMENSIONS);
  78
  79   /**
  80    * @brief Request to relayout of all actors in the sub-tree below the given actor.
  81    *
  82    * This flags the actor and all actors below it for relayout. The actual
  83    * relayout is performed at the end of the frame. This means that multiple calls to relayout
  84    * will not cause multiple relayouts to occur.
  85    *
  86    * @param[in] actor The actor to request relayout on
  87    */
  88   void RequestRelayoutTree(Dali::Actor& actor);
  89
  90   /**
  91    * @brief Force propagate relayout flags through the tree. This is similiar to Request Relayout
  92    * except all dependencies have their flags reset in spite of whether they are all ready set.
  93    *
  94    * This is useful for resetting layout flags during the layout process.
  95    *
  96    * @param[in] actor The actor to propagate from
  97    * @param[in] dimension The dimension to propagate on
  98    */
  99   void PropagateFlags(Dali::Actor& actor, Dimension::Type dimension = Dimension::ALL_DIMENSIONS);
 100
 101   /**
 102    * @brief Relayouts all actors that have been marked as dirty
 103    */
 104   void Relayout();
 105
 106   /**
 107    * @brief Enable/disable the controller
 108    *
 109    * @param[in] enabled Flag to indicate whether the controller should be enabled or disabled
 110    */
 111   void SetEnabled(bool enabled);
 112
 113   /**
 114    * @brief Return true if the relayout controller is currently performing a relayout
 115    *
 116    * @return Return true if the relayout controller is currently performing a relayout
 117    */
 118   bool IsPerformingRelayout() const;
 119
 120   /**
 121    * @brief Sets whether core is processing events.
 122    *
 123    * @param[in] processingEvents whether core is processing events.
 124    */
 125   void SetProcessingCoreEvents(bool processingEvents);
 126
 127   /**
 128    * Get the capacity of the memory pool containing relayout info
 129    * (It Should be regularly purged!)
 130    */
 131   uint32_t GetMemoryPoolCapacity();
 132
 133 public: // CALLBACKS
 134   /**
 135    * @brief Callback raised after the application creates the scene
 136    */
 137   void OnApplicationSceneCreated();
 138
 139   /**
 140    * @brief Callback for when an object is destroyed
 141    *
 142    * @param[in] object The object being destroyed
 143    */
 144   void OnObjectDestroyed(const Dali::RefObject* object);
 145
 146 private:
 147   using RawActorList = Dali::Vector<Dali::Internal::Actor*>;
 148
 149   /**
 150    * @brief Request for relayout. Relays out whole scene.
 151    */
 152   void Request();
 153
 154   /**
 155    * @brief Add actor to request list
 156    *
 157    * @param[in] actor The root of the sub tree to add
 158    */
 159   void AddRequest(Dali::Actor& actor);
 160
 161   /**
 162    * @brief Remove actor from request list
 163    *
 164    * @param[in] actor The root of the sub tree to remove
 165    */
 166   void RemoveRequest(Dali::Actor& actor);
 167
 168   /**
 169    * @brief Disconnect the Relayout() method from the Stage::EventProcessingFinishedSignal().
 170    */
 171   void Disconnect();
 172
 173   /**
 174    * @brief Propagate dirty layout flags to actor and all sub-actors. This will stop propagating when a dirty actor
 175    * is found.
 176    *
 177    * @param[in] actor The actor to propagate on
 178    * @param[in] dimension The dimension to propagate on
 179    * @param[in] topOfSubTreeStack The top of the sub tree that this actor is in
 180    * @param[in] potentialRedundantSubRoots Actors collected as potentially already being included in relayout
 181    */
 182   void PropagateAll(Dali::Actor& actor, Dimension::Type dimension, std::vector<Dali::Actor>& topOfSubTreeStack, std::vector<Dali::Actor>& potentialRedundantSubRoots);
 183
 184   /**
 185    * Queue an actor on the relayout container
 186    *
 187    * @param[in] actor The actor to be queued
 188    * @param[in] actors The container to add the actor to
 189    * @param[in] size The size that this actor should be
 190    */
 191   void QueueActor(Internal::Actor* actor, RelayoutContainer& actors, Vector2 size);
 192
 193   /**
 194    * @brief Find the given object in the list and null it out
 195    *
 196    * @param[in] list The list to search
 197    * @param[in] object The object to search for
 198    */
 199   void FindAndZero(const RawActorList& list, const Dali::RefObject* object);
 200
 201   // Undefined
 202   RelayoutController(const RelayoutController&) = delete;
 203   RelayoutController& operator=(const RelayoutController&) = delete;
 204
 205 private:
 206   Integration::RenderController&                                       mRenderController;
 207   MemoryPoolObjectAllocator<MemoryPoolRelayoutContainer::RelayoutInfo> mRelayoutInfoAllocator;
 208
 209   SlotDelegate<RelayoutController> mSlotDelegate;
 210
 211   RawActorList                 mDirtyLayoutSubTrees; ///< List of roots of sub trees that are dirty
 212   MemoryPoolRelayoutContainer* mRelayoutStack;       ///< Stack for relayouting
 213
 214   bool mRelayoutConnection : 1;   ///< Whether EventProcessingFinishedSignal signal is connected.
 215   bool mRelayoutFlag : 1;         ///< Relayout flag to avoid unnecessary calls
 216   bool mEnabled : 1;              ///< Initially disabled. Must be enabled at some point.
 217   bool mPerformingRelayout : 1;   ///< The relayout controller is currently performing a relayout
 218   bool mProcessingCoreEvents : 1; ///< Whether core is processing events.
 219 };
 220
 221 } // namespace Internal
 222
 223 } // namespace Dali
 224
 225 #endif // DALI_INTERNAL_RELAYOUT_CONTROLLER_IMPL_H