mTrace.PushCall("Resume", "");
}
-void TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
- const ImageAttributes& attributes,
- Vector2& closestSize)
+ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type scalingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection )
{
- closestSize = mClosestSize;
+ ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
mTrace.PushCall("GetClosestImageSize", "");
+ return closestSize;
}
-void TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
- const ImageAttributes& attributes,
- Vector2& closestSize)
+ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
+ ImageDimensions size,
+ FittingMode::Type scalingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection )
{
- closestSize = mClosestSize;
+ ImageDimensions closestSize = ImageDimensions( mClosestSize.x, mClosestSize.y );
mTrace.PushCall("GetClosestImageSize", "");
+ return closestSize;
}
/**
// EXTERNAL INCLUDES
#include <stdint.h>
#include <cstring>
+#include <dali/public-api/images/image-operations.h>
// INTERNAL INCLUDES
#include <dali/public-api/common/set-wrapper.h>
*/
virtual void Resume();
- virtual void GetClosestImageSize( const std::string& filename,
- const ImageAttributes& attributes,
- Vector2& closestSize);
+ /**
+ * @copydoc PlatformAbstraction::GetClosestImageSize()
+ */
+ virtual ImageDimensions GetClosestImageSize( const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type scalingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection );
- virtual void GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
- const ImageAttributes& attributes,
- Vector2& closestSize);
+ /**
+ * @copydoc PlatformAbstraction::GetClosestImageSize()
+ */
+ virtual ImageDimensions GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
+ ImageDimensions size,
+ FittingMode::Type scalingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection );
/**
* @copydoc PlatformAbstraction::LoadResource()
// 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()
*/
virtual ~Scrollable();
} // 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";;
// Progress bar
if( mProgress )
{
- if( clampledValue > 0.0f )
- {
- mProgress.SetVisible( true ); // Deliberately set this in case multiple SetValues are fired at once
- mProgress.SetSize( x, GetBackingRegion().y );
- }
- else
- {
- mProgress.SetVisible( false );
- }
+ mProgress.SetSize( x, GetBackingRegion().y );
}
// Signals
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 );
}
* 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,
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
/**
void Apply( ImageActor actor, const std::string& maskImage )
{
- Vector2 maskSize = ResourceImage::GetImageSize( maskImage );
+ const Uint16Pair maskSize = ResourceImage::GetImageSize( maskImage );
- const float leftRight = (maskSize.width - 1.0f) * 0.5f;
- const float topBottom = (maskSize.height - 1.0f) * 0.5f;
+ const float leftRight = (maskSize.GetWidth() - 1.0f) * 0.5f;
+ const float topBottom = (maskSize.GetHeight() - 1.0f) * 0.5f;
- DoApply( actor, maskImage, maskSize, Vector4( leftRight, topBottom, leftRight, topBottom ) );
+ DoApply( actor, maskImage, Vector2( maskSize.GetWidth(), maskSize.GetHeight() ), Vector4( leftRight, topBottom, leftRight, topBottom ) );
}
void Apply( ImageActor actor, const std::string& maskImage, const Vector4& maskBorder )
{
- Vector2 maskSize = ResourceImage::GetImageSize( maskImage );
+ const Uint16Pair maskSize = ResourceImage::GetImageSize( maskImage );
- DoApply( actor, maskImage, maskSize, maskBorder );
+ DoApply( actor, maskImage, Vector2( maskSize.GetWidth(), maskSize.GetHeight() ), maskBorder );
}
} // namespace NinePatchMaskEffect
<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 ) );
$(v8_plugin_dir)/events/pan-gesture-detector-api.cpp \
$(v8_plugin_dir)/events/pan-gesture-detector-wrapper.cpp \
$(v8_plugin_dir)/stage/stage-api.cpp \
- $(v8_plugin_dir)/image/image-attributes-api.cpp \
$(v8_plugin_dir)/shader-effects/shader-effect-api.cpp \
$(v8_plugin_dir)/shader-effects/shader-effect-wrapper.cpp \
- $(v8_plugin_dir)/image/image-attributes-wrapper.cpp \
$(v8_plugin_dir)/image/image-wrapper.cpp \
$(v8_plugin_dir)/image/image-api.cpp \
$(v8_plugin_dir)/image/buffer-image-api.cpp \
{ "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 },
}
/**
- * 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
* @method isPixelAreaSet
*/
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
{ "RESOURCE_LOADING_SUCCEEDED", Dali::ResourceLoadingSucceeded },
{ "RESOUCE_LOADING_FAILED", Dali::ResourceLoadingFailed },
-
-
+ { "FITTING_MODE_SHRINK_TO_FIT", FittingMode::SHRINK_TO_FIT },
+ { "FITTING_MODE_SCALE_TO_FILL", FittingMode::SCALE_TO_FILL },
+ { "FITTING_MODE_FIT_WIDTH", FittingMode::FIT_WIDTH },
+ { "FITTING_MODE_FIT_HEIGHT", FittingMode::FIT_HEIGHT },
+
+ { "SAMPLING_MODE_BOX", SamplingMode::BOX },
+ { "SAMPLING_MODE_NEAREST", SamplingMode::NEAREST },
+ { "SAMPLING_MODE_LINEAR", SamplingMode::LINEAR },
+ { "SAMPLING_MODE_BOX_THEN_NEAREST", SamplingMode::BOX_THEN_NEAREST },
+ { "SAMPLING_MODE_BOX_THEN_LINEAR", SamplingMode::BOX_THEN_LINEAR },
+ { "SAMPLING_MODE_NO_FILTER", SamplingMode::NO_FILTER },
+ { "SAMPLING_MODE_DONT_CARE", SamplingMode::DONT_CARE },
{ "BLEND_FACTOR_ZERO", BlendingFactor::ZERO },
{ "BLEND_FACTOR_ONE", BlendingFactor::ONE },
#include <dali/integration-api/debug.h>
#include <actors/actor-wrapper.h>
#include <stage/stage-wrapper.h>
-#include <image/image-attributes-wrapper.h>
#include <image/image-wrapper.h>
#include <animation/path-wrapper.h>
#include <animation/path-constraint-wrapper.h>
{ "BufferImage", ImageWrapper::NewImage },
{ "NinePatchImage", ImageWrapper::NewImage },
{ "FrameBufferImage", ImageWrapper::NewImage },
- { "ImageAttributes", ImageAttributesWrapper::NewImageAttributes },
{ "Animation", AnimationWrapper::NewAnimation},
{ "ShaderEffect", ShaderEffectWrapper::NewShaderEffect},
{ "Builder", BuilderWrapper::NewBuilder},
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include "image-attributes-api.h"
-
-// INTERNAL INCLUDES
-#include <v8-utils.h>
-#include <image/image-attributes-wrapper.h>
-#include <object/property-value-wrapper.h>
-#include <shared/base-wrapped-object.h>
-
-namespace Dali
-{
-
-namespace V8Plugin
-{
-
-ImageAttributes ImageAttributesApi::GetImageAttributesFromObject( v8::Isolate* isolate, v8::Local<v8::Object> object )
-{
- v8::HandleScope handleScope( isolate);
-
- if( BaseWrappedObject::IsWrappedType ( isolate, object, BaseWrappedObject::IMAGE_ATTRIBUTES ))
- {
- v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField(0) );
- void* ptr = field->Value();
- BaseWrappedObject* wrappedObject = static_cast< BaseWrappedObject *>(ptr);
- ImageAttributesWrapper* wrapper = static_cast< ImageAttributesWrapper*>( wrappedObject );;
- return wrapper->GetImageAttributes();
- }
- else
- {
- DALI_SCRIPT_EXCEPTION( isolate, "bad image attributes url");
- return ImageAttributes();
- }
-
-}
-
-/***************************************
- * IMAGE ATTRIBUTES FUNCTIONS
- *
- ****************************************/
-ImageAttributes ImageAttributesApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- // two combinations of constructor
- // 1 = no parameters
- // 2 = width, height
- bool foundParams( false );
- int params[2];
-
- V8Utils::ReadIntegerArguments( foundParams, ¶ms[0],2,args,0);
- if( !foundParams )
- {
- if( args.Length() != 0 )
- {
- DALI_SCRIPT_EXCEPTION( isolate, " ImageAttributes::New invalid params");
- return Dali::ImageAttributes();
- }
- return Dali::ImageAttributes::New();
- }
- else
- {
- return Dali::ImageAttributes::New( params[0], params[1] );
- }
-
-}
-
-ImageAttributes& ImageAttributesApi::GetImageAttributes( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Local<v8::Object> object = args.This();
- v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField(0) );
- void* ptr = field->Value();
-
- ImageAttributesWrapper* wrapper = static_cast< ImageAttributesWrapper *>(ptr);
- return wrapper->GetImageAttributes();
-}
-
-void ImageAttributesApi::SetSize( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- bool found;
- Vector2 size = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args );
- if (!found)
- {
- DALI_SCRIPT_EXCEPTION( isolate, "invalid size parameter" );
- return;
- }
- else
- {
- attribs.SetSize( size );
- }
-}
-
-void ImageAttributesApi::SetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- bool found(false);
- int value = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0);
- if( !found )
- {
- DALI_SCRIPT_EXCEPTION( isolate, "invalid scaling mode parameter");
- return;
- }
- if( value!= ImageAttributes::ShrinkToFit ||
- value!= ImageAttributes::ScaleToFill ||
- value!= ImageAttributes::FitWidth ||
- value!= ImageAttributes::FitHeight )
- {
- DALI_SCRIPT_EXCEPTION( isolate, "invalid scaling mode parameter");
- return;
- }
-
- attribs.SetScalingMode(static_cast<ImageAttributes::ScalingMode >( value) );
-}
-
-void ImageAttributesApi::SetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- bool parameterFound(false);
- bool value = V8Utils::GetBooleanParameter( PARAMETER_0 , parameterFound, isolate, args );
-
- if( !parameterFound )
- {
- DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter not found");
- return;
- }
- attribs.SetOrientationCorrection( value );
-}
-
-void ImageAttributesApi::GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetWidth() ) );
-}
-
-void ImageAttributesApi::GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetHeight() ) );
-
-}
-
-void ImageAttributesApi::GetSize( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- Vector2 vec( attribs.GetSize() );
- Dali::Property::Value value( vec );
-
- v8::Local <v8::Object> object = PropertyValueWrapper::WrapDaliProperty( isolate, value);
- args.GetReturnValue().Set( object );
-}
-
-void ImageAttributesApi::GetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetScalingMode() ) );
-
-}
-
-void ImageAttributesApi::GetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
- ImageAttributes& attribs( GetImageAttributes( isolate, args ));
-
- args.GetReturnValue().Set( v8::Boolean::New( isolate, attribs.GetOrientationCorrection() ) );
-
-}
-
-
-} // namespace V8Plugin
-
-} // namespace Dali
+++ /dev/null
-#ifndef __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
-#define __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
-
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <v8.h>
-#include <dali/public-api/images/image-attributes.h>
-
-
-namespace Dali
-{
-
-namespace V8Plugin
-{
-
-namespace ImageAttributesApi
-{
- ImageAttributes& GetImageAttributes( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
-
- ImageAttributes GetImageAttributesFromObject( v8::Isolate* isolate, v8::Local<v8::Object> object );
-
- /**
- * @brief Creates a new Image Attribute object based on some JavaScript parameters.
- * @param[in] args constructor parameters
- * @return ImageAttributes
- */
- ImageAttributes New( const v8::FunctionCallbackInfo< v8::Value >& args );
-
- /**
- * ImageAttributes API see image-attributes.h for a description
- */
- void SetSize( const v8::FunctionCallbackInfo< v8::Value >& args );
- void SetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args );
- void SetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetSize( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args );
-
-}; // namespace ImageAttributesApi
-
-} // namespace V8Plugin
-
-} // namespace Dali
-
-#endif // header __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include "image-attributes-wrapper.h"
-
-// INTERNAL INCLUDES
-#include <v8-utils.h>
-#include <image/image-attributes-api.h>
-#include <dali-wrapper.h>
-#include <shared/api-function.h>
-#include <shared/object-template-helper.h>
-
-namespace Dali
-{
-
-namespace V8Plugin
-{
-
-v8::Persistent<v8::ObjectTemplate> ImageAttributesWrapper::mImageAttributesTemplate;
-
-namespace
-{
-
-/**
- * Contains a list of all functions that can be called
- */
-const ApiFunction ImageAttributeFunctionTable[]=
-{
- /**************************************
- * ImageAttributes API (in order of image-attributes.h)
- **************************************/
- { "SetSize", ImageAttributesApi::SetSize },
- { "SetScalingMode", ImageAttributesApi::SetScalingMode },
- { "SetOrientationCorrection", ImageAttributesApi::SetOrientationCorrection },
- { "GetWidth", ImageAttributesApi::GetWidth },
- { "GetHeight", ImageAttributesApi::GetHeight },
- { "GetSize", ImageAttributesApi::GetSize },
- { "GetScalingMode", ImageAttributesApi::GetScalingMode },
- { "GetOrientationCorrection", ImageAttributesApi::GetOrientationCorrection },
-};
-
-const unsigned int ImageAttributeFunctionTableCount = sizeof(ImageAttributeFunctionTable)/sizeof(ImageAttributeFunctionTable[0]);
-} //un-named space
-
-
-ImageAttributesWrapper::ImageAttributesWrapper( const Dali::ImageAttributes& imageAttributes, GarbageCollectorInterface& gc )
-: BaseWrappedObject( BaseWrappedObject::IMAGE_ATTRIBUTES , gc )
-{
- mImageAttributes = imageAttributes;
-}
-
-v8::Handle<v8::Object> ImageAttributesWrapper::WrapImageAttributes(v8::Isolate* isolate, const Dali::ImageAttributes& attributes )
-{
- v8::EscapableHandleScope handleScope( isolate );
- v8::Local<v8::ObjectTemplate> objectTemplate;
-
- objectTemplate = GetImageAttributesTemplate( isolate);
-
- // create an instance of the template
- v8::Local<v8::Object> localObject = objectTemplate->NewInstance();
-
- // create the ImageAttributes wrapper
- ImageAttributesWrapper* pointer = new ImageAttributesWrapper( attributes, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
-
- // assign the JavaScript object to the wrapper.
- pointer->SetJavascriptObject( isolate, localObject );
-
- return handleScope.Escape( localObject );
-}
-
-v8::Local<v8::ObjectTemplate> ImageAttributesWrapper::GetImageAttributesTemplate( v8::Isolate* isolate)
-{
- v8::EscapableHandleScope handleScope( isolate );
- v8::Local<v8::ObjectTemplate> objectTemplate;
-
-
- if( mImageAttributesTemplate.IsEmpty() )
- {
- objectTemplate = MakeImageAttributesTemplate( isolate );
- mImageAttributesTemplate.Reset( isolate, objectTemplate );
- }
- else
- {
- // get the object template
- objectTemplate = v8::Local<v8::ObjectTemplate>::New( isolate, mImageAttributesTemplate );
- }
- return handleScope.Escape( objectTemplate );
-}
-
-v8::Handle<v8::ObjectTemplate> ImageAttributesWrapper::MakeImageAttributesTemplate( v8::Isolate* isolate )
-{
- v8::EscapableHandleScope handleScope( isolate );
-
- v8::Local<v8::ObjectTemplate> objTemplate = v8::ObjectTemplate::New();
-
- objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
-
- // add our function properties
- ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, ImageAttributeFunctionTable, ImageAttributeFunctionTableCount );
-
- return handleScope.Escape( objTemplate );
-}
-
-void ImageAttributesWrapper::NewImageAttributes( const v8::FunctionCallbackInfo< v8::Value >& args)
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate);
-
- if(!args.IsConstructCall())
- {
- DALI_SCRIPT_EXCEPTION(isolate, "ImageAttributes constructor called without 'new'");
- return;
- }
-
- // attribs can be passed by value
- Dali::ImageAttributes attribs = ImageAttributesApi::New( args );
- v8::Local<v8::Object> localObject = WrapImageAttributes( isolate, attribs );
- args.GetReturnValue().Set( localObject );
-}
-
-
-ImageAttributes& ImageAttributesWrapper::GetImageAttributes()
-{
- return mImageAttributes;
-}
-
-
-} // namespace V8Plugin
-
-} // namespace Dali
+++ /dev/null
-#ifndef __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_WRAPPER_H__
-#define __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_WRAPPER_H__
-
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <v8.h>
-#include <dali/public-api/images/image-attributes.h>
-
-// INTERNAL INCLUDES
-#include <shared/base-wrapped-object.h>
-
-namespace Dali
-{
-
-namespace V8Plugin
-{
-
-
-/**
- * An Image Attributes wrapper.
- * Provides access to ImageAttributes specific functionality and V8 memory handling.
- */
-class ImageAttributesWrapper : public BaseWrappedObject
-{
-
-public:
-
- /**
- * Constructor
- */
- ImageAttributesWrapper( const ImageAttributes& imageAttributes,
- GarbageCollectorInterface& gc );
-
- /**
- * Destructor
- */
- virtual ~ImageAttributesWrapper(){};
-
- /**
- * Constructors
- */
- static void NewImageAttributes( const v8::FunctionCallbackInfo< v8::Value >& args);
-
- /**
- * Wraps an image attributes
- */
- static v8::Handle<v8::Object> WrapImageAttributes(v8::Isolate* isolate, const Dali::ImageAttributes& attributes);
-
-
- // The ImageAttribute ObjectTemplate, we cache templates so we don't have
- // keep generating them everytime we want to create an ImageAttribute
- static v8::Persistent<v8::ObjectTemplate> mImageAttributesTemplate;
-
- ImageAttributes& GetImageAttributes();
-private:
-
- // ImageAttributes
- ImageAttributes mImageAttributes;
-
- static v8::Handle<v8::ObjectTemplate> MakeImageAttributesTemplate( v8::Isolate* isolate );
- static v8::Local<v8::ObjectTemplate> GetImageAttributesTemplate( v8::Isolate* isolate );
-
-};
-
-} // namespace V8Plugin
-
-} // namespace Dali
-
-#endif // header
// CLASS HEADER
#include "resource-image-api.h"
+// EXTERNAL INCLUDES
+#include <dali/public-api/images/image-operations.h>
+
// INTERNAL INCLUDES
#include <v8-utils.h>
#include <image/image-wrapper.h>
-#include <image/image-attributes-wrapper.h>
-#include <image/image-attributes-api.h>
-
namespace Dali
{
* @for ResourceImage
* @param {Object} options
* @param {String} options.url The URL of the image file to use.
- * @param {Object} [option.imageAttributes] image attributes object
* @param {Integer} [options.loadPolicy] The LoadPolicy to apply when loading the image resource.
* @param {Integer} [options.releasePolicy] optionally release memory when image is not visible on screen.
* @return {Object} Image
v8::HandleScope handleScope( isolate );
std::string url;
+ ImageDimensions dimensions;
+ FittingMode::Type fittingMode = FittingMode::DEFAULT;
+ SamplingMode::Type samplingMode = SamplingMode::DEFAULT;
+ bool orientationCorrection = true;
ResourceImage::LoadPolicy loadPolicy( ResourceImage::IMMEDIATE );
Image::ReleasePolicy releasePolicy( Image::NEVER);
- ImageAttributes imageAttributes;
- bool useImageAttributes = false;
v8::Local<v8::Value> options( args[0] );
return Image();
}
- v8::Local<v8::Value> imageAttribsValue= optionsObject->Get( v8::String::NewFromUtf8( isolate, "imageAttributes" ) );
- if( imageAttribsValue->IsObject() )
+ v8::Local<v8::Value> widthValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "width" ) );
+ if( widthValue->IsUint32() )
{
- imageAttributes = ImageAttributesApi::GetImageAttributesFromObject( isolate, imageAttribsValue->ToObject() );
+ const uint32_t width = widthValue->ToUint32()->Value();
+ dimensions = ImageDimensions( width, dimensions.GetHeight() );
}
+ v8::Local<v8::Value> heightValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "height" ) );
+ if( heightValue->IsUint32() )
+ {
+ const uint32_t height = heightValue->ToUint32()->Value();
+ dimensions = ImageDimensions( dimensions.GetWidth(), height );
+ }
+ v8::Local<v8::Value> fittingModeValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "fittingMode" ) );
+ if( fittingModeValue->IsUint32() )
+ {
+ fittingMode = static_cast<FittingMode::Type>( fittingModeValue->ToUint32()->Value() );
+ }
+
+ v8::Local<v8::Value> samplingModeValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "samplingMode" ) );
+ if( samplingModeValue->IsUint32() )
+ {
+ samplingMode = static_cast<SamplingMode::Type>( samplingModeValue->ToUint32()->Value() );
+ }
+
+ v8::Local<v8::Value> orientationCorrectionValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "orientationCorrection" ) );
+ if( orientationCorrectionValue->IsBoolean() )
+ {
+ orientationCorrection = orientationCorrectionValue->ToBoolean()->Value();
+ }
v8::Local<v8::Value> releasePolicyValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "releasePolicy" ) );
if( releasePolicyValue->IsUint32() )
loadPolicy = static_cast< ResourceImage::LoadPolicy >( loadPolicyValue->ToUint32()->Value());
}
- if( useImageAttributes )
- {
- return ResourceImage::New( url, imageAttributes, loadPolicy, releasePolicy);
- }
- else
- {
- return ResourceImage::New( url, loadPolicy, releasePolicy);
- }
+ return ResourceImage::New( url, loadPolicy, releasePolicy, dimensions, fittingMode, samplingMode, orientationCorrection );
}
/**
/**
* Reload the image
- * The set ImageAttributes are used when requesting the image again.
* @note if Image is offstage and OnDemand policy is set, reload request is ignored.
* @method reload
* @for ResourceImage
image.Reload();
}
-
-/**
- * Return attributes for the image
- * Only to be used after the image has finished loading.
- * (Ticket's LoadingSucceeded callback was called)
- * The returned value will reflect the true image dimensions once the asynchronous loading has finished.
- *
- * @method getAttributes
- * @for ResourceImage
- * @return {Object} ImageAttributes
- */
-void ResourceImageApi::GetAttributes( const v8::FunctionCallbackInfo< v8::Value >& args )
-{
- v8::Isolate* isolate = args.GetIsolate();
- v8::HandleScope handleScope( isolate );
-
- ResourceImage image = GetResourceImage( isolate, args );
-
- v8::Local<v8::Object> localObject = ImageAttributesWrapper::WrapImageAttributes(isolate, image.GetAttributes());
-
- args.GetReturnValue().Set( localObject );
-}
} // namespace V8Plugin
} // namespace Dali
void GetLoadingState( const v8::FunctionCallbackInfo< v8::Value >& args );
void GetUrl( const v8::FunctionCallbackInfo< v8::Value >& args );
void Reload( const v8::FunctionCallbackInfo< v8::Value >& args );
- void GetAttributes( const v8::FunctionCallbackInfo< v8::Value >& args );
}; // namespace ResourceImageApi
projects / platform / core / uifw / dali-toolkit.git / commitdiff