dali-toolkit/internal/controls/image-view/image-view-impl.h

   1 #ifndef DALI_TOOLKIT_INTERNAL_IMAGE_VIEW_H
   2 #define DALI_TOOLKIT_INTERNAL_IMAGE_VIEW_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/object/property-map.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/internal/visuals/image/image-visual.h>
  26 #include <dali-toolkit/public-api/controls/control-impl.h>
  27 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  28
  29 namespace Dali
  30 {
  31 namespace Toolkit
  32 {
  33 class ImageView;
  34
  35 namespace Internal
  36 {
  37 class ImageView : public Control
  38 {
  39 protected:
  40   /**
  41    * Construct a new ImageView.
  42    *
  43    * @param[in] additionalBehaviour additional behaviour flags for this ImageView
  44    */
  45   ImageView(ControlBehaviour additionalBehaviour);
  46
  47   /**
  48    * A reference counted object may only be deleted by calling Unreference()
  49    */
  50   virtual ~ImageView();
  51
  52 public:
  53   /**
  54    * Create a new ImageView.
  55    *
  56    * @param[in] additionalBehaviour custom behavior flags for this ImageView. Default is CONTROL_BEHAVIOUR_DEFAULT
  57    * @return A smart-pointer to the newly allocated ImageView.
  58    */
  59   static Toolkit::ImageView New(ControlBehaviour additionalBehaviour = ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
  60
  61   /**
  62    * @brief Sets this ImageView from an Dali::Property::Map
  63    *
  64    * If the handle is empty, ImageView will display nothing
  65    * @param[in] map The Dali::Property::Map to use for to display.
  66    */
  67   void SetImage(const Dali::Property::Map& map);
  68
  69   /**
  70    * @copydoc Dali::Toolkit::SetImage
  71    */
  72   void SetImage(const std::string& imageUrl, ImageDimensions size);
  73
  74   /**
  75    * @brief Unregister ImageView IMAGE visual
  76    *
  77    * ImageView will display nothing
  78    */
  79   void ClearImageVisual();
  80
  81   /**
  82    * @brief Set whether the Pre-multiplied Alpha Blending is required
  83    *
  84    * @param[in] preMultipled whether alpha is pre-multiplied.
  85    */
  86   void EnablePreMultipliedAlpha(bool preMultipled);
  87
  88   /**
  89    * @brief Query whether alpha is pre-multiplied.
  90    *
  91    * @return True if alpha is pre-multiplied, false otherwise.
  92    */
  93   bool IsPreMultipliedAlphaEnabled() const;
  94
  95   // Properties
  96   /**
  97    * Called when a property of an object of this type is set.
  98    * @param[in] object The object whose property is set.
  99    * @param[in] index The property index.
 100    * @param[in] value The new property value.
 101    */
 102   static void SetProperty(BaseObject* object, Property::Index index, const Property::Value& value);
 103
 104   /**
 105    * Called to retrieve a property of an object of this type.
 106    * @param[in] object The object whose property is to be retrieved.
 107    * @param[in] index The property index.
 108    * @return The current value of the property.
 109    */
 110   static Property::Value GetProperty(BaseObject* object, Property::Index propertyIndex);
 111
 112   /**
 113    * @brief Set the depth index of this image renderer
 114    *
 115    * Renderer with higher depth indices are rendered in front of other visuals with smaller values
 116    *
 117    * @param[in] depthIndex The depth index of this renderer
 118    */
 119   void SetDepthIndex(int depthIndex);
 120
 121 private: // From Control
 122   /**
 123    * @copydoc Toolkit::Control::OnInitialize
 124    */
 125   void OnInitialize();
 126
 127   /**
 128    * @copydoc Toolkit::Control::GetNaturalSize
 129    */
 130   Vector3 GetNaturalSize() override;
 131
 132   /**
 133    * @copydoc Toolkit::Control::GetHeightForWidth()
 134    */
 135   float GetHeightForWidth(float width) override;
 136
 137   /**
 138    * @copydoc Toolkit::Control::GetWidthForHeight()
 139    */
 140   float GetWidthForHeight(float height) override;
 141
 142   /**
 143    * @copydoc Toolkit::Control::OnRelayout()
 144    */
 145   void OnRelayout(const Vector2& size, RelayoutContainer& container) override;
 146
 147   /**
 148    * @copydoc Toolkit::Control::OnCreateTransitions()
 149    */
 150   virtual void OnCreateTransitions(std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& sourceProperties,
 151                                    std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& destinationProperties,
 152                                    Dali::Toolkit::Control                                              source,
 153                                    Dali::Toolkit::Control                                              destination) override;
 154
 155   /**
 156    * @copydoc Toolkit::Control::OnUpdateVisualProperties()
 157    */
 158   virtual void OnUpdateVisualProperties(const std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& properties) override;
 159
 160 private:
 161   /**
 162    * @brief Callback for ResourceReadySignal
 163    * param[in] control signal prototype
 164    */
 165   void OnResourceReady(Toolkit::Control control);
 166
 167   /**
 168    * @brief Set TransformMap for fittingMode
 169    * param[in] finalSize The size for fittingMode
 170    * param[in] textureSize The size of texture
 171    * param[in] offset The offset for fittingMode
 172    * param[in] fittingMode The mode for fitting image
 173    * param[in] transformMap  The map for fitting image
 174    */
 175   void SetTransformMapForFittingMode(Vector2 finalSize, Vector2 textureSize, Vector2 offset, Visual::FittingMode fittingMode, Property::Map& transformMap);
 176
 177   /**
 178    * @brief Apply fittingMode
 179    * param[in] finalSize The size for fittingMode
 180    * param[in] textureSize The size of texture
 181    * param[in] offset The offset for fittingMode
 182    * param[in] zeroPadding whether padding is zero
 183    * param[in] transformMap  The map for fitting image
 184    */
 185   void ApplyFittingMode(Vector2 finalSize, Vector2 textureSize, Vector2 offset, bool zeroPadding, Property::Map& transformMap);
 186
 187 private:
 188   // Undefined
 189   ImageView(const ImageView&);
 190   ImageView& operator=(const ImageView&);
 191
 192 private:
 193   Toolkit::Visual::Base mVisual;
 194
 195   std::string     mUrl;         ///< the url for the image if the image came from a URL, empty otherwise
 196   Property::Map   mPropertyMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
 197   Property::Map   mShaderMap;   ///< the Property::Map if the custom shader is set, empty otherwise
 198   ImageDimensions mImageSize;   ///< the image size
 199
 200   bool mImageVisualPaddingSetByTransform : 1;   //< Flag to indicate Padding was set using a transform.
 201   bool mImageViewPixelAreaSetByFittingMode : 1; //< Flag to indicate pixel area was set by fitting Mode
 202 };
 203
 204 } // namespace Internal
 205
 206 // Helpers for public-api forwarding methods
 207 inline Toolkit::Internal::ImageView& GetImpl(Toolkit::ImageView& obj)
 208 {
 209   DALI_ASSERT_ALWAYS(obj);
 210   Dali::RefObject& handle = obj.GetImplementation();
 211   return static_cast<Toolkit::Internal::ImageView&>(handle);
 212 }
 213
 214 inline const Toolkit::Internal::ImageView& GetImpl(const Toolkit::ImageView& obj)
 215 {
 216   DALI_ASSERT_ALWAYS(obj);
 217   const Dali::RefObject& handle = obj.GetImplementation();
 218   return static_cast<const Toolkit::Internal::ImageView&>(handle);
 219 }
 220
 221 } // namespace Toolkit
 222
 223 } // namespace Dali
 224
 225 #endif // DALI_TOOLKIT_INTERNAL_IMAGE_VIEW_H