/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <limits>
#include <stack>
#include <dali/public-api/actors/image-actor.h>
-#include <dali/public-api/actors/mesh-actor.h>
+#include <dali/devel-api/actors/mesh-actor.h>
#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/animation/constraints.h>
-#include <dali/public-api/geometry/mesh.h>
+#include <dali/devel-api/geometry/mesh.h>
#include <dali/public-api/object/type-registry.h>
-#include <dali/public-api/object/type-registry-helper.h>
-#include <dali/public-api/scripting/scripting.h>
+#include <dali/devel-api/object/type-registry-helper.h>
+#include <dali/devel-api/scripting/scripting.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
#include <dali/integration-api/debug.h>
#include <dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
-#include <dali-toolkit/public-api/styling/style-manager.h>
+#include <dali-toolkit/devel-api/styling/style-manager.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
namespace Dali
namespace
{
-#if defined(DEBUG_ENABLED)
-Integration::Log::Filter* gLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_CONTROL");
-#endif
-
-const float MAX_FLOAT_VALUE( std::numeric_limits<float>::max() );
-const Vector3 MAX_SIZE( MAX_FLOAT_VALUE, MAX_FLOAT_VALUE, MAX_FLOAT_VALUE );
const float BACKGROUND_ACTOR_Z_POSITION( -0.1f );
BaseHandle Create()
// Setup signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Control, CustomActor, Create );
-// Note: Properties are registered separately below,
+// Note: Properties are registered separately below.
-DALI_SIGNAL_REGISTRATION( Control, "key-event", SIGNAL_KEY_EVENT )
-DALI_SIGNAL_REGISTRATION( Control, "tapped", SIGNAL_TAPPED )
-DALI_SIGNAL_REGISTRATION( Control, "panned", SIGNAL_PANNED )
-DALI_SIGNAL_REGISTRATION( Control, "pinched", SIGNAL_PINCHED )
-DALI_SIGNAL_REGISTRATION( Control, "long-pressed", SIGNAL_LONG_PRESSED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "key-event", SIGNAL_KEY_EVENT )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "key-input-focus-gained", SIGNAL_KEY_INPUT_FOCUS_GAINED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "key-input-focus-lost", SIGNAL_KEY_INPUT_FOCUS_LOST )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "tapped", SIGNAL_TAPPED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "panned", SIGNAL_PANNED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "pinched", SIGNAL_PINCHED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Control, "long-pressed", SIGNAL_LONG_PRESSED )
-DALI_ACTION_REGISTRATION( Control, "control-activated", ACTION_CONTROL_ACTIVATED )
+DALI_ACTION_REGISTRATION( Toolkit, Control, "control-activated", ACTION_CONTROL_ACTIVATED )
DALI_TYPE_REGISTRATION_END()
* Sets all the required properties for the background actor.
*
* @param[in] actor The actor to set the properties on.
+ * @param[in] color The required color of the actor.
+ */
+void SetupBackgroundActor( Actor actor, const Vector4& color )
+{
+ actor.SetColor( color );
+ actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+ actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
+ actor.SetZ( BACKGROUND_ACTOR_Z_POSITION );
+ actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+}
+
+/**
+ * Sets all the required properties for the background actor.
+ *
+ * @param[in] actor The actor to set the properties on.
* @param[in] constrainingIndex The property index to constrain the parent's size on.
* @param[in] color The required color of the actor.
*/
-void SetupBackgroundActor( Actor actor, Property::Index constrainingIndex, const Vector4& color )
+void SetupBackgroundActorConstrained( Actor actor, Property::Index constrainingIndex, const Vector4& color )
{
actor.SetColor( color );
actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
actor.SetZ( BACKGROUND_ACTOR_Z_POSITION );
- actor.SetRelayoutEnabled( false );
Constraint constraint = Constraint::New<Vector3>( actor,
constrainingIndex,
{
public:
- /**
- * Size indices for mMinMaxSize array
- */
- enum
- {
- MIN_SIZE_INDEX = 0,
- MAX_SIZE_INDEX = 1
- };
-
-public:
// Construction & Destruction
Impl(Control& controlImpl)
: mControlImpl( controlImpl ),
mPanGestureDetector(),
mTapGestureDetector(),
mLongPressGestureDetector(),
- mCurrentSize(),
- mNaturalSize(),
- mFlags( Control::CONTROL_BEHAVIOUR_NONE ),
+ mFlags( Control::ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mIsKeyboardNavigationSupported( false ),
mIsKeyboardFocusGroup( false ),
mInitialized( false )
Background* mBackground; ///< Only create the background if we use it
Vector3* mStartingPinchScale; ///< The scale when a pinch gesture starts, TODO: consider removing this
Toolkit::Control::KeyEventSignalType mKeyEventSignal;
+ Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusGainedSignal;
+ Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusLostSignal;
// Gesture Detection
PinchGestureDetector mPinchGestureDetector;
PanGestureDetector mPanGestureDetector;
TapGestureDetector mTapGestureDetector;
LongPressGestureDetector mLongPressGestureDetector;
- // @todo change all these to Vector2 when we have a chance to sanitize the public API as well
- Vector3 mCurrentSize; ///< Stores the current control's size, this is the negotiated size
- Vector3 mNaturalSize; ///< Stores the size set through the Actor's API. This is size the actor wants to be. Useful when reset to the initial size is needed.
- ControlBehaviour mFlags :6; ///< Flags passed in from constructor. Need to increase this size when new enums are added
+ ControlBehaviour mFlags :CONTROL_BEHAVIOUR_FLAG_COUNT; ///< Flags passed in from constructor.
bool mIsKeyboardNavigationSupported :1; ///< Stores whether keyboard navigation is supported by the control.
bool mIsKeyboardFocusGroup :1; ///< Stores whether the control is a focus group.
bool mInitialized :1;
Toolkit::Control Control::New()
{
// Create the implementation, temporarily owned on stack
- IntrusivePtr<Control> controlImpl = new Control( CONTROL_BEHAVIOUR_NONE );
+ IntrusivePtr<Control> controlImpl = new Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) );
// Pass ownership to handle
Toolkit::Control handle( *controlImpl );
Vector3 Control::GetNaturalSize()
{
- // could be overridden in derived classes.
- return mImpl->mNaturalSize;
-}
-
-float Control::CalculateChildSize( const Dali::Actor& child, Dimension dimension )
-{
- // Could be overridden in derived classes.
- return CalculateChildSizeBase( child, dimension );
-}
-
-bool Control::RelayoutDependentOnChildren( Dimension dimension )
-{
- return RelayoutDependentOnChildrenBase( dimension );
+ if( mImpl->mBackground )
+ {
+ Actor actor = mImpl->mBackground->actor;
+ if( actor )
+ {
+ return actor.GetNaturalSize();
+ }
+ }
+ return Vector3();
}
float Control::GetHeightForWidth( float width )
{
- // could be overridden in derived classes.
- float height( 0.0f );
- if ( mImpl->mNaturalSize.width > 0.0f )
+ if( mImpl->mBackground )
{
- height = mImpl->mNaturalSize.height * width / mImpl->mNaturalSize.width;
+ Actor actor = mImpl->mBackground->actor;
+ if( actor )
+ {
+ return actor.GetHeightForWidth( width );
+ }
}
- return height;
+ return GetHeightForWidthBase( width );
}
float Control::GetWidthForHeight( float height )
{
- // could be overridden in derived classes.
- float width( 0.0f );
- if ( mImpl->mNaturalSize.height > 0.0f )
+ if( mImpl->mBackground )
{
- width = mImpl->mNaturalSize.width * height / mImpl->mNaturalSize.height;
+ Actor actor = mImpl->mBackground->actor;
+ if( actor )
+ {
+ return actor.GetWidthForHeight( height );
+ }
}
- return width;
-}
-
-const Vector3& Control::GetControlSize() const
-{
- return mImpl->mCurrentSize;
-}
-
-const Vector3& Control::GetSizeSet() const
-{
- return mImpl->mNaturalSize;
+ return GetWidthForHeightBase( height );
}
void Control::SetKeyInputFocus()
// Create Mesh Actor
MeshActor meshActor = MeshActor::New( CreateMesh() );
- SetupBackgroundActor( meshActor, Actor::Property::SCALE, color );
+ SetupBackgroundActorConstrained( meshActor, Actor::Property::SCALE, color );
// Set the background actor before adding so that we do not inform deriving classes
background.actor = meshActor;
}
ImageActor imageActor = ImageActor::New( image );
- SetupBackgroundActor( imageActor, Actor::Property::SIZE, background.color );
+ SetupBackgroundActor( imageActor, background.color );
// Set the background actor before adding so that we do not inform derived classes
background.actor = imageActor;
{
controlImpl.KeyEventSignal().Connect( tracker, functor );
}
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_INPUT_FOCUS_GAINED ) )
+ {
+ controlImpl.KeyInputFocusGainedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_INPUT_FOCUS_LOST ) )
+ {
+ controlImpl.KeyInputFocusLostSignal().Connect( tracker, functor );
+ }
else if( 0 == strcmp( signalName.c_str(), SIGNAL_TAPPED ) )
{
controlImpl.EnableGestureDetection( Gesture::Tap );
return mImpl->mKeyEventSignal;
}
+Toolkit::Control::KeyInputFocusSignalType& Control:: KeyInputFocusGainedSignal()
+{
+ return mImpl->mKeyInputFocusGainedSignal;
+}
+
+Toolkit::Control::KeyInputFocusSignalType& Control:: KeyInputFocusLostSignal()
+{
+ return mImpl->mKeyInputFocusLostSignal;
+}
+
bool Control::EmitKeyEventSignal( const KeyEvent& event )
{
// Guard against destruction during signal emission
}
Control::Control( ControlBehaviour behaviourFlags )
-: CustomActorImpl( behaviourFlags & REQUIRES_TOUCH_EVENTS ),
+: CustomActorImpl( static_cast< ActorFlags >( behaviourFlags ) ),
mImpl(new Impl(*this))
{
mImpl->mFlags = behaviourFlags;
// Calling deriving classes
OnInitialize();
- // Test if the no size negotiation flag is not set
- if( ( mImpl->mFlags & NO_SIZE_NEGOTIATION ) == 0 )
- {
- // Size negotiate disabled by default, so turn it on for this actor
- Self().SetRelayoutEnabled( true );
- }
-
if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS )
{
Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
}
- SetRequiresHoverEvents(mImpl->mFlags & REQUIRES_HOVER_EVENTS);
- SetRequiresMouseWheelEvents(mImpl->mFlags & REQUIRES_MOUSE_WHEEL_EVENTS);
+ if( mImpl->mFlags & REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )
+ {
+ SetKeyboardNavigationSupport( true );
+ }
mImpl->mInitialized = true;
}
{
}
-void Control::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange change )
+void Control::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
{
// By default the control is only interested in theme (not font) changes
- if( change.themeChange )
+ if( change == StyleChange::THEME_CHANGE )
{
GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
}
{
}
-void Control::OnCalculateRelayoutSize( Dimension dimension )
+void Control::OnCalculateRelayoutSize( Dimension::Type dimension )
{
}
-void Control::OnLayoutNegotiated( float size, Dimension dimension )
+void Control::OnLayoutNegotiated( float size, Dimension::Type dimension )
{
}
}
}
-void Control::OnSetResizePolicy( ResizePolicy policy, Dimension dimension )
+void Control::OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+{
+}
+
+float Control::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
{
+ return CalculateChildSizeBase( child, dimension );
+}
+
+bool Control::RelayoutDependentOnChildren( Dimension::Type dimension )
+{
+ return RelayoutDependentOnChildrenBase( dimension );
+}
+
+void Control::EmitKeyInputFocusSignal( bool focusGained )
+{
+ Dali::Toolkit::Control handle( GetOwner() );
+
+ if ( focusGained )
+ {
+ // signals are allocated dynamically when someone connects
+ if ( !mImpl->mKeyInputFocusGainedSignal.Empty() )
+ {
+ mImpl->mKeyInputFocusGainedSignal.Emit( handle );
+ }
+ }
+ else
+ {
+ // signals are allocated dynamically when someone connects
+ if ( !mImpl->mKeyInputFocusLostSignal.Empty() )
+ {
+ mImpl->mKeyInputFocusLostSignal.Emit( handle );
+ }
+ }
}
void Control::OnKeyInputFocusGained()
{
- // Do Nothing
+ EmitKeyInputFocusSignal( true );
}
void Control::OnKeyInputFocusLost()
{
- // Do Nothing
+ EmitKeyInputFocusSignal( false );
}
void Control::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
void Control::OnSizeSet(const Vector3& targetSize)
{
- if( targetSize != mImpl->mNaturalSize )
- {
- // Only updates size if set through Actor's API
- mImpl->mNaturalSize = targetSize;
- }
-
- if( targetSize != mImpl->mCurrentSize )
- {
- // Update control size.
- mImpl->mCurrentSize = targetSize;
+ // Background is resized through size negotiation
- // Notify derived classes.
- OnControlSizeSet( targetSize );
- }
+ // Notify derived classes.
+ OnControlSizeSet( targetSize );
}
void Control::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
projects / platform / core / uifw / dali-toolkit.git / blobdiff