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