dali-toolkit/internal/visuals/visual-base-data-impl.h

   1 #ifndef DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H
   2 #define DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_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 <dali/public-api/math/vector2.h>
  23 #include <dali/public-api/rendering/visual-renderer.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  27 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  28 #include <dali-toolkit/internal/visuals/visual-event-observer.h>
  29 #include <dali-toolkit/public-api/align-enumerations.h>
  30 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  31
  32 namespace Dali
  33 {
  34 namespace Toolkit
  35 {
  36 namespace Internal
  37 {
  38 namespace Visual
  39 {
  40 struct Base::Impl
  41 {
  42   /**
  43    * Constructor
  44    * @param [in] fittingMode that the derived class prefers
  45    * @param [in] type The type of the this visual
  46    */
  47   Impl(FittingMode fittingMode, Toolkit::Visual::Type type);
  48
  49   /**
  50    * Destructor
  51    */
  52   ~Impl();
  53
  54   enum Flags
  55   {
  56     IS_ON_SCENE                        = 1,
  57     IS_ATLASING_APPLIED                = 1 << 1,
  58     IS_PREMULTIPLIED_ALPHA             = 1 << 2,
  59     IS_SYNCHRONOUS_RESOURCE_LOADING    = 1 << 3,
  60   };
  61
  62   struct CustomShader
  63   {
  64     CustomShader(const Property::Map& map);
  65     void SetPropertyMap(const Property::Map& map);
  66     void CreatePropertyMap(Property::Map& map) const;
  67
  68     std::string               mVertexShader;
  69     std::string               mFragmentShader;
  70     Dali::ImageDimensions     mGridSize;
  71     Dali::Shader::Hint::Value mHints; //(bitfield) values from enum Shader::Hint
  72   };
  73
  74   struct Transform
  75   {
  76     /**
  77      * Default constructor ensures the visual fills the control
  78      */
  79     Transform();
  80
  81     /**
  82      * Use the property map to set zero or more of the transform
  83      * attributes, and sets the remaining attributes to their default
  84      * values.
  85      */
  86     void SetPropertyMap(const Property::Map& map);
  87
  88     /**
  89      * Add the transform attributes to the map (using integer keys)
  90      */
  91     void GetPropertyMap(Property::Map& map) const;
  92
  93     /**
  94      * Update zero or more attributes from the property map.
  95      */
  96     void UpdatePropertyMap(const Property::Map& map);
  97
  98     /**
  99      * Set the uniform properties onto the renderer
 100      */
 101     void SetUniforms(VisualRenderer renderer, Toolkit::Direction::Type direction);
 102
 103     /**
 104      * Convert the control size and the transform attributes into the actual
 105      * size of the visual.
 106      */
 107     Vector2 GetVisualSize(const Vector2& controlSize);
 108
 109     Vector2              mOffset;
 110     Vector2              mSize;
 111     Vector2              mExtraSize;
 112     Vector4              mOffsetSizeMode;
 113     Toolkit::Align::Type mOrigin;
 114     Toolkit::Align::Type mAnchorPoint;
 115   };
 116
 117   struct DecorationData
 118   {
 119     // Default constructor
 120     DecorationData()
 121     : mBorderlineColor(Color::BLACK),
 122       mCornerRadius(Vector4::ZERO),
 123       mBorderlineWidth(0.0f),
 124       mBorderlineOffset(0.0f),
 125       mCornerRadiusPolicy(static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE))
 126     {
 127     }
 128     Vector4 mBorderlineColor;
 129     Vector4 mCornerRadius;
 130     float   mBorderlineWidth;
 131     float   mBorderlineOffset;
 132     int     mCornerRadiusPolicy;
 133   };
 134
 135   DecorationData* EnsureDecorationData()
 136   {
 137     if(mDecorationData == nullptr)
 138     {
 139       mDecorationData = new DecorationData();
 140     }
 141     return mDecorationData;
 142   }
 143
 144   /**
 145    * @brief Get decoration data value : borderline width
 146    *
 147    * Keep these API as inline function due to the performance.
 148    */
 149   float GetBorderlineWidth()
 150   {
 151     return mDecorationData ? mDecorationData->mBorderlineWidth : 0.0f;
 152   }
 153
 154   /**
 155    * @brief Set decoration data value : borderline width
 156    *
 157    * Keep these API as inline function due to the performance.
 158    */
 159   void SetBorderlineWidth(float value)
 160   {
 161     EnsureDecorationData()->mBorderlineWidth = value;
 162   }
 163
 164   /**
 165    * @brief Get decoration data value : borderline color
 166    *
 167    * Keep these API as inline function due to the performance.
 168    */
 169   Vector4 GetBorderlineColor()
 170   {
 171     return mDecorationData ? mDecorationData->mBorderlineColor : Color::BLACK;
 172   }
 173
 174   /**
 175    * @brief Set decoration data value : borderline color
 176    *
 177    * Keep these API as inline function due to the performance.
 178    */
 179   void SetBorderlineColor(Vector4 value)
 180   {
 181     EnsureDecorationData()->mBorderlineColor = value;
 182   }
 183
 184   /**
 185    * @brief Get decoration data value : borderline offset
 186    *
 187    * Keep these API as inline function due to the performance.
 188    */
 189   float GetBorderlineOffset()
 190   {
 191     return mDecorationData ? mDecorationData->mBorderlineOffset : 0.0f;
 192   }
 193
 194   /**
 195    * @brief Set decoration data value : borderline offset
 196    *
 197    * Keep these API as inline function due to the performance.
 198    */
 199   void SetBorderlineOffset(float value)
 200   {
 201     EnsureDecorationData()->mBorderlineOffset = value;
 202   }
 203
 204   /**
 205    * @brief Get decoration data value : corner radius
 206    *
 207    * Keep these API as inline function due to the performance.
 208    */
 209   Vector4 GetCornerRadius()
 210   {
 211     return mDecorationData ? mDecorationData->mCornerRadius : Vector4::ZERO;
 212   }
 213
 214   /**
 215    * @brief Set decoration data value : corner radius
 216    *
 217    * Keep these API as inline function due to the performance.
 218    */
 219   void SetCornerRadius(Vector4 value)
 220   {
 221     EnsureDecorationData()->mCornerRadius = value;
 222   }
 223
 224   /**
 225    * @brief Get decoration data value : corner radius policy
 226    *
 227    * Keep these API as inline function due to the performance.
 228    */
 229   int GetCornerRadiusPolicy()
 230   {
 231     return mDecorationData ? mDecorationData->mCornerRadiusPolicy : static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE);
 232   }
 233
 234   /**
 235    * @brief Set decoration data value : corner radius policy
 236    *
 237    * Keep these API as inline function due to the performance.
 238    */
 239   void SetCornerRadiusPolicy(int value)
 240   {
 241     EnsureDecorationData()->mCornerRadiusPolicy = value;
 242   }
 243
 244   VisualRenderer                  mRenderer;
 245   CustomShader*                   mCustomShader;
 246   EventObserver*                  mEventObserver; ///< Allows controls to observe when the visual has events to notify
 247   std::string                     mName;
 248   Transform                       mTransform;
 249   Vector4                         mMixColor;
 250   Size                            mControlSize;
 251   DecorationData*                 mDecorationData;
 252   int                             mDepthIndex;
 253   FittingMode                     mFittingMode; ///< How the contents should fit the view
 254   int                             mFlags;
 255   Toolkit::Visual::ResourceStatus mResourceStatus;
 256   const Toolkit::Visual::Type     mType;
 257   bool                            mAlwaysUsingBorderline : 1;     ///< Whether we need the borderline in shader always.
 258   bool                            mAlwaysUsingCornerRadius : 1;   ///< Whether we need the corner radius in shader always.
 259 };
 260
 261 } // namespace Visual
 262
 263 } // namespace Internal
 264
 265 } // namespace Toolkit
 266
 267 } // namespace Dali
 268
 269 #endif // DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H