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

   1 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   2
   3 // CLASS HEADER
   4 #include "image-view-impl.h"
   5
   6 // EXTERNAL INCLUDES
   7 #include <dali/public-api/images/resource-image.h>
   8 #include <dali/public-api/object/type-registry.h>
   9 #include <dali/devel-api/object/type-registry-helper.h>
  10 #include <dali/devel-api/scripting/scripting.h>
  11
  12 // INTERNAL INCLUDES
  13 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  14 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  15
  16 namespace Dali
  17 {
  18
  19 namespace Toolkit
  20 {
  21
  22 namespace Internal
  23 {
  24
  25 namespace
  26 {
  27
  28 BaseHandle Create()
  29 {
  30   return Toolkit::ImageView::New();
  31 }
  32
  33 // Setup properties, signals and actions using the type-registry.
  34 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ImageView, Toolkit::Control, Create );
  35 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "resourceUrl", STRING, RESOURCE_URL )
  36 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "image", MAP, IMAGE )
  37 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "preMultipliedAlpha", BOOLEAN, PRE_MULTIPLIED_ALPHA )
  38
  39 DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT( Toolkit, ImageView, "pixelArea", Vector4(0.f, 0.f, 1.f, 1.f), PIXEL_AREA )
  40 DALI_TYPE_REGISTRATION_END()
  41
  42 } // anonymous namespace
  43
  44 using namespace Dali;
  45
  46 ImageView::ImageView()
  47 : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
  48   mPremultipledAlphaEnabled( false )
  49 {
  50 }
  51
  52 ImageView::~ImageView()
  53 {
  54 }
  55
  56 Toolkit::ImageView ImageView::New()
  57 {
  58   ImageView* impl = new ImageView();
  59
  60   Toolkit::ImageView handle = Toolkit::ImageView( *impl );
  61
  62   // Second-phase init of the implementation
  63   // This can only be done after the CustomActor connection has been made...
  64   impl->Initialize();
  65
  66   return handle;
  67 }
  68
  69 /////////////////////////////////////////////////////////////
  70
  71 void ImageView::SetImage( Image image )
  72 {
  73   if( ( mImage != image ) ||
  74       ! mUrl.empty()      ||   // If we're changing from a URL type to an Image type
  75       ! mPropertyMap.Empty() ) // If we're changing from a property map type to an Image type
  76   {
  77     mUrl.clear();
  78     mPropertyMap.Clear();
  79
  80     mImage = image;
  81
  82     Actor self = Self();
  83     Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, image );
  84     mImageSize = image ? ImageDimensions( image.GetWidth(), image.GetHeight() ) : ImageDimensions( 0, 0 );
  85
  86     RelayoutRequest();
  87   }
  88 }
  89
  90 void ImageView::SetImage( Property::Map map )
  91 {
  92   mUrl.clear();
  93   mImage.Reset();
  94   mPropertyMap = map;
  95
  96   Actor self = Self();
  97   Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mPropertyMap );
  98
  99   Property::Value* widthValue = mPropertyMap.Find( "width" );
 100   if( widthValue )
 101   {
 102     int width;
 103     if( widthValue->Get( width ) )
 104     {
 105       mImageSize = ImageDimensions( width, mImageSize.GetHeight() );
 106     }
 107   }
 108
 109   Property::Value* heightValue = mPropertyMap.Find( "height" );
 110   if( heightValue )
 111   {
 112     int height;
 113     if( heightValue->Get( height ) )
 114     {
 115       mImageSize = ImageDimensions( mImageSize.GetWidth(), height );
 116     }
 117   }
 118
 119   RelayoutRequest();
 120 }
 121
 122 void ImageView::SetImage( const std::string& url, ImageDimensions size )
 123 {
 124   if( ( mUrl != url ) ||
 125       mImage          ||       // If we're changing from an Image type to a URL type
 126       ! mPropertyMap.Empty() ) // If we're changing from a property map type to a URL type
 127   {
 128     mImage.Reset();
 129     mPropertyMap.Clear();
 130
 131     mUrl = url;
 132
 133     if( size.GetWidth() != 0u && size.GetHeight() != 0u )
 134     {
 135       mImageSize = size;
 136     }
 137
 138     Actor self = Self();
 139     Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mUrl, size );
 140
 141     RelayoutRequest();
 142   }
 143 }
 144
 145 void ImageView::EnablePreMultipliedAlpha( bool preMultipled )
 146 {
 147   if( mRenderer )
 148   {
 149      GetImplementation( mRenderer ).EnablePreMultipliedAlpha( preMultipled );
 150   }
 151 }
 152
 153 bool ImageView::IsPreMultipliedAlphaEnabled() const
 154 {
 155   if( mRenderer )
 156   {
 157     return GetImplementation( mRenderer ).IsPreMultipliedAlphaEnabled();
 158   }
 159   return false;
 160 }
 161
 162 void ImageView::SetDepthIndex( int depthIndex )
 163 {
 164   if( mRenderer )
 165   {
 166     mRenderer.SetDepthIndex( depthIndex );
 167   }
 168 }
 169
 170 Vector3 ImageView::GetNaturalSize()
 171 {
 172   if( mRenderer )
 173   {
 174     Vector2 rendererNaturalSize;
 175     mRenderer.GetNaturalSize( rendererNaturalSize );
 176     return Vector3( rendererNaturalSize );
 177   }
 178
 179   Vector3 size;
 180   size.x = mImageSize.GetWidth();
 181   size.y = mImageSize.GetHeight();
 182
 183   if( size.x > 0 && size.y > 0 )
 184   {
 185     size.z = std::min(size.x, size.y);
 186     return size;
 187   }
 188   else
 189   {
 190     // if no image then use Control's natural size
 191     return Control::GetNaturalSize();
 192   }
 193 }
 194
 195 float ImageView::GetHeightForWidth( float width )
 196 {
 197   if( mImageSize.GetWidth() > 0 && mImageSize.GetHeight() > 0 )
 198   {
 199     return GetHeightForWidthBase( width );
 200   }
 201   else
 202   {
 203     return Control::GetHeightForWidth( width );
 204   }
 205 }
 206
 207 float ImageView::GetWidthForHeight( float height )
 208 {
 209   if( mImageSize.GetWidth() > 0 && mImageSize.GetHeight() > 0 )
 210   {
 211     return GetWidthForHeightBase( height );
 212   }
 213   else
 214   {
 215     return Control::GetWidthForHeight( height );
 216   }
 217 }
 218
 219
 220 ///////////////////////////////////////////////////////////
 221 //
 222 // Private methods
 223 //
 224
 225 void ImageView::OnStageConnection( int depth )
 226 {
 227   Control::OnStageConnection( depth );
 228
 229   if( mRenderer )
 230   {
 231     CustomActor self = Self();
 232     mRenderer.SetOnStage( self );
 233   }
 234 }
 235
 236 void ImageView::OnStageDisconnection()
 237 {
 238   if( mRenderer )
 239   {
 240     CustomActor self = Self();
 241     mRenderer.SetOffStage( self );
 242   }
 243
 244   Control::OnStageDisconnection();
 245 }
 246
 247 void ImageView::OnSizeSet( const Vector3& targetSize )
 248 {
 249   Control::OnSizeSet( targetSize );
 250
 251   if( mRenderer )
 252   {
 253     Vector2 size( targetSize );
 254     mRenderer.SetSize( size );
 255   }
 256 }
 257
 258 ///////////////////////////////////////////////////////////
 259 //
 260 // Properties
 261 //
 262
 263 void ImageView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 264 {
 265   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
 266
 267   if ( imageView )
 268   {
 269     switch ( index )
 270     {
 271       case Toolkit::ImageView::Property::RESOURCE_URL:
 272       {
 273         std::string imageUrl;
 274         if( value.Get( imageUrl ) )
 275         {
 276           GetImpl( imageView ).SetImage( imageUrl, ImageDimensions() );
 277         }
 278         break;
 279       }
 280
 281       case Toolkit::ImageView::Property::IMAGE:
 282       {
 283         std::string imageUrl;
 284         if( value.Get( imageUrl ) )
 285         {
 286           ImageView& impl = GetImpl( imageView );
 287           impl.SetImage( imageUrl, ImageDimensions() );
 288         }
 289
 290         // if its not a string then get a Property::Map from the property if possible.
 291         Property::Map map;
 292         if( value.Get( map ) )
 293         {
 294           ImageView& impl = GetImpl( imageView );
 295           impl.SetImage( map );
 296         }
 297
 298         break;
 299       }
 300
 301       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 302       {
 303         bool IsPre;
 304         if( value.Get( IsPre ) )
 305         {
 306           GetImpl(imageView).EnablePreMultipliedAlpha( IsPre );
 307         }
 308         break;
 309       }
 310     }
 311   }
 312 }
 313
 314 Property::Value ImageView::GetProperty( BaseObject* object, Property::Index propertyIndex )
 315 {
 316   Property::Value value;
 317
 318   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
 319
 320   if ( imageview )
 321   {
 322     ImageView& impl = GetImpl( imageview );
 323     switch ( propertyIndex )
 324     {
 325       case Toolkit::ImageView::Property::RESOURCE_URL:
 326       {
 327         if ( !impl.mUrl.empty() )
 328         {
 329           value = impl.mUrl;
 330         }
 331         break;
 332       }
 333
 334       case Toolkit::ImageView::Property::IMAGE:
 335       {
 336         if ( !impl.mUrl.empty() )
 337         {
 338           value = impl.mUrl;
 339         }
 340         else if( impl.mImage )
 341         {
 342           Property::Map map;
 343           Scripting::CreatePropertyMap( impl.mImage, map );
 344           value = map;
 345         }
 346         else if( !impl.mPropertyMap.Empty() )
 347         {
 348           value = impl.mPropertyMap;
 349         }
 350         break;
 351       }
 352
 353       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 354       {
 355         value = impl.IsPreMultipliedAlphaEnabled();
 356         break;
 357       }
 358     }
 359   }
 360
 361   return value;
 362 }
 363
 364 } // namespace Internal
 365 } // namespace Toolkit
 366 } // namespace Dali