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

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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
  18 // CLASS HEADER
  19 #include "image-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/scripting/scripting.h>
  23 #include <dali/public-api/math/math-utils.h>
  24 #include <dali/public-api/object/type-registry-helper.h>
  25 #include <dali/public-api/object/type-registry.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/devel-api/controls/control-devel.h>
  29 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  30 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  31 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  32 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  33 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  34 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  35 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  36 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  37
  38 namespace Dali
  39 {
  40 namespace Toolkit
  41 {
  42 namespace Internal
  43 {
  44 namespace
  45 {
  46 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  47
  48 BaseHandle Create()
  49 {
  50   return Toolkit::ImageView::New();
  51 }
  52
  53 // Setup properties, signals and actions using the type-registry.
  54 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::ImageView, Toolkit::Control, Create);
  55 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "image", MAP, IMAGE)
  56 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "preMultipliedAlpha", BOOLEAN, PRE_MULTIPLIED_ALPHA)
  57
  58 DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(Toolkit, ImageView, "pixelArea", Vector4(0.f, 0.f, 1.f, 1.f), PIXEL_AREA)
  59 DALI_TYPE_REGISTRATION_END()
  60
  61 } // anonymous namespace
  62
  63 using namespace Dali;
  64
  65 ImageView::ImageView(ControlBehaviour additionalBehaviour)
  66 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
  67   mImageSize(),
  68   mImageVisualPaddingSetByTransform(false),
  69   mImageViewPixelAreaSetByFittingMode(false)
  70 {
  71 }
  72
  73 ImageView::~ImageView()
  74 {
  75 }
  76
  77 Toolkit::ImageView ImageView::New(ControlBehaviour additionalBehaviour)
  78 {
  79   ImageView* impl = new ImageView(additionalBehaviour);
  80
  81   Toolkit::ImageView handle = Toolkit::ImageView(*impl);
  82
  83   // Second-phase init of the implementation
  84   // This can only be done after the CustomActor connection has been made...
  85   impl->Initialize();
  86
  87   return handle;
  88 }
  89
  90 /////////////////////////////////////////////////////////////
  91
  92 void ImageView::OnInitialize()
  93 {
  94   // ImageView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to ImageView
  95   Dali::Toolkit::Control handle(GetOwner());
  96   handle.ResourceReadySignal().Connect(this, &ImageView::OnResourceReady);
  97
  98   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE);
  99 }
 100
 101 void ImageView::SetImage(const Property::Map& map)
 102 {
 103   // Comparing a property map is too expensive so just creating a new visual
 104   mPropertyMap = map;
 105   mUrl.clear();
 106
 107   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(mPropertyMap);
 108   if(visual)
 109   {
 110     // Don't set mVisual until it is ready and shown. Getters will still use current visual.
 111     if(!mVisual)
 112     {
 113       mVisual = visual;
 114     }
 115
 116     if(!mShaderMap.Empty())
 117     {
 118       Internal::Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 119       visualImpl.SetCustomShader(mShaderMap);
 120     }
 121
 122     DevelControl::RegisterVisual(*this, Toolkit::ImageView::Property::IMAGE, visual);
 123   }
 124   else
 125   {
 126     // Unregister the exsiting visual
 127     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 128
 129     // Trigger a size negotiation request that may be needed when unregistering a visual.
 130     RelayoutRequest();
 131   }
 132
 133   // Signal that a Relayout may be needed
 134 }
 135
 136 void ImageView::SetImage(const std::string& url, ImageDimensions size)
 137 {
 138   // Don't bother comparing if we had a visual previously, just drop old visual and create new one
 139   mUrl       = url;
 140   mImageSize = size;
 141   mPropertyMap.Clear();
 142
 143   // Don't set mVisual until it is ready and shown. Getters will still use current visual.
 144   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(url, size);
 145   if(visual)
 146   {
 147     if(!mVisual)
 148     {
 149       mVisual = visual;
 150     }
 151
 152     if(!mShaderMap.Empty())
 153     {
 154       Internal::Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 155       visualImpl.SetCustomShader(mShaderMap);
 156     }
 157
 158     DevelControl::RegisterVisual(*this, Toolkit::ImageView::Property::IMAGE, visual);
 159   }
 160   else
 161   {
 162     // Unregister the exsiting visual
 163     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 164
 165     // Trigger a size negotiation request that may be needed when unregistering a visual.
 166     RelayoutRequest();
 167   }
 168
 169   // Signal that a Relayout may be needed
 170 }
 171
 172 void ImageView::ClearImageVisual()
 173 {
 174   // Clear cached properties
 175   mPropertyMap.Clear();
 176   mUrl.clear();
 177
 178   // Unregister the exsiting visual
 179   DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 180
 181   // Trigger a size negotiation request that may be needed when unregistering a visual.
 182   RelayoutRequest();
 183 }
 184
 185 void ImageView::EnablePreMultipliedAlpha(bool preMultipled)
 186 {
 187   if(mVisual)
 188   {
 189     Toolkit::GetImplementation(mVisual).EnablePreMultipliedAlpha(preMultipled);
 190   }
 191 }
 192
 193 bool ImageView::IsPreMultipliedAlphaEnabled() const
 194 {
 195   if(mVisual)
 196   {
 197     return Toolkit::GetImplementation(mVisual).IsPreMultipliedAlphaEnabled();
 198   }
 199   return false;
 200 }
 201
 202 void ImageView::SetDepthIndex(int depthIndex)
 203 {
 204   if(mVisual)
 205   {
 206     mVisual.SetDepthIndex(depthIndex);
 207   }
 208 }
 209
 210 Vector3 ImageView::GetNaturalSize()
 211 {
 212   if(mVisual)
 213   {
 214     Vector2 rendererNaturalSize;
 215     mVisual.GetNaturalSize(rendererNaturalSize);
 216
 217     Extents padding;
 218     padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 219
 220     rendererNaturalSize.width += (padding.start + padding.end);
 221     rendererNaturalSize.height += (padding.top + padding.bottom);
 222     return Vector3(rendererNaturalSize);
 223   }
 224
 225   // if no visual then use Control's natural size
 226   return Control::GetNaturalSize();
 227 }
 228
 229 float ImageView::GetHeightForWidth(float width)
 230 {
 231   Extents padding;
 232   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 233
 234   if(mVisual)
 235   {
 236     return mVisual.GetHeightForWidth(width) + padding.top + padding.bottom;
 237   }
 238   else
 239   {
 240     return Control::GetHeightForWidth(width) + padding.top + padding.bottom;
 241   }
 242 }
 243
 244 float ImageView::GetWidthForHeight(float height)
 245 {
 246   Extents padding;
 247   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 248
 249   if(mVisual)
 250   {
 251     return mVisual.GetWidthForHeight(height) + padding.start + padding.end;
 252   }
 253   else
 254   {
 255     return Control::GetWidthForHeight(height) + padding.start + padding.end;
 256   }
 257 }
 258
 259 void ImageView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 260 {
 261   Control::OnRelayout(size, container);
 262   if(mVisual)
 263   {
 264     Property::Map transformMap = Property::Map();
 265
 266     Extents padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 267
 268     bool zeroPadding = (padding == Extents());
 269
 270     Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(
 271       Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
 272     if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
 273     {
 274       std::swap(padding.start, padding.end);
 275     }
 276
 277     // remove padding from the size to know how much is left for the visual
 278     Vector2 finalSize   = size - Vector2(padding.start + padding.end, padding.top + padding.bottom);
 279     Vector2 finalOffset = Vector2(padding.start, padding.top);
 280
 281     ApplyFittingMode(finalSize, finalOffset, zeroPadding, transformMap);
 282
 283     mVisual.SetTransformAndSize(transformMap, size);
 284
 285     // mVisual is not updated util the resource is ready in the case of visual replacement.
 286     // in this case, the Property Map must be initialized so that the previous value is not reused.
 287     // after mVisual is updated, the correct value will be reset.
 288     Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 289     if(visual && visual != mVisual)
 290     {
 291       visual.SetTransformAndSize(Property::Map(), size);
 292     }
 293   }
 294 }
 295
 296 void ImageView::OnCreateTransitions(std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& sourceProperties,
 297                                     std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& destinationProperties,
 298                                     Dali::Toolkit::Control                                              source,
 299                                     Dali::Toolkit::Control                                              destination)
 300 {
 301   // Retrieves image properties to be transitioned.
 302   Dali::Property::Map imageSourcePropertyMap, imageDestinationPropertyMap;
 303   MakeVisualTransition(imageSourcePropertyMap, imageDestinationPropertyMap, source, destination, Toolkit::ImageView::Property::IMAGE);
 304   if(imageSourcePropertyMap.Count() > 0)
 305   {
 306     sourceProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageSourcePropertyMap));
 307     destinationProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageDestinationPropertyMap));
 308   }
 309 }
 310
 311 void ImageView::OnUpdateVisualProperties(const std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& properties)
 312 {
 313   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 314   if(visual)
 315   {
 316     Dali::Toolkit::Control handle(GetOwner());
 317
 318     for(auto&& data : properties)
 319     {
 320       if(data.first == Toolkit::ImageView::Property::IMAGE)
 321       {
 322         DevelControl::DoAction(handle, Toolkit::ImageView::Property::IMAGE, DevelVisual::Action::UPDATE_PROPERTY, data.second);
 323         break;
 324       }
 325     }
 326   }
 327 }
 328
 329 void ImageView::OnResourceReady(Toolkit::Control control)
 330 {
 331   // Visual ready so update visual attached to this ImageView, following call to RelayoutRequest will use this visual.
 332   mVisual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 333   // Signal that a Relayout may be needed
 334 }
 335
 336 void ImageView::SetTransformMapForFittingMode(Vector2 finalSize, Vector2 naturalSize, Vector2 finalOffset, Visual::FittingMode fittingMode, Property::Map& transformMap)
 337 {
 338   switch(fittingMode)
 339   {
 340     case Visual::FittingMode::FIT_KEEP_ASPECT_RATIO:
 341     {
 342       auto availableVisualSize = finalSize;
 343
 344       // scale to fit the padded area
 345       finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0),
 346                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0));
 347
 348       // calculate final offset within the padded area
 349       finalOffset += (availableVisualSize - finalSize) * .5f;
 350
 351       // populate the transform map
 352       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 353         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 354       break;
 355     }
 356     case Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO:
 357     {
 358       mImageViewPixelAreaSetByFittingMode = true;
 359       auto availableVisualSize            = finalSize;
 360       finalSize                           = naturalSize * std::max((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 361                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 362
 363       auto originalOffset = finalOffset;
 364       finalOffset += (availableVisualSize - finalSize) * .5f;
 365
 366       float   x           = abs((availableVisualSize.width - finalSize.width) / finalSize.width) * .5f;
 367       float   y           = abs((availableVisualSize.height - finalSize.height) / finalSize.height) * .5f;
 368       float   widthRatio  = 1.f - abs((availableVisualSize.width - finalSize.width) / finalSize.width);
 369       float   heightRatio = 1.f - abs((availableVisualSize.height - finalSize.height) / finalSize.height);
 370       Vector4 pixelArea   = Vector4(x, y, widthRatio, heightRatio);
 371       Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, pixelArea);
 372
 373       // populate the transform map
 374       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, originalOffset)
 375         .Add(Toolkit::Visual::Transform::Property::SIZE, availableVisualSize);
 376       break;
 377     }
 378     case Visual::FittingMode::CENTER:
 379     {
 380       auto availableVisualSize = finalSize;
 381       if(availableVisualSize.width > naturalSize.width && availableVisualSize.height > naturalSize.height)
 382       {
 383         finalSize = naturalSize;
 384       }
 385       else
 386       {
 387         finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 388                                            (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 389       }
 390
 391       finalOffset += (availableVisualSize - finalSize) * .5f;
 392
 393       // populate the transform map
 394       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 395         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 396       break;
 397     }
 398     case Visual::FittingMode::FILL:
 399     {
 400       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 401         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 402       break;
 403     }
 404     case Visual::FittingMode::FIT_WIDTH:
 405     case Visual::FittingMode::FIT_HEIGHT:
 406     {
 407       // This FittingMode already converted
 408       break;
 409     }
 410   }
 411 }
 412
 413 void ImageView::ApplyFittingMode(Vector2 finalSize, Vector2 finalOffset, bool zeroPadding, Property::Map& transformMap)
 414 {
 415   Visual::FittingMode fittingMode = Toolkit::GetImplementation(mVisual).GetFittingMode();
 416
 417   // Reset PIXEL_AREA after using OVER_FIT_KEEP_ASPECT_RATIO
 418   if(mImageViewPixelAreaSetByFittingMode)
 419   {
 420     Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, FULL_TEXTURE_RECT);
 421     mImageViewPixelAreaSetByFittingMode = false;
 422   }
 423
 424   if((!zeroPadding) || // If padding is not zero
 425      (fittingMode != Visual::FittingMode::FILL))
 426   {
 427     mImageVisualPaddingSetByTransform = true;
 428
 429     Vector2 naturalSize;
 430     // NaturalSize will not be used for FILL fitting mode, which is default.
 431     // Skip GetNaturalSize
 432     if(fittingMode != Visual::FittingMode::FILL)
 433     {
 434       mVisual.GetNaturalSize(naturalSize);
 435     }
 436
 437     // If FittingMode use FIT_WIDTH or FIT_HEIGTH, it need to change proper fittingMode
 438     if(fittingMode == Visual::FittingMode::FIT_WIDTH)
 439     {
 440       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::FIT_KEEP_ASPECT_RATIO;
 441     }
 442     else if(fittingMode == Visual::FittingMode::FIT_HEIGHT)
 443     {
 444       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO;
 445     }
 446
 447     SetTransformMapForFittingMode(finalSize, naturalSize, finalOffset, fittingMode, transformMap);
 448
 449     // Set extra value for applying transformMap
 450     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 451                      Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 452       .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
 453       .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
 454       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 455            Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 456   }
 457   else if(mImageVisualPaddingSetByTransform && zeroPadding) // Reset offset to zero only if padding applied previously
 458   {
 459     mImageVisualPaddingSetByTransform = false;
 460     // Reset the transform map
 461     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2::ZERO)
 462       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 463            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
 464       .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2::ONE)
 465       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 466            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
 467   }
 468 }
 469
 470 ///////////////////////////////////////////////////////////
 471 //
 472 // Properties
 473 //
 474
 475 void ImageView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 476 {
 477   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 478
 479   if(imageView)
 480   {
 481     ImageView& impl = GetImpl(imageView);
 482     switch(index)
 483     {
 484       case Toolkit::ImageView::Property::IMAGE:
 485       {
 486         std::string          imageUrl;
 487         const Property::Map* map;
 488         if(value.Get(imageUrl))
 489         {
 490           impl.SetImage(imageUrl, ImageDimensions());
 491         }
 492         // if its not a string then get a Property::Map from the property if possible.
 493         else
 494         {
 495           map = value.GetMap();
 496           if(DALI_LIKELY(map))
 497           {
 498             // the property map is emtpy map. Unregister visual.
 499             if(DALI_UNLIKELY(map->Count() == 0u))
 500             {
 501               impl.ClearImageVisual();
 502             }
 503             else
 504             {
 505               Property::Value* shaderValue = map->Find(Toolkit::Visual::Property::SHADER, CUSTOM_SHADER);
 506               // set image only if property map contains image information other than custom shader
 507               if(map->Count() > 1u || !shaderValue)
 508               {
 509                 impl.SetImage(*map);
 510               }
 511               // the property map contains only the custom shader
 512               else if((map->Count() == 1u) && (shaderValue))
 513               {
 514                 Property::Map* shaderMap = shaderValue->GetMap();
 515                 if(shaderMap)
 516                 {
 517                   impl.mShaderMap = *shaderMap;
 518
 519                   if(!impl.mUrl.empty())
 520                   {
 521                     impl.SetImage(impl.mUrl, impl.mImageSize);
 522                   }
 523                   else if(!impl.mPropertyMap.Empty())
 524                   {
 525                     impl.SetImage(impl.mPropertyMap);
 526                   }
 527                 }
 528               }
 529             }
 530           }
 531           else
 532           {
 533             // invalid property value comes. Unregister visual.
 534             impl.ClearImageVisual();
 535           }
 536         }
 537         break;
 538       }
 539
 540       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 541       {
 542         bool isPre;
 543         if(value.Get(isPre))
 544         {
 545           impl.EnablePreMultipliedAlpha(isPre);
 546         }
 547         break;
 548       }
 549     }
 550   }
 551 }
 552
 553 Property::Value ImageView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 554 {
 555   Property::Value value;
 556
 557   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 558
 559   if(imageview)
 560   {
 561     ImageView& impl = GetImpl(imageview);
 562     switch(propertyIndex)
 563     {
 564       case Toolkit::ImageView::Property::IMAGE:
 565       {
 566         if(!impl.mUrl.empty())
 567         {
 568           value = impl.mUrl;
 569         }
 570         else
 571         {
 572           Property::Map         map;
 573           Toolkit::Visual::Base visual = DevelControl::GetVisual(impl, Toolkit::ImageView::Property::IMAGE);
 574           if(visual)
 575           {
 576             visual.CreatePropertyMap(map);
 577           }
 578           value = map;
 579         }
 580         break;
 581       }
 582
 583       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 584       {
 585         value = impl.IsPreMultipliedAlphaEnabled();
 586         break;
 587       }
 588     }
 589   }
 590
 591   return value;
 592 }
 593
 594 } // namespace Internal
 595 } // namespace Toolkit
 596 } // namespace Dali