X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fcontrol%2Fcontrol-data-impl.cpp;h=e1d82e39f97b11bad91889ec9db0d36f7e1aabf3;hb=refs%2Fchanges%2F76%2F135976%2F11;hp=38c9a57d4037566c0b7fa22f57230513035c10b3;hpb=24ea337df1049251ab2e47c556edc6e8458f9c93;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/controls/control/control-data-impl.cpp b/dali-toolkit/internal/controls/control/control-data-impl.cpp index 38c9a57..e1d82e3 100644 --- a/dali-toolkit/internal/controls/control/control-data-impl.cpp +++ b/dali-toolkit/internal/controls/control/control-data-impl.cpp @@ -21,11 +21,13 @@ // EXTERNAL INCLUDES #include #include +#include #include #include #include #include #include +#include // INTERNAL INCLUDES #include @@ -35,6 +37,7 @@ #include #include #include +#include namespace Dali { @@ -93,6 +96,21 @@ Toolkit::DevelVisual::Type GetVisualTypeFromMap( const Property::Map& map ) return type; } +/** + * Finds visual in given array, returning true if found along with the iterator for that visual as a out parameter + */ +bool FindVisual( Property::Index targetIndex, const RegisteredVisualContainer& visuals, RegisteredVisualContainer::Iterator& iter ) +{ + for ( iter = visuals.Begin(); iter != visuals.End(); iter++ ) + { + if ( (*iter)->index == targetIndex ) + { + return true; + } + } + return false; +} + void FindChangableVisuals( Dictionary& stateVisualsToAdd, Dictionary& stateVisualsToChange, DictionaryKeys& stateVisualsToRemove) @@ -113,6 +131,38 @@ void FindChangableVisuals( Dictionary& stateVisualsToAdd, } } +Toolkit::Visual::Base GetVisualByName( + const RegisteredVisualContainer& visuals, + const std::string& visualName ) +{ + Toolkit::Visual::Base visualHandle; + + RegisteredVisualContainer::Iterator iter; + for ( iter = visuals.Begin(); iter != visuals.End(); iter++ ) + { + Toolkit::Visual::Base visual = (*iter)->visual; + if( visual && visual.GetName() == visualName ) + { + visualHandle = visual; + break; + } + } + return visualHandle; +} + +/** + * Move visual from source to destination container + */ +void MoveVisual( RegisteredVisualContainer::Iterator sourceIter, RegisteredVisualContainer& source, RegisteredVisualContainer& destination ) +{ + Toolkit::Visual::Base visual = (*sourceIter)->visual; + if( visual ) + { + RegisteredVisual* rv = source.Release( sourceIter ); + destination.PushBack( rv ); + } +} + /** * Performs actions as requested using the action name. * @param[in] object The object on which to perform the action. @@ -225,8 +275,6 @@ TypeAction registerAction( typeRegistration, ACTION_ACCESSIBILITY_ACTIVATED, &Do DALI_TYPE_REGISTRATION_END() - - } // unnamed namespace @@ -285,28 +333,6 @@ const Control::Impl& Control::Impl::Get( const Internal::Control& internalContro return *internalControl.mImpl; } - - - -Toolkit::Visual::Base Control::Impl::GetVisualByName( - RegisteredVisualContainer& visuals, - const std::string& visualName ) -{ - Toolkit::Visual::Base visualHandle; - - RegisteredVisualContainer::Iterator iter; - for ( iter = visuals.Begin(); iter != visuals.End(); iter++ ) - { - Toolkit::Visual::Base visual = (*iter)->visual; - if( visual && visual.GetName() == visualName ) - { - visualHandle = visual; - break; - } - } - return visualHandle; -} - // Gesture Detection Methods void Control::Impl::PinchDetected(Actor actor, const PinchGesture& pinch) { @@ -331,9 +357,51 @@ void Control::Impl::LongPressDetected(Actor actor, const LongPressGesture& longP // Called by a Visual when it's resource is ready void Control::Impl::ResourceReady( Visual::Base& object) { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceReady \n"); + + // A resource is ready, check if is in the replacement visual container + // Iterate through all visuals in replacement container and store indexes of ready visuals + Dali::Vector readyVisuals; + Actor self = mControlImpl.Self(); + + for( auto replacementVisualIter = mReplacementVisuals.Begin(); + replacementVisualIter < mReplacementVisuals.End(); ++replacementVisualIter ) + { + const Toolkit::Visual::Base replacementVisual = (*replacementVisualIter)->visual; + const Internal::Visual::Base& replacementVisualImpl = Toolkit::GetImplementation( replacementVisual ); + + if( replacementVisualImpl.IsResourceReady() ) + { + // Check if new replacement visual (index) is already queued for replacement and swap old for new. + RegisteredVisualContainer::Iterator registeredVisualsIter; + if( FindVisual( (*replacementVisualIter)->index, mVisuals, registeredVisualsIter ) ) + { + Property::Index readyVisualIndex = (*replacementVisualIter)->index; + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceReady: %d Ready to replace\n", readyVisualIndex ); + readyVisuals.PushBack( readyVisualIndex ); + // Remove current shown visual from stage and from registered visuals container + Toolkit::GetImplementation((*registeredVisualsIter)->visual).SetOffStage( self ); + mVisuals.Erase( registeredVisualsIter ); + } + } + } + + for( auto readyVisualsIter = readyVisuals.Begin(); readyVisualsIter != readyVisuals.End(); readyVisualsIter++ ) + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceReady: %d Matched\n", (*readyVisualsIter) ); + // Move new visual to be shown from replacement container into the control's registered visuals container + // Replacement visual has already been set on stage when it was added to replacement container + RegisteredVisualContainer::Iterator readyReplacementVisual; + if( FindVisual( (*readyVisualsIter) , mReplacementVisuals, readyReplacementVisual ) ) + { + MoveVisual( readyReplacementVisual, mReplacementVisuals, mVisuals ); // Erases visual from replacement queue + } + // A visual has been replaced so control will most likely need relayouting + mControlImpl.RelayoutRequest(); + } // go through and check if all the visuals are ready, if they are emit a signal - for ( RegisteredVisualContainer::ConstIterator visualIter = mVisuals.Begin(); + for( auto visualIter = mVisuals.Begin(); visualIter != mVisuals.End(); ++visualIter ) { const Toolkit::Visual::Base visual = (*visualIter)->visual; @@ -349,7 +417,6 @@ void Control::Impl::ResourceReady( Visual::Base& object) // all the visuals are ready Dali::Toolkit::Control handle( mControlImpl.GetOwner() ); mResourceReadySignal.Emit( handle ); - } bool Control::Impl::IsResourceReady() const @@ -369,6 +436,220 @@ bool Control::Impl::IsResourceReady() const } return true; } + +void Control::Impl::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual ) +{ + RegisterVisual( index, visual, VisualState::ENABLED, DepthIndexValue::NOT_SET ); +} + +void Control::Impl::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, int depthIndex ) +{ + RegisterVisual( index, visual, VisualState::ENABLED, DepthIndexValue::SET, depthIndex ); +} + +void Control::Impl::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled ) +{ + RegisterVisual( index, visual, ( enabled ? VisualState::ENABLED : VisualState::DISABLED ), DepthIndexValue::NOT_SET ); +} + +void Control::Impl::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled, int depthIndex ) +{ + RegisterVisual( index, visual, ( enabled ? VisualState::ENABLED : VisualState::DISABLED ), DepthIndexValue::SET, depthIndex ); +} + +void Control::Impl::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, VisualState::Type enabled, DepthIndexValue::Type depthIndexValueSet, int depthIndex ) +{ + DALI_LOG_INFO( gLogFilter, Debug::Concise, "RegisterVisual:%d \n", index ); + + bool visualReplaced ( false ); + Actor self = mControlImpl.Self(); + + if( !mVisuals.Empty() ) + { + RegisteredVisualContainer::Iterator registeredVisualsiter; + // Check if visual (index) is already registered. Replace if so. + if( FindVisual( index, mVisuals, registeredVisualsiter ) ) + { + if( (*registeredVisualsiter)->visual ) + { + // Store current visual depth index as may need to set the replacement visual to same depth + const int currentDepthIndex = (*registeredVisualsiter)->visual.GetDepthIndex(); + + // Monitor when the visuals resources are ready + StopObservingVisual( (*registeredVisualsiter)->visual ); + StartObservingVisual( visual ); + + if( self.OnStage() ) + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "RegisterVisual Adding visual to replacement Queue: %d \n", index ); + // Check if visual is currently in the process of being replaced + RegisteredVisualContainer::Iterator queuedReplacementVisual; + if ( FindVisual( index, mReplacementVisuals, queuedReplacementVisual ) ) + { + // If visual on replacement queue is going to be replaced before it's ready then will be removed from queue (and stage) + // Only the the last requested visual will be queued and then displayed. + Toolkit::GetImplementation( (*queuedReplacementVisual)->visual ).SetOffStage( self ); + mReplacementVisuals.Erase(queuedReplacementVisual); + } + // Add to replacement list + mReplacementVisuals.PushBack( new RegisteredVisual( index, visual, ( enabled == VisualState::ENABLED ? true : false ) ) ); + } + else + { + // Not staged so can just replace registered visual + (*registeredVisualsiter)->visual = visual; + (*registeredVisualsiter)->enabled = ( enabled == VisualState::ENABLED ) ? true : false; + } + + // If we've not set the depth-index value and the new visual does not have a depth index applied to it, then use the previously set depth-index for this index + if( ( depthIndexValueSet == DepthIndexValue::NOT_SET ) && + ( visual.GetDepthIndex() == 0 ) ) + { + visual.SetDepthIndex( currentDepthIndex ); + } + } + + visualReplaced = true; + } + } + + // If not set, set the name of the visual to the same name as the control's property. + // ( If the control has been type registered ) + if( visual.GetName().empty() ) + { + try + { + std::string visualName = self.GetPropertyName( index ); + if( !visualName.empty() ) + { + DALI_LOG_INFO( gLogFilter, Debug::Concise, "Setting visual name for property %d to %s\n", + index, visualName.c_str() ); + visual.SetName( visualName ); + } + } + catch( Dali::DaliException e ) + { + DALI_LOG_WARNING( "Attempting to register visual without a registered property, index: %d\n", index ); + } + } + + if( !visualReplaced ) // New registration entry + { + DALI_LOG_INFO( gLogFilter, Debug::Concise, "New Visual registration %d\n", index); + mVisuals.PushBack( new RegisteredVisual( index, visual, ( enabled == VisualState::ENABLED ? true : false ) ) ); + + // monitor when the visuals resources are ready + StartObservingVisual( visual ); + + // If we've not set the depth-index value, we have more than one visual and the visual does not have a depth index, then set it to be the highest + if( ( depthIndexValueSet == DepthIndexValue::NOT_SET ) && + ( mVisuals.Size() > 1 ) && + ( visual.GetDepthIndex() == 0 ) ) + { + int maxDepthIndex = std::numeric_limits< int >::min(); + + RegisteredVisualContainer::ConstIterator iter; + const RegisteredVisualContainer::ConstIterator endIter = mVisuals.End(); + for ( iter = mVisuals.Begin(); iter != endIter; iter++ ) + { + const int visualDepthIndex = (*iter)->visual.GetDepthIndex(); + if ( visualDepthIndex > maxDepthIndex ) + { + maxDepthIndex = visualDepthIndex; + } + } + + ++maxDepthIndex; // Add one to the current maximum depth index so that our added visual appears on top + visual.SetDepthIndex( maxDepthIndex ); + } + } + + if( visual ) + { + // If the caller has set the depth-index, then set it here + if( depthIndexValueSet == DepthIndexValue::SET ) + { + visual.SetDepthIndex( depthIndex ); + } + + // Put on stage if enabled and the control is already on the stage + if( ( enabled == VisualState::ENABLED ) && self.OnStage() ) + { + // Visual must be set on stage for the renderer to be created and the ResourceReady triggered. + Toolkit::GetImplementation(visual).SetOnStage( self ); + } + } + + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::RegisterVisual() Registered %s(%d), enabled:%s\n", visual.GetName().c_str(), index, enabled?"T":"F" ); +} + +void Control::Impl::UnregisterVisual( Property::Index index ) +{ + RegisteredVisualContainer::Iterator iter; + if ( FindVisual( index, mVisuals, iter ) ) + { + // stop observing visual + StopObservingVisual( (*iter)->visual ); + + Actor self( mControlImpl.Self() ); + Toolkit::GetImplementation((*iter)->visual).SetOffStage( self ); + (*iter)->visual.Reset(); + mVisuals.Erase( iter ); + } +} + +Toolkit::Visual::Base Control::Impl::GetVisual( Property::Index index ) const +{ + RegisteredVisualContainer::Iterator iter; + if ( FindVisual( index, mVisuals, iter ) ) + { + return (*iter)->visual; + } + + return Toolkit::Visual::Base(); +} + +void Control::Impl::EnableVisual( Property::Index index, bool enable ) +{ + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Visual (%d)\n", index); + + RegisteredVisualContainer::Iterator iter; + if ( FindVisual( index, mVisuals, iter ) ) + { + if ( (*iter)->enabled == enable ) + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Visual %s(%d) already %s\n", (*iter)->visual.GetName().c_str(), index, enable?"enabled":"disabled"); + return; + } + + (*iter)->enabled = enable; + Actor parentActor = mControlImpl.Self(); + if ( mControlImpl.Self().OnStage() ) // If control not on Stage then Visual will be added when StageConnection is called. + { + if ( enable ) + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Setting %s(%d) on stage \n", (*iter)->visual.GetName().c_str(), index ); + Toolkit::GetImplementation((*iter)->visual).SetOnStage( parentActor ); + } + else + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Setting %s(%d) off stage \n", (*iter)->visual.GetName().c_str(), index ); + Toolkit::GetImplementation((*iter)->visual).SetOffStage( parentActor ); // No need to call if control not staged. + } + } + } +} + +bool Control::Impl::IsVisualEnabled( Property::Index index ) const +{ + RegisteredVisualContainer::Iterator iter; + if ( FindVisual( index, mVisuals, iter ) ) + { + return (*iter)->enabled; + } + return false; +} + void Control::Impl::StopObservingVisual( Toolkit::Visual::Base& visual ) { Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual ); @@ -385,14 +666,82 @@ void Control::Impl::StartObservingVisual( Toolkit::Visual::Base& visual) visualImpl.AddResourceObserver( *this ); } -// Properties +Dali::Animation Control::Impl::CreateTransition( const Toolkit::TransitionData& handle ) +{ + Dali::Animation transition; + const Internal::TransitionData& transitionData = Toolkit::GetImplementation( handle ); + + if( transitionData.Count() > 0 ) + { + // Setup a Transition from TransitionData. + TransitionData::Iterator end = transitionData.End(); + for( TransitionData::Iterator iter = transitionData.Begin() ; + iter != end; ++iter ) + { + TransitionData::Animator* animator = (*iter); + + Toolkit::Visual::Base visual = GetVisualByName( mVisuals, animator->objectName ); + + if( visual ) + { +#if defined(DEBUG_ENABLED) + Dali::TypeInfo typeInfo; + ControlWrapper* controlWrapperImpl = dynamic_cast(&mControlImpl); + if( controlWrapperImpl ) + { + typeInfo = controlWrapperImpl->GetTypeInfo(); + } + + DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Found %s visual for %s\n", + visual.GetName().c_str(), typeInfo?typeInfo.GetName().c_str():"Unknown" ); +#endif + Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual ); + visualImpl.AnimateProperty( transition, *animator ); + } + else + { + DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Could not find visual. Trying actors"); + // Otherwise, try any actor children of control (Including the control) + Actor child = mControlImpl.Self().FindChildByName( animator->objectName ); + if( child ) + { + Property::Index propertyIndex = DevelHandle::GetPropertyIndex( child, animator->propertyKey ); + if( propertyIndex != Property::INVALID_INDEX ) + { + if( animator->animate == false ) + { + if( animator->targetValue.GetType() != Property::NONE ) + { + child.SetProperty( propertyIndex, animator->targetValue ); + } + } + else // animate the property + { + if( animator->initialValue.GetType() != Property::NONE ) + { + child.SetProperty( propertyIndex, animator->initialValue ); + } + + if( ! transition ) + { + transition = Dali::Animation::New( 0.1f ); + } + + transition.AnimateTo( Property( child, propertyIndex ), + animator->targetValue, + animator->alphaFunction, + TimePeriod( animator->timePeriodDelay, + animator->timePeriodDuration ) ); + } + } + } + } + } + } + + return transition; +} -/** - * Called when a property of an object of this type is set. - * @param[in] object The object whose property is set. - * @param[in] index The property index. - * @param[in] value The new property value. - */ void Control::Impl::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value ) { Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) ); @@ -537,8 +886,7 @@ void Control::Impl::SetProperty( BaseObject* object, Property::Index index, cons Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( url, ImageDimensions() ); if( visual ) { - controlImpl.RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual ); - visual.SetDepthIndex( DepthIndex::BACKGROUND ); + controlImpl.mImpl->RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual, DepthIndex::BACKGROUND ); } } else if( value.Get( color ) ) @@ -566,12 +914,6 @@ void Control::Impl::SetProperty( BaseObject* object, Property::Index index, cons } } -/** - * Called to retrieve a property of an object of this type. - * @param[in] object The object whose property is to be retrieved. - * @param[in] index The property index. - * @return The current value of the property. - */ Property::Value Control::Impl::GetProperty( BaseObject* object, Property::Index index ) { Property::Value value; @@ -637,7 +979,7 @@ Property::Value Control::Impl::GetProperty( BaseObject* object, Property::Index { DALI_LOG_WARNING( "BACKGROUND_IMAGE property is deprecated. Use BACKGROUND property instead\n" ); Property::Map map; - Toolkit::Visual::Base visual = controlImpl.GetVisual( Toolkit::Control::Property::BACKGROUND ); + Toolkit::Visual::Base visual = controlImpl.mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND ); if( visual ) { visual.CreatePropertyMap( map ); @@ -655,7 +997,7 @@ Property::Value Control::Impl::GetProperty( BaseObject* object, Property::Index case Toolkit::Control::Property::BACKGROUND: { Property::Map map; - Toolkit::Visual::Base visual = controlImpl.GetVisual( Toolkit::Control::Property::BACKGROUND ); + Toolkit::Visual::Base visual = controlImpl.mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND ); if( visual ) { visual.CreatePropertyMap( map ); @@ -725,12 +1067,6 @@ void Control::Impl::RemoveVisuals( RegisteredVisualContainer& visuals, Dictionar } } - -/** - * Go through the list of visuals that are common to both states. - * If they are different types, or are both image types with different - * URLs, then the existing visual needs moving and the new visual creating - */ void Control::Impl::RecreateChangedVisuals( Dictionary& stateVisualsToChange, Dictionary& instancedProperties ) {