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

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