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/public-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 Image ImageView::GetImage() const
 146 {
 147   return mImage;
 148 }
 149
 150 void ImageView::EnablePreMultipliedAlpha( bool preMultipled )
 151 {
 152   if( mRenderer )
 153   {
 154      GetImplementation( mRenderer ).EnablePreMultipliedAlpha( preMultipled );
 155   }
 156 }
 157
 158 bool ImageView::IsPreMultipliedAlphaEnabled() const
 159 {
 160   if( mRenderer )
 161   {
 162     return GetImplementation( mRenderer ).IsPreMultipliedAlphaEnabled();
 163   }
 164   return false;
 165 }
 166
 167 void ImageView::SetDepthIndex( int depthIndex )
 168 {
 169   if( mRenderer )
 170   {
 171     mRenderer.SetDepthIndex( depthIndex );
 172   }
 173 }
 174
 175 Vector3 ImageView::GetNaturalSize()
 176 {
 177   if( mRenderer )
 178   {
 179     Vector2 rendererNaturalSize;
 180     mRenderer.GetNaturalSize( rendererNaturalSize );
 181     return Vector3( rendererNaturalSize );
 182   }
 183
 184   Vector3 size;
 185   size.x = mImageSize.GetWidth();
 186   size.y = mImageSize.GetHeight();
 187
 188   if( size.x > 0 && size.y > 0 )
 189   {
 190     size.z = std::min(size.x, size.y);
 191     return size;
 192   }
 193   else
 194   {
 195     // if no image then use Control's natural size
 196     return Control::GetNaturalSize();
 197   }
 198 }
 199
 200 float ImageView::GetHeightForWidth( float width )
 201 {
 202   if( mImageSize.GetWidth() > 0 && mImageSize.GetHeight() > 0 )
 203   {
 204     return GetHeightForWidthBase( width );
 205   }
 206   else
 207   {
 208     return Control::GetHeightForWidth( width );
 209   }
 210 }
 211
 212 float ImageView::GetWidthForHeight( float height )
 213 {
 214   if( mImageSize.GetWidth() > 0 && mImageSize.GetHeight() > 0 )
 215   {
 216     return GetWidthForHeightBase( height );
 217   }
 218   else
 219   {
 220     return Control::GetWidthForHeight( height );
 221   }
 222 }
 223
 224
 225 ///////////////////////////////////////////////////////////
 226 //
 227 // Private methods
 228 //
 229
 230 void ImageView::OnStageConnection( int depth )
 231 {
 232   Control::OnStageConnection( depth );
 233
 234   if( mRenderer )
 235   {
 236     CustomActor self = Self();
 237     mRenderer.SetOnStage( self );
 238   }
 239 }
 240
 241 void ImageView::OnStageDisconnection()
 242 {
 243   if( mRenderer )
 244   {
 245     CustomActor self = Self();
 246     mRenderer.SetOffStage( self );
 247   }
 248
 249   Control::OnStageDisconnection();
 250 }
 251
 252 void ImageView::OnSizeSet( const Vector3& targetSize )
 253 {
 254   Control::OnSizeSet( targetSize );
 255
 256   if( mRenderer )
 257   {
 258     Vector2 size( targetSize );
 259     mRenderer.SetSize( size );
 260   }
 261 }
 262
 263 ///////////////////////////////////////////////////////////
 264 //
 265 // Properties
 266 //
 267
 268 void ImageView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 269 {
 270   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
 271
 272   if ( imageView )
 273   {
 274     switch ( index )
 275     {
 276       case Toolkit::ImageView::Property::RESOURCE_URL:
 277       {
 278         std::string imageUrl;
 279         if( value.Get( imageUrl ) )
 280         {
 281           GetImpl( imageView ).SetImage( imageUrl, ImageDimensions() );
 282         }
 283         break;
 284       }
 285
 286       case Toolkit::ImageView::Property::IMAGE:
 287       {
 288         std::string imageUrl;
 289         if( value.Get( imageUrl ) )
 290         {
 291           ImageView& impl = GetImpl( imageView );
 292           impl.SetImage( imageUrl, ImageDimensions() );
 293         }
 294
 295         // if its not a string then get a Property::Map from the property if possible.
 296         Property::Map map;
 297         if( value.Get( map ) )
 298         {
 299           ImageView& impl = GetImpl( imageView );
 300           impl.SetImage( map );
 301         }
 302
 303         break;
 304       }
 305
 306       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 307       {
 308         bool IsPre;
 309         if( value.Get( IsPre ) )
 310         {
 311           GetImpl(imageView).EnablePreMultipliedAlpha( IsPre );
 312         }
 313         break;
 314       }
 315     }
 316   }
 317 }
 318
 319 Property::Value ImageView::GetProperty( BaseObject* object, Property::Index propertyIndex )
 320 {
 321   Property::Value value;
 322
 323   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
 324
 325   if ( imageview )
 326   {
 327     ImageView& impl = GetImpl( imageview );
 328     switch ( propertyIndex )
 329     {
 330       case Toolkit::ImageView::Property::RESOURCE_URL:
 331       {
 332         if ( !impl.mUrl.empty() )
 333         {
 334           value = impl.mUrl;
 335         }
 336         break;
 337       }
 338
 339       case Toolkit::ImageView::Property::IMAGE:
 340       {
 341         if ( !impl.mUrl.empty() )
 342         {
 343           value = impl.mUrl;
 344         }
 345         else if( impl.mImage )
 346         {
 347           Property::Map map;
 348           Scripting::CreatePropertyMap( impl.mImage, map );
 349           value = map;
 350         }
 351         else if( !impl.mPropertyMap.Empty() )
 352         {
 353           value = impl.mPropertyMap;
 354         }
 355         break;
 356       }
 357
 358       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
 359       {
 360         value = impl.IsPreMultipliedAlphaEnabled();
 361         break;
 362       }
 363     }
 364   }
 365
 366   return value;
 367 }
 368
 369 } // namespace Internal
 370 } // namespace Toolkit
 371 } // namespace Dali