examples/styling/image-channel-control-impl.cpp

   1 /*
   2  * Copyright (c) 2016 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 #include "image-channel-control-impl.h"
  18 #include <dali-toolkit/dali-toolkit.h>
  19 #include <dali/public-api/object/type-registry-helper.h>
  20 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  21 #include <cstdio>
  22
  23 using namespace Dali; // Needed for macros
  24
  25 namespace Demo
  26 {
  27 namespace Internal
  28 {
  29
  30 namespace
  31 {
  32
  33 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
  34   varying mediump vec2 vTexCoord;\n
  35   uniform sampler2D sTexture;\n
  36   uniform mediump vec4 uColor;\n
  37   uniform mediump vec3 uChannels;\n
  38   \n
  39   void main()\n
  40   {\n
  41     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4(uChannels, 1.0) ;\n
  42   }\n
  43 );
  44
  45 Dali::BaseHandle Create()
  46 {
  47   return Demo::ImageChannelControl::New();
  48 }
  49
  50 DALI_TYPE_REGISTRATION_BEGIN( ImageChannelControl, Dali::Toolkit::Control, Create );
  51
  52 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "url", STRING, RESOURCE_URL );
  53 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "redChannel", FLOAT, RED_CHANNEL );
  54 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "greenChannel", FLOAT, GREEN_CHANNEL );
  55 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "blueChannel", FLOAT, BLUE_CHANNEL );
  56
  57 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "visibility", BOOLEAN, VISIBILITY );
  58 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "enableVisibilityTransition", ARRAY, ENABLE_VISIBILITY_TRANSITION );
  59 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "disableVisibilityTransition", ARRAY, DISABLE_VISIBILITY_TRANSITION );
  60
  61 DALI_PROPERTY_REGISTRATION( Demo, ImageChannelControl, "imageVisual", MAP, IMAGE_VISUAL );
  62 DALI_TYPE_REGISTRATION_END();
  63
  64 } // anonymous namespace
  65
  66
  67 Internal::ImageChannelControl::ImageChannelControl()
  68 : Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
  69   mChannels( 1.0f, 1.0f, 1.0f ),
  70   mVisibility(true),
  71   mTargetVisibility(true)
  72 {
  73 }
  74
  75 Internal::ImageChannelControl::~ImageChannelControl()
  76 {
  77 }
  78
  79 Demo::ImageChannelControl Internal::ImageChannelControl::New()
  80 {
  81   IntrusivePtr<Internal::ImageChannelControl> impl = new Internal::ImageChannelControl();
  82   Demo::ImageChannelControl handle = Demo::ImageChannelControl( *impl );
  83   impl->Initialize();
  84   return handle;
  85 }
  86
  87 void ImageChannelControl::SetImage( const std::string& url )
  88 {
  89   mUrl = url;
  90
  91   Actor self = Self();
  92
  93   Property::Map properties;
  94   Property::Map shader;
  95   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = FRAGMENT_SHADER;
  96   properties[Dali::Toolkit::Visual::Property::TYPE] = Dali::Toolkit::Visual::IMAGE;
  97   properties[Dali::Toolkit::Visual::Property::SHADER]=shader;
  98   properties[Dali::Toolkit::ImageVisual::Property::URL] = url;
  99
 100   mVisual = Toolkit::VisualFactory::Get().CreateVisual( properties );
 101   RegisterVisual( Demo::ImageChannelControl::Property::IMAGE_VISUAL, mVisual );
 102   mVisual.SetName("imageVisual");
 103
 104   RelayoutRequest();
 105 }
 106
 107 void ImageChannelControl::SetVisibility( bool visibility )
 108 {
 109   printf("ImageChannelControl %s: SetVisibility( %s )\n", Self().GetName().c_str(), visibility?"T":"F" );
 110
 111   Animation animation;
 112
 113   if( mAnimation )
 114   {
 115     mAnimation.Stop();
 116     mAnimation.FinishedSignal().Disconnect( this, &ImageChannelControl::OnStateChangeAnimationFinished );
 117     OnStateChangeAnimationFinished(mAnimation);
 118   }
 119
 120   if( mVisibility != visibility )
 121   {
 122     if( mVisibility )
 123     {
 124       if( mDisableVisibilityTransition.Count() > 0 )
 125       {
 126         mAnimation = CreateTransition( mDisableVisibilityTransition );
 127       }
 128     }
 129     else
 130     {
 131       if( mEnableVisibilityTransition.Count() > 0 )
 132       {
 133         mAnimation = CreateTransition( mEnableVisibilityTransition );
 134       }
 135     }
 136   }
 137
 138   if( mAnimation )
 139   {
 140     mAnimation.FinishedSignal().Connect( this, &ImageChannelControl::OnStateChangeAnimationFinished );
 141     mAnimation.Play();
 142     mTargetVisibility = visibility;
 143   }
 144   else
 145   {
 146     mVisibility = visibility;
 147   }
 148 }
 149
 150 void ImageChannelControl::OnStateChangeAnimationFinished( Animation& src )
 151 {
 152   mVisibility = mTargetVisibility;
 153 }
 154
 155 void ImageChannelControl::OnInitialize()
 156 {
 157   Actor self = Self();
 158   mChannelIndex = self.RegisterProperty( "uChannels", Vector3(1.0f, 1.0f, 1.0f) );
 159 }
 160
 161 void ImageChannelControl::OnStageConnection( int depth )
 162 {
 163   Control::OnStageConnection( depth );
 164 }
 165
 166 void ImageChannelControl::OnStageDisconnection()
 167 {
 168   Control::OnStageDisconnection();
 169 }
 170
 171 void ImageChannelControl::OnSizeSet( const Vector3& targetSize )
 172 {
 173   Control::OnSizeSet( targetSize );
 174
 175   if( mVisual )
 176   {
 177     Vector2 size( targetSize );
 178     mVisual.SetSize( size );
 179   }
 180 }
 181
 182 Vector3 ImageChannelControl::GetNaturalSize()
 183 {
 184   if( mVisual )
 185   {
 186     Vector2 naturalSize;
 187     mVisual.GetNaturalSize(naturalSize);
 188     return Vector3(naturalSize);
 189   }
 190   return Vector3::ZERO;
 191 }
 192
 193 void ImageChannelControl::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
 194 {
 195   // Chain up.
 196   Control::OnStyleChange( styleManager, change );
 197 }
 198
 199
 200 ///////////////////////////////////////////////////////////
 201 //
 202 // Properties
 203 //
 204
 205 void ImageChannelControl::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 206 {
 207   Demo::ImageChannelControl imageChannelControl = Demo::ImageChannelControl::DownCast( Dali::BaseHandle( object ) );
 208
 209   if( imageChannelControl )
 210   {
 211     ImageChannelControl& impl = GetImpl( imageChannelControl );
 212     Actor self = impl.Self();
 213     switch ( index )
 214     {
 215       case Demo::ImageChannelControl::Property::RESOURCE_URL:
 216       {
 217         impl.SetImage( value.Get<std::string>() );
 218         break;
 219       }
 220       case Demo::ImageChannelControl::Property::IMAGE_VISUAL:
 221       {
 222         Property::Map* map = value.GetMap();
 223         if( map )
 224         {
 225           impl.mVisual = Toolkit::VisualFactory::Get().CreateVisual( *map );
 226           impl.RegisterVisual( Demo::ImageChannelControl::Property::IMAGE_VISUAL, impl.mVisual );
 227         }
 228         break;
 229       }
 230       case Demo::ImageChannelControl::Property::VISIBILITY:
 231       {
 232         impl.SetVisibility( value.Get<bool>() );
 233         break;
 234       }
 235       case Demo::ImageChannelControl::Property::ENABLE_VISIBILITY_TRANSITION:
 236       {
 237         if( value.GetType() == Property::ARRAY )
 238         {
 239           impl.mEnableVisibilityTransition = Toolkit::TransitionData::New( *value.GetArray());
 240         }
 241         else if( value.GetType() == Property::MAP )
 242         {
 243           impl.mEnableVisibilityTransition = Toolkit::TransitionData::New( *value.GetMap() );
 244         }
 245         break;
 246       }
 247       case Demo::ImageChannelControl::Property::DISABLE_VISIBILITY_TRANSITION:
 248       {
 249         if( value.GetType() == Property::ARRAY )
 250         {
 251           impl.mDisableVisibilityTransition = Toolkit::TransitionData::New( *value.GetArray());
 252         }
 253         else if( value.GetType() == Property::MAP )
 254         {
 255           impl.mDisableVisibilityTransition = Toolkit::TransitionData::New( *value.GetMap() );
 256         }
 257         break;
 258       }
 259       case Demo::ImageChannelControl::Property::RED_CHANNEL:
 260       {
 261         impl.mChannels[0] = value.Get<float>();
 262         self.SetProperty( impl.mChannelIndex, impl.mChannels );
 263         break;
 264       }
 265       case Demo::ImageChannelControl::Property::GREEN_CHANNEL:
 266       {
 267         impl.mChannels[1] = value.Get<float>();
 268         self.SetProperty( impl.mChannelIndex, impl.mChannels );
 269         break;
 270       }
 271       case Demo::ImageChannelControl::Property::BLUE_CHANNEL:
 272       {
 273         impl.mChannels[2] = value.Get<float>();
 274         self.SetProperty( impl.mChannelIndex, impl.mChannels );
 275         break;
 276       }
 277     }
 278   }
 279 }
 280
 281 Property::Value ImageChannelControl::GetProperty( BaseObject* object, Property::Index propertyIndex )
 282 {
 283   Property::Value value;
 284
 285   Demo::ImageChannelControl imageChannelControl = Demo::ImageChannelControl::DownCast( Dali::BaseHandle( object ) );
 286
 287   if ( imageChannelControl )
 288   {
 289     ImageChannelControl& impl = GetImpl( imageChannelControl );
 290     switch ( propertyIndex )
 291     {
 292       case Demo::ImageChannelControl::Property::RED_CHANNEL:
 293       {
 294         value = impl.mChannels[0];
 295         break;
 296       }
 297       case Demo::ImageChannelControl::Property::GREEN_CHANNEL:
 298       {
 299         value = impl.mChannels[1];
 300         break;
 301       }
 302       case Demo::ImageChannelControl::Property::BLUE_CHANNEL:
 303       {
 304         value = impl.mChannels[2];
 305         break;
 306       }
 307       case Demo::ImageChannelControl::Property::VISIBILITY:
 308       {
 309         value = impl.mVisibility;
 310         break;
 311       }
 312       default:
 313         break;
 314     }
 315   }
 316
 317   return value;
 318 }
 319
 320 } // Internal
 321 } // Demo