// Check gesture actually happens
{
DummyControl dummy = DummyControl::New(true);
- dummy.SetRelayoutEnabled( true );
dummy.SetSize( Vector2(100.0f, 100.0f ) );
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
// Ensure full code coverage
{
DummyControl dummy = DummyControl::New();
- dummy.SetRelayoutEnabled( true );
dummy.SetSize( Vector2( 100.0f, 100.0f ) );
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
{
DummyControl dummy = DummyControl::New( true );
- dummy.SetRelayoutEnabled( true );
DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
Stage::GetCurrent().Add(dummy);
// Ensure full code coverage
{
DummyControl dummy = DummyControl::New();
- dummy.SetRelayoutEnabled( true );
Stage::GetCurrent().Add(dummy);
Vector2 size(100.0f, 200.0f);
{
DummyControl dummy = DummyControl::New( true );
- dummy.SetRelayoutEnabled( true );
DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
dummy.SetSize( Vector2( 100.0f, 100.0f ) );
// Ensure full code coverage
{
DummyControl dummy = DummyControl::New();
- dummy.SetRelayoutEnabled( true );
dummy.SetSize( Vector2( 100.0f, 100.0f ) );
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
{
DummyControl dummy = DummyControl::New( true );
- dummy.SetRelayoutEnabled( true );
DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
dummy.SetSize( Vector2( 100.0f, 100.0f ) );
// Ensure full code coverage
{
DummyControl dummy = DummyControl::New();
- dummy.SetRelayoutEnabled( true );
dummy.SetSize( Vector2( 100.0f, 100.0f ) );
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
factory.EnableOffscreenRendering( );
PageTurnView pageTurnView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
- pageTurnView.SetRelayoutEnabled( false );
pageTurnView.SetPositionInheritanceMode( USE_PARENT_POSITION );
Stage::GetCurrent().Add( pageTurnView );
factory.EnableOffscreenRendering( );
PageTurnView pageTurnView = PageTurnPortraitView::New( factory, PAGE_SIZE );
- pageTurnView.SetRelayoutEnabled( false );
pageTurnView.SetParentOrigin( ParentOrigin::TOP_LEFT );
pageTurnView.SetAnchorPoint( AnchorPoint::TOP_LEFT );
Stage::GetCurrent().Add( pageTurnView );
TestPageFactory factory(application);
factory.EnableOffscreenRendering( );
PageTurnView pageTurnView = PageTurnPortraitView::New( factory, PAGE_SIZE );
- pageTurnView.SetRelayoutEnabled( false );
pageTurnView.SetParentOrigin( ParentOrigin::TOP_LEFT );
pageTurnView.SetAnchorPoint( AnchorPoint::TOP_LEFT );
Stage::GetCurrent().Add( pageTurnView );
TestPageFactory factory(application);
Vector2 size = Stage::GetCurrent().GetSize();
PageTurnView portraitView = PageTurnPortraitView::New( factory, size );
- portraitView.SetRelayoutEnabled( false );
portraitView.SetPositionInheritanceMode( USE_PARENT_POSITION );
Stage::GetCurrent().Add( portraitView );
application.SendNotification();
application.Render();
- // Just check if check box button size changes when a bigger image is set.
-
+ pushButton.SetSize( Vector2( 20.0f, 20.0f ) );
pushButton.SetButtonImage( image01 );
application.SendNotification();
size = pushButton.GetCurrentSize();
- DALI_TEST_EQUALS( size.width, 10.f, TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, 10.f, TEST_LOCATION );
+ DALI_TEST_EQUALS( size.width, 20.f, TEST_LOCATION );
+ DALI_TEST_EQUALS( size.height, 20.f, TEST_LOCATION );
END_TEST;
}
tet_infoline( "UtcDaliSuperBlurViewGetBlurredImage" );
SuperBlurView blurView = SuperBlurView::New( BLUR_LEVELS );
- blurView.SetRelayoutEnabled( false );
blurView.SetSize( 100.f,100.f );
Image inputImage = CreateSolidColorImage( application, Color::GREEN, 100, 100 );
blurView.SetImage( inputImage );
tableView = TableView::New( 10, 10 ); // 10 by 10 grid.
DALI_TEST_CHECK( tableView );
- tableView.SetRelayoutEnabled( true );
-
Stage::GetCurrent().Add( tableView );
tableView.SetSize( Dali::Vector2( 100.0f, 100.0f ) );
actor2 = Actor::New();
actor3 = Actor::New();
- actor1.SetRelayoutEnabled( true );
actor1.SetSize( Dali::Vector2( 10, 10 ) );
- actor2.SetRelayoutEnabled( true );
actor2.SetSize( Dali::Vector2( 10, 10 ) );
- actor3.SetRelayoutEnabled( true );
actor3.SetSize( Dali::Vector2( 10, 10 ) );
tableView.AddChild( actor1, TableView::CellPosition( 0, 0 ) );
try
{
View view = View::New();
- view.SetRelayoutEnabled( true );
Stage::GetCurrent().Add( view );
view.SetSize( Vector2( 480, 800 ) );
}
Alignment::Alignment( Toolkit::Alignment::Type horizontal, Toolkit::Alignment::Type vertical )
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mHorizontal( horizontal ),
mVertical( vertical ),
mScaling( Toolkit::Alignment::ScaleNone ),
BloomView::BloomView()
- : Control( CONTROL_BEHAVIOUR_NONE )
+ : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) )
, mBlurNumSamples(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES)
, mBlurBellCurveWidth(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH)
, mPixelFormat(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT)
BloomView::BloomView( const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
const float downsampleWidthScale, const float downsampleHeightScale)
- : Control( CONTROL_BEHAVIOUR_NONE )
+ : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) )
, mBlurNumSamples(blurNumSamples)
, mBlurBellCurveWidth(blurBellCurveWidth)
, mPixelFormat(renderTargetPixelFormat)
Image shapeImage,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange )
-: Control( REQUIRES_TOUCH_EVENTS ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
mMovementArea( movementArea ),
mShapeImage( shapeImage ),
mTotalNumOfBubble( maximumNumberOfBubble ),
}
OnButtonImageSet();
+
+ RelayoutRequest();
}
Actor Button::GetButtonImage() const
}
OnSelectedImageSet();
+
+ RelayoutRequest();
}
Actor Button::GetSelectedImage() const
}
OnBackgroundImageSet();
+
+ RelayoutRequest();
}
Actor Button::GetBackgroundImage() const
}
OnSelectedBackgroundImageSet();
+
+ RelayoutRequest();
}
Actor Button::GetSelectedBackgroundImage() const
{
label.SetAnchorPoint( AnchorPoint::CENTER );
label.SetParentOrigin( ParentOrigin::CENTER );
- label.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
Toolkit::TextLabel textLabel = Toolkit::TextLabel::DownCast( label );
if( textLabel )
textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
textLabel.SetProperty( Toolkit::TextLabel::Property::MULTI_LINE, true );
}
+
+ ConfigureSizeNegotiation();
}
}
void PushButton::OnButtonImageSet()
{
- Actor& buttonImage = GetButtonImage();
-
- buttonImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- buttonImage.RelayoutRequestTree();
-
+ ConfigureSizeNegotiation();
RelayoutRequest();
}
void PushButton::OnSelectedImageSet()
{
- Actor& selectedImage = GetSelectedImage();
-
- selectedImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- selectedImage.RelayoutRequestTree();
-
+ ConfigureSizeNegotiation();
RelayoutRequest();
}
void PushButton::OnBackgroundImageSet()
{
- Actor& backgroundImage = GetBackgroundImage();
-
- backgroundImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- backgroundImage.RelayoutRequestTree();
-
+ ConfigureSizeNegotiation();
RelayoutRequest();
}
void PushButton::OnSelectedBackgroundImageSet()
{
- Actor& selectedBackgroundImage = GetSelectedBackgroundImage();
-
- selectedBackgroundImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ ConfigureSizeNegotiation();
+ RelayoutRequest();
}
void PushButton::OnDisabledImageSet()
{
- Actor& disabledImage = GetDisabledImage();
-
- disabledImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- disabledImage.RelayoutRequestTree();
-
+ ConfigureSizeNegotiation();
RelayoutRequest();
}
void PushButton::OnDisabledBackgroundImageSet()
{
- Actor& disabledBackgroundImage = GetDisabledBackgroundImage();
-
- disabledBackgroundImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- disabledBackgroundImage.RelayoutRequestTree();
-
+ ConfigureSizeNegotiation();
RelayoutRequest();
}
}
}
-Vector3 PushButton::GetNaturalSize()
-{
- Vector3 size;
-
- // Check Image and Background image and use the largest size as the control's Natural size.
- SizeOfActorIfLarger( GetButtonImage(), size );
- SizeOfActorIfLarger( GetBackgroundImage(), size );
-
- // If label, test against it's size
- Toolkit::TextLabel label = Toolkit::TextLabel::DownCast( GetLabel() );
- if( label )
- {
- Vector3 labelSize = label.GetNaturalSize();
-
- size.width = std::max( size.width, labelSize.width + TEXT_PADDING * 2.0f );
- size.height = std::max( size.height, labelSize.height + TEXT_PADDING * 2.0f );
- }
-
- return size;
-}
-
void PushButton::StartTransitionAnimation()
{
if( mTransitionAnimation )
StopTransitionAnimation();
}
+Vector3 PushButton::GetNaturalSize()
+{
+ Vector3 size;
+
+ // If label, test against it's size
+ Toolkit::TextLabel label = Toolkit::TextLabel::DownCast( GetLabel() );
+ if( label )
+ {
+ size.width = std::max( size.width, label.GetRelayoutSize( Dimension::WIDTH ) );
+ size.height = std::max( size.height, label.GetRelayoutSize( Dimension::HEIGHT ) );
+ }
+ else
+ {
+ // Check Image and Background image and use the largest size as the control's Natural size.
+ SizeOfActorIfLarger( GetButtonImage(), size );
+ SizeOfActorIfLarger( GetBackgroundImage(), size );
+ }
+
+ return size;
+}
+
+void PushButton::OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+{
+ ConfigureSizeNegotiation();
+}
+
+void PushButton::ConfigureSizeNegotiation()
+{
+ ActorContainer images;
+ images.reserve( 7 );
+
+ images.push_back( GetButtonImage() );
+ images.push_back( GetSelectedImage() );
+ images.push_back( GetSelectedBackgroundImage() );
+ images.push_back( GetBackgroundImage() );
+ images.push_back( GetDisabledImage() );
+ images.push_back( GetDisabledSelectedImage() );
+ images.push_back( GetDisabledBackgroundImage() );
+
+ Actor label = GetLabel();
+
+ for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ ConfigureSizeNegotiationDimension( static_cast< Dimension::Type >( 1 << i ), images, label );
+ }
+
+ if( label )
+ {
+ label.SetPadding( Padding( TEXT_PADDING, TEXT_PADDING, TEXT_PADDING, TEXT_PADDING) );
+ }
+}
+
+void PushButton::ConfigureSizeNegotiationDimension( Dimension::Type dimension, const ActorContainer& images, Actor& label )
+{
+ ResizePolicy::Type imageResizePolicy = ResizePolicy::FILL_TO_PARENT;
+ ResizePolicy::Type labelResizePolicy = ResizePolicy::FILL_TO_PARENT;
+
+ switch( Self().GetResizePolicy( dimension ) )
+ {
+ case ResizePolicy::FIT_TO_CHILDREN:
+ {
+ imageResizePolicy = labelResizePolicy = ResizePolicy::USE_NATURAL_SIZE;
+ break;
+ }
+ case ResizePolicy::USE_NATURAL_SIZE:
+ {
+ if( label )
+ {
+ labelResizePolicy = ResizePolicy::USE_NATURAL_SIZE;
+ }
+ else
+ {
+ imageResizePolicy = ResizePolicy::USE_NATURAL_SIZE;
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ if( label )
+ {
+ label.SetResizePolicy( labelResizePolicy, dimension );
+ }
+
+ for( ActorConstIter it = images.begin(), itEnd = images.end(); it != itEnd; ++it )
+ {
+ Actor actor = *it;
+ if( actor )
+ {
+ actor.SetResizePolicy( imageResizePolicy, dimension );
+ }
+ }
+}
+
} // namespace Internal
} // namespace Toolkit
virtual void OnControlSizeSet( const Vector3& targetSize );
/**
- * @copydoc Toolkit::Control::GetNaturalSize()
+ * @copydoc Toolkit::Control::GetNaturalSize
*/
- virtual Vector3 GetNaturalSize();
+ Vector3 GetNaturalSize();
+
+ /**
+ * @copydoc Toolkit::Control::OnSetResizePolicy
+ */
+ virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension );
private:
*/
void FadeOutImage( Actor& image, float opacity = 1.f, Vector3 scale = Vector3( 1.f, 1.f, 1.f ) );
+ /**
+ * @brief Custom configuration for size negotiation
+ */
+ void ConfigureSizeNegotiation();
+
+ /**
+ * @brief Configure size negotiation for a given dimension
+ *
+ * @param[in] dimension The dimension to configure
+ * @param[in] images The list of images to configure
+ * @param[in] label The text label to configure
+ */
+ void ConfigureSizeNegotiationDimension( Dimension::Type dimension, const ActorContainer& images, Actor& label );
+
// slots
/**
}
Cluster::Cluster(Toolkit::ClusterStyle& style)
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS | DISABLE_SIZE_NEGOTIATION ) ),
mClusterStyle(style),
mExpandedCount(0)
{
}
EffectsView::EffectsView()
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mEffectType( Toolkit::EffectsView::INVALID_TYPE ),
mPixelFormat( EFFECTS_VIEW_DEFAULT_PIXEL_FORMAT ),
mSpread(0.0f),
GaussianBlurView::GaussianBlurView()
- : Control( CONTROL_BEHAVIOUR_NONE )
+ : Control( ControlBehaviour( DISABLE_SIZE_NEGOTIATION ) )
, mNumSamples(GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES)
, mBlurBellCurveWidth( 0.001f )
, mPixelFormat(GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT)
GaussianBlurView::GaussianBlurView( const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
const float downsampleWidthScale, const float downsampleHeightScale,
bool blurUserImage)
- : Control( NO_SIZE_NEGOTIATION )
+ : Control( ControlBehaviour( DISABLE_SIZE_NEGOTIATION ) )
, mNumSamples(numSamples)
, mBlurBellCurveWidth( 0.001f )
, mPixelFormat(renderTargetPixelFormat)
// Create an ImageActor for performing a horizontal blur on the texture
mImageActorHorizBlur = ImageActor::New();
- mImageActorHorizBlur.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mImageActorHorizBlur.SetParentOrigin(ParentOrigin::CENTER);
mImageActorHorizBlur.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
mImageActorHorizBlur.SetShaderEffect( mHorizBlurShader );
// Create an ImageActor for performing a vertical blur on the texture
mImageActorVertBlur = ImageActor::New();
- mImageActorVertBlur.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mImageActorVertBlur.SetParentOrigin(ParentOrigin::CENTER);
mImageActorVertBlur.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
mImageActorVertBlur.SetShaderEffect( mVertBlurShader );
if(!mBlurUserImage)
{
mImageActorComposite = ImageActor::New();
- mImageActorComposite.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mImageActorComposite.SetParentOrigin(ParentOrigin::CENTER);
mImageActorComposite.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
mImageActorComposite.SetOpacity(GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH); // ensure alpha is enabled for this object and set default value
// Create an ImageActor for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task
mTargetActor = ImageActor::New();
- mTargetActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mTargetActor.SetParentOrigin(ParentOrigin::CENTER);
mTargetActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
}
Magnifier::Magnifier()
-: Control( REQUIRES_TOUCH_EVENTS ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
mPropertySourcePosition(Property::INVALID_INDEX),
mDefaultCameraDistance(1000.f),
mActorSize(Vector3::ZERO),
Image image = ResourceImage::New( DEFAULT_FRAME_IMAGE_PATH );
mFrame = ImageActor::New( image );
- mFrame.SetRelayoutEnabled( false );
mFrame.SetDrawMode(DrawMode::OVERLAY);
mFrame.SetStyle( ImageActor::STYLE_NINE_PATCH );
mFrame.SetPositionInheritanceMode(DONT_INHERIT_POSITION);
mFrame.SetInheritScale(true);
+ mFrame.SetResizePolicy( ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT, Dimension::ALL_DIMENSIONS );
+ Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
+ mFrame.SetSizeModeFactor( sizeOffset );
Constraint constraint = Constraint::New<Vector3>( mFrame, Actor::Property::POSITION, EqualToConstraint() );
constraint.AddSource( ParentSource( Actor::Property::WORLD_POSITION ) );
mFrame.SetNinePatchBorder( Vector4::ONE * IMAGE_BORDER_INDENT );
self.Add(mFrame);
-
- Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
- mFrame.SetSize(mActorSize + sizeOffset);
}
else if(!visible && mFrame)
{
void Magnifier::OnControlSizeSet(const Vector3& targetSize)
{
- if( mFrame )
- {
- Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
- mFrame.SetSize(targetSize + sizeOffset);
- }
-
// TODO: Once Camera/CameraActor properties function as proper animatable properties
// this code can disappear.
// whenever the size of the magnifier changes, the field of view needs to change
}
NavigationControl::NavigationControl()
-: Control( REQUIRES_TOUCH_EVENTS ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
mToolBar(NULL),
mTitleBar(NULL),
mOrientationAngle( 0 ),
} // unnamed namespace
Page::Page()
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mTitle(""),
mSubTitle(""),
mPropertyTitle(Property::INVALID_INDEX),
const float PageTurnView::STATIC_PAGE_INTERVAL_DISTANCE = 1.0f;
PageTurnView::PageTurnView( PageFactory& pageFactory, const Vector2& pageSize )
-: Control( REQUIRES_TOUCH_EVENTS ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
mPageFactory( pageFactory ),
mPageSize( pageSize ),
mTotalPageCount( 0 ),
SetAsKeyboardFocusGroup(true);
}
-void Popup::MarkDirtyForRelayout()
-{
- // Flag all the popup controls for relayout as it is about to be hidden and miss the main flagging pass
- mLayer.RelayoutRequestTree();
-}
-
void Popup::OnPropertySet( Property::Index index, Property::Value propertyValue )
{
if( index == mPropertyTitle )
// Adds bottom background
mBottomBg = Actor::New();
mBottomBg.SetName( "POPUP_BOTTOM_BG" );
- mBottomBg.SetRelayoutEnabled( true );
mBottomBg.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mPopupLayout.SetFixedHeight( 2, mPopupStyle->bottomSize.height ); // Buttons
*/
PopupStylePtr GetStyle() const;
- /**
- * @copydoc Toolkit::Popup::MarkDirtyForRelayout
- */
- void MarkDirtyForRelayout();
-
protected:
/**
}
ItemView::ItemView(ItemFactory& factory)
-: Scrollable(),
+: Scrollable( ControlBehaviour( DISABLE_SIZE_NEGOTIATION | REQUIRES_MOUSE_WHEEL_EVENTS | REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ),
mItemFactory(factory),
mActiveLayout(NULL),
mAnimatingOvershootOn(false),
mItemsParentOrigin( ParentOrigin::CENTER),
mItemsAnchorPoint( AnchorPoint::CENTER)
{
- SetRequiresMouseWheelEvents(true);
- SetKeyboardNavigationSupport(true);
}
void ItemView::OnInitialize()
{
Actor self = Self();
- // Disable size negotiation for item views
- self.SetRelayoutEnabled( false );
-
mScrollConnector = Dali::Toolkit::ScrollConnector::New();
mScrollPositionObject = mScrollConnector.GetScrollPositionObject();
mScrollConnector.ScrollPositionChangedSignal().Connect( this, &ItemView::OnScrollPositionChanged );
{
}
+ScrollBase::ScrollBase( ControlBehaviour behaviourFlags )
+: Scrollable( behaviourFlags ),
+ mParent(NULL),
+ mDelay(0.0f)
+{
+}
+
void ScrollBase::SetParent(ScrollBase *parent)
{
mParent = parent;
*/
ScrollBase();
+ /**
+ * @brief Construct a new ScrollBase.
+ *
+ * @param[in] behaviourFlags Flags to enable
+ */
+ ScrollBase( ControlBehaviour behaviourFlags );
+
protected:
ScrollBase *mParent; ///< Pointer to ScrollBase parent, if exists.
}
ScrollView::ScrollView()
-: ScrollBase(),
+: ScrollBase( ControlBehaviour( REQUIRES_MOUSE_WHEEL_EVENTS ) ), // Enable size negotiation
mTouchDownTime(0u),
mGestureStackDepth(0),
mScrollStateFlags(0),
mCanScrollHorizontal(true),
mCanScrollVertical(true)
{
- SetRequiresMouseWheelEvents(true);
}
void ScrollView::OnInitialize()
// Scrollable controls are not layout containers so they dont need size negotiation..
// we dont want size negotiation while scrolling if we can avoid it
Scrollable::Scrollable()
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS | NO_SIZE_NEGOTIATION ) ),
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS | DISABLE_SIZE_NEGOTIATION ) ),
+ mOvershootEffectColor( DEFAULT_OVERSHOOT_COLOUR ),
+ mOvershootAnimationSpeed ( DEFAULT_OVERSHOOT_ANIMATION_SPEED ),
+ mOvershootEnabled(false)
+{
+}
+
+Scrollable::Scrollable( ControlBehaviour behaviourFlags )
+: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS | behaviourFlags ) ),
mOvershootEffectColor( DEFAULT_OVERSHOOT_COLOUR ),
mOvershootAnimationSpeed ( DEFAULT_OVERSHOOT_ANIMATION_SPEED ),
mOvershootEnabled(false)
*/
Scrollable();
+ /**
+ * @brief Construct a new Scrollable.
+ *
+ * @param[in] behaviourFlags Flags to enable
+ */
+ Scrollable( ControlBehaviour behaviourFlags );
+
/**
* A reference counted object may only be deleted by calling Unreference()
*/
} // namespace
ShadowView::ShadowView( float downsampleWidthScale, float downsampleHeightScale )
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mChildrenRoot(Actor::New()),
mCachedShadowColor(DEFAULT_SHADOW_COLOR),
mCachedBackgroundColor(DEFAULT_SHADOW_COLOR.r, DEFAULT_SHADOW_COLOR.g, DEFAULT_SHADOW_COLOR.b, 0.0f),
{
// root actor to parent all user added actors. Used as source actor for shadow render task.
mChildrenRoot.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
- mChildrenRoot.SetRelayoutEnabled( true );
mChildrenRoot.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
Vector2 stageSize = Stage::GetCurrent().GetSize();
mBlurRootActor = Actor::New();
mBlurRootActor.SetName( "BLUR_ROOT_ACTOR" );
- mBlurRootActor.SetRelayoutEnabled( true );
// Turn off inheritance to ensure filter renders properly
mBlurRootActor.SetPositionInheritanceMode(USE_PARENT_POSITION);
const float DEFAULT_HEIGHT = 27.0f;
const float DEFAULT_HIT_HEIGHT = 72.0f;
const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
+const float POPUP_TEXT_PADDING = 10.0f;
const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png";
const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
ImageActor Slider::CreateBacking()
{
ImageActor backing = ImageActor::New();
- backing.SetRelayoutEnabled( false );
backing.SetParentOrigin( ParentOrigin::CENTER );
backing.SetAnchorPoint( AnchorPoint::CENTER );
backing.SetZ( BACKING_Z );
ImageActor Slider::CreateProgress()
{
ImageActor progress = ImageActor::New();
- progress.SetRelayoutEnabled( false );
progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
progress.SetZ( PROGRESS_Z );
ImageActor Slider::CreateHandle()
{
ImageActor handle = ImageActor::New();
- handle.SetRelayoutEnabled( false );
handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
handle.SetAnchorPoint( AnchorPoint::CENTER );
handle.SetZ( HANDLE_Z );
ImageActor Slider::CreatePopupArrow()
{
ImageActor arrow = ImageActor::New();
- arrow.SetRelayoutEnabled( false );
arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
arrow.SetZ( HANDLE_Z );
Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
textLabel.SetParentOrigin( ParentOrigin::CENTER );
textLabel.SetAnchorPoint( AnchorPoint::CENTER );
+ textLabel.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
+ textLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, DEFAULT_POPUP_TEXT_COLOR );
textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
+ textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
return textLabel;
}
ImageActor Slider::CreatePopup()
{
ImageActor popup = ImageActor::New();
- popup.SetRelayoutEnabled( false );
popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
mValueTextLabel = CreatePopupText();
popup.Add( mValueTextLabel );
} // unnamed namespace
SuperBlurView::SuperBlurView( unsigned int blurLevels )
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( DISABLE_SIZE_NEGOTIATION ) ),
mBlurLevels( blurLevels ),
mBlurStrengthPropertyIndex(Property::INVALID_INDEX),
mResourcesCleared( true ),
DALI_ASSERT_DEBUG( row < mCellData.GetRows() );
DALI_ASSERT_DEBUG( column < mCellData.GetColumns() );
- Actor& actor = mCellData[ row ][ column ].actor;
+ const CellData& cellData = mCellData[ row ][ column ];
+ const Actor& actor = cellData.actor;
if( actor )
{
- if( FitToChild( actor, dimension ) )
+ if( FitToChild( actor, dimension ) && ( dimension == Dimension::WIDTH ) ? ( cellData.position.columnSpan == 1 ) : ( cellData.position.rowSpan == 1 ) )
{
maxActorHeight = std::max( maxActorHeight, actor.GetRelayoutSize( dimension ) + cellPadding.x + cellPadding.y );
}
option.SetName( name );
option.SetAnimationTime( 0.0f );
option.SetSize( OPTION_ICON_SIZE );
- option.SetRelayoutEnabled( false );
//option.ClickedSignal().Connect( this, &TextInputPopup::OnButtonPressed );
// 6. Set the normal option image.
Actor scrollview = Actor::New(); //todo make a scrollview
scrollview.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
scrollview.SetParentOrigin( ParentOrigin::CENTER );
- scrollview.SetRelayoutEnabled( true );
mTableOfButtons.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
mTableOfButtons.SetFitHeight( 0 );
void TextSelectionPopup::AddPopupOptions( bool createTail, bool showIcons, bool showCaptions )
{
mContentSize = Vector2::ZERO;
+
// Add the options into the buttons container.
// 1. Determine how many buttons are active and should be added to container.
}
TextSelectionPopup::TextSelectionPopup()
-: Control( ControlBehaviour( CONTROL_BEHAVIOUR_NONE ) ),
+: Control( ControlBehaviour( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ) ),
mMaxSize ( DEFAULT_POPUP_MAX_SIZE ),
mVisiblePopUpSize( DEFAULT_POPUP_MAX_SIZE ),
mRequiredPopUpSize( DEFAULT_POPUP_MAX_SIZE ),
}
ToolBar::ToolBar()
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mLayout(),
mLeftOffset( 0 ),
mCenterBase( 1 ),
}
View::View(bool fullscreen)
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mOrientation( -1 ),
mFullScreen(fullscreen),
mContentLayers(),
// Create a root actor and an image actor for offscreen rendering.
mOffscreenRootActor = Layer::New();
- mOffscreenRootActor.SetRelayoutEnabled( false );
mOffscreenRootActor.SetColorMode( USE_OWN_COLOR );
mOffscreenRootActor.SetPositionInheritanceMode( DONT_INHERIT_POSITION );
mOffscreenRootActor.SetInheritScale( false );
mOffscreenRootActor.SetSize( offscreenSize );
mImageActor = ImageActor::New();
- mImageActor.SetRelayoutEnabled( false );
mImageActor.SetParentOrigin( ParentOrigin::CENTER );
mImageActor.SetBlendFunc( BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA,
BlendingFactor::ONE, BlendingFactor::ONE );
cursor = CreateSolidColorActor( Color::WHITE );
cursor.SetParentOrigin( ParentOrigin::TOP_LEFT ); // Need to set the default parent origin as CreateSolidColorActor() sets a different one.
cursor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- cursor.SetRelayoutEnabled( false );
}
// Add or Remove cursor(s) from parent
else
{
mGrabArea = Actor::New();
- mGrabArea.SetRelayoutEnabled( true );
mGrabArea.SetName( "GrabArea" );
}
#else
mGrabArea = Actor::New();
- mGrabArea.SetRelayoutEnabled( true );
#endif
mGrabArea.SetParentOrigin( ParentOrigin::TOP_CENTER );
primary.flipped = false;
primary.grabArea = Actor::New(); // Area that Grab handle responds to, larger than actual handle so easier to move
- primary.grabArea.SetRelayoutEnabled( true );
#ifdef DECORATOR_DEBUG
primary.grabArea.SetName("SelectionHandleOneGrabArea");
#endif
secondary.flipped = false;
secondary.grabArea = Actor::New(); // Area that Grab handle responds to, larger than actual handle so easier to move
- secondary.grabArea.SetRelayoutEnabled( true );
#ifdef DECORATOR_DEBUG
secondary.grabArea.SetName("SelectionHandleTwoGrabArea");
#endif
// helper actor to create a off-screen image using shader effect
mEmptyImage = ImageActor::New( placeHolder );
- mEmptyImage.SetRelayoutEnabled( false );
- mEmptyImage.SetSize(Stage::GetCurrent().GetSize());
+ mEmptyImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mEmptyImage.SetParentOrigin( ParentOrigin::CENTER );
mEmptyImage.SetAnchorPoint( AnchorPoint::CENTER );
mFullImageCreator = FullAreaImageCreator::New();
ImageActor CubeTransitionEffect::CreateTile( Image image, const Vector4& color )
{
ImageActor tile = ImageActor::New( image );
- tile.SetRelayoutEnabled( false );
tile.SetParentOrigin( ParentOrigin::CENTER );
tile.SetAnchorPoint( AnchorPoint::CENTER );
tile.SetSize( mTileSize );
void PushButton::SetButtonImage( Image image )
{
Actor imageActor = ImageActor::New( image );
- imageActor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
Dali::Toolkit::GetImplementation( *this ).SetButtonImage( imageActor );
}
void PushButton::SetBackgroundImage( Image image )
{
Actor imageActor = ImageActor::New( image );
- imageActor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
Dali::Toolkit::GetImplementation( *this ).SetBackgroundImage( imageActor );
}
return Mesh::New( meshData );
}
+/**
+ * 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] 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,
mLongPressGestureDetector(),
mCurrentSize(),
mNaturalSize(),
- mFlags( Control::CONTROL_BEHAVIOUR_NONE ),
+ mFlags( Control::ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mIsKeyboardNavigationSupported( false ),
mIsKeyboardFocusGroup( false ),
mInitialized( false )
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 );
// 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;
}
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;
}
// 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.
+ REQUIRES_STYLE_CHANGE_SIGNALS = 1 << ( CustomActorImpl::ACTOR_FLAG_COUNT + 0 ), ///< True if needs to monitor style change signals such as theme/font change
+ REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = 1 << ( CustomActorImpl::ACTOR_FLAG_COUNT + 1 ), ///< True if needs to support keyboard navigation
+
+ LAST_CONTROL_BEHAVIOUR_FLAG
};
+ static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log< LAST_CONTROL_BEHAVIOUR_FLAG - 1 >::value + 1; ///< Total count of flags
+
/**
* @brief Create a Control.
*
GetImpl(*this).HideTail();
}
-void Popup::MarkDirtyForRelayout()
-{
- GetImpl(*this).MarkDirtyForRelayout();
-}
-
Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
{
return GetImpl(*this).OutsideTouchedSignal();
*/
void HideTail();
- /**
- * @brief Flag the popup as dirty for relayout
- */
- void MarkDirtyForRelayout();
-
public: // Not intended for application developers
/**
<h3>Initialization</h3>
Size negotiation is enabled on controls by default. If a control is desired to not have size negotiation enabled then simply pass in the
-NO_SIZE_NEGOTIATION flag into the Control constructor. This will then call SetRelayoutEnabled( false ) on the base class.
+DISABLE_SIZE_NEGOTIATION flag into the Control constructor.
The other step to perform is to set default resize policies for width and height.
<h3>Enabling Size Negotiation</h3>
-The first thing to do is to specify whether you want an actor to be included or excluded from the relayout process. The following method is used to enable or disable the relayout
-for an individual actor. Make sure this is the first thing that is called after the actor is created otherwise the actor may still be negotiated.
-@code void SetRelayoutEnabled( bool enabled ) @endcode
-Text and image actors have relayout enabled by default, while a plain Actor is disabled. Be aware that if desiring to use an Actor in relayout
-then relayout needs to be explicitly enabled first.
+Text and image actors have relayout enabled by default, while a plain Actor is disabled unless a call to SetResizePolicy is made.
<h3>Specifying Size Policies</h3>
@code
Actor rootActor = Actor::New();
-rootActor.SetRelayoutEnabled( true );
rootActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
rootActor.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::HEIGHT );
ImageActor image = ImageActor::New( Image::New( MY_IMAGE_PATH ) );
{ "SetImage", ImageActorApi::SetImage, IMAGE_ACTOR_API },
{ "GetImage", ImageActorApi::GetImage, IMAGE_ACTOR_API },
- { "SetToNaturalSize", ImageActorApi::SetToNaturalSize, IMAGE_ACTOR_API },
// ignore SetPixelArea, use imageActor.pixelArea
// ignore GetPixelArea, use imageActor.pixelArea
{ "IsPixelAreaSet", ImageActorApi::IsPixelAreaSet, IMAGE_ACTOR_API },
args.GetReturnValue().Set( localObject );
}
-/**
- * Tell the image actor to use the natural size of the current image
- * or future images.
- *
- * Calling SetSize on this actor or animating the size of the actor
- * overrides this behaviour.
- *
- * The image actor uses the natural image size after an image
- * has been loaded.
- * @for ImageActor
- * @method setToNaturalSize
- */
-void ImageActorApi::SetToNaturalSize( const v8::FunctionCallbackInfo<v8::Value>& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageActor imageActor = GetImageActor( isolate, args );
-
- imageActor.SetToNaturalSize();
-
-}
-
/**
* Query whether a pixel area has been set.
* @for ImageActor
*/
void SetImage( const v8::FunctionCallbackInfo< v8::Value >& args );
void GetImage( const v8::FunctionCallbackInfo< v8::Value >& args );
- void SetToNaturalSize( const v8::FunctionCallbackInfo< v8::Value >& args );
void IsPixelAreaSet( const v8::FunctionCallbackInfo< v8::Value >& args );
void ClearPixelArea( const v8::FunctionCallbackInfo< v8::Value >& args );
}; // namespace ImageActorApi
projects / platform / core / uifw / dali-toolkit.git / commitdiff