--- /dev/null
+//
+// Copyright (c) 2014 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Flora License, Version 1.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://floralicense.org/license/
+//
+// 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 <sstream>
+
+// INTERNAL INCLUDES
+#include "../shared/view.h"
+#include <dali/dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+using namespace std;
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+namespace
+{
+const char * const BACKGROUND_IMAGE( DALI_IMAGE_DIR "background-default.png" );
+const char * const TOOLBAR_IMAGE( DALI_IMAGE_DIR "top-bar.png" );
+const char * const APPLICATION_TITLE( "ScrollView" );
+const char * const EFFECT_NORMAL_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-normal.png" );
+const char * const EFFECT_OUTER_CUBE_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-outer-cube.png" );
+const char * const EFFECT_DEPTH_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-depth.png" );
+const char * const EFFECT_INNER_CUBE_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-inner-cube.png" );
+const char * const EFFECT_CAROUSEL_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-carousel.png" );
+const char * const EFFECT_SPIRAL_IMAGE( DALI_IMAGE_DIR "icon-scroll-view-spiral.png" );
+
+const Vector3 ICON_SIZE(100.0f, 100.0f, 0.0f);
+
+const char* EFFECT_MODE_NAME[] = { "Normal",
+ "OuterCube",
+ "Depth",
+ "InnerCube",
+ "Carousel",
+ "Spiral",
+ };
+
+const char* PEOPLE_IMAGE_PATHS[] = { DALI_IMAGE_DIR "people-medium-1.jpg",
+ DALI_IMAGE_DIR "people-medium-2.jpg",
+ DALI_IMAGE_DIR "people-medium-3.jpg",
+ DALI_IMAGE_DIR "people-medium-4.jpg",
+ DALI_IMAGE_DIR "people-medium-5.jpg",
+ DALI_IMAGE_DIR "people-medium-6.jpg",
+ DALI_IMAGE_DIR "people-medium-7.jpg",
+ DALI_IMAGE_DIR "people-medium-8.jpg",
+ NULL};
+
+const char* TODAY_IMAGE_PATHS[] = { DALI_IMAGE_DIR "gallery-medium-1.jpg",
+ DALI_IMAGE_DIR "gallery-medium-2.jpg",
+ DALI_IMAGE_DIR "gallery-medium-3.jpg",
+ DALI_IMAGE_DIR "gallery-medium-4.jpg",
+ DALI_IMAGE_DIR "gallery-medium-5.jpg",
+ NULL};
+
+const char* PHONE_IMAGE_PATHS[] = { DALI_IMAGE_DIR "gallery-medium-5.jpg",
+ DALI_IMAGE_DIR "gallery-medium-6.jpg",
+ DALI_IMAGE_DIR "gallery-medium-7.jpg",
+ DALI_IMAGE_DIR "gallery-medium-8.jpg",
+ DALI_IMAGE_DIR "gallery-medium-9.jpg",
+ NULL};
+
+const char* PICTURES_IMAGE_PATHS[] = { DALI_IMAGE_DIR "gallery-medium-10.jpg",
+ DALI_IMAGE_DIR "gallery-medium-11.jpg",
+ DALI_IMAGE_DIR "gallery-medium-12.jpg",
+ DALI_IMAGE_DIR "gallery-medium-13.jpg",
+ DALI_IMAGE_DIR "gallery-medium-14.jpg",
+ NULL};
+
+const char* MUSIC_IMAGE_PATHS[] = { DALI_IMAGE_DIR "gallery-medium-15.jpg",
+ DALI_IMAGE_DIR "gallery-medium-16.jpg",
+ DALI_IMAGE_DIR "gallery-medium-17.jpg",
+ DALI_IMAGE_DIR "gallery-medium-18.jpg",
+ DALI_IMAGE_DIR "gallery-medium-19.jpg",
+ DALI_IMAGE_DIR "gallery-medium-20.jpg",
+ NULL};
+
+const char* MAGAZINE_IMAGE_PATHS[] = { DALI_IMAGE_DIR "gallery-medium-21.jpg",
+ DALI_IMAGE_DIR "gallery-medium-22.jpg",
+ DALI_IMAGE_DIR "gallery-medium-23.jpg",
+ DALI_IMAGE_DIR "gallery-medium-24.jpg",
+ DALI_IMAGE_DIR "gallery-medium-25.jpg",
+ DALI_IMAGE_DIR "gallery-medium-26.jpg",
+ NULL};
+
+const char **IMAGE_GROUPS[] = {PEOPLE_IMAGE_PATHS,
+ TODAY_IMAGE_PATHS,
+ PHONE_IMAGE_PATHS,
+ PICTURES_IMAGE_PATHS,
+ MUSIC_IMAGE_PATHS,
+ MAGAZINE_IMAGE_PATHS,
+ NULL};
+
+const int PAGE_COLUMNS = 10; ///< Number of Pages going across (columns)
+const int PAGE_ROWS = 1; ///< Number of Pages going down (rows)
+const int IMAGE_COLUMNS = 3; ///< Number of Images going across (columns) within a Page
+const int IMAGE_ROWS = 5; ///< Number of Images going down (rows) with a Page
+
+// 3D Effect constants
+const Vector3 ANGLE_CUBE_PAGE_ROTATE(Math::PI * 0.2f, Math::PI * 0.2f, 0.0f); ///< Cube page rotates as if it has ten sides with the camera positioned inside
+const Vector2 ANGLE_CUSTOM_CUBE_SWING(-Math::PI * 0.45f, -Math::PI * 0.45f); ///< outer cube pages swing 90 degrees as they pan offscreen
+const Vector2 ANGLE_SPIRAL_SWING_IN(Math::PI * 0.45f, Math::PI * 0.45f);
+const Vector2 ANGLE_SPIRAL_SWING_OUT(Math::PI * 0.3f, Math::PI * 0.3f);
+
+// Depth Effect constants
+const Vector2 POSITION_EXTENT_DEPTH_EFFECT(0.5f, 2.5f); ///< Extent of X & Y position to alter function exponent.
+const Vector2 OFFSET_EXTENT_DEPTH_EFFECT(1.0f, 1.0f); ///< Function exponent offset constant.
+const float POSITION_SCALE_DEPTH_EFFECT(1.5f); ///< Position scaling.
+const float SCALE_EXTENT_DEPTH_EFFECT(0.5f); ///< Maximum scale factor when Actors scrolled one page away (50% size)
+
+const unsigned int IMAGE_THUMBNAIL_WIDTH = 256; ///< Width of Thumbnail Image in texels
+const unsigned int IMAGE_THUMBNAIL_HEIGHT = 256; ///< Height of Thumbnail Image in texels
+
+const float SPIN_DURATION = 5.0f; ///< Times to spin an Image by upon touching, each spin taking a second.
+
+const float EFFECT_SNAP_DURATION(0.66f); ///< Scroll Snap Duration for Effects
+const float EFFECT_FLICK_DURATION(0.5f); ///< Scroll Flick Duration for Effects
+
+/**
+ * WrapActorOffsetedConstraint
+ * Wraps an Actor's position based on its position
+ * within a scroll domain taking into account its
+ * size, anchor point, and an offset.
+ */
+struct WrapActorOffsetedConstraint
+{
+ WrapActorOffsetedConstraint(Vector2 offset)
+ : mOffset(offset)
+ {
+ }
+
+ Vector3 operator()(const Vector3& current,
+ const PropertyInput& actorScaleProperty,
+ const PropertyInput& actorAnchorPointProperty,
+ const PropertyInput& actorSizeProperty,
+ const PropertyInput& scrollPositionMin,
+ const PropertyInput& scrollPositionMax,
+ const PropertyInput& scrollWrap)
+ {
+ Vector3 position = current;
+ bool wrap = scrollWrap.GetBoolean();
+
+ if(wrap)
+ {
+ Vector3 min = scrollPositionMin.GetVector3();
+ Vector3 max = scrollPositionMax.GetVector3();
+
+ Vector3 anchor = actorAnchorPointProperty.GetVector3();
+ Vector3 scale = actorScaleProperty.GetVector3();
+ Vector3 size = actorSizeProperty.GetVector3();
+
+ if(fabsf(min.x - max.x) > Math::MACHINE_EPSILON_1)
+ {
+ // WRAP X (based on the position of the right side)
+ float offsetX = (1.0f - anchor.x) * size.x * scale.x;
+ offsetX += mOffset.x;
+ position.x = WrapInDomain(position.x + offsetX, min.x, max.x) - offsetX;
+ }
+
+ if(fabsf(min.y - max.y) > Math::MACHINE_EPSILON_1)
+ {
+ // WRAP Y (based on the position of the bottom side)
+ float offsetY = (1.0f - anchor.y) * size.y * scale.y;
+ offsetY += mOffset.y;
+ position.y = WrapInDomain(position.y + offsetY, min.y, max.y) - offsetY;
+ }
+ }
+
+ return position;
+ }
+
+private:
+
+ const Vector2 mOffset;
+
+};
+
+
+} // unnamed namespace
+
+/**
+ * This example shows how to do custom Scroll Effects
+ */
+class ExampleController : public ConnectionTracker
+{
+public:
+
+ /**
+ * Constructor
+ * @param application class, stored as reference
+ */
+ ExampleController( Application& application )
+ : mApplication( application ),
+ mView(),
+ mScrolling(false),
+ mEffectMode(CarouselEffect)
+ {
+ // Connect to the Application's Init and orientation changed signal
+ mApplication.InitSignal().Connect(this, &ExampleController::OnInit);
+ }
+
+ ~ExampleController()
+ {
+ // Nothing to do here; everything gets deleted automatically
+ }
+
+ /**
+ * This method gets called once the main loop of application is up and running
+ */
+ void OnInit(Application& app)
+ {
+ Stage::GetCurrent().KeyEventSignal().Connect(this, &ExampleController::OnKeyEvent);
+
+ // Hide the indicator bar
+ mApplication.GetWindow().ShowIndicator(false);
+
+ // Creates a default view with a default tool bar.
+ // The view is added to the stage.
+
+ mContentLayer = DemoHelper::CreateView( app,
+ mView,
+ mToolBar,
+ BACKGROUND_IMAGE,
+ TOOLBAR_IMAGE,
+ "" );
+
+ mEffectIcon[ Normal ] = Image::New( EFFECT_NORMAL_IMAGE );
+ mEffectIcon[ OuterCubeEffect ] = Image::New( EFFECT_OUTER_CUBE_IMAGE );
+ mEffectIcon[ DepthEffect ] = Image::New( EFFECT_DEPTH_IMAGE );
+ mEffectIcon[ InnerCubeEffect ] = Image::New( EFFECT_INNER_CUBE_IMAGE );
+ mEffectIcon[ CarouselEffect ] = Image::New( EFFECT_CAROUSEL_IMAGE );
+ mEffectIcon[ SpiralEffect ] = Image::New( EFFECT_SPIRAL_IMAGE );
+
+ // Create a effect change button. (right of toolbar)
+ mEffectChangeButton = Toolkit::PushButton::New();
+ mEffectChangeButton.ClickedSignal().Connect( this, &ExampleController::OnEffectTouched );
+ mToolBar.AddControl( mEffectChangeButton, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage, Toolkit::Alignment::HorizontalRight, DemoHelper::DEFAULT_MODE_SWITCH_PADDING );
+
+ // Create the content layer.
+ AddContentLayer();
+
+ // Hack to force screen refresh.
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(mContentLayer, Actor::POSITION), Vector3::ZERO );
+ animation.Play();
+ }
+
+private:
+
+ /**
+ * Adds content to the ContentLayer. This is everything we see
+ * excluding the toolbar at the top.
+ */
+ void AddContentLayer()
+ {
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ mScrollView = ScrollView::New();
+ mScrollView.SetAnchorPoint(AnchorPoint::CENTER);
+ mScrollView.SetParentOrigin(ParentOrigin::CENTER);
+ mContentLayer.Add( mScrollView );
+ mScrollView.SetSize( stageSize );
+ mScrollView.SetAxisAutoLock( true );
+ mScrollView.SetAxisAutoLockGradient( 1.0f );
+
+ mScrollView.ScrollStartedSignal().Connect( this, &ExampleController::OnScrollStarted );
+ mScrollView.ScrollCompletedSignal().Connect( this, &ExampleController::OnScrollCompleted );
+
+ int groupIndex = 0;
+ for(int row = 0;row<PAGE_ROWS;row++)
+ {
+ for(int column = 0;column<PAGE_COLUMNS;column++)
+ {
+ Actor page = CreatePage(IMAGE_GROUPS[groupIndex]);
+
+ page.SetPosition( column * stageSize.x, row * stageSize.y );
+ mScrollView.Add( page );
+
+ groupIndex++;
+ if(!IMAGE_GROUPS[groupIndex])
+ {
+ groupIndex = 0;
+ }
+
+ mPages.push_back(page);
+ }
+ }
+
+ Update();
+ }
+
+ /**
+ * Updates the ScrollView and it's children based
+ * on the current effect.
+ */
+ void Update()
+ {
+ std::stringstream ss(APPLICATION_TITLE);
+ ss << APPLICATION_TITLE << ": " << EFFECT_MODE_NAME[mEffectMode];
+ SetTitle(ss.str());
+
+ mEffectChangeButton.SetBackgroundImage( mEffectIcon[ mEffectMode ] );
+
+ // remove old Effect if exists.
+ if(mScrollViewEffect)
+ {
+ mScrollView.RemoveEffect(mScrollViewEffect);
+ }
+
+ // apply new Effect to ScrollView
+ ApplyEffectToScrollView();
+
+ for(ActorIter pageIter = mPages.begin(); pageIter != mPages.end(); ++pageIter)
+ {
+ Actor page = *pageIter;
+ ApplyEffectToPage( page );
+
+ unsigned int numChildren = (*pageIter).GetChildCount();
+ for(unsigned int i=0; i<numChildren; ++i)
+ {
+ Actor image = (*pageIter).GetChildAt(i);
+
+ // Remove old effect's manual constraints.
+ image.RemoveConstraints();
+
+ // Apply new effect's manual constraints.
+ ApplyEffectToActor( image, page, (rand()&1) );
+ }
+ }
+ }
+
+ /**
+ * Creates a page using a source of images.
+ * @param[in] paths pointer to Null-terminated array of Null-terminated strings.
+ */
+ Actor CreatePage(const char **paths)
+ {
+ int pathIndex = 0;
+ Actor page = Actor::New();
+ page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
+ page.SetParentOrigin( ParentOrigin::CENTER );
+ page.SetAnchorPoint( AnchorPoint::CENTER );
+
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ const float margin = 10.0f;
+
+ const Vector3 imageSize((stageSize.x / IMAGE_COLUMNS) - margin, (stageSize.y / IMAGE_ROWS) - margin, 0.0f);
+
+ for(int row = 0;row<IMAGE_ROWS;row++)
+ {
+ for(int column = 0;column<IMAGE_COLUMNS;column++)
+ {
+ ImageActor image = CreateImage(paths[pathIndex]);
+
+ image.SetParentOrigin( ParentOrigin::CENTER );
+ image.SetAnchorPoint( AnchorPoint::CENTER );
+
+ Vector3 position( margin * 0.5f + (imageSize.x + margin) * column - stageSize.width * 0.5f,
+ margin * 0.5f + (imageSize.y + margin) * row - stageSize.height * 0.5f,
+ 0.0f);
+ image.SetPosition( position + imageSize * 0.5f );
+ image.SetSize( imageSize );
+ page.Add(image);
+
+ pathIndex++;
+ if(!paths[pathIndex])
+ {
+ pathIndex = 0;
+ }
+ }
+ }
+
+ return page;
+ }
+
+ /**
+ * [ScrollView]
+ * Applies effect to scrollView
+ */
+ void ApplyEffectToScrollView()
+ {
+ bool wrap(true);
+ bool snap(true);
+
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ switch(mEffectMode)
+ {
+ case Normal:
+ {
+ SetupNormalPageEffect();
+ break;
+ }
+
+ case OuterCubeEffect:
+ {
+ SetupOuterPageCubeEffect();
+ break;
+ }
+
+ case DepthEffect:
+ {
+ mScrollViewEffect = ScrollViewDepthEffect::New();
+ mScrollView.SetScrollSnapDuration(EFFECT_SNAP_DURATION);
+ mScrollView.SetScrollFlickDuration(EFFECT_FLICK_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.RemoveConstraintsFromChildren();
+ break;
+ }
+
+ case InnerCubeEffect:
+ {
+ SetupInnerPageCubeEffect();
+ break;
+ }
+
+ case CarouselEffect:
+ {
+ SetupCarouselPageEffect();
+ break;
+ }
+
+ case SpiralEffect:
+ {
+ SetupSpiralPageEffect();
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ } // end switch
+
+ if(mScrollViewEffect)
+ {
+ mScrollView.ApplyEffect(mScrollViewEffect);
+ }
+
+ mScrollView.SetWrapMode(wrap);
+
+ RulerPtr rulerX = CreateRuler(snap ? stageSize.width : 0.0f);
+ RulerPtr rulerY = new DefaultRuler;
+ rulerX->SetDomain(RulerDomain(0.0f, stageSize.x * PAGE_COLUMNS, !wrap));
+ rulerY->Disable();
+
+ mScrollView.SetRulerX( rulerX );
+ mScrollView.SetRulerY( rulerY );
+ }
+
+ /**
+ * Creates a Ruler that snaps to a specified grid size.
+ * If that grid size is 0.0 then this ruler does not
+ * snap.
+ *
+ * @param[in] gridSize (optional) The grid size for the ruler,
+ * (Default = 0.0 i.e. no snapping)
+ * @return The ruler is returned.
+ */
+ RulerPtr CreateRuler(float gridSize = 0.0f)
+ {
+ if(gridSize <= Math::MACHINE_EPSILON_0)
+ {
+ return new DefaultRuler();
+ }
+ return new FixedRuler(gridSize);
+ }
+
+ void SetupNormalPageEffect()
+ {
+ mScrollViewEffect.Reset();
+ mScrollView.SetScrollSnapDuration(ScrollView::DEFAULT_SLOW_SNAP_ANIMATION_DURATION);
+ mScrollView.SetScrollFlickDuration(ScrollView::DEFAULT_FAST_SNAP_ANIMATION_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.RemoveConstraintsFromChildren();
+ }
+
+ void SetupInnerPageCubeEffect()
+ {
+ ScrollViewCustomEffect customEffect;
+ mScrollViewEffect = customEffect = ScrollViewCustomEffect::New();
+ mScrollView.SetScrollSnapDuration(EFFECT_SNAP_DURATION);
+ mScrollView.SetScrollFlickDuration(EFFECT_FLICK_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.RemoveConstraintsFromChildren();
+
+ customEffect.SetPageSpacing(Vector2(30.0f, 30.0f));
+ customEffect.SetAngledOriginPageRotation(ANGLE_CUBE_PAGE_ROTATE);
+ customEffect.SetSwingAngle(ANGLE_CUBE_PAGE_ROTATE.x, Vector3(0,-1,0));
+ customEffect.SetOpacityThreshold(0.7f);
+ }
+
+ void SetupOuterPageCubeEffect()
+ {
+ ScrollViewCustomEffect customEffect;
+ mScrollViewEffect = customEffect = ScrollViewCustomEffect::New();
+ mScrollView.SetScrollSnapDuration(EFFECT_SNAP_DURATION);
+ mScrollView.SetScrollFlickDuration(EFFECT_FLICK_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOut);
+ mScrollView.RemoveConstraintsFromChildren();
+
+ Vector2 pageSize = Stage::GetCurrent().GetSize();
+ customEffect.SetPageTranslation(Vector3(pageSize.x, pageSize.y, 0));
+ customEffect.SetSwingAngleOut(ANGLE_CUSTOM_CUBE_SWING.x, Vector3(0.0f, -1.0f, 0.0f));
+ customEffect.SetSwingAnchor(AnchorPoint::CENTER, AnchorPoint::CENTER_LEFT);
+ customEffect.SetOpacityThreshold(0.5f);
+ }
+
+ void SetupCarouselPageEffect()
+ {
+ ScrollViewCustomEffect customEffect;
+ mScrollViewEffect = customEffect = ScrollViewCustomEffect::New();
+ mScrollView.SetScrollSnapDuration(EFFECT_SNAP_DURATION);
+ mScrollView.SetScrollFlickDuration(EFFECT_FLICK_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.RemoveConstraintsFromChildren();
+
+ customEffect.SetPageTranslation(Vector3(0,0,0), Vector3(-30, 0, 0));
+ customEffect.SetPageSpacing(Vector2(60.0f, 60.0f));
+ customEffect.SetAngledOriginPageRotation(-ANGLE_CUBE_PAGE_ROTATE);
+ customEffect.SetOpacityThreshold(0.2f, 0.6f);
+ }
+
+ void SetupSpiralPageEffect()
+ {
+ ScrollViewCustomEffect customEffect;
+ mScrollViewEffect = customEffect = ScrollViewCustomEffect::New();
+ mScrollView.SetScrollSnapDuration(EFFECT_SNAP_DURATION);
+ mScrollView.SetScrollFlickDuration(EFFECT_FLICK_DURATION);
+ mScrollView.SetScrollSnapAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.SetScrollFlickAlphaFunction(AlphaFunctions::EaseOutBack);
+ mScrollView.RemoveConstraintsFromChildren();
+
+ Vector2 pageSize = Stage::GetCurrent().GetSize();
+ customEffect.SetPageTranslation(Vector3(pageSize.x, pageSize.y, 0.0f));
+ customEffect.SetSwingAngle(-ANGLE_SPIRAL_SWING_IN.x, Vector3(0.0f, -1.0f, 0.0f), ANGLE_SPIRAL_SWING_OUT.x, Vector3(0.0f, -1.0f, 0.0f));
+ customEffect.SetSwingAnchor(AnchorPoint::CENTER_RIGHT);
+ customEffect.SetPageTranslation(Vector3(pageSize.x, pageSize.y, 0), Vector3(pageSize.x, pageSize.y, 0) * 0.5f);
+ customEffect.SetOpacityThreshold(0.66f);
+ }
+
+ /**
+ * [Page]
+ * Applies effect to the pages within scroll view.
+ *
+ * @param[in] page The page Actor to apply effect to.
+ */
+ void ApplyEffectToPage(Actor page)
+ {
+ page.RemoveConstraints();
+ page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
+
+ if( mEffectMode == Normal )
+ {
+ Constraint constraint;
+
+ // MoveActor (scrolling)
+ constraint = Constraint::New<Vector3>( Actor::POSITION,
+ Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_PROPERTY_NAME ) ),
+ MoveActorConstraint );
+ constraint.SetRemoveAction(Constraint::Discard);
+ page.ApplyConstraint(constraint);
+
+ // WrapActor (wrap functionality) - takes into account parent origin
+ constraint = Constraint::New<Vector3>( Actor::POSITION,
+ LocalSource( Actor::SCALE ),
+ LocalSource( Actor::ANCHOR_POINT ),
+ LocalSource( Actor::SIZE ),
+ Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_MIN_PROPERTY_NAME ) ),
+ Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_MAX_PROPERTY_NAME ) ),
+ Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_WRAP_PROPERTY_NAME ) ),
+ WrapActorOffsetedConstraint( Stage::GetCurrent().GetSize() * 0.5f ) );
+ constraint.SetRemoveAction(Constraint::Discard);
+ page.ApplyConstraint(constraint);
+ }
+ else if( ( mEffectMode == InnerCubeEffect ) ||
+ ( mEffectMode == OuterCubeEffect ) ||
+ ( mEffectMode == SpiralEffect ) ||
+ ( mEffectMode == CarouselEffect) )
+ {
+ ApplyCustomEffectToPage(page);
+ }
+ }
+
+ void ApplyCustomEffectToPage(Actor page)
+ {
+ ScrollViewCustomEffect customEffect = ScrollViewCustomEffect::DownCast(mScrollViewEffect);
+ Vector2 vStageSize(Stage::GetCurrent().GetSize());
+ customEffect.ApplyToPage(page, Vector3(vStageSize.x, vStageSize.y, 1.0f));
+ }
+
+ /**
+ * [Actor]
+ * Applies effect to child which resides in page (which in turn resides in scrollview)
+ *
+ * @note Page is typically the Parent of child, although in
+ * some scenarios Page is simply a container which has a child as
+ * a descendent.
+ *
+ * @param[in] child The child actor to apply effect to
+ * @param[in] page The page which this child is inside
+ * @param[in] style The style of effect either 0 or 1. (changes anchor point)
+ */
+ void ApplyEffectToActor(Actor child, Actor page, int style)
+ {
+ if( mEffectMode == DepthEffect )
+ {
+ ApplyDepthEffectToActor(child, style);
+ }
+ }
+
+ /**
+ * Applies depth effect to the child which resides in page (which in turn resides in scrollview)
+ *
+ * @param[in] child The child actor to apply depth effect to
+ * @param[in] style The style of effect either 0 or 1. (changes anchor point)
+ */
+ void ApplyDepthEffectToActor(Actor child, int style)
+ {
+ ScrollViewDepthEffect depthEffect = ScrollViewDepthEffect::DownCast(mScrollViewEffect);
+ depthEffect.ApplyToActor( child,
+ POSITION_EXTENT_DEPTH_EFFECT,
+ OFFSET_EXTENT_DEPTH_EFFECT,
+ POSITION_SCALE_DEPTH_EFFECT,
+ SCALE_EXTENT_DEPTH_EFFECT );
+ }
+
+ /**
+ * Creates an Image (Helper)
+ *
+ * @param[in] filename the path of the image.
+ * @param[in] width the width of the image in texels
+ * @param[in] height the height of the image in texels.
+ */
+ ImageActor CreateImage( const std::string& filename, unsigned int width = IMAGE_THUMBNAIL_WIDTH, unsigned int height = IMAGE_THUMBNAIL_HEIGHT )
+ {
+ ImageAttributes attributes;
+
+ attributes.SetSize(width, height);
+ attributes.SetScalingMode(ImageAttributes::ShrinkToFit);
+ Image img = Image::New(filename, attributes);
+ ImageActor actor = ImageActor::New(img);
+ actor.SetName( filename );
+ actor.SetParentOrigin(ParentOrigin::CENTER);
+ actor.SetAnchorPoint(AnchorPoint::CENTER);
+
+ actor.TouchedSignal().Connect( this, &ExampleController::OnTouchImage );
+ return actor;
+ }
+
+ /**
+ * When scroll starts (i.e. user starts to drag scrollview),
+ * note this state (mScrolling = true)
+ * @param[in] position Current Scroll Position
+ */
+ void OnScrollStarted( const Vector3& position )
+ {
+ mScrolling = true;
+ }
+
+ /**
+ * When scroll starts (i.e. user stops dragging scrollview, and scrollview has snapped to destination),
+ * note this state (mScrolling = false)
+ * @param[in] position Current Scroll Position
+ */
+ void OnScrollCompleted( const Vector3& position )
+ {
+ mScrolling = false;
+ }
+
+ /**
+ * Upon Touching an image (Release), make it spin
+ * (provided we're not scrolling).
+ * @param[in] actor The actor touched
+ * @param[in] event The TouchEvent.
+ */
+ bool OnTouchImage( Actor actor, const TouchEvent& event )
+ {
+ if( (event.points.size() > 0) && (!mScrolling) )
+ {
+ TouchPoint point = event.points[0];
+ if(point.state == TouchPoint::Up)
+ {
+ // Spin the Image a few times.
+ Animation animation = Animation::New(SPIN_DURATION);
+ animation.RotateBy( actor, Degree(360.0f * SPIN_DURATION), Vector3::XAXIS, AlphaFunctions::EaseOut);
+ animation.Play();
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Signal handler, called when the 'Effect' button has been touched.
+ *
+ * @param[in] button The button that was pressed.
+ */
+ bool OnEffectTouched(Button button)
+ {
+ mEffectMode = static_cast<EffectMode>((static_cast<int>(mEffectMode) + 1) % static_cast<int>(Total));
+ Update();
+ return true;
+ }
+
+ /**
+ * Sets/Updates the title of the View
+ * @param[in] title The new title for the view.
+ */
+ void SetTitle(const std::string& title)
+ {
+ if(!mTitleActor)
+ {
+ mTitleActor = TextView::New();
+ // Add title to the tool bar.
+ mToolBar.AddControl( mTitleActor, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarTitlePercentage, Alignment::HorizontalCenter );
+ }
+
+ Font font = Font::New();
+ mTitleActor.SetText( title );
+ mTitleActor.SetSize( font.MeasureText( title ) );
+ mTitleActor.SetStyleToCurrentText(DemoHelper::GetDefaultTextStyle());
+ }
+
+ /**
+ * Main key event handler
+ */
+ void OnKeyEvent(const KeyEvent& event)
+ {
+ if(event.state == KeyEvent::Down)
+ {
+ if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
+ {
+ mApplication.Quit();
+ }
+ }
+ }
+
+private:
+
+ Application& mApplication; ///< Application instance
+ Toolkit::View mView; ///< The View instance.
+ Toolkit::ToolBar mToolBar; ///< The View's Toolbar.
+ TextView mTitleActor; ///< The Toolbar's Title.
+ Layer mContentLayer; ///< The content layer (contains game actors)
+ ScrollView mScrollView; ///< ScrollView UI Component
+ bool mScrolling; ///< ScrollView scrolling state (true = scrolling, false = stationary)
+ ScrollViewEffect mScrollViewEffect; ///< ScrollView Effect instance.
+ ActorContainer mPages; ///< Keeps track of all the pages for applying effects.
+
+ /**
+ * Enumeration of different effects this scrollview can operate under.
+ */
+ enum EffectMode
+ {
+ Normal, ///< No Effect (Standard ScrollView)
+ OuterCubeEffect, ///< 3D Rotating Cube Effect
+ DepthEffect, ///< Depth Effect
+ InnerCubeEffect, ///< Page Cube Effect
+ CarouselEffect, ///< Page Carousel Effect
+ SpiralEffect, ///< Page Spiral Effect
+
+ Total,
+ };
+
+ EffectMode mEffectMode; ///< Current Effect mode
+
+ Image mEffectIcon[Total]; ///< Icons for the effect button
+ Toolkit::PushButton mEffectChangeButton; ///< Effect Change Button
+};
+
+int main(int argc, char **argv)
+{
+ Application app = Application::New(&argc, &argv);
+ ExampleController test(app);
+ app.MainLoop();
+ return 0;
+}
projects / platform / core / uifw / dali-demo.git / commitdiff
