dali-toolkit/internal/controls/scrollable/scrollable-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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
  18 // EXTERNAL INCLUDES
  19 #include <dali/public-api/object/type-registry.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-toolkit/internal/controls/scrollable/scrollable-impl.h>
  23 #include <dali-toolkit/internal/controls/scroll-component/scroll-bar-internal-impl.h>
  24
  25 using namespace Dali;
  26
  27 namespace
  28 {
  29
  30 } // unnamed namespace
  31
  32 namespace Dali
  33 {
  34
  35 namespace Toolkit
  36 {
  37
  38 const Property::Index Scrollable::PROPERTY_OVERSHOOT_EFFECT_COLOR( Toolkit::Internal::Control::CONTROL_PROPERTY_END_INDEX + 1 );
  39 const Property::Index Scrollable::PROPERTY_OVERSHOOT_ANIMATION_SPEED( Toolkit::Internal::Control::CONTROL_PROPERTY_END_INDEX + 2 );
  40
  41 namespace Internal
  42 {
  43
  44 namespace
  45 {
  46 const Vector4 DEFAULT_OVERSHOOT_COLOUR(0.0f, 0.64f, 0.85f, 0.25f);
  47 const float DEFAULT_OVERSHOOT_ANIMATION_SPEED(120.0f); // 120 pixels per second
  48
  49 // Signals
  50
  51 const char* const SIGNAL_SCROLL_STARTED =   "scroll-started";
  52 const char* const SIGNAL_SCROLL_COMPLETED = "scroll-completed";
  53 const char* const SIGNAL_SCROLL_UPDATED =   "scroll-updated";
  54 const char* const SIGNAL_SCROLL_CLAMPED =   "scroll-clamped";
  55
  56 BaseHandle Create()
  57 {
  58   // empty handle as we cannot create Scrollable (but type registered for scroll signal)
  59   return BaseHandle();
  60 }
  61
  62 TypeRegistration mType( typeid( Toolkit::Scrollable ), typeid( Toolkit::Control ), Create );
  63
  64 SignalConnectorType s1( mType, SIGNAL_SCROLL_STARTED,   &Scrollable::DoConnectSignal );
  65 SignalConnectorType s2( mType, SIGNAL_SCROLL_COMPLETED, &Scrollable::DoConnectSignal );
  66 SignalConnectorType s3( mType, SIGNAL_SCROLL_UPDATED,   &Scrollable::DoConnectSignal );
  67 SignalConnectorType s4( mType, SIGNAL_SCROLL_CLAMPED,   &Scrollable::DoConnectSignal );
  68
  69 PropertyRegistration property1( mType,
  70                                 "overshoot-effect-color",
  71                                 Toolkit::Scrollable::PROPERTY_OVERSHOOT_EFFECT_COLOR,
  72                                 Property::VECTOR4,
  73                                 &Scrollable::SetProperty,
  74                                 &Scrollable::GetProperty );
  75
  76 PropertyRegistration property2( mType,
  77                                 "overshoot-animation-speed",
  78                                 Toolkit::Scrollable::PROPERTY_OVERSHOOT_ANIMATION_SPEED,
  79                                 Property::FLOAT,
  80                                 &Scrollable::SetProperty,
  81                                 &Scrollable::GetProperty );
  82
  83 }
  84
  85 const std::string Scrollable::SCROLLABLE_CAN_SCROLL_VERTICAL( "scrollable-can-scroll-vertical" );
  86 const std::string Scrollable::SCROLLABLE_CAN_SCROLL_HORIZONTAL( "scrollable-can-scroll-horizontal" );
  87
  88 ///////////////////////////////////////////////////////////////////////////////////////////////////
  89 // Scrollable
  90 ///////////////////////////////////////////////////////////////////////////////////////////////////
  91
  92 // Scrollable controls are not layout containers so they dont need size negotiation..
  93 // we dont want size negotiation while scrolling if we can avoid it
  94 Scrollable::Scrollable()
  95 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS | NO_SIZE_NEGOTIATION ) ),
  96   mOvershootEffectColor(  DEFAULT_OVERSHOOT_COLOUR ),
  97   mOvershootAnimationSpeed ( DEFAULT_OVERSHOOT_ANIMATION_SPEED ),
  98   mPropertyRelativePosition(Property::INVALID_INDEX),
  99   mPropertyPositionMin(Property::INVALID_INDEX),
 100   mPropertyPositionMax(Property::INVALID_INDEX),
 101   mPropertyScrollDirection(Property::INVALID_INDEX),
 102   mPropertyCanScrollVertical(Property::INVALID_INDEX),
 103   mPropertyCanScrollHorizontal(Property::INVALID_INDEX),
 104   mOvershootEnabled(false)
 105 {
 106 }
 107
 108 Scrollable::~Scrollable()
 109 {
 110   // Clear scroll components, forces their destruction before Scrollable is destroyed.
 111   mComponents.clear();
 112 }
 113
 114 void Scrollable::RegisterCommonProperties()
 115 {
 116   Actor self = Self();
 117
 118   // Register properties.
 119   mPropertyRelativePosition = self.RegisterProperty(Toolkit::Scrollable::SCROLL_RELATIVE_POSITION_PROPERTY_NAME, Vector3::ZERO);
 120   mPropertyPositionMin = self.RegisterProperty(Toolkit::Scrollable::SCROLL_POSITION_MIN_PROPERTY_NAME, Vector3::ZERO);
 121   mPropertyPositionMax = self.RegisterProperty(Toolkit::Scrollable::SCROLL_POSITION_MAX_PROPERTY_NAME, Vector3::ZERO);
 122   mPropertyScrollDirection = self.RegisterProperty(Toolkit::Scrollable::SCROLL_DIRECTION_PROPERTY_NAME, Vector3::ZERO);
 123   mPropertyCanScrollVertical = self.RegisterProperty(SCROLLABLE_CAN_SCROLL_VERTICAL, true);
 124   mPropertyCanScrollHorizontal = self.RegisterProperty(SCROLLABLE_CAN_SCROLL_HORIZONTAL, true);
 125 }
 126
 127 bool Scrollable::IsScrollComponentEnabled(Toolkit::Scrollable::ScrollComponentType type) const
 128 {
 129   if(type == Toolkit::Scrollable::OvershootIndicator)
 130   {
 131     return mOvershootEnabled;
 132   }
 133   return (mComponents.find(type) != mComponents.end());
 134 }
 135
 136 void Scrollable::EnableScrollComponent(Toolkit::Scrollable::ScrollComponentType type)
 137 {
 138   if(type == Toolkit::Scrollable::OvershootIndicator)
 139   {
 140     if( !mOvershootEnabled )
 141     {
 142       SetOvershootEnabled(true);
 143       mOvershootEnabled = true;
 144     }
 145     return;
 146   }
 147   if( mComponents.find(type) == mComponents.end() )
 148   {
 149     // Create ScrollComponent
 150     Toolkit::Scrollable scrollable = Toolkit::Scrollable::DownCast(Self());
 151     Toolkit::ScrollComponent scrollComponent = NewScrollComponent(scrollable, type);
 152     Toolkit::ScrollComponentImpl& component = static_cast<Toolkit::ScrollComponentImpl&>(scrollComponent.GetImplementation());
 153     ScrollComponentPtr componentPtr(&component);
 154
 155     mComponents[type] = componentPtr;
 156   }
 157 }
 158
 159 void Scrollable::DisableScrollComponent(Toolkit::Scrollable::ScrollComponentType type)
 160 {
 161   if(type == Toolkit::Scrollable::OvershootIndicator)
 162   {
 163     if( mOvershootEnabled )
 164     {
 165       SetOvershootEnabled(false);
 166       mOvershootEnabled = false;
 167     }
 168     return;
 169   }
 170   ComponentIter pair = mComponents.find( type );
 171
 172   if( mComponents.end() != pair )
 173   {
 174     ScrollComponentPtr component = pair->second;
 175
 176     // Disconnect the scroll component first.
 177     component->OnDisconnect();
 178
 179     // Destroy ScrollComponent.
 180     mComponents.erase( type );
 181   }
 182 }
 183
 184 Vector4 Scrollable::GetOvershootEffectColor() const
 185 {
 186   return mOvershootEffectColor;
 187 };
 188
 189 void Scrollable::SetOvershootAnimationSpeed( float pixelsPerSecond )
 190 {
 191   mOvershootAnimationSpeed = pixelsPerSecond;
 192 }
 193
 194 float Scrollable::GetOvershootAnimationSpeed() const
 195 {
 196   return mOvershootAnimationSpeed;
 197 };
 198
 199 Toolkit::Scrollable::ScrollStartedSignalType& Scrollable::ScrollStartedSignal()
 200 {
 201   return mScrollStartedSignal;
 202 }
 203
 204 Toolkit::Scrollable::ScrollUpdatedSignalType& Scrollable::ScrollUpdatedSignal()
 205 {
 206   return mScrollUpdatedSignal;
 207 }
 208
 209 Toolkit::Scrollable::ScrollCompletedSignalType& Scrollable::ScrollCompletedSignal()
 210 {
 211   return mScrollCompletedSignal;
 212 }
 213
 214 Toolkit::Scrollable::ScrollClampedSignalType& Scrollable::ScrollClampedSignal()
 215 {
 216   return mScrollClampedSignal;
 217 }
 218
 219 bool Scrollable::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 220 {
 221   Dali::BaseHandle handle( object );
 222
 223   bool connected( true );
 224   Toolkit::Scrollable scrollable = Toolkit::Scrollable::DownCast( handle );
 225
 226   if( 0 == strcmp( signalName.c_str(), SIGNAL_SCROLL_STARTED ) )
 227   {
 228     scrollable.ScrollStartedSignal().Connect( tracker, functor );
 229   }
 230   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCROLL_UPDATED ) )
 231   {
 232     scrollable.ScrollUpdatedSignal().Connect( tracker, functor );
 233   }
 234   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCROLL_COMPLETED ) )
 235   {
 236     scrollable.ScrollCompletedSignal().Connect( tracker, functor );
 237   }
 238   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCROLL_CLAMPED ) )
 239   {
 240     scrollable.ScrollClampedSignal().Connect( tracker, functor );
 241   }
 242   else
 243   {
 244     // signalName does not match any signal
 245     connected = false;
 246   }
 247
 248   return connected;
 249 }
 250
 251 void Scrollable::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 252 {
 253   Toolkit::Scrollable scrollable = Toolkit::Scrollable::DownCast( Dali::BaseHandle( object ) );
 254
 255   if( scrollable )
 256   {
 257     Scrollable& scrollableImpl( GetImpl( scrollable ) );
 258     switch( index )
 259     {
 260       case Toolkit::Scrollable::PROPERTY_OVERSHOOT_EFFECT_COLOR:
 261       {
 262         scrollableImpl.SetOvershootEffectColor( value.Get<Vector4>() );
 263         break;
 264       }
 265       case Toolkit::Scrollable::PROPERTY_OVERSHOOT_ANIMATION_SPEED:
 266       {
 267         scrollableImpl.SetOvershootAnimationSpeed( value.Get<float>() );
 268         break;
 269       }
 270     }
 271   }
 272 }
 273
 274 Property::Value Scrollable::GetProperty( BaseObject* object, Property::Index index )
 275 {
 276   Property::Value value;
 277
 278   Toolkit::Scrollable scrollable = Toolkit::Scrollable::DownCast( Dali::BaseHandle( object ) );
 279
 280   if( scrollable )
 281   {
 282     Scrollable& scrollableImpl( GetImpl( scrollable ) );
 283     switch( index )
 284     {
 285       case Toolkit::Scrollable::PROPERTY_OVERSHOOT_EFFECT_COLOR:
 286       {
 287         value = scrollableImpl.GetOvershootEffectColor();
 288         break;
 289       }
 290       case Toolkit::Scrollable::PROPERTY_OVERSHOOT_ANIMATION_SPEED:
 291       {
 292         value = scrollableImpl.GetOvershootAnimationSpeed();
 293         break;
 294       }
 295     }
 296   }
 297
 298   return value;
 299 }
 300
 301 Toolkit::ScrollComponent Scrollable::NewScrollComponent(Toolkit::Scrollable& scrollable, Toolkit::Scrollable::ScrollComponentType type)
 302 {
 303   Toolkit::ScrollComponent instance;
 304
 305   switch(type)
 306   {
 307     case Toolkit::Scrollable::VerticalScrollBar:
 308     {
 309       instance = static_cast<Toolkit::ScrollComponent>(Toolkit::ScrollBarInternal::New(scrollable, true));
 310       break;
 311     }
 312     case Toolkit::Scrollable::HorizontalScrollBar:
 313     {
 314       instance = static_cast<Toolkit::ScrollComponent>(Toolkit::ScrollBarInternal::New(scrollable, false));
 315       break;
 316     }
 317     case Toolkit::Scrollable::OvershootIndicator:
 318     {
 319       DALI_ASSERT_ALWAYS(!"Unrecognized component type");
 320       break;
 321     }
 322   }
 323
 324   return instance;
 325 }
 326
 327 } // namespace Internal
 328
 329 } // namespace Toolkit
 330
 331 } // namespace Dali