[dali_2.0.15] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-ItemView.cpp
1 /*
2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #include <iostream>
19 #include <stdlib.h>
20 #include <float.h>       // for FLT_MAX
21
22 // Need to override adaptor classes for toolkit test harness, so include
23 // test harness headers before dali headers.
24 #include <dali-toolkit-test-suite-utils.h>
25 #include <dali-toolkit/dali-toolkit.h>
26 #include <dali/integration-api/events/touch-event-integ.h>
27 #include <dali/integration-api/events/wheel-event-integ.h>
28
29 using namespace Dali;
30 using namespace Toolkit;
31
32 void utc_dali_toolkit_item_view_startup(void)
33 {
34   test_return_value = TET_UNDEF;
35 }
36
37 void utc_dali_toolkit_item_view_cleanup(void)
38 {
39   test_return_value = TET_PASS;
40 }
41
42 namespace
43 {
44
45 const unsigned int TOTAL_ITEM_NUMBER = 400;
46 const char* TEST_IMAGE_FILE_NAME = "gallery_image_01.jpg";
47
48 const int RENDER_FRAME_INTERVAL = 16;                     ///< Duration of each frame in ms. (at approx 60FPS)
49
50 static bool gObjectCreatedCallBackCalled;
51 static bool gOnLayoutActivatedCalled;                     ///< Whether the LayoutActivated signal was invoked.
52 static bool gOnScrollUpdateCalled;
53 static bool gOnWheelEventCalled;                          ///< Whether the WheelEventSignal signal was invoked.
54
55 static void TestCallback(BaseHandle handle)
56 {
57   gObjectCreatedCallBackCalled = true;
58 }
59
60 static void OnLayoutActivated()
61 {
62   gOnLayoutActivatedCalled = true;
63 }
64
65 static void OnScrollUpdate( const Vector2& position )
66 {
67   gOnScrollUpdateCalled = true;
68 }
69
70 static bool OnWheelEvent( Actor actor, const Dali::WheelEvent& wheelEvent )
71 {
72   gOnWheelEventCalled = true;
73   return false;
74 }
75
76 Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
77 {
78   Integration::TouchEvent touchEvent;
79   Integration::Point point;
80   point.SetState( state );
81   point.SetDeviceId(4);
82   point.SetScreenPosition( screenPosition );
83   point.SetDeviceClass( Device::Class::TOUCH );
84   point.SetDeviceSubclass( Device::Subclass::NONE );
85   touchEvent.points.push_back( point );
86   touchEvent.time = time;
87   return touchEvent;
88 }
89
90 /*
91  * Simulate time passed by.
92  *
93  * @note this will always process at least 1 frame (1/60 sec)
94  *
95  * @param application Test application instance
96  * @param duration Time to pass in milliseconds.
97  * @return The actual time passed in milliseconds
98  */
99 int Wait(ToolkitTestApplication& application, int duration = 0)
100 {
101   int time = 0;
102
103   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
104   {
105     application.SendNotification();
106     application.Render(RENDER_FRAME_INTERVAL);
107     time += RENDER_FRAME_INTERVAL;
108   }
109
110   return time;
111 }
112
113 // Implementation of ItemFactory for providing actors to ItemView
114 class TestItemFactory : public ItemFactory
115 {
116 public:
117
118   /**
119    * Constructor
120    * @param application class, stored as reference
121    */
122   TestItemFactory()
123   {
124   }
125
126 public: // From ItemFactory
127
128   /**
129    * Query the number of items available from the factory.
130    * The maximum available item has an ID of GetNumberOfItems() - 1.
131    */
132   virtual unsigned int GetNumberOfItems()
133   {
134     return TOTAL_ITEM_NUMBER;
135   }
136
137   /**
138    * Create an Actor to represent a visible item.
139    * @param itemId
140    * @return the created actor.
141    */
142   virtual Actor NewItem(unsigned int itemId)
143   {
144     // Create a renderable actor for this item
145     return ImageView::New( TEST_IMAGE_FILE_NAME );
146   }
147 };
148
149 } // namespace
150
151
152 int UtcDaliItemViewNew(void)
153 {
154   ToolkitTestApplication application;
155
156   // Create the ItemView actor
157   TestItemFactory factory;
158   ItemView view = ItemView::New(factory);
159
160   DALI_TEST_CHECK(view);
161
162   //Additional check to ensure object is created by checking if it's registered
163   ObjectRegistry registry = application.GetCore().GetObjectRegistry();
164   DALI_TEST_CHECK( registry );
165
166   gObjectCreatedCallBackCalled = false;
167   registry.ObjectCreatedSignal().Connect(&TestCallback);
168   {
169     TestItemFactory factory;
170     ItemView view = ItemView::New(factory);
171   }
172   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
173   END_TEST;
174 }
175
176 int UtcDaliItemViewCopyConstructor(void)
177 {
178   ToolkitTestApplication application;
179
180   TestItemFactory factory;
181   ItemView itemView = ItemView::New( factory );
182   DALI_TEST_CHECK( itemView );
183
184   ItemView copy( itemView );
185   DALI_TEST_CHECK( copy );
186
187   END_TEST;
188 }
189
190 int UtcDaliItemViewCopyAssignment(void)
191 {
192   ToolkitTestApplication application;
193
194   TestItemFactory factory;
195   ItemView itemView = ItemView::New( factory );
196   DALI_TEST_CHECK( itemView );
197
198   ItemView copy;
199   copy = itemView;
200   DALI_TEST_CHECK( copy );
201   DALI_TEST_EQUALS( itemView, copy, TEST_LOCATION );
202
203   END_TEST;
204 }
205
206 int UtcDaliItemViewMoveConstructor(void)
207 {
208   ToolkitTestApplication application;
209
210   TestItemFactory factory;
211   ItemView itemView = ItemView::New( factory );
212   DALI_TEST_EQUALS( 1, itemView.GetBaseObject().ReferenceCount(), TEST_LOCATION );
213   itemView.SetProperty( Actor::Property::SENSITIVE, false );
214   DALI_TEST_CHECK( false == itemView.GetProperty< bool >( Actor::Property::SENSITIVE ) );
215
216   ItemView moved = std::move( itemView );
217   DALI_TEST_CHECK( moved );
218   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
219   DALI_TEST_CHECK( false == moved.GetProperty< bool >( Actor::Property::SENSITIVE ) );
220   DALI_TEST_CHECK( !itemView );
221
222   END_TEST;
223 }
224
225 int UtcDaliItemViewMoveAssignment(void)
226 {
227   ToolkitTestApplication application;
228
229   TestItemFactory factory;
230   ItemView itemView = ItemView::New( factory );
231   DALI_TEST_EQUALS( 1, itemView.GetBaseObject().ReferenceCount(), TEST_LOCATION );
232   itemView.SetProperty( Actor::Property::SENSITIVE, false );
233   DALI_TEST_CHECK( false == itemView.GetProperty< bool >( Actor::Property::SENSITIVE ) );
234
235   ItemView moved;
236   moved = std::move( itemView );
237   DALI_TEST_CHECK( moved );
238   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
239   DALI_TEST_CHECK( false == moved.GetProperty< bool >( Actor::Property::SENSITIVE ) );
240   DALI_TEST_CHECK( !itemView );
241
242   END_TEST;
243 }
244
245 int UtcDaliItemViewDownCast(void)
246 {
247   ToolkitTestApplication application;
248
249   // Create the ItemView actor
250   TestItemFactory factory;
251   const ItemView itemViewConst = ItemView::New(factory);
252   ItemView itemView(itemViewConst);
253
254   BaseHandle handle(itemView);
255
256   ItemView newItemView = ItemView::DownCast( handle );
257   DALI_TEST_CHECK( itemView );
258   DALI_TEST_CHECK( newItemView == itemView );
259   END_TEST;
260 }
261
262 int UtcDaliItemViewAddAndGetLayout(void)
263 {
264   ToolkitTestApplication application;
265
266   // Create the ItemView actor
267   TestItemFactory factory;
268   ItemView view = ItemView::New(factory);
269
270   // Create a grid layout and add it to ItemView
271   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
272   view.AddLayout(*gridLayout);
273
274   // As we have added one layout, check the number of layout is now 1
275   DALI_TEST_CHECK(view.GetLayoutCount() == 1);
276
277   // Create a depth layout and add it to ItemView
278   ItemLayoutPtr depthLayout = DefaultItemLayout::New( DefaultItemLayout::DEPTH );
279   view.AddLayout(*depthLayout);
280
281   // As we have added another layout, check the number of layout is now 2
282   DALI_TEST_CHECK(view.GetLayoutCount() == 2);
283
284   // Create a spiral layout and add it to ItemView
285   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
286   view.AddLayout(*spiralLayout);
287
288   // As we have added another layout, check the number of layout is now 3
289   DALI_TEST_CHECK(view.GetLayoutCount() == 3);
290
291   // Check we are getting the correct layout from ItemView
292   DALI_TEST_CHECK(view.GetLayout(0) == gridLayout);
293   DALI_TEST_CHECK(view.GetLayout(1) == depthLayout);
294   DALI_TEST_CHECK(view.GetLayout(2) == spiralLayout);
295   END_TEST;
296 }
297
298 int UtcDaliItemViewAddAndRemoveLayout(void)
299 {
300   ToolkitTestApplication application;
301
302   // Create the ItemView actor
303   TestItemFactory factory;
304   ItemView view = ItemView::New(factory);
305
306   // Create a grid layout and add it to ItemView
307   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
308   view.AddLayout(*gridLayout);
309
310   // As we have added one layout, check the number of layout is now 1
311   DALI_TEST_CHECK(view.GetLayoutCount() == 1);
312
313   // Create a depth layout and add it to ItemView
314   ItemLayoutPtr depthLayout = DefaultItemLayout::New( DefaultItemLayout::DEPTH );
315   view.AddLayout(*depthLayout);
316
317   // As we have added another layout, check the number of layout is now 2
318   DALI_TEST_CHECK(view.GetLayoutCount() == 2);
319
320   // Check we are getting the correct layout from ItemView
321   DALI_TEST_CHECK(view.GetLayout(0) == gridLayout);
322   DALI_TEST_CHECK(view.GetLayout(1) == depthLayout);
323
324   // Remove the grid layout
325   view.RemoveLayout(0);
326
327   // As we have removed the grid layout, check the number of layout is now 1
328   DALI_TEST_CHECK(view.GetLayoutCount() == 1);
329
330   // Check we are getting the correct layout from ItemView
331   DALI_TEST_CHECK(view.GetLayout(0) == depthLayout);
332
333   // Remove the depth layout
334   view.RemoveLayout(0);
335
336   // As we also removed the depth layout, check the number of layout is now 0
337   DALI_TEST_CHECK(view.GetLayoutCount() == 0);
338   END_TEST;
339 }
340
341 int UtcDaliItemViewActivateLayoutAndGetActiveLayout(void)
342 {
343   ToolkitTestApplication application;
344
345   // Create the ItemView actor
346   TestItemFactory factory;
347   ItemView view = ItemView::New(factory);
348
349   // Create a grid layout and add it to ItemView
350   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
351   view.AddLayout(*gridLayout);
352
353   // Create a depth layout and add it to ItemView
354   ItemLayoutPtr depthLayout = DefaultItemLayout::New( DefaultItemLayout::DEPTH );
355   view.AddLayout(*depthLayout);
356
357   // Create a spiral layout and add it to ItemView
358   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
359   view.AddLayout(*spiralLayout);
360
361   // As we have added three layouts, check the number of layout is now 3
362   DALI_TEST_CHECK(view.GetLayoutCount() == 3);
363
364   // Check there is no active layout at the moment
365   DALI_TEST_CHECK(view.GetActiveLayout() == NULL);
366
367   // Activate the depth layout
368   Vector3 stageSize(application.GetScene().GetSize());
369   view.ActivateLayout(1, stageSize, 0.5f);
370
371   // Check the current active layout is the depth layout
372   DALI_TEST_CHECK(view.GetActiveLayout() == depthLayout);
373
374   // Activate the grid layout
375   view.ActivateLayout(0, stageSize, 0.5f);
376
377   // Check the current active layout is the grid layout
378   DALI_TEST_CHECK(view.GetActiveLayout() == gridLayout);
379
380   // Activate the spiral layout
381   view.ActivateLayout(2, stageSize, 0.5f);
382
383   // Check the current active layout is the spiral layout
384   DALI_TEST_CHECK(view.GetActiveLayout() == spiralLayout);
385   END_TEST;
386 }
387
388 int UtcDaliItemViewDeactivateCurrentLayout(void)
389 {
390   ToolkitTestApplication application;
391
392   // Create the ItemView actor
393   TestItemFactory factory;
394   ItemView view = ItemView::New(factory);
395
396   // Create a grid layout and add it to ItemView
397   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
398   gridLayout->SetOrientation(ControlOrientation::Down);
399   view.AddLayout(*gridLayout);
400
401   // Check there is no active layout at the moment
402   DALI_TEST_CHECK(view.GetActiveLayout() == NULL);
403
404   // Activate the grid layout
405   Vector3 stageSize(application.GetScene().GetSize());
406   view.ActivateLayout(0, stageSize, 0.5f);
407
408   // Check the current active layout is the grid layout
409   DALI_TEST_CHECK(view.GetActiveLayout() == gridLayout);
410
411   // Deactivate the current layout
412   view.DeactivateCurrentLayout();
413
414   // Check there is no active layout at the moment
415   DALI_TEST_CHECK(view.GetActiveLayout() == NULL);
416   END_TEST;
417 }
418
419 int UtcDaliItemViewGetItemAndGetItemId(void)
420 {
421   ToolkitTestApplication application;
422
423   // Create the ItemView actor
424   TestItemFactory factory;
425   ItemView view = ItemView::New(factory);
426
427   // Create a grid layout and add it to ItemView
428   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
429   gridLayout->SetOrientation(ControlOrientation::Left);
430   view.AddLayout(*gridLayout);
431
432   // Activate the grid layout so that the items will be created and added to ItemView
433   Vector3 stageSize(application.GetScene().GetSize());
434   view.ActivateLayout(0, stageSize, 0.5f);
435
436   // Get the item given the item ID
437   Actor itemActor = view.GetItem(2);
438
439   // Check we are getting the correct Item ID given the specified actor
440   DALI_TEST_CHECK(view.GetItemId(itemActor) == 2);
441   END_TEST;
442 }
443
444 int UtcDaliItemViewRemoveItem(void)
445 {
446   ToolkitTestApplication application;
447
448   // Create the ItemView actor
449   TestItemFactory factory;
450   ItemView view = ItemView::New(factory);
451
452   // Create a grid layout and add it to ItemView
453   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
454   gridLayout->SetOrientation(ControlOrientation::Right);
455   view.AddLayout(*gridLayout);
456
457   // Activate the grid layout so that the items will be created and added to ItemView
458   Vector3 stageSize(application.GetScene().GetSize());
459   view.ActivateLayout(0, stageSize, 0.5f);
460
461   // Get the item given the item ID 2 and 3
462   Actor oldItemActorID2 = view.GetItem(2);
463   Actor oldItemActorID3 = view.GetItem(3);
464
465   // Remove the item with ID 2
466   view.RemoveItem(2, 0.0f);
467
468   // Get the new item given the item ID 2 and 3
469   Actor newItemActorID2 = view.GetItem(2);
470   Actor newItemActorID3 = view.GetItem(3);
471
472   // Check the original item with item ID 2 was deleted and now item ID 2 represents the original item with ID 3
473   DALI_TEST_CHECK(view.GetItemId(newItemActorID2) == 2);
474   DALI_TEST_CHECK(oldItemActorID2 != newItemActorID2);
475   DALI_TEST_CHECK(newItemActorID2 == oldItemActorID3);
476
477   // scroll to the end of item view
478   view.ScrollToItem(TOTAL_ITEM_NUMBER - 1, 0.00f);
479
480   application.SendNotification();
481   application.Render(0);
482
483   // Refresh the item view
484   view.Refresh();
485
486   Actor itemActorID390 = view.GetItem(390);
487   DALI_TEST_CHECK(view.GetItemId(itemActorID390) == 390);
488
489   // Remove the item with ID 2 (which is now before the current item range)
490   view.RemoveItem(2, 0.0f);
491
492   // Check the original item with item ID 2 was deleted and now item ID 389 represents the original item with ID 390
493   DALI_TEST_CHECK(view.GetItemId(itemActorID390) == 389);
494   DALI_TEST_CHECK(view.GetItem(389) == itemActorID390);
495
496   END_TEST;
497 }
498
499 int UtcDaliItemViewGetCurrentLayoutPosition(void)
500 {
501   ToolkitTestApplication application;
502
503   // Create the ItemView actor
504   TestItemFactory factory;
505   ItemView view = ItemView::New(factory);
506
507   // Create a depth layout and add it to ItemView
508   ItemLayoutPtr depthLayout = DefaultItemLayout::New( DefaultItemLayout::DEPTH );
509   depthLayout->SetOrientation(ControlOrientation::Up);
510   view.AddLayout(*depthLayout);
511
512   // Activate the grid layout so that the items will be created and added to ItemView
513   Vector3 stageSize(application.GetScene().GetSize());
514   view.ActivateLayout(0, stageSize, 0.0f);
515
516   // Check the current layout position for the 10th items is 9.0f
517   DALI_TEST_EQUALS(view.GetCurrentLayoutPosition(9), 9.0f, TEST_LOCATION );
518   END_TEST;
519 }
520
521 int UtcDaliItemViewSetAndGetMinimumSwipeSpeed(void)
522 {
523   ToolkitTestApplication application;
524
525   // Create the ItemView actor
526   TestItemFactory factory;
527   ItemView view = ItemView::New(factory);
528
529   // Set the minimum swipe speed to be 1.5f
530   view.SetMinimumSwipeSpeed(1.5f);
531
532   // Check the minimum swipe speed is 1.5f
533   DALI_TEST_EQUALS(view.GetMinimumSwipeSpeed(), 1.5f, TEST_LOCATION );
534   END_TEST;
535 }
536
537 int UtcDaliItemViewSetAndGetMinimumSwipeDistance(void)
538 {
539   ToolkitTestApplication application;
540
541   // Create the ItemView actor
542   TestItemFactory factory;
543   ItemView view = ItemView::New(factory);
544
545   // Set the minimum swipe distance to be 2.5f
546   view.SetMinimumSwipeDistance(2.5f);
547
548   // Check the minimum swipe distance is 2.5f
549   DALI_TEST_EQUALS(view.GetMinimumSwipeDistance(), 2.5f, TEST_LOCATION );
550   END_TEST;
551 }
552
553 int UtcDaliItemViewSetAndGetAnchoring(void)
554 {
555   ToolkitTestApplication application;
556
557   // Create the ItemView actor
558   TestItemFactory factory;
559   ItemView view = ItemView::New(factory);
560
561   // Disable the anchor animation
562   view.SetAnchoring(false);
563
564   // Check the anchor animation is disabled
565   DALI_TEST_CHECK(view.GetAnchoring() == false);
566   END_TEST;
567 }
568
569 int UtcDaliItemViewSetAndGetAnchoringDuration(void)
570 {
571   ToolkitTestApplication application;
572
573   // Create the ItemView actor
574   TestItemFactory factory;
575   ItemView view = ItemView::New(factory);
576
577   // Set the duration of anchor animation to be 1.5f
578   view.SetAnchoringDuration(1.5f);
579
580   // Check the duration of anchor animation is 1.5f
581   DALI_TEST_EQUALS(view.GetAnchoringDuration(), 1.5f, TEST_LOCATION );
582   END_TEST;
583 }
584
585 int UtcDaliItemViewSetAndGetRefreshInterval(void)
586 {
587   ToolkitTestApplication application;
588
589   // Create the ItemView actor
590   TestItemFactory factory;
591   ItemView view = ItemView::New(factory);
592
593   // Set the interval between refreshes to be 20
594   view.SetRefreshInterval(20);
595
596   view.Refresh();
597
598   // Check the interval between refreshes is 20
599   DALI_TEST_CHECK(view.GetRefreshInterval() == 20);
600   END_TEST;
601 }
602
603 int UtcDaliItemViewScrollToItem(void)
604 {
605   ToolkitTestApplication application;
606
607   // Create the ItemView actor
608   TestItemFactory factory;
609   ItemView view = ItemView::New(factory);
610   Vector3 vec(480.0f, 800.0f, 0.0f);
611   ItemLayoutPtr layout = DefaultItemLayout::New( DefaultItemLayout::DEPTH );
612
613   view.SetProperty( Dali::Actor::Property::NAME,"view actor");
614   view.AddLayout(*layout);
615   view.SetProperty( Actor::Property::SIZE, vec );
616
617   application.GetScene().Add(view);
618   layout->SetOrientation(ControlOrientation::Down);
619   view.ActivateLayout(0, vec, 0.0f);
620
621   application.SendNotification();
622   application.Render(0);
623
624   // render 10 frames
625   for(int i = 0; i < 10; ++i)
626   {
627     application.Render(16); // 60hz frames
628   }
629
630   // Confirm: we have actors in the view.
631   std::vector<unsigned int> indices;
632   for(unsigned int i = 0; i < 10; i++)
633   {
634     Actor testActor = view.GetItem(i);
635     if (testActor)
636     {
637       indices.push_back(i);
638     }
639   }
640
641   try
642   {
643     if (!indices.empty())
644     {
645       const unsigned int firstTargetIndex = indices[indices.size()-1];
646       // scroll to last item
647       view.ScrollToItem(firstTargetIndex, 0.00f);
648       for(int i = 0; i < 10; ++i)
649       {
650         application.Render(16); // 60hz frames
651       }
652
653       std::size_t moveCount = 0;
654       for(std::size_t i = 0; i < indices.size(); i++)
655       {
656         float layoutPosBefore = view.GetCurrentLayoutPosition(i);
657         view.ScrollToItem(indices[i], 0.0f);
658         float layoutPosAfter = view.GetCurrentLayoutPosition(i);
659
660         if (fabs(layoutPosBefore-layoutPosAfter) <= FLT_EPSILON)
661         {
662           ++moveCount;
663         }
664       }
665
666       DALI_TEST_CHECK((moveCount == indices.size()));
667     }
668   }
669   catch(...)
670   {
671     tet_result(TET_FAIL);
672   }
673
674   application.GetScene().Remove(view);
675   END_TEST;
676 }
677
678 int UtcDaliItemViewSetAndGetWheelScrollDistanceStep(void)
679 {
680   ToolkitTestApplication application;
681
682   // Create the ItemView actor
683   TestItemFactory factory;
684   ItemView view = ItemView::New(factory);
685
686   // Set the scroll distance step for the wheel event to be 100.0f
687   view.SetWheelScrollDistanceStep(100.0f);
688
689   // Check the scroll distance step is 100.0f
690   DALI_TEST_EQUALS(view.GetWheelScrollDistanceStep(), 100.0f, TEST_LOCATION );
691   END_TEST;
692 }
693
694 int UtcDaliItemViewInsertItemP(void)
695 {
696   ToolkitTestApplication application;
697
698   // Create the ItemView actor
699   TestItemFactory factory;
700   ItemView view = ItemView::New(factory);
701
702   // Create a grid layout and add it to ItemView
703   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID);
704   gridLayout->SetOrientation(ControlOrientation::Left);
705   view.AddLayout(*gridLayout);
706
707   // Activate the grid layout so that the items will be created and added to ItemView
708   Vector3 stageSize(application.GetScene().GetSize());
709   view.ActivateLayout(0, stageSize, 0.0f);
710
711   // Get the specified item where new item to be inserted before that
712   Actor itemActor = view.GetItem(2);
713
714   ItemId id = view.GetItemId( itemActor );
715
716   // Check we are getting the correct Item ID given the specified actor
717   DALI_TEST_CHECK(view.GetItemId(itemActor) == 2);
718
719   Actor newActor = Actor::New();
720
721   view.InsertItem(Item(id, newActor), 0.0f);
722
723   DALI_TEST_CHECK(view.GetItem(2) == newActor);
724
725   DALI_TEST_CHECK(view.GetItemId(itemActor) == 3);
726   DALI_TEST_CHECK(view.GetItem(3) == itemActor);
727
728   // scroll to the end of item view
729   view.ScrollToItem(TOTAL_ITEM_NUMBER - 1, 0.00f);
730
731   application.SendNotification();
732   application.Render(0);
733
734   // Refresh the item view
735   view.Refresh();
736
737   Actor itemActorID390 = view.GetItem(390);
738   DALI_TEST_CHECK(view.GetItemId(itemActorID390) == 390);
739
740   // Insert the item with ID 2 (which is now before the current item range)
741   Actor anotherNewActor = Actor::New();
742   view.InsertItem(Item(id, anotherNewActor), 0.0f);
743
744   // Check that item ID 391 now represents the original item with ID 390
745   DALI_TEST_CHECK(view.GetItemId(itemActorID390) == 391);
746   DALI_TEST_CHECK(view.GetItem(391) == itemActorID390);
747
748   END_TEST;
749 }
750
751 int UtcDaliItemViewInsertItemsP(void)
752 {
753   ToolkitTestApplication application;
754
755   // Create the ItemView actor
756   TestItemFactory factory;
757   ItemView view = ItemView::New(factory);
758
759   // Create a depth layout and add it to ItemView
760   ItemLayoutPtr depthLayout = DefaultItemLayout::New( DefaultItemLayout::DEPTH);
761   depthLayout->SetOrientation(ControlOrientation::Right);
762   view.AddLayout(*depthLayout);
763
764   // Activate the grid layout so that the items will be created and added to ItemView
765   Vector3 stageSize(application.GetScene().GetSize());
766   view.ActivateLayout(0, stageSize, 0.5f);
767
768   unsigned int itemCount = view.GetChildCount();
769
770   // Get the specified item where new items to be inserted before that
771   Actor itemActor = view.GetItem(1);
772
773   // Check we are getting the correct Item ID given the specified item
774   DALI_TEST_CHECK(view.GetItemId(itemActor) == 1);
775
776   ItemContainer insertList;
777
778   for( unsigned int i = 1u; i < 11; ++i )
779   {
780     Actor child = view.GetChildAt( i );
781     Actor newActor = Actor::New();
782     newActor.SetProperty( Dali::Actor::Property::NAME,"Inserted");
783     insertList.push_back( Item( view.GetItemId(child), newActor ) );
784   }
785
786   if( !insertList.empty() )
787   {
788     view.InsertItems( insertList, 0.5f );
789   }
790
791   DALI_TEST_CHECK(view.GetChildCount() == itemCount + 10);
792
793   // Check that new items are inserted in the correct positions
794   DALI_TEST_CHECK(view.GetItemId(itemActor) == 11);
795   DALI_TEST_CHECK(view.GetItem(11) == itemActor);
796
797   ItemIdContainer removeList;
798
799   for( unsigned int i = 0u; i < view.GetChildCount(); ++i )
800   {
801     Actor child = view.GetChildAt( i );
802
803     if( child.GetProperty< std::string >( Dali::Actor::Property::NAME ) == "Inserted" )
804     {
805       removeList.push_back( view.GetItemId(child) );
806     }
807   }
808
809   if( ! removeList.empty() )
810   {
811     view.RemoveItems( removeList, 0.5f );
812   }
813
814   DALI_TEST_CHECK(view.GetChildCount() == itemCount);
815
816   // Check that new items are removed correctly so that we are getting the correct Item ID given the specified item
817   DALI_TEST_CHECK(view.GetItemId(itemActor) == 1);
818   DALI_TEST_CHECK(view.GetItem(1) == itemActor);
819
820   END_TEST;
821 }
822
823 int UtcDaliItemViewReplaceItemP(void)
824 {
825   ToolkitTestApplication application;
826
827   // Create the ItemView actor
828   TestItemFactory factory;
829   ItemView view = ItemView::New(factory);
830
831   // Create a spiral layout and add it to ItemView
832   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
833   view.AddLayout(*spiralLayout);
834
835   // Activate the grid layout so that the items will be created and added to ItemView
836   Vector3 stageSize(application.GetScene().GetSize());
837   view.ActivateLayout(0, stageSize, 0.5f);
838
839   Actor newActor = Actor::New();
840
841   view.ReplaceItem( Item( 5, newActor ), 0.5f );
842
843   DALI_TEST_CHECK(view.GetItem(5) == newActor);
844
845   END_TEST;
846 }
847
848 int UtcDaliItemViewReplaceItemsP(void)
849 {
850   ToolkitTestApplication application;
851
852   // Create the ItemView actor
853   TestItemFactory factory;
854   ItemView view = ItemView::New(factory);
855
856   // Create a spiral layout and add it to ItemView
857   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
858   spiralLayout->SetOrientation( ControlOrientation::Down );
859   view.AddLayout(*spiralLayout);
860
861   // Activate the grid layout so that the items will be created and added to ItemView
862   Vector3 stageSize(application.GetScene().GetSize());
863   view.ActivateLayout(0, stageSize, 0.5f);
864
865   ItemContainer replaceList;
866
867   for( unsigned int i = 0u; i < 10; ++i )
868   {
869     Actor child = view.GetItem( i );
870     Actor newActor = Actor::New();
871     newActor.SetProperty( Dali::Actor::Property::NAME,"Replaced");
872
873     replaceList.push_back( Item( i, newActor ) );
874   }
875
876   if( !replaceList.empty() )
877   {
878     view.ReplaceItems( replaceList, 0.5f );
879   }
880
881   DALI_TEST_CHECK(view.GetItem(0).GetProperty< std::string >( Dali::Actor::Property::NAME ) == "Replaced");
882   DALI_TEST_CHECK(view.GetItem(8).GetProperty< std::string >( Dali::Actor::Property::NAME ) == "Replaced");
883   END_TEST;
884 }
885
886 int UtcDaliItemViewGetItemsRangeP(void)
887 {
888   ToolkitTestApplication application;
889
890   // Create the ItemView actor
891   TestItemFactory factory;
892   ItemView view = ItemView::New(factory);
893
894   // Create a spiral layout and add it to ItemView
895   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
896   spiralLayout->SetOrientation( ControlOrientation::Left );
897   view.AddLayout(*spiralLayout);
898
899   // Activate the grid layout so that the items will be created and added to ItemView
900   Vector3 stageSize(application.GetScene().GetSize());
901   view.ActivateLayout(0, stageSize, 0.5f);
902
903   ItemRange itemRange(0, 0);
904
905   view.GetItemsRange(itemRange);
906
907   DALI_TEST_CHECK(itemRange.Within(0));
908   END_TEST;
909 }
910
911 int UtcDaliItemViewSetItemsAnchorPointP(void)
912 {
913   ToolkitTestApplication application;
914
915   // Create the ItemView actor
916   TestItemFactory factory;
917   ItemView view = ItemView::New(factory);
918
919   // Create a spiral layout and add it to ItemView
920   ItemLayoutPtr spiralLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
921   spiralLayout->SetOrientation( ControlOrientation::Right );
922   view.AddLayout(*spiralLayout);
923
924   // Activate the grid layout so that the items will be created and added to ItemView
925   Vector3 stageSize(application.GetScene().GetSize());
926   view.ActivateLayout(0, stageSize, 0.5f);
927
928   Vector3 anchorPoint(10.0f, 10.0f, 0.0f);
929
930   view.SetItemsAnchorPoint(anchorPoint);
931
932   DALI_TEST_CHECK(view.GetItemsAnchorPoint() == anchorPoint);
933   DALI_TEST_CHECK(view.GetItem(0).GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ) == anchorPoint);
934   END_TEST;
935 }
936
937 int UtcDaliItemViewSetItemsParentOriginP(void)
938 {
939   ToolkitTestApplication application;
940
941   // Create the ItemView actor
942   TestItemFactory factory;
943   ItemView view = ItemView::New(factory);
944
945   // Create a grid layout and add it to ItemView
946   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
947   view.AddLayout(*gridLayout);
948
949   // Activate the grid layout so that the items will be created and added to ItemView
950   Vector3 stageSize(application.GetScene().GetSize());
951   view.ActivateLayout(0, stageSize, 0.5f);
952
953   Vector3 parentOrigin(10.0f, 10.0f, 0.0f);
954
955   view.SetItemsParentOrigin(parentOrigin);
956
957   DALI_TEST_CHECK(view.GetItemsParentOrigin() == parentOrigin);
958   DALI_TEST_CHECK(view.GetItem(0).GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ) == parentOrigin);
959   END_TEST;
960 }
961
962 int UtcDaliItemFactoryGetExtention(void)
963 {
964   ToolkitTestApplication application;
965   TestItemFactory factory;
966   DALI_TEST_CHECK( factory.GetExtension() == NULL );
967   END_TEST;
968 }
969
970 int UtcDaliItemViewLayoutActivatedSignalP(void)
971 {
972   ToolkitTestApplication application;
973
974   // Create the ItemView actor
975   TestItemFactory factory;
976   ItemView view = ItemView::New(factory);
977
978   // Create a grid layout and add it to ItemView
979   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
980   view.AddLayout(*gridLayout);
981
982   application.GetScene().Add( view );
983
984   // Connect the layout activated signal
985   view.LayoutActivatedSignal().Connect( &OnLayoutActivated );
986
987   gOnLayoutActivatedCalled = false;
988
989   // Render and notify
990   application.SendNotification();
991   application.Render();
992
993   // Activate the grid layout so that the items will be created and added to ItemView
994   Vector3 stageSize(application.GetScene().GetSize());
995   view.ActivateLayout(0, stageSize, 0.1f);
996
997   // Wait for 0.1 second
998   Wait(application, 100);
999
1000   DALI_TEST_EQUALS( gOnLayoutActivatedCalled, true, TEST_LOCATION );
1001
1002   END_TEST;
1003 }
1004
1005 int UtcDaliItemViewSetGetProperty(void)
1006 {
1007   ToolkitTestApplication application;
1008
1009   // Create the ItemView actor
1010   TestItemFactory factory;
1011   ItemView view = ItemView::New(factory);
1012   DALI_TEST_CHECK(view);
1013
1014   // Event side properties
1015
1016   // Test "minimumSwipeSpeed" property
1017   DALI_TEST_CHECK( view.GetPropertyIndex("minimumSwipeSpeed") == ItemView::Property::MINIMUM_SWIPE_SPEED  );
1018   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::MINIMUM_SWIPE_SPEED).Get<float>(), view.GetMinimumSwipeSpeed(), TEST_LOCATION );
1019   view.SetProperty( ItemView::Property::MINIMUM_SWIPE_SPEED, 2.5f );
1020   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::MINIMUM_SWIPE_SPEED).Get<float>(), 2.5f, TEST_LOCATION );
1021
1022   // Test "minimumSwipeDistance" property
1023   DALI_TEST_CHECK( view.GetPropertyIndex("minimumSwipeDistance") == ItemView::Property::MINIMUM_SWIPE_DISTANCE  );
1024   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::MINIMUM_SWIPE_DISTANCE).Get<float>(), view.GetMinimumSwipeDistance(), TEST_LOCATION );
1025   view.SetProperty( ItemView::Property::MINIMUM_SWIPE_DISTANCE, 8.725f );
1026   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::MINIMUM_SWIPE_DISTANCE).Get<float>(), 8.725f, TEST_LOCATION );
1027
1028   // Test "wheelScrollDistanceStep" property
1029   DALI_TEST_CHECK( view.GetPropertyIndex("wheelScrollDistanceStep") == ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP  );
1030   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP).Get<float>(), view.GetWheelScrollDistanceStep(), TEST_LOCATION );
1031   view.SetProperty( ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP, 5.0f );
1032   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP).Get<float>(), 5.0f, TEST_LOCATION );
1033
1034   // Test "snapToItemEnabled" property
1035   DALI_TEST_CHECK( view.GetPropertyIndex("snapToItemEnabled") == ItemView::Property::SNAP_TO_ITEM_ENABLED  );
1036   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::SNAP_TO_ITEM_ENABLED).Get<bool>(), view.GetAnchoring(), TEST_LOCATION );
1037   view.SetProperty( ItemView::Property::SNAP_TO_ITEM_ENABLED, true );
1038   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::SNAP_TO_ITEM_ENABLED).Get<bool>(), true, TEST_LOCATION );
1039
1040   // Test "refreshInterval" property
1041   DALI_TEST_CHECK( view.GetPropertyIndex("refreshInterval") == ItemView::Property::REFRESH_INTERVAL  );
1042   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::REFRESH_INTERVAL).Get<float>(), view.GetRefreshInterval(), TEST_LOCATION );
1043   view.SetProperty( ItemView::Property::REFRESH_INTERVAL, 11.0f );
1044   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::REFRESH_INTERVAL).Get<float>(), 11.0f, TEST_LOCATION );
1045
1046   // Test "layout" property
1047   DALI_TEST_CHECK( view.GetPropertyIndex("layout") == ItemView::Property::LAYOUT  );
1048   Property::Map gridLayoutProperty;
1049   gridLayoutProperty.Insert( DefaultItemLayoutProperty::TYPE, Dali::Property::Value((int)DefaultItemLayout::GRID) );
1050   gridLayoutProperty.Insert( DefaultItemLayoutProperty::ITEM_SIZE, Dali::Property::Value(Vector3(200, 200,50)) );
1051   gridLayoutProperty.Insert( DefaultItemLayoutProperty::GRID_ROW_SPACING, Dali::Property::Value(50.0f) );
1052   gridLayoutProperty.Insert( DefaultItemLayoutProperty::GRID_COLUMN_NUMBER, Dali::Property::Value(4) );
1053
1054   Property::Map depthLayoutProperty;
1055   depthLayoutProperty.Insert( DefaultItemLayoutProperty::TYPE, Dali::Property::Value((int)DefaultItemLayout::DEPTH) );
1056   depthLayoutProperty.Insert( DefaultItemLayoutProperty::DEPTH_COLUMN_NUMBER, Dali::Property::Value(3) );
1057   depthLayoutProperty.Insert( DefaultItemLayoutProperty::DEPTH_ROW_NUMBER, Dali::Property::Value(26.0f) );
1058
1059   Property::Map spiralLayoutPrperty;
1060   spiralLayoutPrperty.Insert( DefaultItemLayoutProperty::TYPE, Dali::Property::Value((int)DefaultItemLayout::SPIRAL) );
1061   spiralLayoutPrperty.Insert( DefaultItemLayoutProperty::SPIRAL_ITEM_SPACING, Dali::Property::Value((Math::PI*2.0f)/9.5f) );
1062   spiralLayoutPrperty.Insert( DefaultItemLayoutProperty::SPIRAL_TOP_ITEM_ALIGNMENT, Dali::Property::Value(-0.125f) );
1063
1064   Property::Map listLayoutPrperty;
1065   listLayoutPrperty.Insert( DefaultItemLayoutProperty::TYPE, Dali::Property::Value((int)DefaultItemLayout::LIST) );
1066   listLayoutPrperty.Insert( DefaultItemLayoutProperty::ITEM_SIZE, Dali::Property::Value(Vector3(100, 100,50)) );
1067
1068
1069   Property::Array layoutArray;
1070   layoutArray.PushBack(gridLayoutProperty);
1071   layoutArray.PushBack(depthLayoutProperty);
1072   layoutArray.PushBack(spiralLayoutPrperty);
1073   layoutArray.PushBack(listLayoutPrperty);
1074
1075   view.SetProperty( ItemView::Property::LAYOUT, layoutArray);
1076
1077   Property::Array getLayoutArray;
1078   DALI_TEST_CHECK( view.GetProperty( ItemView::Property::LAYOUT ).Get( getLayoutArray ) );
1079
1080   //Check that the result is the same as
1081   DALI_TEST_EQUALS( layoutArray.Count(), getLayoutArray.Count(), TEST_LOCATION );
1082   Property::Map firstLayout = *((getLayoutArray.GetElementAt( 0 )).GetMap());
1083
1084   for( unsigned int mapIdx = 0, mapCount = firstLayout.Count(); mapIdx < mapCount; ++mapIdx )
1085   {
1086     KeyValuePair propertyPair( firstLayout.GetKeyValue( mapIdx ) );
1087     if(propertyPair.first == DefaultItemLayoutProperty::TYPE)
1088     {
1089       int layoutType = propertyPair.second.Get<int>();
1090       DALI_TEST_EQUALS( layoutType, (int)DefaultItemLayout::GRID, TEST_LOCATION );
1091     }
1092     else if(propertyPair.first == DefaultItemLayoutProperty::ITEM_SIZE)
1093     {
1094       Vector3 size = propertyPair.second.Get<Vector3>();
1095       DALI_TEST_EQUALS( size, Vector3(200, 200,50), TEST_LOCATION );
1096     }
1097     else if(propertyPair.first == DefaultItemLayoutProperty::GRID_ROW_SPACING)
1098     {
1099       float spacing = propertyPair.second.Get<float>();
1100       DALI_TEST_EQUALS( spacing, 50.0f, TEST_LOCATION );
1101     }
1102     else if(propertyPair.first == DefaultItemLayoutProperty::GRID_COLUMN_NUMBER)
1103     {
1104       int number = propertyPair.second.Get<int>();
1105       DALI_TEST_EQUALS(number, 4, TEST_LOCATION );
1106     }
1107   }
1108   view.SetProperty( ItemView::Property::LAYOUT, layoutArray);
1109
1110
1111   // Test "overshootEnabled" property
1112   DALI_TEST_CHECK( view.GetPropertyIndex("overshootEnabled") == Scrollable::Property::OVERSHOOT_ENABLED  );
1113   DALI_TEST_EQUALS( view.GetProperty(Scrollable::Property::OVERSHOOT_ENABLED).Get<bool>(), view.IsOvershootEnabled(), TEST_LOCATION );
1114   view.SetProperty( Scrollable::Property::OVERSHOOT_ENABLED, false );
1115   DALI_TEST_EQUALS( view.GetProperty(Scrollable::Property::OVERSHOOT_ENABLED).Get<bool>(), false, TEST_LOCATION );
1116
1117   // Test "overshootSize" property
1118   DALI_TEST_CHECK( view.GetPropertyIndex("overshootSize") == Scrollable::Property::OVERSHOOT_SIZE  );
1119   Vector2 overshootSize = Vector2(100.0f,100.0f);
1120   view.SetProperty( Scrollable::Property::OVERSHOOT_SIZE, overshootSize );
1121   DALI_TEST_EQUALS( view.GetProperty(Scrollable::Property::OVERSHOOT_SIZE).Get<Vector2>(), overshootSize, TEST_LOCATION );
1122
1123   // Animatable properties
1124
1125   // Test "layoutPosition" property
1126   DALI_TEST_CHECK( view.GetPropertyIndex("layoutPosition") == ItemView::Property::LAYOUT_POSITION  );
1127   view.SetProperty( ItemView::Property::LAYOUT_POSITION, 20.5f );
1128   Wait(application);
1129   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::LAYOUT_POSITION).Get<float>(), 20.5f, TEST_LOCATION );
1130
1131   // Test "scrollSpeed" property
1132   DALI_TEST_CHECK( view.GetPropertyIndex("scrollSpeed") == ItemView::Property::SCROLL_SPEED  );
1133   view.SetProperty( ItemView::Property::SCROLL_SPEED, 3.35f );
1134   Wait(application);
1135   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::SCROLL_SPEED).Get<float>(), 3.35f, TEST_LOCATION );
1136
1137   // Test "overshoot" property
1138   DALI_TEST_CHECK( view.GetPropertyIndex("overshoot") == ItemView::Property::OVERSHOOT  );
1139   view.SetProperty( ItemView::Property::OVERSHOOT, 0.15f );
1140   Wait(application);
1141   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::OVERSHOOT).Get<float>(), 0.15f, TEST_LOCATION );
1142
1143   // Test "scrollDirection" property
1144   DALI_TEST_CHECK( view.GetPropertyIndex("scrollDirection") == ItemView::Property::SCROLL_DIRECTION  );
1145   view.SetProperty( ItemView::Property::SCROLL_DIRECTION, Vector2(0.85f, 0.5f) );
1146   Wait(application);
1147   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::SCROLL_DIRECTION).Get<Vector2>(), Vector2(0.85f, 0.5f), TEST_LOCATION );
1148
1149   // Test "layoutOrientation" property
1150   DALI_TEST_CHECK( view.GetPropertyIndex("layoutOrientation") == ItemView::Property::LAYOUT_ORIENTATION  );
1151   view.SetProperty( ItemView::Property::LAYOUT_ORIENTATION, 2 );
1152   Wait(application);
1153   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::LAYOUT_ORIENTATION).Get<int>(), 2, TEST_LOCATION );
1154
1155   // Test "scrollContentSize" property
1156   DALI_TEST_CHECK( view.GetPropertyIndex("scrollContentSize") == ItemView::Property::SCROLL_CONTENT_SIZE  );
1157   view.SetProperty( ItemView::Property::SCROLL_CONTENT_SIZE, 250.0f );
1158   Wait(application);
1159   DALI_TEST_EQUALS( view.GetProperty(ItemView::Property::SCROLL_CONTENT_SIZE).Get<float>(), 250.0f, TEST_LOCATION );
1160
1161   END_TEST;
1162 }
1163
1164
1165 int UtcDaliItemViewOvershootVertical(void)
1166 {
1167   ToolkitTestApplication application;
1168   Dali::Integration::Scene stage = application.GetScene();
1169
1170   // Create the ItemView actor
1171   TestItemFactory factory;
1172   ItemView view = ItemView::New(factory);
1173
1174   // Create a grid layout and add it to ItemView
1175   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
1176   view.AddLayout(*gridLayout);
1177   stage.Add(view);
1178
1179   // Activate the grid layout so that the items will be created and added to ItemView
1180   Vector3 stageSize(stage.GetSize());
1181   view.ActivateLayout(0, stageSize, 0.5f);
1182
1183   view.SetProperty( Scrollable::Property::OVERSHOOT_ENABLED, true );
1184   DALI_TEST_EQUALS( view.GetProperty(Scrollable::Property::OVERSHOOT_ENABLED).Get<bool>(), true, TEST_LOCATION );
1185
1186   view.SetProperty( Scrollable::Property::OVERSHOOT_SIZE, Vector2(30, 30) );
1187
1188   Wait(application);
1189
1190   // Do a pan starting from 100,100 and moving down
1191   Vector2 pos(100.0f, 100.0f);
1192
1193   application.ProcessEvent( GenerateSingleTouch(PointState::DOWN, pos, 100 ) );
1194   application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1195
1196   pos.y += 5.0f;
1197   Wait(application, 100);
1198
1199   for(int i = 0;i<200;i++)
1200   {
1201     application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1202     pos.y += 5.0f;
1203     Wait(application);
1204   }
1205
1206   application.ProcessEvent( GenerateSingleTouch(PointState::UP, pos, 100 ) );
1207
1208   Wait(application, 100);
1209
1210   // Do a pan starting from 100,100 and moving up
1211   pos = Vector2(100.0f, 300.0f);
1212
1213   application.ProcessEvent( GenerateSingleTouch(PointState::DOWN, pos, 100 ) );
1214   application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1215
1216   pos.y -= 5.0f;
1217   Wait(application, 100);
1218
1219   for(int i = 0;i<200;i++)
1220   {
1221     application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1222     pos.y -= 5.0f;
1223     Wait(application);
1224   }
1225
1226   application.ProcessEvent( GenerateSingleTouch(PointState::UP, pos, 100 ) );
1227   Wait(application, 100);
1228   END_TEST;
1229 }
1230
1231 int UtcDaliItemViewOvershootHorizontal(void)
1232 {
1233   ToolkitTestApplication application;
1234   Dali::Integration::Scene stage = application.GetScene();
1235
1236   // Create the ItemView actor
1237   TestItemFactory factory;
1238   ItemView view = ItemView::New(factory);
1239
1240   // Create a grid layout and add it to ItemView
1241   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::SPIRAL );
1242   view.AddLayout(*gridLayout);
1243   stage.Add(view);
1244
1245   // Activate the grid layout so that the items will be created and added to ItemView
1246   Vector3 stageSize(stage.GetSize());
1247   view.ActivateLayout(0, stageSize, 0.5f);
1248
1249   view.SetProperty( Scrollable::Property::OVERSHOOT_ENABLED, true );
1250   DALI_TEST_EQUALS( view.GetProperty(Scrollable::Property::OVERSHOOT_ENABLED).Get<bool>(), true, TEST_LOCATION );
1251
1252   view.SetProperty( Scrollable::Property::OVERSHOOT_SIZE, Vector2(30, 30) );
1253
1254   Wait(application);
1255
1256   // Do a pan starting from 100,100 and moving left
1257   Vector2 pos(100.0f, 100.0f);
1258   application.ProcessEvent( GenerateSingleTouch(PointState::DOWN, pos, 100 ));
1259   application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ));
1260   pos.x -= 5.0f;
1261   Wait(application, 100);
1262
1263   for(int i = 0;i<200;i++)
1264   {
1265     application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1266     pos.x -= 5.0f;
1267     Wait(application);
1268   }
1269
1270   application.ProcessEvent( GenerateSingleTouch(PointState::UP, pos, 100 ) );
1271   Wait(application, 100);
1272
1273   // Do a pan starting from 100,100 and moving right
1274   pos = Vector2(100.0f, 100.0f);
1275   application.ProcessEvent( GenerateSingleTouch(PointState::DOWN, pos, 100 ) );
1276   application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1277   pos.x += 5.0f;
1278   Wait(application, 100);
1279
1280   for(int i = 0;i<200;i++)
1281   {
1282     application.ProcessEvent( GenerateSingleTouch(PointState::MOTION, pos, 100 ) );
1283     pos.x += 5.0f;
1284     Wait(application);
1285   }
1286
1287   application.ProcessEvent( GenerateSingleTouch(PointState::UP, pos, 100 ) );
1288   Wait(application, 100);
1289
1290   END_TEST;
1291 }
1292
1293 int UtcDaliItemEnableDisableRefresh(void)
1294 {
1295   ToolkitTestApplication application;
1296   Dali::Integration::Scene stage = application.GetScene();
1297
1298   // Create the ItemView actor
1299   TestItemFactory factory;
1300   ItemView view = ItemView::New(factory);
1301
1302   // Create a grid layout and add it to ItemView
1303   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
1304   view.AddLayout(*gridLayout);
1305   stage.Add(view);
1306
1307   // Activate the grid layout so that the items will be created and added to ItemView
1308   Vector3 stageSize(stage.GetSize());
1309   view.ActivateLayout(0, stageSize, 0.5f);
1310
1311   //Connect to signal scroll updated
1312   view.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
1313
1314   Property::Map attributes;
1315   view.DoAction("enableRefresh", attributes );
1316   gOnScrollUpdateCalled = true;
1317   view.SetProperty( ItemView::Property::LAYOUT_POSITION, 100.0f );
1318   application.SendNotification();
1319   application.Render(1000);
1320   DALI_TEST_EQUALS( gOnScrollUpdateCalled, true, TEST_LOCATION );
1321
1322
1323   view.DoAction("disableRefresh", attributes );
1324   gOnScrollUpdateCalled = false;
1325   view.SetProperty( ItemView::Property::LAYOUT_POSITION, 100.0f );
1326   application.SendNotification();
1327   application.Render(1000);
1328
1329   DALI_TEST_EQUALS( gOnScrollUpdateCalled, false, TEST_LOCATION );
1330
1331   END_TEST;
1332 }
1333
1334 int UtcDaliItemViewWheelEvent(void)
1335 {
1336   ToolkitTestApplication application;
1337   Dali::Integration::Scene stage = application.GetScene();
1338
1339   // Create the ItemView actor
1340   TestItemFactory factory;
1341   ItemView view = ItemView::New( factory );
1342
1343   // Create a grid layout and add it to ItemView
1344   ItemLayoutPtr gridLayout = DefaultItemLayout::New( DefaultItemLayout::GRID );
1345   view.AddLayout( *gridLayout );
1346   stage.Add( view );
1347
1348   // Activate the grid layout so that the items will be created and added to ItemView
1349   Vector3 stageSize( stage.GetSize() );
1350   view.ActivateLayout (0, stageSize, 0.5f );
1351
1352   //Connect to wheel event signal
1353   view.WheelEventSignal().Connect( &OnWheelEvent );
1354
1355   DALI_TEST_CHECK( !gOnWheelEventCalled );
1356
1357   // Render and notify
1358   application.Render();
1359   application.SendNotification();
1360   application.Render();
1361   application.SendNotification();
1362
1363   // Perform a wheel event
1364   Dali::Integration::WheelEvent wheelEvent( Dali::Integration::WheelEvent::MOUSE_WHEEL, 0, 0u, Vector2( 10.0f, 10.0f ), 1, 1000u );
1365   application.ProcessEvent( wheelEvent );
1366   DALI_TEST_CHECK( gOnWheelEventCalled );
1367
1368   END_TEST;
1369 }