dali/internal/event/events/gesture-detector-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 // CLASS HEADER
  19 #include <dali/internal/event/events/gesture-detector-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/internal/event/events/actor-gesture-data.h>
  27 #include <dali/internal/event/events/gesture-event-processor.h>
  28 #include <dali/internal/event/common/thread-local-storage.h>
  29 #include <dali/internal/event/common/stage-impl.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 GestureDetector::GestureDetector(Gesture::Type type)
  38 : mType(type),
  39   mGestureEventProcessor(ThreadLocalStorage::Get().GetGestureEventProcessor())
  40 {
  41 }
  42
  43 GestureDetector::~GestureDetector()
  44 {
  45   if ( !mAttachedActors.empty() )
  46   {
  47     for ( GestureDetectorActorContainer::iterator iter = mAttachedActors.begin(), endIter = mAttachedActors.end(); iter != endIter; ++iter )
  48     {
  49       Actor* actor( *iter );
  50       actor->RemoveObserver( *this );
  51       actor->GetGestureData().RemoveGestureDetector( *this );
  52     }
  53
  54     mAttachedActors.clear();
  55
  56     // Guard to allow handle destruction after Core has been destroyed
  57     if ( Stage::IsInstalled() )
  58     {
  59       mGestureEventProcessor.RemoveGestureDetector( this );
  60     }
  61   }
  62 }
  63
  64 void GestureDetector::Attach(Actor& actor)
  65 {
  66   if ( !IsAttached(actor) )
  67   {
  68     // Register with EventProcessor if first actor being added
  69     if ( mAttachedActors.empty() )
  70     {
  71       mGestureEventProcessor.AddGestureDetector(this);
  72     }
  73
  74     mAttachedActors.push_back(&actor);
  75
  76     // We need to observe the actor's destruction
  77     actor.AddObserver(*this);
  78
  79     // Add the detector to the actor (so the actor knows it requires this gesture when going through hit-test algorithm)
  80     actor.GetGestureData().AddGestureDetector( *this );
  81
  82     // Notification for derived classes
  83     OnActorAttach(actor);
  84   }
  85 }
  86
  87 void GestureDetector::Detach(Actor& actor)
  88 {
  89   if ( !mAttachedActors.empty() )
  90   {
  91     GestureDetectorActorContainer::iterator match = find(mAttachedActors.begin(), mAttachedActors.end(), &actor);
  92
  93     if ( match != mAttachedActors.end() )
  94     {
  95       // We no longer need to observe the actor's destruction
  96       actor.RemoveObserver(*this);
  97
  98       // Remove detector from actor-gesture-data
  99       actor.GetGestureData().RemoveGestureDetector( *this );
 100
 101       mAttachedActors.erase(match);
 102
 103       // Notification for derived classes
 104       OnActorDetach(actor);
 105
 106       // Unregister from gesture event processor if we do not have any actors
 107       if ( mAttachedActors.empty() )
 108       {
 109         mGestureEventProcessor.RemoveGestureDetector(this);
 110       }
 111     }
 112   }
 113 }
 114
 115 void GestureDetector::DetachAll()
 116 {
 117   if ( !mAttachedActors.empty() )
 118   {
 119     GestureDetectorActorContainer attachedActors(mAttachedActors);
 120
 121     // Clear mAttachedActors before we call OnActorDetach in case derived classes call a method which manipulates mAttachedActors.
 122     mAttachedActors.clear();
 123
 124     for ( GestureDetectorActorContainer::iterator iter = attachedActors.begin(), endIter = attachedActors.end(); iter != endIter; ++iter )
 125     {
 126       Actor* actor(*iter);
 127
 128       // We no longer need to observe the actor's destruction
 129       actor->RemoveObserver(*this);
 130
 131       // Remove detector from actor-gesture-data
 132       actor->GetGestureData().RemoveGestureDetector( *this );
 133
 134       // Notification for derived classes
 135       OnActorDetach(*actor);
 136     }
 137
 138     // Unregister from gesture event processor
 139     mGestureEventProcessor.RemoveGestureDetector(this);
 140   }
 141 }
 142
 143 size_t GestureDetector::GetAttachedActorCount() const
 144 {
 145   return mAttachedActors.size();
 146 }
 147
 148 Dali::Actor GestureDetector::GetAttachedActor(size_t index) const
 149 {
 150   Dali::Actor actor;
 151
 152   if( index < mAttachedActors.size() )
 153   {
 154     actor = Dali::Actor( mAttachedActors[index] );
 155   }
 156
 157   return actor;
 158 }
 159
 160 bool GestureDetector::IsAttached(Actor& actor) const
 161 {
 162   return find(mAttachedActors.begin(), mAttachedActors.end(), &actor) != mAttachedActors.end();
 163 }
 164
 165 void GestureDetector::ObjectDestroyed(Object& object)
 166 {
 167   if ( !mAttachedActors.empty() )
 168   {
 169     GestureDetectorActorContainer::iterator match = find(mAttachedActors.begin(), mAttachedActors.end(), &object);
 170
 171     if ( match != mAttachedActors.end() )
 172     {
 173       mAttachedActors.erase(match);
 174
 175       // Notification for derived classes
 176       OnActorDestroyed(object);
 177
 178       // Unregister from gesture event processor if we do not have any actors
 179       if ( mAttachedActors.empty() )
 180       {
 181         mGestureEventProcessor.RemoveGestureDetector(this);
 182       }
 183     }
 184   }
 185 }
 186
 187 unsigned int GestureDetector::GetDefaultPropertyCount() const
 188 {
 189   return 0;
 190 }
 191
 192 void GestureDetector::GetDefaultPropertyIndices( Property::IndexContainer& ) const
 193 {
 194 }
 195
 196 const char* GestureDetector::GetDefaultPropertyName( Property::Index index ) const
 197 {
 198   return NULL;
 199 }
 200
 201 Property::Index GestureDetector::GetDefaultPropertyIndex(const std::string& name) const
 202 {
 203   return 0;
 204 }
 205
 206 bool GestureDetector::IsDefaultPropertyWritable(Property::Index index) const
 207 {
 208   return false;
 209 }
 210
 211 bool GestureDetector::IsDefaultPropertyAnimatable(Property::Index index) const
 212 {
 213   return false;
 214 }
 215
 216 bool GestureDetector::IsDefaultPropertyAConstraintInput( Property::Index index ) const
 217 {
 218   return false;
 219 }
 220
 221 Property::Type GestureDetector::GetDefaultPropertyType(Property::Index index) const
 222 {
 223   return Property::NONE;
 224 }
 225
 226 void GestureDetector::SetDefaultProperty( Property::Index index, const Property::Value& property )
 227 {
 228   // None of our properties should be settable from Public API
 229 }
 230
 231 Property::Value GestureDetector::GetDefaultProperty(Property::Index index) const
 232 {
 233   return Property::Value();
 234 }
 235
 236 const SceneGraph::PropertyOwner* GestureDetector::GetSceneObject() const
 237 {
 238   return NULL;
 239 }
 240
 241 const SceneGraph::PropertyBase* GestureDetector::GetSceneObjectAnimatableProperty( Property::Index index ) const
 242 {
 243   return NULL;
 244 }
 245
 246 const PropertyInputImpl* GestureDetector::GetSceneObjectInputProperty( Property::Index index ) const
 247 {
 248   return NULL;
 249 }
 250
 251 } // namespace Internal
 252
 253 } // namespace Dali