dali-toolkit/internal/layouting/layout-controller-impl.h

   1 #ifndef DALI_TOOLKIT_INTERNAL_LAYOUT_CONTROLLER_H
   2 #define DALI_TOOLKIT_INTERNAL_LAYOUT_CONTROLLER_H
   3
   4 /*
   5  * Copyright (c) 2018 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 #include <list>
  20 #include <dali/public-api/object/base-object.h>
  21 #include <dali/integration-api/core.h>
  22 #include <dali-toolkit/public-api/controls/control.h>
  23 #include <dali-toolkit/devel-api/layouting/layout-controller.h>
  24 #include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
  25 #include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
  26 #include <dali-toolkit/internal/layouting/layout-transition-data-impl.h>
  27
  28 namespace Dali
  29 {
  30 namespace Toolkit
  31 {
  32 namespace Internal
  33 {
  34
  35 /**
  36  * @brief Layout controller handles measurement and layout of all
  37  * controls that utilize Layouts.
  38  */
  39 class LayoutController : public Dali::BaseObject, public Integration::Processor
  40 {
  41 public:
  42   /**
  43    * Constructor
  44    */
  45   LayoutController();
  46
  47   /**
  48    * Destructor
  49    */
  50   ~LayoutController();
  51
  52   /**
  53    * Second stage initialization
  54    */
  55   void Initialize();
  56
  57   /**
  58    * This marks the given layout and all its parents as dirty and triggers a transition if set.
  59    */
  60   void RequestLayout( LayoutItem& layout, int layoutTransitionType, Actor gainedChild, Actor lostChild );
  61
  62   /**
  63    * Measures next level of layouts in the actor hierarchy.
  64    */
  65   void MeasureHierarchy( Actor root, MeasureSpec widthSpec, MeasureSpec heightSpec );
  66
  67   /**
  68    * Perform layout of the hierarchy
  69    */
  70   void PerformLayout( Actor root, int left, int top, int right, int bottom );
  71
  72   /**
  73    * Perform positioning of actors after layout update
  74    */
  75   void PerformLayoutPositioning( LayoutPositionDataArray& layoutPositionDataArray, bool all ) const;
  76
  77   /**
  78    * Perform animation of actors properties after layout update
  79    */
  80   void PerformLayoutAnimation( LayoutTransition& layoutTransition, LayoutPositionDataArray& layoutPositionDataArray, LayoutDataArray& layoutDataArray, LayoutAnimatorArray& layoutAnimatorArray );
  81
  82   /**
  83    * Focus change callback.
  84    */
  85   void KeyInputFocusChangedCallback( Control gainingActor, Control lostActor );
  86
  87 protected: // Implementation of Processor
  88
  89   /**
  90    * @copydoc Dali::Integration::Processor::Process()
  91    */
  92   virtual void Process();
  93
  94 private:
  95   std::list< LayoutTransition > mLayoutTransitions;
  96   struct AnimationFinishedFunctor
  97   {
  98     AnimationFinishedFunctor( LayoutController& layoutController, LayoutTransition& layoutTransition, LayoutPositionDataArray& array )
  99     : layoutController( layoutController ),
 100       layoutDataPositionArray(),
 101       layoutItem( layoutTransition.layoutItem ),
 102       layoutTransitionType( layoutTransition.layoutTransitionType )
 103     {
 104       layoutDataPositionArray.swap( array );
 105     }
 106
 107     void operator()( Animation& animation )
 108     {
 109       layoutController.PerformLayoutPositioning( layoutDataPositionArray, true );
 110       layoutController.mAnimationFinishedFunctors.pop_front();
 111       if (layoutTransitionType != -1)
 112       {
 113         LayoutTransitionDataPtr layoutTransitionDataPtr = layoutItem->GetTransitionData( layoutTransitionType );
 114         layoutTransitionDataPtr->EmitSignalFinish( layoutTransitionType );
 115       }
 116     }
 117
 118     LayoutController& layoutController;
 119     LayoutPositionDataArray layoutDataPositionArray;
 120     LayoutItemPtr layoutItem;
 121     int layoutTransitionType;
 122   };
 123
 124   bool mLayoutRequested;
 125   Animation mAnimation;
 126   std::list< AnimationFinishedFunctor > mAnimationFinishedFunctors;
 127
 128   struct FocusChangedFunctor
 129   {
 130     FocusChangedFunctor( LayoutController& layoutController )
 131     : layoutController( layoutController )
 132     {
 133     }
 134
 135     void operator() ( Dali::Toolkit::Control gainingControl, Dali::Toolkit::Control lostActor );
 136     LayoutController& layoutController;
 137   };
 138   FocusChangedFunctor mFocusChangedFunctor;
 139
 140   SlotDelegate<LayoutController> mSlotDelegate;
 141 };
 142
 143 } // namespace Internal
 144
 145 inline Internal::LayoutController& GetImpl( Dali::Toolkit::LayoutController& handle )
 146 {
 147   DALI_ASSERT_ALWAYS(handle);
 148   Dali::BaseObject& object = handle.GetBaseObject();
 149   return static_cast<Internal::LayoutController&>(object);
 150 }
 151
 152 inline const Internal::LayoutController& GetImpl( const Dali::Toolkit::LayoutController& handle )
 153 {
 154   DALI_ASSERT_ALWAYS(handle);
 155   const Dali::BaseObject& object = handle.GetBaseObject();
 156   return static_cast<const Internal::LayoutController&>(object);
 157 }
 158
 159 } // namespace Toolkit
 160 } // namespace Dali
 161
 162 #endif // DALI_TOOLKIT_INTERNAL_LAYOUT_CONTROLLER_H