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

   1 /*
   2  * Copyright (c) 2022 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     Vector2 naturalSize;
 271     mVisual.GetNaturalSize(naturalSize);
 272
 273     Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(
 274       Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
 275     if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
 276     {
 277       std::swap(padding.start, padding.end);
 278     }
 279
 280     // remove padding from the size to know how much is left for the visual
 281     Vector2 finalSize   = size - Vector2(padding.start + padding.end, padding.top + padding.bottom);
 282     Vector2 finalOffset = Vector2(padding.start, padding.top);
 283
 284     ApplyFittingMode(finalSize, naturalSize, finalOffset, zeroPadding, transformMap);
 285
 286     mVisual.SetTransformAndSize(transformMap, size);
 287
 288     // mVisual is not updated util the resource is ready in the case of visual replacement.
 289     // in this case, the Property Map must be initialized so that the previous value is not reused.
 290     // after mVisual is updated, the correct value will be reset.
 291     Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 292     if(visual && visual != mVisual)
 293     {
 294       visual.SetTransformAndSize(Property::Map(), size);
 295     }
 296   }
 297 }
 298
 299 void ImageView::OnCreateTransitions(std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& sourceProperties,
 300                                     std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& destinationProperties,
 301                                     Dali::Toolkit::Control                                              source,
 302                                     Dali::Toolkit::Control                                              destination)
 303 {
 304   // Retrieves image properties to be transitioned.
 305   Dali::Property::Map imageSourcePropertyMap, imageDestinationPropertyMap;
 306   MakeVisualTransition(imageSourcePropertyMap, imageDestinationPropertyMap, source, destination, Toolkit::ImageView::Property::IMAGE);
 307   if(imageSourcePropertyMap.Count() > 0)
 308   {
 309     sourceProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageSourcePropertyMap));
 310     destinationProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageDestinationPropertyMap));
 311   }
 312 }
 313
 314 void ImageView::OnUpdateVisualProperties(const std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& properties)
 315 {
 316   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 317   if(visual)
 318   {
 319     Dali::Toolkit::Control handle(GetOwner());
 320
 321     for(auto&& data : properties)
 322     {
 323       if(data.first == Toolkit::ImageView::Property::IMAGE)
 324       {
 325         DevelControl::DoAction(handle, Toolkit::ImageView::Property::IMAGE, DevelVisual::Action::UPDATE_PROPERTY, data.second);
 326         break;
 327       }
 328     }
 329   }
 330 }
 331
 332 void ImageView::OnResourceReady(Toolkit::Control control)
 333 {
 334   // Visual ready so update visual attached to this ImageView, following call to RelayoutRequest will use this visual.
 335   mVisual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 336   // Signal that a Relayout may be needed
 337 }
 338
 339 void ImageView::SetTransformMapForFittingMode(Vector2 finalSize, Vector2 naturalSize, Vector2 finalOffset, Visual::FittingMode fittingMode, Property::Map& transformMap)
 340 {
 341   switch(fittingMode)
 342   {
 343     case Visual::FittingMode::FIT_KEEP_ASPECT_RATIO:
 344     {
 345       auto availableVisualSize = finalSize;
 346
 347       // scale to fit the padded area
 348       finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0),
 349                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0));
 350
 351       // calculate final offset within the padded area
 352       finalOffset += (availableVisualSize - finalSize) * .5f;
 353
 354       // populate the transform map
 355       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 356         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 357       break;
 358     }
 359     case Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO:
 360     {
 361       mImageViewPixelAreaSetByFittingMode = true;
 362       auto availableVisualSize            = finalSize;
 363       finalSize                           = naturalSize * std::max((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 364                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 365
 366       auto originalOffset = finalOffset;
 367       finalOffset += (availableVisualSize - finalSize) * .5f;
 368
 369       float   x           = abs((availableVisualSize.width - finalSize.width) / finalSize.width) * .5f;
 370       float   y           = abs((availableVisualSize.height - finalSize.height) / finalSize.height) * .5f;
 371       float   widthRatio  = 1.f - abs((availableVisualSize.width - finalSize.width) / finalSize.width);
 372       float   heightRatio = 1.f - abs((availableVisualSize.height - finalSize.height) / finalSize.height);
 373       Vector4 pixelArea   = Vector4(x, y, widthRatio, heightRatio);
 374       Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, pixelArea);
 375
 376       // populate the transform map
 377       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, originalOffset)
 378         .Add(Toolkit::Visual::Transform::Property::SIZE, availableVisualSize);
 379       break;
 380     }
 381     case Visual::FittingMode::CENTER:
 382     {
 383       auto availableVisualSize = finalSize;
 384       if(availableVisualSize.width > naturalSize.width && availableVisualSize.height > naturalSize.height)
 385       {
 386         finalSize = naturalSize;
 387       }
 388       else
 389       {
 390         finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 391                                            (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 392       }
 393
 394       finalOffset += (availableVisualSize - finalSize) * .5f;
 395
 396       // populate the transform map
 397       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 398         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 399       break;
 400     }
 401     case Visual::FittingMode::FILL:
 402     {
 403       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 404         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 405       break;
 406     }
 407     case Visual::FittingMode::FIT_WIDTH:
 408     case Visual::FittingMode::FIT_HEIGHT:
 409     {
 410       // This FittingMode already converted
 411       break;
 412     }
 413   }
 414 }
 415
 416 void ImageView::ApplyFittingMode(Vector2 finalSize, Vector2 naturalSize, Vector2 finalOffset, bool zeroPadding, Property::Map& transformMap)
 417 {
 418   Visual::FittingMode fittingMode = Toolkit::GetImplementation(mVisual).GetFittingMode();
 419
 420   // Reset PIXEL_AREA after using OVER_FIT_KEEP_ASPECT_RATIO
 421   if(mImageViewPixelAreaSetByFittingMode)
 422   {
 423     Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, FULL_TEXTURE_RECT);
 424     mImageViewPixelAreaSetByFittingMode = false;
 425   }
 426
 427   if((!zeroPadding) || // If padding is not zero
 428      (fittingMode != Visual::FittingMode::FILL))
 429   {
 430     mImageVisualPaddingSetByTransform = true;
 431
 432     // If FittingMode use FIT_WIDTH or FIT_HEIGTH, it need to change proper fittingMode
 433     if(fittingMode == Visual::FittingMode::FIT_WIDTH)
 434     {
 435       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::FIT_KEEP_ASPECT_RATIO;
 436     }
 437     else if(fittingMode == Visual::FittingMode::FIT_HEIGHT)
 438     {
 439       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO;
 440     }
 441
 442     SetTransformMapForFittingMode(finalSize, naturalSize, finalOffset, fittingMode, transformMap);
 443
 444     // Set extra value for applying transformMap
 445     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 446                      Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 447       .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
 448       .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
 449       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 450            Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 451   }
 452   else if(mImageVisualPaddingSetByTransform && zeroPadding) // Reset offset to zero only if padding applied previously
 453   {
 454     mImageVisualPaddingSetByTransform = false;
 455     // Reset the transform map
 456     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2::ZERO)
 457       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 458            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
 459       .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2::ONE)
 460       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 461            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
 462   }
 463 }
 464
 465 ///////////////////////////////////////////////////////////
 466 //
 467 // Properties
 468 //
 469
 470 void ImageView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 471 {
 472   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 473
 474   if(imageView)
 475   {
 476     ImageView& impl = GetImpl(imageView);
 477     switch(index)
 478     {
 479       case Toolkit::ImageView::Property::IMAGE:
 480       {
 481         std::string          imageUrl;
 482         const Property::Map* map;
 483         if(value.Get(imageUrl))
 484         {
 485           impl.SetImage(imageUrl, ImageDimensions());
 486         }
 487         // if its not a string then get a Property::Map from the property if possible.
 488         else
 489         {
 490           map = value.GetMap();
 491           if(DALI_LIKELY(map))
 492           {
 493             // the property map is emtpy map. Unregister visual.
 494             if(DALI_UNLIKELY(map->Count() == 0u))
 495             {
 496               impl.ClearImageVisual();
 497             }
 498             else
 499             {
 500               Property::Value* shaderValue = map->Find(Toolkit::Visual::Property::SHADER, CUSTOM_SHADER);
 501               // set image only if property map contains image information other than custom shader
 502               if(map->Count() > 1u || !shaderValue)
 503               {
 504                 impl.SetImage(*map);
 505               }
 506               // the property map contains only the custom shader
 507               else if((map->Count() == 1u) && (shaderValue))
 508               {
 509                 Property::Map* shaderMap = shaderValue->GetMap();
 510                 if(shaderMap)
 511                 {
 512                   impl.mShaderMap = *shaderMap;
 513
 514                   if(!impl.mUrl.empty())
 515                   {
 516                     impl.SetImage(impl.mUrl, impl.mImageSize);
 517                   }
 518                   else if(!impl.mPropertyMap.Empty())
 519                   {
 520                     impl.SetImage(impl.mPropertyMap);
 521                   }
 522                 }
 523               }
 524             }
 525           }
 526           else
 527           {
 528             // invalid property value comes. Unregister visual.
 529             impl.ClearImageVisual();
 530           }
 531         }
 532         break;
 533       }
 534
 535       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 536       {
 537         bool isPre;
 538         if(value.Get(isPre))
 539         {
 540           impl.EnablePreMultipliedAlpha(isPre);
 541         }
 542         break;
 543       }
 544     }
 545   }
 546 }
 547
 548 Property::Value ImageView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 549 {
 550   Property::Value value;
 551
 552   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 553
 554   if(imageview)
 555   {
 556     ImageView& impl = GetImpl(imageview);
 557     switch(propertyIndex)
 558     {
 559       case Toolkit::ImageView::Property::IMAGE:
 560       {
 561         if(!impl.mUrl.empty())
 562         {
 563           value = impl.mUrl;
 564         }
 565         else
 566         {
 567           Property::Map         map;
 568           Toolkit::Visual::Base visual = DevelControl::GetVisual(impl, Toolkit::ImageView::Property::IMAGE);
 569           if(visual)
 570           {
 571             visual.CreatePropertyMap(map);
 572           }
 573           value = map;
 574         }
 575         break;
 576       }
 577
 578       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 579       {
 580         value = impl.IsPreMultipliedAlphaEnabled();
 581         break;
 582       }
 583     }
 584   }
 585
 586   return value;
 587 }
 588
 589 } // namespace Internal
 590 } // namespace Toolkit
 591 } // namespace Dali