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 constexpr float FULL_OPACITY = 1.0f;
  49 constexpr float LOW_OPACITY  = 0.2f;
  50 constexpr float TRANSITION_EFFECT_SPEED = 0.3f;
  51
  52 BaseHandle Create()
  53 {
  54   return Toolkit::ImageView::New();
  55 }
  56
  57 // Setup properties, signals and actions using the type-registry.
  58 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::ImageView, Toolkit::Control, Create);
  59 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "image", MAP, IMAGE)
  60 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "preMultipliedAlpha", BOOLEAN, PRE_MULTIPLIED_ALPHA)
  61 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "placeholderImage", STRING, PLACEHOLDER_IMAGE)
  62 DALI_PROPERTY_REGISTRATION(Toolkit, ImageView, "enableTransitionEffect", BOOLEAN, ENABLE_TRANSITION_EFFECT)
  63 DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(Toolkit, ImageView, "pixelArea", Vector4(0.f, 0.f, 1.f, 1.f), PIXEL_AREA)
  64 DALI_TYPE_REGISTRATION_END()
  65
  66 } // anonymous namespace
  67
  68 using namespace Dali;
  69
  70 ImageView::ImageView(ControlBehaviour additionalBehaviour)
  71 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
  72   mImageSize(),
  73   mTransitionTargetAlpha(FULL_OPACITY),
  74   mImageVisualPaddingSetByTransform(false),
  75   mImageViewPixelAreaSetByFittingMode(false),
  76   mTransitionEffect(false),
  77   mNeedLazyFittingMode(false)
  78 {
  79 }
  80
  81 ImageView::~ImageView()
  82 {
  83 }
  84
  85 Toolkit::ImageView ImageView::New(ControlBehaviour additionalBehaviour)
  86 {
  87   ImageView* impl = new ImageView(additionalBehaviour);
  88
  89   Toolkit::ImageView handle = Toolkit::ImageView(*impl);
  90
  91   // Second-phase init of the implementation
  92   // This can only be done after the CustomActor connection has been made...
  93   impl->Initialize();
  94
  95   return handle;
  96 }
  97
  98 /////////////////////////////////////////////////////////////
  99
 100 void ImageView::OnInitialize()
 101 {
 102   // ImageView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to ImageView
 103   Dali::Toolkit::Control handle(GetOwner());
 104   handle.ResourceReadySignal().Connect(this, &ImageView::OnResourceReady);
 105
 106   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE);
 107 }
 108
 109 void ImageView::SetImage(const Property::Map& map)
 110 {
 111   if(mTransitionEffect && mVisual)
 112   {
 113     // Clear previous transition effect if it is playing
 114     if(mPreviousVisual)
 115     {
 116       if(mTransitionAnimation)
 117       {
 118         if(mTransitionAnimation.GetState() == Animation::PLAYING)
 119         {
 120           mTransitionAnimation.Stop();
 121           ClearTransitionAnimation();
 122         }
 123       }
 124     }
 125
 126     // Enable transition effect for previous visual.
 127     // This previous visual will be deleted when transition effect is done.
 128     Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(*this);
 129     controlDataImpl.EnableReadyTransitionOverriden(mVisual, true);
 130     mPreviousVisual = mVisual;
 131   }
 132
 133   // Comparing a property map is too expensive so just creating a new visual
 134   mPropertyMap = map;
 135   mUrl.clear();
 136
 137   // keep alpha for transition effect
 138   if(mTransitionEffect)
 139   {
 140     float            alpha      = FULL_OPACITY;
 141     Property::Value* alphaValue = map.Find(Toolkit::Visual::Property::OPACITY);
 142     if(alphaValue && alphaValue->Get(alpha))
 143     {
 144       mTransitionTargetAlpha = alpha;
 145     }
 146   }
 147
 148   if(!mVisual)
 149   {
 150     ShowPlaceholderImage();
 151   }
 152
 153   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(mPropertyMap);
 154   if(visual)
 155   {
 156     // Don't set mVisual until it is ready and shown. Getters will still use current visual.
 157     if(!mVisual)
 158     {
 159       mVisual = visual;
 160     }
 161
 162     if(!mShaderMap.Empty())
 163     {
 164       Internal::Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 165       visualImpl.SetCustomShader(mShaderMap);
 166     }
 167
 168     DevelControl::RegisterVisual(*this, Toolkit::ImageView::Property::IMAGE, visual);
 169   }
 170   else
 171   {
 172     // Unregister the exsiting visual
 173     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 174
 175     // Trigger a size negotiation request that may be needed when unregistering a visual.
 176     RelayoutRequest();
 177   }
 178
 179   // Signal that a Relayout may be needed
 180 }
 181
 182 void ImageView::SetImage(const std::string& url, ImageDimensions size)
 183 {
 184   if(mTransitionEffect && mVisual)
 185   {
 186     // Clear previous transition effect if it is playing
 187     if(mPreviousVisual)
 188     {
 189       if(mTransitionAnimation)
 190       {
 191         if(mTransitionAnimation.GetState() == Animation::PLAYING)
 192         {
 193           mTransitionAnimation.Stop();
 194           ClearTransitionAnimation();
 195         }
 196       }
 197     }
 198
 199     // Enable transition effect for previous visual.
 200     // This previous visual will be deleted when transition effect is done.
 201     Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(*this);
 202     controlDataImpl.EnableReadyTransitionOverriden(mVisual, true);
 203     mPreviousVisual = mVisual;
 204   }
 205
 206   // Don't bother comparing if we had a visual previously, just drop old visual and create new one
 207   mUrl       = url;
 208   mImageSize = size;
 209   mPropertyMap.Clear();
 210
 211   if(!mVisual)
 212   {
 213     ShowPlaceholderImage();
 214   }
 215
 216   // Don't set mVisual until it is ready and shown. Getters will still use current visual.
 217   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(url, size);
 218   if(visual)
 219   {
 220     if(!mVisual)
 221     {
 222       mVisual = visual;
 223     }
 224
 225     if(!mShaderMap.Empty())
 226     {
 227       Internal::Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 228       visualImpl.SetCustomShader(mShaderMap);
 229     }
 230
 231     DevelControl::RegisterVisual(*this, Toolkit::ImageView::Property::IMAGE, visual);
 232   }
 233   else
 234   {
 235     // Unregister the exsiting visual
 236     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 237
 238     // Trigger a size negotiation request that may be needed when unregistering a visual.
 239     RelayoutRequest();
 240   }
 241
 242   // Signal that a Relayout may be needed
 243 }
 244
 245 void ImageView::ClearImageVisual()
 246 {
 247   // Clear cached properties
 248   mPropertyMap.Clear();
 249   mUrl.clear();
 250   mVisual.Reset();
 251
 252   // Unregister the exsiting visual
 253   DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::IMAGE);
 254
 255   // Trigger a size negotiation request that may be needed when unregistering a visual.
 256   RelayoutRequest();
 257 }
 258
 259 void ImageView::EnablePreMultipliedAlpha(bool preMultipled)
 260 {
 261   if(mVisual)
 262   {
 263     Toolkit::GetImplementation(mVisual).EnablePreMultipliedAlpha(preMultipled);
 264   }
 265 }
 266
 267 bool ImageView::IsPreMultipliedAlphaEnabled() const
 268 {
 269   if(mVisual)
 270   {
 271     return Toolkit::GetImplementation(mVisual).IsPreMultipliedAlphaEnabled();
 272   }
 273   return false;
 274 }
 275
 276 void ImageView::SetDepthIndex(int depthIndex)
 277 {
 278   if(mVisual)
 279   {
 280     mVisual.SetDepthIndex(depthIndex);
 281   }
 282 }
 283
 284 void ImageView::SetPlaceholderUrl(const std::string& url)
 285 {
 286   mPlaceholderUrl = url;
 287   if(!url.empty())
 288   {
 289     mPlaceholderVisual.Reset();
 290     CreatePlaceholderImage();
 291   }
 292   else
 293   {
 294     // Clear current placeholder image
 295     Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE);
 296     if(visual)
 297     {
 298       DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE);
 299     }
 300
 301     mPlaceholderVisual.Reset();
 302     mPlaceholderUrl = url;
 303   }
 304 }
 305
 306 std::string ImageView::GetPlaceholderUrl() const
 307 {
 308   return mPlaceholderUrl;
 309 }
 310
 311 void ImageView::EnableTransitionEffect(bool effectEnable)
 312 {
 313   mTransitionEffect = effectEnable;
 314 }
 315
 316 bool ImageView::IsTransitionEffectEnabled() const
 317 {
 318   return mTransitionEffect;
 319 }
 320
 321 Vector3 ImageView::GetNaturalSize()
 322 {
 323   if(mVisual)
 324   {
 325     Vector2 rendererNaturalSize;
 326     mVisual.GetNaturalSize(rendererNaturalSize);
 327
 328     Extents padding;
 329     padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 330
 331     rendererNaturalSize.width += (padding.start + padding.end);
 332     rendererNaturalSize.height += (padding.top + padding.bottom);
 333     return Vector3(rendererNaturalSize);
 334   }
 335
 336   // if no visual then use Control's natural size
 337   return Control::GetNaturalSize();
 338 }
 339
 340 float ImageView::GetHeightForWidth(float width)
 341 {
 342   Extents padding;
 343   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 344
 345   if(mVisual)
 346   {
 347     return mVisual.GetHeightForWidth(width) + padding.top + padding.bottom;
 348   }
 349   else
 350   {
 351     return Control::GetHeightForWidth(width) + padding.top + padding.bottom;
 352   }
 353 }
 354
 355 float ImageView::GetWidthForHeight(float height)
 356 {
 357   Extents padding;
 358   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 359
 360   if(mVisual)
 361   {
 362     return mVisual.GetWidthForHeight(height) + padding.start + padding.end;
 363   }
 364   else
 365   {
 366     return Control::GetWidthForHeight(height) + padding.start + padding.end;
 367   }
 368 }
 369
 370 void ImageView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 371 {
 372   Control::OnRelayout(size, container);
 373   if(mVisual)
 374   {
 375     // If Resource is not ready, fittingMode is not working well.
 376     // in this case, imageview set the flag for working applyFittingMode again when the resource is ready
 377     if(!IsResourceReady())
 378     {
 379       mNeedLazyFittingMode = true;
 380     }
 381
 382     // Apply FittingMode using actor's size
 383     ApplyFittingMode(size);
 384
 385     // mVisual is not updated util the resource is ready in the case of visual replacement.
 386     // in this case, the Property Map must be initialized so that the previous value is not reused.
 387     // after mVisual is updated, the correct value will be reset.
 388     Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 389     if(visual && visual != mVisual)
 390     {
 391       visual.SetTransformAndSize(Property::Map(), size);
 392     }
 393   }
 394 }
 395
 396 void ImageView::OnCreateTransitions(std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& sourceProperties,
 397                                     std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& destinationProperties,
 398                                     Dali::Toolkit::Control                                              source,
 399                                     Dali::Toolkit::Control                                              destination)
 400 {
 401   // Retrieves image properties to be transitioned.
 402   Dali::Property::Map imageSourcePropertyMap, imageDestinationPropertyMap;
 403   MakeVisualTransition(imageSourcePropertyMap, imageDestinationPropertyMap, source, destination, Toolkit::ImageView::Property::IMAGE);
 404   if(imageSourcePropertyMap.Count() > 0)
 405   {
 406     sourceProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageSourcePropertyMap));
 407     destinationProperties.push_back(std::pair<Dali::Property::Index, Dali::Property::Map>(Toolkit::ImageView::Property::IMAGE, imageDestinationPropertyMap));
 408   }
 409 }
 410
 411 void ImageView::OnUpdateVisualProperties(const std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& properties)
 412 {
 413   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 414   if(visual)
 415   {
 416     Dali::Toolkit::Control handle(GetOwner());
 417
 418     for(auto&& data : properties)
 419     {
 420       if(data.first == Toolkit::ImageView::Property::IMAGE)
 421       {
 422         DevelControl::DoAction(handle, Toolkit::ImageView::Property::IMAGE, DevelVisual::Action::UPDATE_PROPERTY, data.second);
 423         break;
 424       }
 425     }
 426   }
 427 }
 428
 429 void ImageView::OnResourceReady(Toolkit::Control control)
 430 {
 431   // In case of placeholder, we need to skip this call.
 432   // TODO: In case of placeholder, it needs to be modified not to call OnResourceReady()
 433   if(control.GetVisualResourceStatus(Toolkit::ImageView::Property::IMAGE) != Toolkit::Visual::ResourceStatus::READY)
 434   {
 435     return;
 436   }
 437
 438   // Do transition effect if need.
 439   if(mTransitionEffect)
 440   {
 441     // TODO: Consider about placeholder image is loaded failed
 442     Toolkit::Visual::Base placeholderVisual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE);
 443     if(!placeholderVisual || control.GetVisualResourceStatus(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE) == Toolkit::Visual::ResourceStatus::READY)
 444     {
 445       // when placeholder is disabled or ready placeholder and image, we need to transition effect
 446       TransitionImageWithEffect();
 447     }
 448     else
 449     {
 450       ClearTransitionAnimation();
 451     }
 452   }
 453   else
 454   {
 455     // we don't need placeholder anymore because visual is replaced. so hide placeholder.
 456     HidePlaceholderImage();
 457   }
 458
 459   // Visual ready so update visual attached to this ImageView, following call to RelayoutRequest will use this visual.
 460   mVisual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 461
 462   // Applying FittingMode again if it is not working well on OnRelayout().
 463   if(mNeedLazyFittingMode)
 464   {
 465     const Vector2& size = Self().GetProperty(Dali::Actor::Property::SIZE).Get<Vector2>();
 466     ApplyFittingMode(size);
 467     mNeedLazyFittingMode = false;
 468   }
 469
 470   // Signal that a Relayout may be needed
 471 }
 472
 473 void ImageView::SetTransformMapForFittingMode(Vector2 finalSize, Vector2 naturalSize, Vector2 finalOffset, Visual::FittingMode fittingMode, Property::Map& transformMap)
 474 {
 475   switch(fittingMode)
 476   {
 477     case Visual::FittingMode::FIT_KEEP_ASPECT_RATIO:
 478     {
 479       auto availableVisualSize = finalSize;
 480
 481       // scale to fit the padded area
 482       finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0),
 483                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0));
 484
 485       // calculate final offset within the padded area
 486       finalOffset += (availableVisualSize - finalSize) * .5f;
 487
 488       // populate the transform map
 489       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 490         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 491       break;
 492     }
 493     case Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO:
 494     {
 495       mImageViewPixelAreaSetByFittingMode = true;
 496       auto availableVisualSize            = finalSize;
 497       finalSize                           = naturalSize * std::max((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 498                                          (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 499
 500       auto originalOffset = finalOffset;
 501       finalOffset += (availableVisualSize - finalSize) * .5f;
 502
 503       float   x           = abs((availableVisualSize.width - finalSize.width) / finalSize.width) * .5f;
 504       float   y           = abs((availableVisualSize.height - finalSize.height) / finalSize.height) * .5f;
 505       float   widthRatio  = 1.f - abs((availableVisualSize.width - finalSize.width) / finalSize.width);
 506       float   heightRatio = 1.f - abs((availableVisualSize.height - finalSize.height) / finalSize.height);
 507       Vector4 pixelArea   = Vector4(x, y, widthRatio, heightRatio);
 508       Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, pixelArea);
 509
 510       // populate the transform map
 511       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, originalOffset)
 512         .Add(Toolkit::Visual::Transform::Property::SIZE, availableVisualSize);
 513       break;
 514     }
 515     case Visual::FittingMode::CENTER:
 516     {
 517       auto availableVisualSize = finalSize;
 518       if(availableVisualSize.width > naturalSize.width && availableVisualSize.height > naturalSize.height)
 519       {
 520         finalSize = naturalSize;
 521       }
 522       else
 523       {
 524         finalSize = naturalSize * std::min((!Dali::EqualsZero(naturalSize.width) ? (availableVisualSize.width / naturalSize.width) : 0.0f),
 525                                            (!Dali::EqualsZero(naturalSize.height) ? (availableVisualSize.height / naturalSize.height) : 0.0f));
 526       }
 527
 528       finalOffset += (availableVisualSize - finalSize) * .5f;
 529
 530       // populate the transform map
 531       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 532         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 533       break;
 534     }
 535     case Visual::FittingMode::FILL:
 536     {
 537       transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, finalOffset)
 538         .Add(Toolkit::Visual::Transform::Property::SIZE, finalSize);
 539       break;
 540     }
 541     case Visual::FittingMode::FIT_WIDTH:
 542     case Visual::FittingMode::FIT_HEIGHT:
 543     {
 544       // This FittingMode already converted
 545       break;
 546     }
 547   }
 548 }
 549
 550 void ImageView::ApplyFittingMode(const Vector2& size)
 551 {
 552   Property::Map transformMap = Property::Map();
 553
 554   Extents padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 555
 556   bool zeroPadding = (padding == Extents());
 557
 558   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(
 559   Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
 560   if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
 561   {
 562     std::swap(padding.start, padding.end);
 563   }
 564
 565   // remove padding from the size to know how much is left for the visual
 566   Vector2 finalSize   = size - Vector2(padding.start + padding.end, padding.top + padding.bottom);
 567   Vector2 finalOffset = Vector2(padding.start, padding.top);
 568
 569   Visual::FittingMode fittingMode = Toolkit::GetImplementation(mVisual).GetFittingMode();
 570
 571   // Reset PIXEL_AREA after using OVER_FIT_KEEP_ASPECT_RATIO
 572   if(mImageViewPixelAreaSetByFittingMode)
 573   {
 574     Self().SetProperty(Toolkit::ImageView::Property::PIXEL_AREA, FULL_TEXTURE_RECT);
 575     mImageViewPixelAreaSetByFittingMode = false;
 576   }
 577
 578   if((!zeroPadding) || // If padding is not zero
 579      (fittingMode != Visual::FittingMode::FILL))
 580   {
 581     mImageVisualPaddingSetByTransform = true;
 582
 583     Vector2 naturalSize;
 584     // NaturalSize will not be used for FILL fitting mode, which is default.
 585     // Skip GetNaturalSize
 586     if(fittingMode != Visual::FittingMode::FILL)
 587     {
 588       mVisual.GetNaturalSize(naturalSize);
 589     }
 590
 591     // If FittingMode use FIT_WIDTH or FIT_HEIGTH, it need to change proper fittingMode
 592     if(fittingMode == Visual::FittingMode::FIT_WIDTH)
 593     {
 594       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::FIT_KEEP_ASPECT_RATIO;
 595     }
 596     else if(fittingMode == Visual::FittingMode::FIT_HEIGHT)
 597     {
 598       fittingMode = (finalSize.height / naturalSize.height) < (finalSize.width / naturalSize.width) ? Visual::FittingMode::FIT_KEEP_ASPECT_RATIO : Visual::FittingMode::OVER_FIT_KEEP_ASPECT_RATIO;
 599     }
 600
 601     SetTransformMapForFittingMode(finalSize, naturalSize, finalOffset, fittingMode, transformMap);
 602
 603     // Set extra value for applying transformMap
 604     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 605                      Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 606       .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
 607       .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
 608       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 609            Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 610   }
 611   else if(mImageVisualPaddingSetByTransform && zeroPadding) // Reset offset to zero only if padding applied previously
 612   {
 613     mImageVisualPaddingSetByTransform = false;
 614     // Reset the transform map
 615     transformMap.Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2::ZERO)
 616       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
 617            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
 618       .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2::ONE)
 619       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY,
 620            Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
 621   }
 622
 623   mVisual.SetTransformAndSize(transformMap, size);
 624 }
 625
 626 void ImageView::CreatePlaceholderImage()
 627 {
 628   Property::Map propertyMap;
 629   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
 630   propertyMap.Insert(Toolkit::ImageVisual::Property::URL, mPlaceholderUrl);
 631   //propertyMap.Insert(Toolkit::ImageVisual::Property::LOAD_POLICY, Toolkit::ImageVisual::LoadPolicy::IMMEDIATE); // TODO: need to enable this property
 632   propertyMap.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, Toolkit::ImageVisual::ReleasePolicy::DESTROYED);
 633   propertyMap.Insert(Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE, false);
 634   mPlaceholderVisual = Toolkit::VisualFactory::Get().CreateVisual(propertyMap);
 635   if(mPlaceholderVisual)
 636   {
 637     mPlaceholderVisual.SetName("placeholder");
 638   }
 639   else
 640   {
 641     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE);
 642     mPlaceholderVisual.Reset();
 643   }
 644 }
 645
 646 void ImageView::ShowPlaceholderImage()
 647 {
 648   if(mPlaceholderVisual)
 649   {
 650     DevelControl::RegisterVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, mPlaceholderVisual, false);
 651     Actor self = Self();
 652     Toolkit::GetImplementation(mPlaceholderVisual).SetOnScene(self);
 653   }
 654 }
 655
 656 void ImageView::HidePlaceholderImage()
 657 {
 658   if(mPlaceholderVisual)
 659   {
 660     DevelControl::UnregisterVisual(*this, Toolkit::ImageView::Property::PLACEHOLDER_IMAGE);
 661
 662     // Hide placeholder
 663     Actor self = Self();
 664     Toolkit::GetImplementation(mPlaceholderVisual).SetOffScene(self);
 665   }
 666 }
 667
 668 void ImageView::TransitionImageWithEffect()
 669 {
 670   Toolkit::ImageView handle = Toolkit::ImageView(GetOwner());
 671
 672   if(handle)
 673   {
 674     mTransitionAnimation = Animation::New(TRANSITION_EFFECT_SPEED);
 675     mTransitionAnimation.SetEndAction(Animation::EndAction::DISCARD);
 676     float destinationAlpha = (mTransitionTargetAlpha > LOW_OPACITY) ? mTransitionTargetAlpha : LOW_OPACITY;
 677
 678     // Transition current image
 679     Toolkit::Visual::Base imageVisual = DevelControl::GetVisual(*this, Toolkit::ImageView::Property::IMAGE);
 680     if(imageVisual)
 681     {
 682       Dali::KeyFrames fadeinKeyFrames = Dali::KeyFrames::New();
 683       fadeinKeyFrames.Add(0.0f, LOW_OPACITY);
 684       fadeinKeyFrames.Add(1.0f, destinationAlpha);
 685       mTransitionAnimation.AnimateBetween(DevelControl::GetVisualProperty(handle, Toolkit::ImageView::Property::IMAGE, Toolkit::Visual::Property::OPACITY), fadeinKeyFrames,  AlphaFunction::EASE_IN_OUT);
 686     }
 687
 688     // Play transition animation
 689     mTransitionAnimation.FinishedSignal().Connect(this, &ImageView::OnTransitionAnimationFinishedCallback);
 690     mTransitionAnimation.Play();
 691   }
 692 }
 693
 694 void ImageView::ClearTransitionAnimation()
 695 {
 696   // Hide placeholder
 697   HidePlaceholderImage();
 698
 699   // Clear PreviousVisual
 700   if(mPreviousVisual)
 701   {
 702     Actor                    self            = Self();
 703     Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(*this);
 704     controlDataImpl.EnableReadyTransitionOverriden(mVisual, false);
 705     Toolkit::GetImplementation(mPreviousVisual).SetOffScene(self);
 706     mPreviousVisual.Reset();
 707   }
 708
 709   if(mTransitionAnimation)
 710   {
 711     mTransitionAnimation.FinishedSignal().Disconnect(this, &ImageView::OnTransitionAnimationFinishedCallback);
 712     mTransitionAnimation.Clear();
 713   }
 714 }
 715
 716 ///////////////////////////////////////////////////////////
 717 //
 718 // Properties
 719 //
 720
 721 void ImageView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 722 {
 723   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 724
 725   if(imageView)
 726   {
 727     ImageView& impl = GetImpl(imageView);
 728     switch(index)
 729     {
 730       case Toolkit::ImageView::Property::IMAGE:
 731       {
 732         std::string          imageUrl;
 733         const Property::Map* map;
 734         if(value.Get(imageUrl))
 735         {
 736           impl.SetImage(imageUrl, ImageDimensions());
 737         }
 738         // if its not a string then get a Property::Map from the property if possible.
 739         else
 740         {
 741           map = value.GetMap();
 742           if(DALI_LIKELY(map))
 743           {
 744             // the property map is emtpy map. Unregister visual.
 745             if(DALI_UNLIKELY(map->Count() == 0u))
 746             {
 747               impl.ClearImageVisual();
 748             }
 749             else
 750             {
 751               Property::Value* shaderValue = map->Find(Toolkit::Visual::Property::SHADER, CUSTOM_SHADER);
 752               // set image only if property map contains image information other than custom shader
 753               if(map->Count() > 1u || !shaderValue)
 754               {
 755                 impl.SetImage(*map);
 756               }
 757               // the property map contains only the custom shader
 758               else if((map->Count() == 1u) && (shaderValue))
 759               {
 760                 Property::Map* shaderMap = shaderValue->GetMap();
 761                 if(shaderMap)
 762                 {
 763                   impl.mShaderMap = *shaderMap;
 764
 765                   if(!impl.mUrl.empty())
 766                   {
 767                     impl.SetImage(impl.mUrl, impl.mImageSize);
 768                   }
 769                   else if(!impl.mPropertyMap.Empty())
 770                   {
 771                     impl.SetImage(impl.mPropertyMap);
 772                   }
 773                 }
 774               }
 775             }
 776           }
 777           else
 778           {
 779             // invalid property value comes. Unregister visual.
 780             impl.ClearImageVisual();
 781           }
 782         }
 783         break;
 784       }
 785
 786       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 787       {
 788         bool isPre;
 789         if(value.Get(isPre))
 790         {
 791           impl.EnablePreMultipliedAlpha(isPre);
 792         }
 793         break;
 794       }
 795
 796       case Toolkit::ImageView::Property::PLACEHOLDER_IMAGE:
 797       {
 798         std::string placeholderUrl;
 799         if(value.Get(placeholderUrl))
 800         {
 801           impl.SetPlaceholderUrl(placeholderUrl);
 802         }
 803         break;
 804       }
 805
 806       case Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT:
 807       {
 808         bool transitionEffect;
 809         if(value.Get(transitionEffect))
 810         {
 811           impl.EnableTransitionEffect(transitionEffect);
 812         }
 813         break;
 814       }
 815     }
 816   }
 817 }
 818
 819 Property::Value ImageView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 820 {
 821   Property::Value value;
 822
 823   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast(Dali::BaseHandle(object));
 824
 825   if(imageview)
 826   {
 827     ImageView& impl = GetImpl(imageview);
 828     switch(propertyIndex)
 829     {
 830       case Toolkit::ImageView::Property::IMAGE:
 831       {
 832         if(!impl.mUrl.empty())
 833         {
 834           value = impl.mUrl;
 835         }
 836         else
 837         {
 838           Property::Map         map;
 839           Toolkit::Visual::Base visual = DevelControl::GetVisual(impl, Toolkit::ImageView::Property::IMAGE);
 840           if(visual)
 841           {
 842             visual.CreatePropertyMap(map);
 843           }
 844           value = map;
 845         }
 846         break;
 847       }
 848
 849       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 850       {
 851         value = impl.IsPreMultipliedAlphaEnabled();
 852         break;
 853       }
 854
 855       case Toolkit::ImageView::Property::PLACEHOLDER_IMAGE:
 856       {
 857         value = impl.GetPlaceholderUrl();
 858         break;
 859       }
 860
 861       case Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT:
 862       {
 863         value = impl.IsTransitionEffectEnabled();
 864         break;
 865       }
 866     }
 867   }
 868
 869   return value;
 870 }
 871
 872 void ImageView::OnTransitionAnimationFinishedCallback(Animation& animation)
 873 {
 874   ClearTransitionAnimation();
 875 }
 876
 877 } // namespace Internal
 878 } // namespace Toolkit
 879 } // namespace Dali