delete mImpl;
}
-void Control::Initialize()
+void Control::SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy )
{
+ bool relayoutRequest( false );
- // Calling deriving classes
- OnInitialize();
-
- if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS )
+ if ( ( mImpl->mWidthPolicy != widthPolicy ) || ( mImpl->mHeightPolicy != heightPolicy ) )
{
- Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
+ relayoutRequest = true;
+ }
- // Register for style changes
- styleManager.StyleChangeSignal().Connect( this, &Control::DoStyleChange );
+ mImpl->mWidthPolicy = widthPolicy;
+ mImpl->mHeightPolicy = heightPolicy;
- // SetTheme
- GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
+ // Ensure RelayoutRequest is called AFTER new policies have been set.
+ if ( relayoutRequest )
+ {
+ RelayoutRequest();
}
+}
- SetRequiresHoverEvents(mImpl->mFlags & REQUIRES_HOVER_EVENTS);
- SetRequiresMouseWheelEvents(mImpl->mFlags & REQUIRES_MOUSE_WHEEL_EVENTS);
-
- mImpl->mInitialized = true;
+void Control::GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const
+{
+ widthPolicy = mImpl->mWidthPolicy;
+ heightPolicy = mImpl->mHeightPolicy;
}
-void Control::EnableGestureDetection(Gesture::Type type)
+void Control::SetMinimumSize( const Vector3& size )
{
- if ( (type & Gesture::Pinch) && !mImpl->mPinchGestureDetector )
+ const Vector3& minSize = mImpl->GetMinimumSize();
+ if ( fabsf( minSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
+ fabsf( minSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
{
- mImpl->mPinchGestureDetector = PinchGestureDetector::New();
- mImpl->mPinchGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PinchDetected);
- mImpl->mPinchGestureDetector.Attach(Self());
- }
+ mImpl->SetMinimumSize( size );
- if ( (type & Gesture::Pan) && !mImpl->mPanGestureDetector )
- {
- mImpl->mPanGestureDetector = PanGestureDetector::New();
- mImpl->mPanGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PanDetected);
- mImpl->mPanGestureDetector.Attach(Self());
+ // Only relayout if our control is using the minimum or range policy.
+ if ( ( mImpl->mHeightPolicy == Toolkit::Control::Minimum ) || ( mImpl->mWidthPolicy == Toolkit::Control::Minimum ) ||
+ ( mImpl->mHeightPolicy == Toolkit::Control::Range ) || ( mImpl->mWidthPolicy == Toolkit::Control::Range ) )
+ {
+ RelayoutRequest();
+ }
}
+}
- if ( (type & Gesture::Tap) && !mImpl->mTapGestureDetector )
+const Vector3& Control::GetMinimumSize() const
+{
+ return mImpl->GetMinimumSize();
+}
+
+void Control::SetMaximumSize( const Vector3& size )
+{
+ const Vector3& maxSize = mImpl->GetMaximumSize();
+ if ( fabsf( maxSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
+ fabsf( maxSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
{
- mImpl->mTapGestureDetector = TapGestureDetector::New();
- mImpl->mTapGestureDetector.DetectedSignal().Connect(mImpl, &Impl::TapDetected);
- mImpl->mTapGestureDetector.Attach(Self());
+ mImpl->SetMaximumSize( size );
+
+ // Only relayout if our control is using the maximum or range policy.
+ if ( ( mImpl->mHeightPolicy == Toolkit::Control::Maximum ) || ( mImpl->mWidthPolicy == Toolkit::Control::Maximum ) ||
+ ( mImpl->mHeightPolicy == Toolkit::Control::Range ) || ( mImpl->mWidthPolicy == Toolkit::Control::Range ) )
+ {
+ RelayoutRequest();
+ }
}
+}
- if ( (type & Gesture::LongPress) && !mImpl->mLongPressGestureDetector )
+const Vector3& Control::GetMaximumSize() const
+{
+ return mImpl->GetMaximumSize();
+}
+
+Vector3 Control::GetNaturalSize()
+{
+ // could be overridden in derived classes.
+ return mImpl->mNaturalSize;
+}
+
+float Control::GetHeightForWidth( float width )
+{
+ // could be overridden in derived classes.
+ float height( 0.0f );
+ if ( mImpl->mNaturalSize.width > 0.0f )
{
- mImpl->mLongPressGestureDetector = LongPressGestureDetector::New();
- mImpl->mLongPressGestureDetector.DetectedSignal().Connect(mImpl, &Impl::LongPressDetected);
- mImpl->mLongPressGestureDetector.Attach(Self());
+ height = mImpl->mNaturalSize.height * width / mImpl->mNaturalSize.width;
}
+ return height;
}
-void Control::DisableGestureDetection(Gesture::Type type)
+float Control::GetWidthForHeight( float height )
{
- if ( (type & Gesture::Pinch) && mImpl->mPinchGestureDetector )
+ // could be overridden in derived classes.
+ float width( 0.0f );
+ if ( mImpl->mNaturalSize.height > 0.0f )
{
- mImpl->mPinchGestureDetector.Detach(Self());
- mImpl->mPinchGestureDetector.Reset();
+ width = mImpl->mNaturalSize.width * height / mImpl->mNaturalSize.height;
}
+ return width;
+}
- if ( (type & Gesture::Pan) && mImpl->mPanGestureDetector )
+const Vector3& Control::GetControlSize() const
+{
+ return mImpl->mCurrentSize;
+}
+
+const Vector3& Control::GetSizeSet() const
+{
+ return mImpl->mNaturalSize;
+}
+
+void Control::SetKeyInputFocus()
+{
+ if( Self().OnStage() )
{
- mImpl->mPanGestureDetector.Detach(Self());
- mImpl->mPanGestureDetector.Reset();
+ Toolkit::KeyInputFocusManager::Get().SetFocus(Toolkit::Control::DownCast(Self()));
}
+}
- if ( (type & Gesture::Tap) && mImpl->mTapGestureDetector )
+bool Control::HasKeyInputFocus()
+{
+ bool result = false;
+ if( Self().OnStage() )
{
- mImpl->mTapGestureDetector.Detach(Self());
- mImpl->mTapGestureDetector.Reset();
+ result = Toolkit::KeyInputFocusManager::Get().IsKeyboardListener(Toolkit::Control::DownCast(Self()));
}
+ return result;
+}
- if ( (type & Gesture::LongPress) && mImpl->mLongPressGestureDetector)
+void Control::ClearKeyInputFocus()
+{
+ if( Self().OnStage() )
{
- mImpl->mLongPressGestureDetector.Detach(Self());
- mImpl->mLongPressGestureDetector.Reset();
+ Toolkit::KeyInputFocusManager::Get().RemoveFocus(Toolkit::Control::DownCast(Self()));
}
}
return Actor();
}
-void Control::OnThemeChange( Toolkit::StyleManager styleManager )
+void Control::SetKeyboardNavigationSupport(bool isSupported)
{
- GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
+ mImpl->mIsKeyboardNavigationSupported = isSupported;
}
-void Control::OnPinch(const PinchGesture& pinch)
+bool Control::IsKeyboardNavigationSupported()
{
- if( !( mImpl->mStartingPinchScale ) )
- {
- // lazy allocate
- mImpl->mStartingPinchScale = new Vector3;
- }
-
- if( pinch.state == Gesture::Started )
- {
- *( mImpl->mStartingPinchScale ) = Self().GetCurrentScale();
- }
-
- Self().SetScale( *( mImpl->mStartingPinchScale ) * pinch.scale );
+ return mImpl->mIsKeyboardNavigationSupported;
}
-void Control::OnPan( const PanGesture& pan )
+void Control::Activate()
{
+ // Inform deriving classes
+ OnActivated();
}
-void Control::OnTap(const TapGesture& tap)
+bool Control::OnAccessibilityPan(PanGesture gesture)
{
+ return false; // Accessibility pan gesture is not handled by default
}
-void Control::OnLongPress( const LongPressGesture& longPress )
+bool Control::OnAccessibilityTouch(const TouchEvent& touchEvent)
{
+ return false; // Accessibility touch event is not handled by default
}
-void Control::OnStageConnection()
+bool Control::OnAccessibilityValueChange(bool isIncrease)
{
- RelayoutRequest();
-
- // Notify derived classes.
- OnControlStageConnection();
+ return false; // Accessibility value change action is not handled by default
}
-void Control::OnStageDisconnection()
+void Control::NegotiateSize( Vector2 allocatedSize, ActorSizeContainer& container )
{
- // Notify derived classes
- OnControlStageDisconnection();
-}
+ Vector2 size;
-void Control::OnChildAdd(Actor& child)
-{
- // If this is the background actor, then we do not want to relayout or inform deriving classes
- if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
+ if ( mImpl->mWidthPolicy == Toolkit::Control::Fixed )
{
- return;
- }
+ if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
+ {
+ // If a control says it has a fixed size, then use the size set by the application / control.
+ Vector2 setSize( mImpl->mNaturalSize );
+ if ( setSize != Vector2::ZERO )
+ {
+ size = setSize;
- // Request for relayout as we may need to position the new child and old ones
- RelayoutRequest();
+ // Policy is set to Fixed, so if the application / control has not set one of the dimensions,
+ // then we should use the natural size of the control rather than the full allocation.
+ if ( EqualsZero( size.width ) )
+ {
+ size.width = GetWidthForHeight( size.height );
+ }
+ else if ( EqualsZero( size.height ) )
+ {
+ size.height = GetHeightForWidth( size.width );
+ }
+ }
+ else
+ {
+ // If that is not set then set the size to the control's natural size
+ size = Vector2( GetNaturalSize() );
+ }
+ }
+ else
+ {
+ // Width is fixed so if the application / control has set it, then use that.
+ if ( !EqualsZero( mImpl->mNaturalSize.width ) )
+ {
+ size.width = mImpl->mNaturalSize.width;
+ }
+ else
+ {
+ // Otherwise, set the width to what has been allocated.
+ size.width = allocatedSize.width;
+ }
- // Notify derived classes.
- OnControlChildAdd( child );
-}
+ // Height is flexible so ask control what the height should be for our width.
+ size.height = GetHeightForWidth( size.width );
-void Control::OnChildRemove(Actor& child)
-{
- // If this is the background actor, then we do not want to relayout or inform deriving classes
- if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
- {
- return;
+ // Ensure height is within our policy rules
+ size.height = Calculate( mImpl->mHeightPolicy, GetMinimumSize().height, GetMaximumSize().height, size.height );
+ }
}
-
- // Request for relayout as we may need to re-position the old child
- RelayoutRequest();
-
- // Notify derived classes.
- OnControlChildRemove( child );
-}
-
-void Control::OnSizeSet(const Vector3& targetSize)
-{
- if( ( !mImpl->mInsideRelayout ) && ( targetSize != mImpl->mNaturalSize ) )
+ else
{
- // Only updates size if set through Actor's API
- mImpl->mNaturalSize = targetSize;
- }
+ if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
+ {
+ // Height is fixed so if the application / control has set it, then use that.
+ if ( !EqualsZero( mImpl->mNaturalSize.height ) )
+ {
+ size.height = mImpl->mNaturalSize.height;
+ }
+ else
+ {
+ // Otherwise, set the height to what has been allocated.
+ size.height = allocatedSize.height;
+ }
- if( targetSize != mImpl->mCurrentSize )
- {
- // Update control size.
- mImpl->mCurrentSize = targetSize;
+ // Width is flexible so ask control what the width should be for our height.
+ size.width = GetWidthForHeight( size.height );
- // Notify derived classes.
- OnControlSizeSet( targetSize );
+ // Ensure width is within our policy rules
+ size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, size.width );
+ }
+ else
+ {
+ // Width and height are BOTH flexible.
+ // Calculate the width and height using the policy rules.
+ size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, allocatedSize.width );
+ size.height = Calculate( mImpl->mHeightPolicy, mImpl->GetMinimumSize().height, mImpl->GetMaximumSize().height, allocatedSize.height );
+ }
}
-}
-
-void Control::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
-{
- // @todo consider animating negotiated child sizes to target size
-}
-
-bool Control::OnTouchEvent(const TouchEvent& event)
-{
- return false; // Do not consume
-}
-
-bool Control::OnHoverEvent(const HoverEvent& event)
-{
- return false; // Do not consume
-}
-
-bool Control::OnKeyEvent(const KeyEvent& event)
-{
- return false; // Do not consume
-}
-
-bool Control::OnMouseWheelEvent(const MouseWheelEvent& event)
-{
- return false; // Do not consume
-}
-
-void Control::OnKeyInputFocusGained()
-{
- // Do Nothing
-}
-
-void Control::OnKeyInputFocusLost()
-{
- // Do Nothing
-}
-
-Actor Control::GetChildByAlias(const std::string& actorAlias)
-{
- return Actor();
-}
-
-bool Control::OnAccessibilityPan(PanGesture gesture)
-{
- return false; // Accessibility pan gesture is not handled by default
-}
-
-bool Control::OnAccessibilityTouch(const TouchEvent& touchEvent)
-{
- return false; // Accessibility touch event is not handled by default
-}
-bool Control::OnAccessibilityValueChange(bool isIncrease)
-{
- return false; // Accessibility value change action is not handled by default
-}
+ // If the width has not been set, then set to the allocated width.
+ // Also if the width set is greater than the allocated, then set to allocated (no exceed support).
+ if ( EqualsZero( size.width ) || ( size.width > allocatedSize.width ) )
+ {
+ size.width = allocatedSize.width;
+ }
+ // If the height has not been set, then set to the allocated height.
+ // Also if the height set is greater than the allocated, then set to allocated (no exceed support).
+ if ( EqualsZero( size.height ) || ( size.height > allocatedSize.height ) )
+ {
+ size.height = allocatedSize.height;
+ }
-void Control::SetKeyboardNavigationSupport(bool isSupported)
-{
- mImpl->mIsKeyboardNavigationSupported = isSupported;
-}
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose,
+ "%p: Natural: [%.2f, %.2f] Allocated: [%.2f, %.2f] Set: [%.2f, %.2f]\n",
+ Self().GetObjectPtr(),
+ GetNaturalSize().x, GetNaturalSize().y,
+ allocatedSize.x, allocatedSize.y,
+ size.x, size.y );
-bool Control::IsKeyboardNavigationSupported()
-{
- return mImpl->mIsKeyboardNavigationSupported;
+ Relayout( size, container );
}
void Control::SetAsKeyboardFocusGroup(bool isFocusGroup)
return Actor();
}
+void Control::OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
+{
+}
+
bool Control::DoAction(BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes)
{
bool ret = false;
return connected;
}
-void Control::DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change )
-{
- if( change.themeChange )
- {
- OnThemeChange( styleManager );
- }
- else if( change.defaultFontChange || change.defaultFontSizeChange )
- {
- OnFontChange( change.defaultFontChange, change.defaultFontSizeChange );
- }
-}
-
Toolkit::Control::KeyEventSignalV2& Control::KeyEventSignal()
{
return mImpl->mKeyEventSignalV2;
}
-void Control::SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy )
+bool Control::EmitKeyEventSignal( const KeyEvent& event )
{
- bool relayoutRequest( false );
+ // Guard against destruction during signal emission
+ Dali::Toolkit::Control handle( GetOwner() );
- if ( ( mImpl->mWidthPolicy != widthPolicy ) || ( mImpl->mHeightPolicy != heightPolicy ) )
+ bool consumed = false;
+
+ // signals are allocated dynamically when someone connects
+ if ( !mImpl->mKeyEventSignalV2.Empty() )
{
- relayoutRequest = true;
+ consumed = mImpl->mKeyEventSignalV2.Emit( handle, event );
}
- mImpl->mWidthPolicy = widthPolicy;
- mImpl->mHeightPolicy = heightPolicy;
-
- // Ensure RelayoutRequest is called AFTER new policies have been set.
- if ( relayoutRequest )
+ if (!consumed)
{
- RelayoutRequest();
+ // Notification for derived classes
+ consumed = OnKeyEvent(event);
}
+
+ return consumed;
}
-void Control::GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const
+Control::Control( ControlBehaviour behaviourFlags )
+: CustomActorImpl( behaviourFlags & REQUIRES_TOUCH_EVENTS ),
+ mImpl(new Impl(*this))
{
- widthPolicy = mImpl->mWidthPolicy;
- heightPolicy = mImpl->mHeightPolicy;
+ mImpl->mFlags = behaviourFlags;
}
-void Control::SetMinimumSize( const Vector3& size )
+void Control::Initialize()
{
- const Vector3& minSize = mImpl->GetMinimumSize();
- if ( fabsf( minSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
- fabsf( minSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
+
+ // Calling deriving classes
+ OnInitialize();
+
+ if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS )
{
- mImpl->SetMinimumSize( size );
+ Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
- // Only relayout if our control is using the minimum or range policy.
- if ( ( mImpl->mHeightPolicy == Toolkit::Control::Minimum ) || ( mImpl->mWidthPolicy == Toolkit::Control::Minimum ) ||
- ( mImpl->mHeightPolicy == Toolkit::Control::Range ) || ( mImpl->mWidthPolicy == Toolkit::Control::Range ) )
- {
- RelayoutRequest();
- }
+ // Register for style changes
+ styleManager.StyleChangeSignal().Connect( this, &Control::DoStyleChange );
+
+ // SetTheme
+ GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
}
-}
-const Vector3& Control::GetMinimumSize() const
-{
- return mImpl->GetMinimumSize();
+ SetRequiresHoverEvents(mImpl->mFlags & REQUIRES_HOVER_EVENTS);
+ SetRequiresMouseWheelEvents(mImpl->mFlags & REQUIRES_MOUSE_WHEEL_EVENTS);
+
+ mImpl->mInitialized = true;
}
-void Control::SetMaximumSize( const Vector3& size )
+void Control::EnableGestureDetection(Gesture::Type type)
{
- const Vector3& maxSize = mImpl->GetMaximumSize();
- if ( fabsf( maxSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
- fabsf( maxSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
+ if ( (type & Gesture::Pinch) && !mImpl->mPinchGestureDetector )
{
- mImpl->SetMaximumSize( size );
+ mImpl->mPinchGestureDetector = PinchGestureDetector::New();
+ mImpl->mPinchGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PinchDetected);
+ mImpl->mPinchGestureDetector.Attach(Self());
+ }
- // Only relayout if our control is using the maximum or range policy.
- if ( ( mImpl->mHeightPolicy == Toolkit::Control::Maximum ) || ( mImpl->mWidthPolicy == Toolkit::Control::Maximum ) ||
- ( mImpl->mHeightPolicy == Toolkit::Control::Range ) || ( mImpl->mWidthPolicy == Toolkit::Control::Range ) )
- {
- RelayoutRequest();
- }
+ if ( (type & Gesture::Pan) && !mImpl->mPanGestureDetector )
+ {
+ mImpl->mPanGestureDetector = PanGestureDetector::New();
+ mImpl->mPanGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PanDetected);
+ mImpl->mPanGestureDetector.Attach(Self());
}
-}
-const Vector3& Control::GetMaximumSize() const
-{
- return mImpl->GetMaximumSize();
-}
+ if ( (type & Gesture::Tap) && !mImpl->mTapGestureDetector )
+ {
+ mImpl->mTapGestureDetector = TapGestureDetector::New();
+ mImpl->mTapGestureDetector.DetectedSignal().Connect(mImpl, &Impl::TapDetected);
+ mImpl->mTapGestureDetector.Attach(Self());
+ }
-Vector3 Control::GetNaturalSize()
-{
- // could be overridden in derived classes.
- return mImpl->mNaturalSize;
+ if ( (type & Gesture::LongPress) && !mImpl->mLongPressGestureDetector )
+ {
+ mImpl->mLongPressGestureDetector = LongPressGestureDetector::New();
+ mImpl->mLongPressGestureDetector.DetectedSignal().Connect(mImpl, &Impl::LongPressDetected);
+ mImpl->mLongPressGestureDetector.Attach(Self());
+ }
}
-float Control::GetHeightForWidth( float width )
+void Control::DisableGestureDetection(Gesture::Type type)
{
- // could be overridden in derived classes.
- float height( 0.0f );
- if ( mImpl->mNaturalSize.width > 0.0f )
+ if ( (type & Gesture::Pinch) && mImpl->mPinchGestureDetector )
{
- height = mImpl->mNaturalSize.height * width / mImpl->mNaturalSize.width;
+ mImpl->mPinchGestureDetector.Detach(Self());
+ mImpl->mPinchGestureDetector.Reset();
}
- return height;
-}
-float Control::GetWidthForHeight( float height )
-{
- // could be overridden in derived classes.
- float width( 0.0f );
- if ( mImpl->mNaturalSize.height > 0.0f )
+ if ( (type & Gesture::Pan) && mImpl->mPanGestureDetector )
{
- width = mImpl->mNaturalSize.width * height / mImpl->mNaturalSize.height;
+ mImpl->mPanGestureDetector.Detach(Self());
+ mImpl->mPanGestureDetector.Reset();
}
- return width;
-}
-const Vector3& Control::GetControlSize() const
-{
- return mImpl->mCurrentSize;
-}
-
-const Vector3& Control::GetSizeSet() const
-{
- return mImpl->mNaturalSize;
-}
-
-void Control::SetKeyInputFocus()
-{
- if( Self().OnStage() )
- {
- Toolkit::KeyInputFocusManager::Get().SetFocus(Toolkit::Control::DownCast(Self()));
- }
-}
-
-bool Control::HasKeyInputFocus()
-{
- bool result = false;
- if( Self().OnStage() )
+ if ( (type & Gesture::Tap) && mImpl->mTapGestureDetector )
{
- result = Toolkit::KeyInputFocusManager::Get().IsKeyboardListener(Toolkit::Control::DownCast(Self()));
+ mImpl->mTapGestureDetector.Detach(Self());
+ mImpl->mTapGestureDetector.Reset();
}
- return result;
-}
-void Control::ClearKeyInputFocus()
-{
- if( Self().OnStage() )
+ if ( (type & Gesture::LongPress) && mImpl->mLongPressGestureDetector)
{
- Toolkit::KeyInputFocusManager::Get().RemoveFocus(Toolkit::Control::DownCast(Self()));
+ mImpl->mLongPressGestureDetector.Detach(Self());
+ mImpl->mLongPressGestureDetector.Reset();
}
}
}
}
-void Control::Relayout(Vector2 size, ActorSizeContainer& container)
-{
- // Avoids relayout again when OnSizeSet callback arrives.
- mImpl->mInsideRelayout = true;
- Self().SetSize( size );
- // @todo this really needs to be at the end of method but not sure why the scope used to be only the SetSize, needs to be cleaned up in size negotiation rework
- mImpl->mInsideRelayout = false;
-
- // Only relayout controls which requested to be relaid out.
- OnRelaidOut( size, container );
-}
-
void Control::Relayout( Actor actor, Vector2 size, ActorSizeContainer& container )
{
if ( actor )
}
}
+void Control::OnInitialize()
+{
+}
+
+void Control::OnActivated()
+{
+}
+
+void Control::OnThemeChange( Toolkit::StyleManager styleManager )
+{
+ GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
+}
+
+void Control::OnFontChange( bool defaultFontChange, bool defaultFontSizeChange )
+{
+}
+
+void Control::OnPinch(const PinchGesture& pinch)
+{
+ if( !( mImpl->mStartingPinchScale ) )
+ {
+ // lazy allocate
+ mImpl->mStartingPinchScale = new Vector3;
+ }
+
+ if( pinch.state == Gesture::Started )
+ {
+ *( mImpl->mStartingPinchScale ) = Self().GetCurrentScale();
+ }
+
+ Self().SetScale( *( mImpl->mStartingPinchScale ) * pinch.scale );
+}
+
+void Control::OnPan( const PanGesture& pan )
+{
+}
+
+void Control::OnTap(const TapGesture& tap)
+{
+}
+
+void Control::OnLongPress( const LongPressGesture& longPress )
+{
+}
+
+void Control::OnControlStageConnection()
+{
+}
+
+void Control::OnControlStageDisconnection()
+{
+}
+
+void Control::OnControlChildAdd( Actor& child )
+{
+}
+
+void Control::OnControlChildRemove( Actor& child )
+{
+}
+
+void Control::OnControlSizeSet( const Vector3& size )
+{
+}
+
void Control::OnRelaidOut( Vector2 size, ActorSizeContainer& container )
{
unsigned int numChildren = Self().GetChildCount();
}
}
-void Control::NegotiateSize( Vector2 allocatedSize, ActorSizeContainer& container )
+void Control::OnKeyInputFocusGained()
{
- Vector2 size;
+ // Do Nothing
+}
- if ( mImpl->mWidthPolicy == Toolkit::Control::Fixed )
- {
- if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
- {
- // If a control says it has a fixed size, then use the size set by the application / control.
- Vector2 setSize( mImpl->mNaturalSize );
- if ( setSize != Vector2::ZERO )
- {
- size = setSize;
+void Control::OnKeyInputFocusLost()
+{
+ // Do Nothing
+}
- // Policy is set to Fixed, so if the application / control has not set one of the dimensions,
- // then we should use the natural size of the control rather than the full allocation.
- if ( EqualsZero( size.width ) )
- {
- size.width = GetWidthForHeight( size.height );
- }
- else if ( EqualsZero( size.height ) )
- {
- size.height = GetHeightForWidth( size.width );
- }
- }
- else
- {
- // If that is not set then set the size to the control's natural size
- size = Vector2( GetNaturalSize() );
- }
- }
- else
- {
- // Width is fixed so if the application / control has set it, then use that.
- if ( !EqualsZero( mImpl->mNaturalSize.width ) )
- {
- size.width = mImpl->mNaturalSize.width;
- }
- else
- {
- // Otherwise, set the width to what has been allocated.
- size.width = allocatedSize.width;
- }
+void Control::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
+{
+ // @todo consider animating negotiated child sizes to target size
+}
- // Height is flexible so ask control what the height should be for our width.
- size.height = GetHeightForWidth( size.width );
+bool Control::OnTouchEvent(const TouchEvent& event)
+{
+ return false; // Do not consume
+}
- // Ensure height is within our policy rules
- size.height = Calculate( mImpl->mHeightPolicy, GetMinimumSize().height, GetMaximumSize().height, size.height );
- }
- }
- else
- {
- if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
- {
- // Height is fixed so if the application / control has set it, then use that.
- if ( !EqualsZero( mImpl->mNaturalSize.height ) )
- {
- size.height = mImpl->mNaturalSize.height;
- }
- else
- {
- // Otherwise, set the height to what has been allocated.
- size.height = allocatedSize.height;
- }
+bool Control::OnHoverEvent(const HoverEvent& event)
+{
+ return false; // Do not consume
+}
- // Width is flexible so ask control what the width should be for our height.
- size.width = GetWidthForHeight( size.height );
+bool Control::OnKeyEvent(const KeyEvent& event)
+{
+ return false; // Do not consume
+}
- // Ensure width is within our policy rules
- size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, size.width );
- }
- else
- {
- // Width and height are BOTH flexible.
- // Calculate the width and height using the policy rules.
- size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, allocatedSize.width );
- size.height = Calculate( mImpl->mHeightPolicy, mImpl->GetMinimumSize().height, mImpl->GetMaximumSize().height, allocatedSize.height );
- }
- }
+bool Control::OnMouseWheelEvent(const MouseWheelEvent& event)
+{
+ return false; // Do not consume
+}
- // If the width has not been set, then set to the allocated width.
- // Also if the width set is greater than the allocated, then set to allocated (no exceed support).
- if ( EqualsZero( size.width ) || ( size.width > allocatedSize.width ) )
- {
- size.width = allocatedSize.width;
- }
+Actor Control::GetChildByAlias(const std::string& actorAlias)
+{
+ return Actor();
+}
- // If the height has not been set, then set to the allocated height.
- // Also if the height set is greater than the allocated, then set to allocated (no exceed support).
- if ( EqualsZero( size.height ) || ( size.height > allocatedSize.height ) )
+void Control::OnStageConnection()
+{
+ RelayoutRequest();
+
+ // Notify derived classes.
+ OnControlStageConnection();
+}
+
+void Control::OnStageDisconnection()
+{
+ // Notify derived classes
+ OnControlStageDisconnection();
+}
+
+void Control::OnChildAdd(Actor& child)
+{
+ // If this is the background actor, then we do not want to relayout or inform deriving classes
+ if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
{
- size.height = allocatedSize.height;
+ return;
}
- DALI_LOG_INFO( gLogFilter, Debug::Verbose,
- "%p: Natural: [%.2f, %.2f] Allocated: [%.2f, %.2f] Set: [%.2f, %.2f]\n",
- Self().GetObjectPtr(),
- GetNaturalSize().x, GetNaturalSize().y,
- allocatedSize.x, allocatedSize.y,
- size.x, size.y );
+ // Request for relayout as we may need to position the new child and old ones
+ RelayoutRequest();
- Relayout( size, container );
+ // Notify derived classes.
+ OnControlChildAdd( child );
}
-bool Control::EmitKeyEventSignal( const KeyEvent& event )
+void Control::OnChildRemove(Actor& child)
{
- // Guard against destruction during signal emission
- Dali::Toolkit::Control handle( GetOwner() );
+ // If this is the background actor, then we do not want to relayout or inform deriving classes
+ if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
+ {
+ return;
+ }
- bool consumed = false;
+ // Request for relayout as we may need to re-position the old child
+ RelayoutRequest();
- // signals are allocated dynamically when someone connects
- if ( !mImpl->mKeyEventSignalV2.Empty() )
+ // Notify derived classes.
+ OnControlChildRemove( child );
+}
+
+void Control::OnSizeSet(const Vector3& targetSize)
+{
+ if( ( !mImpl->mInsideRelayout ) && ( targetSize != mImpl->mNaturalSize ) )
{
- consumed = mImpl->mKeyEventSignalV2.Emit( handle, event );
+ // Only updates size if set through Actor's API
+ mImpl->mNaturalSize = targetSize;
}
- if (!consumed)
+ if( targetSize != mImpl->mCurrentSize )
{
- // Notification for derived classes
- consumed = OnKeyEvent(event);
- }
+ // Update control size.
+ mImpl->mCurrentSize = targetSize;
- return consumed;
+ // Notify derived classes.
+ OnControlSizeSet( targetSize );
+ }
}
void Control::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
mImpl->SignalDisconnected( slotObserver, callback );
}
-Control::Control( ControlBehaviour behaviourFlags )
-: CustomActorImpl( behaviourFlags & REQUIRES_TOUCH_EVENTS ),
- mImpl(new Impl(*this))
+void Control::DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change )
{
- mImpl->mFlags = behaviourFlags;
+ if( change.themeChange )
+ {
+ OnThemeChange( styleManager );
+ }
+ else if( change.defaultFontChange || change.defaultFontSizeChange )
+ {
+ OnFontChange( change.defaultFontChange, change.defaultFontSizeChange );
+ }
+}
+
+void Control::Relayout(Vector2 size, ActorSizeContainer& container)
+{
+ // Avoids relayout again when OnSizeSet callback arrives.
+ mImpl->mInsideRelayout = true;
+ Self().SetSize( size );
+ // @todo this really needs to be at the end of method but not sure why the scope used to be only the SetSize, needs to be cleaned up in size negotiation rework
+ mImpl->mInsideRelayout = false;
+
+ // Only relayout controls which requested to be relaid out.
+ OnRelaidOut( size, container );
}
} // namespace Internal
CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000 ///< Reserving 1000 property indices
};
- // Creation
+ // Creation & Destruction
/**
* @brief Create a new ControlImpl instance that does not require touch by default.
*
* If touch is required then the user can connect to this class' touch signal.
- * @return A handle to the ConntrolImpl instance.
+ * @return A handle to the ControlImpl instance.
*/
static Toolkit::Control New();
- // Destruction
-
/**
* @brief Virtual destructor.
*/
virtual ~Control();
- // Actions
+ // Size negotiation
/**
- * @brief This method should be overridden by deriving classes when they wish to be notified when they
- * are activated.
+ * @copydoc Toolkit::Control::SetSizePolicy()
*/
- virtual void OnActivated() { }
+ void SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy );
/**
- * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
- * pan gesture.
- *
- * @param[in] gesture The pan gesture.
- * @return true if the pan gesture has been consumed by this control
+ * @copydoc Toolkit::Control::GetSizePolicy()
*/
- virtual bool OnAccessibilityPan(PanGesture gesture);
+ void GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const;
/**
- * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
- * touch event.
- *
- * @param[in] touchEvent The touch event.
- * @return true if the touch event has been consumed by this control
+ * @copydoc Toolkit::Control::SetMinimumSize()
*/
- virtual bool OnAccessibilityTouch(const TouchEvent& touchEvent);
+ void SetMinimumSize( const Vector3& size );
/**
- * @brief This method should be overridden by deriving classes when they wish to respond
- * the accessibility up and down action (i.e. value change of slider control).
- *
- * @param[in] isIncrease Whether the value should be increased or decreased
- * @return true if the value changed action has been consumed by this control
+ * @copydoc Toolkit::Control::GetMinimumSize()
*/
- virtual bool OnAccessibilityValueChange(bool isIncrease);
+ const Vector3& GetMinimumSize() const;
/**
- * @brief Sets whether this control supports two dimensional
- * keyboard navigation (i.e. whether it knows how to handle the
- * keyboardn focus movement between its child actors).
- *
- * The control doesn't support it by default.
- * @param[in] isSupported Whether this control supports two dimensional keyboard navigation.
+ * @copydoc Toolkit::Control::SetMaximumSize()
*/
- void SetKeyboardNavigationSupport(bool isSupported);
+ void SetMaximumSize( const Vector3& size );
/**
- * @brief Gets whether this control supports two dimensional keyboard navigation.
- *
- * @return true if this control supports two dimensional keyboard navigation.
+ * @copydoc Toolkit::Control::GetMaximumSize()
*/
- bool IsKeyboardNavigationSupported();
+ const Vector3& GetMaximumSize() const;
/**
- * @brief Sets whether this control is a focus group for keyboard navigation.
- *
- * (i.e. the scope of keyboard focus movement
- * can be limitied to its child actors). The control is not a focus group by default.
- * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation.
+ * @copydoc Toolkit::Control::GetNaturalSize()
*/
- void SetAsKeyboardFocusGroup(bool isFocusGroup);
+ virtual Vector3 GetNaturalSize();
/**
- * @brief Gets whether this control is a focus group for keyboard navigation.
+ * @brief This method is called during size negotiation when a height is required for a given width.
*
- * @return true if this control is set as a focus group for keyboard navigation.
+ * Derived classes should override this if they wish to customize the height returned.
*/
- bool IsKeyboardFocusGroup();
+ virtual float GetHeightForWidth( float width );
/**
- * @brief Gets the next keyboard focusable actor in this control towards the given direction.
+ * @brief This method is called during size negotiation when a width is required for a given height.
*
- * A control needs to override this function in order to support two dimensional keyboard navigation.
- * @param[in] currentFocusedActor The current focused actor.
- * @param[in] direction The direction to move the focus towards.
- * @param[in] loopEnabled Whether the focus movement should be looped within the control.
- * @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused.
+ * Derived classes should override this if they wish to customize the width returned.
*/
- virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ virtual float GetWidthForHeight( float height );
/**
- * @brief Informs this control that its chosen focusable actor will be focused.
- *
- * This allows the application to preform any actions if wishes
- * before the focus is actually moved to the chosen actor.
+ * @brief Retrieves the current Control's size.
*
- * @param[in] commitedFocusableActor The commited focusable actor.
+ * @return The control's size.
*/
- virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor) { }
+ const Vector3& GetControlSize() const;
/**
- * @brief Performs actions as requested using the action name.
+ * @brief Retrieves the Control's size set by the Application / Control.
*
- * @param[in] object The object on which to perform the action.
- * @param[in] actionName The action to perform.
- * @param[in] attributes The attributes with which to perfrom this action.
- * @return true if action has been accepted by this control
+ * @return The control's size.
*/
- static bool DoAction(BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes);
+ const Vector3& GetSizeSet() const;
+
+ // Key Input
/**
- * Connects a callback function with the object's signals.
- * @param[in] object The object providing the signal.
- * @param[in] tracker Used to disconnect the signal.
- * @param[in] signalName The signal to connect to.
- * @param[in] functor A newly allocated FunctorDelegate.
- * @return True if the signal was connected.
- * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
+ * @copydoc Toolkit::Control::SetKeyInputFocus()
*/
- static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
+ void SetKeyInputFocus();
+
+ /**
+ * @copydoc Toolkit::Control::HasKeyInputFocus()
+ */
+ bool HasKeyInputFocus();
+
+ /**
+ * @copydoc Toolkit::Control::ClearKeyInputFocus()
+ */
+ void ClearKeyInputFocus();
+
+ // Gesture Detection
/**
* @brief If deriving classes wish to fine tune pinch gesture
*/
Actor GetBackgroundActor() const;
-public:
+ // Keyboard Navigation
+
+ /**
+ * @brief Sets whether this control supports two dimensional
+ * keyboard navigation (i.e. whether it knows how to handle the
+ * keyboardn focus movement between its child actors).
+ *
+ * The control doesn't support it by default.
+ * @param[in] isSupported Whether this control supports two dimensional keyboard navigation.
+ */
+ void SetKeyboardNavigationSupport(bool isSupported);
+
+ /**
+ * @brief Gets whether this control supports two dimensional keyboard navigation.
+ *
+ * @return true if this control supports two dimensional keyboard navigation.
+ */
+ bool IsKeyboardNavigationSupported();
+
+ // Called by Focus Managers
+
+ /**
+ * @brief Called by the focus manager and keyboard focus manager to Activate the Control
+ */
+ DALI_INTERNAL void Activate();
+
+ /**
+ * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
+ * pan gesture.
+ *
+ * @param[in] gesture The pan gesture.
+ * @return true if the pan gesture has been consumed by this control
+ */
+ virtual bool OnAccessibilityPan(PanGesture gesture);
+
+ /**
+ * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
+ * touch event.
+ *
+ * @param[in] touchEvent The touch event.
+ * @return true if the touch event has been consumed by this control
+ */
+ virtual bool OnAccessibilityTouch(const TouchEvent& touchEvent);
+
+ /**
+ * @brief This method should be overridden by deriving classes when they wish to respond
+ * the accessibility up and down action (i.e. value change of slider control).
+ *
+ * @param[in] isIncrease Whether the value should be increased or decreased
+ * @return true if the value changed action has been consumed by this control
+ */
+ virtual bool OnAccessibilityValueChange(bool isIncrease);
+
+ // Called by the RelayoutController
+
+ /**
+ * @brief Called by the RelayoutController to negotiate the size of a control.
+ *
+ * The size allocated by the the algorithm is passed in which the
+ * control must adhere to. A container is passed in as well which
+ * the control should populate with actors it has not / or does not
+ * need to handle in its size negotiation.
+ *
+ * @param[in] size The allocated size.
+ * @param[in,out] container The container that holds actors that are fed back into the
+ * RelayoutController algorithm.
+ */
+ DALI_INTERNAL void NegotiateSize( Vector2 size, ActorSizeContainer& container );
+
+ // Keyboard Focus
+
+ /**
+ * @brief Sets whether this control is a focus group for keyboard navigation.
+ *
+ * (i.e. the scope of keyboard focus movement
+ * can be limitied to its child actors). The control is not a focus group by default.
+ * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation.
+ */
+ void SetAsKeyboardFocusGroup(bool isFocusGroup);
+
+ /**
+ * @brief Gets whether this control is a focus group for keyboard navigation.
+ *
+ * @return true if this control is set as a focus group for keyboard navigation.
+ */
+ bool IsKeyboardFocusGroup();
+
+ /**
+ * @brief Gets the next keyboard focusable actor in this control towards the given direction.
+ *
+ * A control needs to override this function in order to support two dimensional keyboard navigation.
+ * @param[in] currentFocusedActor The current focused actor.
+ * @param[in] direction The direction to move the focus towards.
+ * @param[in] loopEnabled Whether the focus movement should be looped within the control.
+ * @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused.
+ */
+ virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+
+ /**
+ * @brief Informs this control that its chosen focusable actor will be focused.
+ *
+ * This allows the application to preform any actions if wishes
+ * before the focus is actually moved to the chosen actor.
+ *
+ * @param[in] commitedFocusableActor The commited focusable actor.
+ */
+ virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor);
+
+ // Actions & Signals
+
+ /**
+ * @brief Performs actions as requested using the action name.
+ *
+ * @param[in] object The object on which to perform the action.
+ * @param[in] actionName The action to perform.
+ * @param[in] attributes The attributes with which to perfrom this action.
+ * @return true if action has been accepted by this control
+ */
+ static bool DoAction(BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes);
+
+ /**
+ * Connects a callback function with the object's signals.
+ * @param[in] object The object providing the signal.
+ * @param[in] tracker Used to disconnect the signal.
+ * @param[in] signalName The signal to connect to.
+ * @param[in] functor A newly allocated FunctorDelegate.
+ * @return True if the signal was connected.
+ * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
+ */
+ static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
/**
* @copydoc Dali::Toolkit::Control::KeyEventSignal()
*/
Toolkit::Control::KeyEventSignalV2& KeyEventSignal();
+ /**
+ * @brief Called by the KeyInputFocusManager to emit key event signals.
+ *
+ * @param[in] event The key event.
+ * @return True if the event was consumed.
+ */
+ DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
+
protected:
// Construction
+ // Flags for the constructor
+ enum ControlBehaviour
+ {
+ CONTROL_BEHAVIOUR_NONE = 0,
+ REQUIRES_TOUCH_EVENTS = 1<<1, ///< True if the OnTouchEvent() callback is required.
+ REQUIRES_STYLE_CHANGE_SIGNALS = 1<<2, ///< True if needs to monitor style change signals such as theme/font change
+ NO_SIZE_NEGOTIATION = 1<<3, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm
+ REQUIRES_HOVER_EVENTS = 1<<4, ///< True if the OnHoverEvent() callback is required.
+ REQUIRES_MOUSE_WHEEL_EVENTS = 1<<5 ///< True if the OnMouseWheelEvent() callback is required.
+ };
+
+ /**
+ * @brief Create a Control.
+ *
+ * @param[in] behaviourFlags Behavioural flags from ControlBehaviour enum
+ */
+ Control(ControlBehaviour behaviourFlags);
+
/**
* @brief Second phase initialization.
*/
void EnableGestureDetection(Gesture::Type type);
/**
- * @brief Allows deriving classes to disable any of the gesture detectors.
+ * @brief Allows deriving classes to disable any of the gesture detectors.
+ *
+ * Like EnableGestureDetection, this can also be called using bitwise or.
+ * @param[in] type The gesture type(s) to disable.
+ * @see EnableGetureDetection
+ */
+ void DisableGestureDetection(Gesture::Type type);
+
+ // Size Negotiation
+
+ /**
+ * @brief Sends a request to be relaid-out.
+ *
+ * This method is called from OnStageConnection(), OnChildAdd(),
+ * OnChildRemove(), SetSizePolicy(), SetMinimumSize() and
+ * SetMaximumSize().
+ *
+ * This method could also be called from derived classes every time
+ * a control's poperty change and it needs to be relaid-out. After
+ * the Dali::Stage::SignalMessageQueueFlushed() is emitted a
+ * relayout process starts and all controls which called this method
+ * will be relaid-out.
+ *
+ * @note RelayoutRequest() only sends a request per Control before
+ * the Dali::Stage::SignalMessageQueueFlushed() signal is
+ * emitted. That means a control will be relaid-out only once, even
+ * if more than one request is sent between two consecutive signals.
+ */
+ void RelayoutRequest();
+
+ /**
+ * @brief Helper method for controls to Relayout their children if
+ * they do not know whether that child is a control or not.
*
- * Like EnableGestureDetection, this can also be called using bitwise or.
- * @param[in] type The gesture type(s) to disable.
- * @see EnableGetureDetection
+ * @param[in] actor The actor to relayout.
+ * @param[in] size The size to allocate to the actor.
+ * @param[in,out] container The container that holds actors that have not been allocated a size yet.
*/
- void DisableGestureDetection(Gesture::Type type);
+ static void Relayout( Actor actor, Vector2 size, ActorSizeContainer& container );
-private: // For derived classes to override
+private:
+
+ // For derived classes to override
/**
* @brief This method is called after the Control has been initialized.
*
- * Derived classes should do any second phase initialization by
- * overriding this method.
+ * Derived classes should do any second phase initialization by overriding this method.
+ */
+ virtual void OnInitialize();
+
+ /**
+ * @brief This method is called when the control is activates.
+ *
+ * Derived classes should override this if they wish to be notified when they are activated.
*/
- virtual void OnInitialize() { }
+ virtual void OnActivated();
/**
* @brief This method should be overridden by deriving classes when
* @param[in] defaultFontChange Information denoting whether the default font has changed.
* @param[in] defaultFontSizeChange Information denoting whether the default font size has changed.
*/
- virtual void OnFontChange( bool defaultFontChange, bool defaultFontSizeChange ){ }
+ virtual void OnFontChange( bool defaultFontChange, bool defaultFontSizeChange );
/**
* @brief Called whenever a pinch gesture is detected on this control.
*
* Could be overridden by derived classes.
*/
- virtual void OnControlStageConnection() { }
+ virtual void OnControlStageConnection();
/**
* @brief Called whenever the control is removed from the stage.
*
* Could be overridden by derived classes.
*/
- virtual void OnControlStageDisconnection() { }
+ virtual void OnControlStageDisconnection();
/**
* @brief Called whenever an Actor is added to the control.
*
* @param[in] child The added actor.
*/
- virtual void OnControlChildAdd( Actor& child ) { }
+ virtual void OnControlChildAdd( Actor& child );
/**
* @brief Called whenever an Actor is removed from the control.
*
* @param[in] child The removed actor.
*/
- virtual void OnControlChildRemove( Actor& child ) { }
+ virtual void OnControlChildRemove( Actor& child );
/**
* @brief Called whenever the Control's size is set.
*
* @param[in] size The new size.
*/
- virtual void OnControlSizeSet( const Vector3& size ) { }
+ virtual void OnControlSizeSet( const Vector3& size );
/**
* @brief Called after the Dali::Stage::SignalMessageQueueFlushed()
*/
virtual void OnRelaidOut( Vector2 size, ActorSizeContainer& container );
-private: // From CustomActorImpl, derived classes can override these.
+ /**
+ * @brief Called when the control gains key input focus.
+ *
+ * Should be overridden by derived classes if they need to customize what happens when focus is gained.
+ */
+ virtual void OnKeyInputFocusGained();
+
+ /**
+ * @brief Called when the control loses key input focus.
+ *
+ * Should be overridden by derived classes if they need to customize what happens when focus is lost.
+ */
+ virtual void OnKeyInputFocusLost();
+
+ // From CustomActorImpl, derived classes can override these.
+
+ /**
+ * @copydoc Dali::CustomActorImpl::OnSizeAnimation(Animation&, const Vector3&)
+ */
+ virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize);
+
+ /**
+ * @copydoc Dali::CustomActorImpl::OnTouchEvent(const TouchEvent&)
+ */
+ virtual bool OnTouchEvent(const TouchEvent& event);
+
+ /**
+ * @copydoc Dali::CustomActorImpl::OnHoverEvent(const HoverEvent&)
+ */
+ virtual bool OnHoverEvent(const HoverEvent& event);
+
+ /**
+ * @copydoc Dali::CustomActorImpl::OnKeyEvent(const KeyEvent&)
+ */
+ virtual bool OnKeyEvent(const KeyEvent& event);
+
+ /**
+ * @copydoc Dali::CustomActorImpl::OnMouseWheelEvent(const MouseWheelEvent&)
+ */
+ virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
+
+ /**
+ * @copydoc Dali::CustomActorImpl::GetChildByAlias(const std::string& actorAlias)
+ */
+ virtual Actor GetChildByAlias(const std::string& actorAlias);
+
+ // From CustomActorImpl, derived classes should NOT override these.
/**
* @brief Sends a request to relayout this control.
*/
virtual void OnSizeSet(const Vector3& targetSize);
- /**
- * @copydoc Dali::CustomActorImpl::OnSizeAnimation(Animation&, const Vector3&)
- */
- virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize);
-
- /**
- * @copydoc Dali::CustomActorImpl::OnTouchEvent(const TouchEvent&)
- */
- virtual bool OnTouchEvent(const TouchEvent& event);
-
- /**
- * @copydoc Dali::CustomActorImpl::OnHoverEvent(const HoverEvent&)
- */
- virtual bool OnHoverEvent(const HoverEvent& event);
-
- /**
- * @copydoc Dali::CustomActorImpl::OnKeyEvent(const KeyEvent&)
- */
- virtual bool OnKeyEvent(const KeyEvent& event);
-
- /**
- * @copydoc Dali::CustomActorImpl::OnMouseWheelEvent(const MouseWheelEvent&)
- */
- virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
-
- /**
- * @copydoc Dali::CustomActorImpl::OnKeyInputFocusGained()
- */
- virtual void OnKeyInputFocusGained();
-
- /**
- * @copydoc Dali::CustomActorImpl::OnKeyInputFocusLost()
- */
- virtual void OnKeyInputFocusLost();
-
- /**
- * @copydoc Dali::CustomActorImpl::GetChildByAlias(const std::string& actorAlias)
- */
- virtual Actor GetChildByAlias(const std::string& actorAlias);
-
-private:
-
- /**
- * @brief This method is the callback for the StyleChangeSignal from StyleManager
- *
- * @param[in] styleManager The StyleManager Object
- * @param[in] change Information denoting what has changed.
- */
- DALI_INTERNAL void DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change );
-
-protected: // Construction
-
- // Flags for the constructor
- enum ControlBehaviour
- {
- CONTROL_BEHAVIOUR_NONE = 0,
- REQUIRES_TOUCH_EVENTS = 1<<1, ///< True if the OnTouchEvent() callback is required.
- REQUIRES_STYLE_CHANGE_SIGNALS = 1<<2, ///< True if needs to monitor style change signals such as theme/font change
- NO_SIZE_NEGOTIATION = 1<<3, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm
- REQUIRES_HOVER_EVENTS = 1<<4, ///< True if the OnHoverEvent() callback is required.
- REQUIRES_MOUSE_WHEEL_EVENTS = 1<<5 ///< True if the OnMouseWheelEvent() callback is required.
- };
-
- /**
- * @brief Create a Control.
- *
- * @param[in] behaviourFlags Behavioural flags from ControlBehaviour enum
- */
- Control(ControlBehaviour behaviourFlags);
-
-public:
-
- // Size negotiation
-
- /**
- * @copydoc Toolkit::Control::SetSizePolicy()
- */
- void SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy );
-
- /**
- * @copydoc Toolkit::Control::GetSizePolicy()
- */
- void GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const;
-
- /**
- * @copydoc Toolkit::Control::SetMinimumSize()
- */
- void SetMinimumSize( const Vector3& size );
-
- /**
- * @copydoc Toolkit::Control::GetMinimumSize()
- */
- const Vector3& GetMinimumSize() const;
-
- /**
- * @copydoc Toolkit::Control::SetMaximumSize()
- */
- void SetMaximumSize( const Vector3& size );
-
- /**
- * @copydoc Toolkit::Control::GetMaximumSize()
- */
- const Vector3& GetMaximumSize() const;
-
- /**
- * @copydoc Toolkit::Control::GetNaturalSize()
- */
- virtual Vector3 GetNaturalSize();
-
- /**
- * @copydoc Toolkit::Control::GetHeightForWidth()
- */
- virtual float GetHeightForWidth( float width );
-
- /**
- * @copydoc Toolkit::Control::GetWidthForHeight()
- */
- virtual float GetWidthForHeight( float height );
-
- /**
- * @brief Retrieves the current Control's size.
- *
- * @return The control's size.
- */
- const Vector3& GetControlSize() const;
-
- /**
- * @brief Retrieves the Control's size set by the Application / Control.
- *
- * @return The control's size.
- */
- const Vector3& GetSizeSet() const;
-
- //KeyInput
-
- /**
- * @copydoc Toolkit::Control::SetKeyInputFocus()
- */
- void SetKeyInputFocus();
-
- /**
- * @copydoc Toolkit::Control::HasKeyInputFocus()
- */
- bool HasKeyInputFocus();
-
- /**
- * @copydoc Toolkit::Control::ClearKeyInputFocus()
- */
- void ClearKeyInputFocus();
+ // From ConnectionTrackerInterface
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
-protected:
-
- /**
- * @brief Sends a request to be relaid-out.
- *
- * This method is called from OnStageConnection(), OnChildAdd(),
- * OnChildRemove(), SetSizePolicy(), SetMinimumSize() and
- * SetMaximumSize().
- *
- * This method could also be called from derived classes every time
- * a control's poperty change and it needs to be relaid-out. After
- * the Dali::Stage::SignalMessageQueueFlushed() is emitted a
- * relayout process starts and all controls which called this method
- * will be relaid-out.
- *
- * @note RelayoutRequest() only sends a request per Control before
- * the Dali::Stage::SignalMessageQueueFlushed() signal is
- * emitted. That means a control will be relaid-out only once, even
- * if more than one request is sent between two consecutive signals.
- */
- void RelayoutRequest();
-
- /**
- * @brief Helper method for controls to Relayout their children if
- * they do not know whether that child is a control or not.
- *
- * @param[in] actor The actor to relayout.
- * @param[in] size The size to allocate to the actor.
- * @param[in,out] container The container that holds actors that have not been allocated a size yet.
- */
- static void Relayout( Actor actor, Vector2 size, ActorSizeContainer& container );
-
-private: // Used by the RelayoutController
+ // Style
/**
- * @brief Called by the RelayoutController to negotiate the size of a control.
- *
- * The size allocated by the the algorithm is passed in which the
- * control must adhere to. A container is passed in as well which
- * the control should populate with actors it has not / or does not
- * need to handle in its size negotiation.
+ * @brief This method is the callback for the StyleChangeSignal from StyleManager
*
- * @param[in] size The allocated size.
- * @param[in,out] container The container that holds actors that are fed back into the
- * RelayoutController algorithm.
+ * @param[in] styleManager The StyleManager Object
+ * @param[in] change Information denoting what has changed.
*/
- DALI_INTERNAL void NegotiateSize( Vector2 size, ActorSizeContainer& container );
+ DALI_INTERNAL void DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change );
-private:
+ // Size Negotiation
/**
* @brief Called by NegotiateSize when the size to allocate to the control has been calculated.
*/
DALI_INTERNAL void Relayout( Vector2 size, ActorSizeContainer& container );
- /**
- * @brief Used by the KeyInputFocusManager to emit key event signals.
- *
- * @param[in] event The key event.
- * @return True if the event was consumed.
- */
- DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
-
private:
// Undefined
class Impl;
Impl* mImpl;
- friend class Internal::RelayoutControllerImpl; ///< Relayout controller needs to call Relayout() which is private.
- friend class Internal::KeyInputFocusManager; ///< KeyInputFocusManager needs to call which is private.
+ friend class Internal::KeyInputFocusManager; ///< KeyInputFocusManager needs to call several methods which are private. // TODO: Remove
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / commitdiff