From: junqing.ma Date: Sun, 30 Sep 2018 02:26:35 +0000 (+0800) Subject: add drag&drop support in actor level X-Git-Tag: dali_1.3.53~1^2 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=6e8f8dee9c5f4e9d78e1060dfd642f57ff8f754e;hp=8a313bb71bb0d1b443e2b5d7f383155433d385e0 add drag&drop support in actor level Change-Id: I6d97964a68b6c9b3d8f13e6b3515df1e60695d73 --- diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index fe9102e..e0b1cab 100755 --- a/automated-tests/src/dali-toolkit/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit/CMakeLists.txt @@ -76,6 +76,7 @@ SET(TC_SOURCES utc-Dali-AsyncImageLoader.cpp utc-Dali-SyncImageLoader.cpp utc-Dali-ControlWrapper.cpp + utc-Dali-DragAndDropDetector.cpp ) # Append list of test harness files (Won't get parsed for test cases) diff --git a/automated-tests/src/dali-toolkit/utc-Dali-DragAndDropDetector.cpp b/automated-tests/src/dali-toolkit/utc-Dali-DragAndDropDetector.cpp new file mode 100755 index 0000000..8e574b4 --- /dev/null +++ b/automated-tests/src/dali-toolkit/utc-Dali-DragAndDropDetector.cpp @@ -0,0 +1,607 @@ +/* + * Copyright (c) 2018 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. + * + */ + +#include +#include + +// Need to override adaptor classes for toolkit test harness, so include +// test harness headers before dali headers. +#include + +#include +#include +#include + +using namespace Dali; +using namespace Dali::Toolkit; + +void utc_dali_toolkit_drag_drop_detector_startup(void) +{ + test_return_value = TET_UNDEF; +} + +void utc_dali_toolkit_drag_drop_detector_cleanup(void) +{ + test_return_value = TET_PASS; +} + +namespace +{ + const int RENDER_FRAME_INTERVAL = 16; + struct SignalData + { + SignalData() + :functorCalled(false), + control(), + detector() + { + } + + void Reset() + { + functorCalled = false; + control.Reset(); + } + + bool functorCalled; + Control control; + Dali::Toolkit::DragAndDropDetector detector; + }; + + struct DragSignalFunctor + { + DragSignalFunctor(SignalData& data, bool returnValue = true) + :signalData(data), + returnValue(returnValue) + { + } + + bool operator()(Control control, Dali::Toolkit::DragAndDropDetector detector) + { + signalData.functorCalled = true; + signalData.control = control; + signalData.detector = detector; + return returnValue; + } + + SignalData& signalData; + bool returnValue; + }; + + Integration::TouchEvent GenerateSingleTouch(TouchPoint::State state, const Vector2& screenPosition) + { + Integration::TouchEvent touchEvent; + Integration::Point point; + point.SetState(static_cast(state)); + point.SetScreenPosition(screenPosition); + touchEvent.points.push_back(point); + return touchEvent; + } + + Integration::PanGestureEvent GeneratePan( + Gesture::State state, + Vector2 previousPosition, + Vector2 currentPosition, + unsigned long timeDelta, + unsigned int numberOfTouches = 1, + unsigned int time = 1u) + { + Integration::PanGestureEvent pan(state); + pan.previousPosition = previousPosition; + pan.currentPosition = currentPosition; + pan.timeDelta = timeDelta; + pan.numberOfTouches = numberOfTouches; + pan.time = time; + + return pan; + } + +} + +int UtcDaliDragAndDropDetectorConstructorN(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector; + DALI_TEST_CHECK(!detector); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorConstructorP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + DALI_TEST_CHECK(detector); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorAttachN(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control; + detector.Attach(control); + + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + Control control1 = Control::New(); + detector.Attach(control1); + DALI_TEST_EQUALS(1, detector.GetAttachedControlCount(), TEST_LOCATION); + detector.Attach(control1); + DALI_TEST_EQUALS(1, detector.GetAttachedControlCount(), TEST_LOCATION); + END_TEST; +} + +int UtcDaliDragAndDropDetectorAttachP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control = Control::New(); + + detector.Attach(control); + DALI_TEST_EQUALS(1, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorDetachN(void) + { + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1; + Control control2 = Control::New(); + + detector.Attach(control1); + detector.Attach(control2); + DALI_TEST_EQUALS(1, detector.GetAttachedControlCount(), TEST_LOCATION); + + detector.Detach(control2); + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + + detector.Detach(control1); + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; + +} + +int UtcDaliDragAndDropDetectorDetachP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + Control control3; + + detector.Attach(control1); + detector.Attach(control2); + detector.Attach(control3); + + DALI_TEST_EQUALS(2, detector.GetAttachedControlCount(), TEST_LOCATION); + + detector.Detach(control3); + DALI_TEST_EQUALS(2, detector.GetAttachedControlCount(), TEST_LOCATION); + detector.Detach(control2); + DALI_TEST_EQUALS(1, detector.GetAttachedControlCount(), TEST_LOCATION); + + detector.Detach(control1); + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorDetachAllN(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + detector.DetachAll(); + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; +} +int UtcDaliDragAndDropDetectorDetachAllP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + + detector.Attach(control1); + detector.Attach(control2); + detector.DetachAll(); + DALI_TEST_EQUALS(0, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorGetAttachedControlCountP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + + detector.Attach(control1); + detector.Attach(control2); + DALI_TEST_EQUALS(2, detector.GetAttachedControlCount(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorGetAttachedControlN(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + + detector.Attach(control1); + + Control control = detector.GetAttachedControl(1); + DALI_TEST_CHECK(!control); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorGetAttachedControlP(void) +{ + ToolkitTestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + + detector.Attach(control1); + detector.Attach(control2); + Control control = detector.GetAttachedControl(1); + DALI_TEST_CHECK(control); + DALI_TEST_EQUALS(control2, control, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorStartSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control = Control::New(); + control.SetSize(100.0f, 100.0f); + control.SetAnchorPoint(AnchorPoint::TOP_LEFT); + Stage::GetCurrent().Add(control); + detector.Attach(control); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + DALI_TEST_CHECK(detector); + DALI_TEST_CHECK(control); + + SignalData data; + DragSignalFunctor functor(data); + detector.StartedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control, data.control, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION); + data.Reset(); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorEnteredSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + detector.Attach(control1); + detector.Attach(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + SignalData data; + DragSignalFunctor functor(data); + detector.EnteredSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 110.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control2, data.control, TEST_LOCATION); + + data.Reset(); + + END_TEST; + +} + +int UtcDaliDragAndDropDetectorMovedSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + detector.Attach(control1); + detector.Attach(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + SignalData data; + DragSignalFunctor functor(data); + detector.MovedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 110.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 120.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2(10.0f, 120.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION); + DALI_TEST_EQUALS(control2, data.control, TEST_LOCATION); + + data.Reset(); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorExitedSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + control1.SetLeaveRequired(true); + control2.SetLeaveRequired(true); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + detector.Attach(control1); + detector.Attach(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + SignalData data; + DragSignalFunctor functor(data); + detector.ExitedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 110.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + screenCoordinates.x = 20.0f; + screenCoordinates.y = 20.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control2, data.control, TEST_LOCATION); + + data.Reset(); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorDroppedSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + detector.Attach(control1); + detector.Attach(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + SignalData data; + DragSignalFunctor functor(data); + detector.DroppedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 110.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 112.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Up, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control2, data.control, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2(10.0f, 112.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION); + DALI_TEST_EQUALS(true, detector.GetContent().empty(), TEST_LOCATION); + + data.Reset(); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorEndedSignal(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + detector.Attach(control1); + detector.Attach(control2); + + SignalData data; + DragSignalFunctor functor(data); + detector.EndedSignal().Connect(&application, functor); + + application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10)); + application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10)); + + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, Vector2(10.0f, 10.0f))); + + application.ProcessEvent(GeneratePan(Gesture::Continuing, Vector2(10.0f, 10.0f), Vector2(120.0f, 12.0f), 10)); + application.ProcessEvent(GeneratePan(Gesture::Finished, Vector2(120.0f, 12.0f), Vector2(120.0f, 20.0f), 10)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control1, data.control, TEST_LOCATION); + data.Reset(); + + END_TEST; +} + +int UtcDaliDragAndDropDetectorGetContent(void) +{ + TestApplication application; + + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New(); + Control control1 = Control::New(); + Control control2 = Control::New(); + control1.SetName("control1"); + control2.SetName("control2"); + control1.SetSize(100.0f,100.0f); + control2.SetSize(100.0f, 100.0f); + control1.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control2.SetAnchorPoint(AnchorPoint::TOP_LEFT); + control1.SetParentOrigin(ParentOrigin::TOP_LEFT); + control2.SetParentOrigin(ParentOrigin::TOP_LEFT); + control1.SetPosition(0.0f, 0.0f); + control2.SetPosition(0.0f, 100.0f); + + Stage::GetCurrent().Add(control1); + Stage::GetCurrent().Add(control2); + + detector.Attach(control1); + detector.Attach(control2); + + application.SendNotification(); + application.Render(RENDER_FRAME_INTERVAL); + + SignalData data; + DragSignalFunctor functor(data); + detector.DroppedSignal().Connect(&application, functor); + + Vector2 screenCoordinates(10.0f, 10.0f); + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 110.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates)); + + screenCoordinates.x = 10.0f; + screenCoordinates.y = 112.0f; + application.ProcessEvent(GenerateSingleTouch(TouchPoint::Up, screenCoordinates)); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_EQUALS(control2, data.control, TEST_LOCATION); + DALI_TEST_EQUALS(Vector2(10.0f, 112.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION); + DALI_TEST_EQUALS("control1", detector.GetContent(), TEST_LOCATION); + + data.Reset(); + + END_TEST; +} diff --git a/build/tizen/dali-toolkit/Makefile.am b/build/tizen/dali-toolkit/Makefile.am index 3d77bb8..53a4788 100644 --- a/build/tizen/dali-toolkit/Makefile.am +++ b/build/tizen/dali-toolkit/Makefile.am @@ -160,6 +160,7 @@ develapitextselectionpopupdir = $(develapicontrolsdir)/text-controls develapitextdir = $(develapidir)/text develapivisualfactorydir = $(develapidir)/visual-factory develapivisualsdir = $(develapidir)/visuals +develapidragdropdir = $(develapidir)/drag-drop-detector # devel headers develapi_HEADERS = $(devel_api_header_files) @@ -192,6 +193,7 @@ develapitooltip_HEADERS = $(devel_api_tooltip_header_files) develapitransitioneffects_HEADERS = $(devel_api_transition_effects_header_files) develapitextselectionpopup_HEADERS = $(devel_api_text_controls_header_files) develapitext_HEADERS = $(devel_api_text_header_files) +develapidragdrop_HEADERS = $(devel_api_drag_and_drop_detector_header_files) # public api source publicapidir = $(topleveldir)/public-api diff --git a/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.cpp b/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.cpp new file mode 100755 index 0000000..bbbcf51 --- /dev/null +++ b/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.cpp @@ -0,0 +1,115 @@ +/* + * 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 + +// INTERNAL INCLUDES +#include + +namespace Dali +{ + +namespace Toolkit +{ + +DragAndDropDetector::DragAndDropDetector() +{ +} + +DragAndDropDetector::~DragAndDropDetector() +{ +} + +DragAndDropDetector DragAndDropDetector::New() +{ + return Internal::DragAndDropDetector::New(); +} + +void DragAndDropDetector::Attach(Control control) +{ + GetImplementation(*this).Attach(control); +} + +void DragAndDropDetector::Detach(Control control) +{ + GetImplementation(*this).Detach(control); +} + +void DragAndDropDetector::DetachAll() +{ + GetImplementation(*this).DetachAll(); +} + +uint32_t DragAndDropDetector::GetAttachedControlCount() const +{ + return GetImplementation(*this).GetAttachedControlCount(); +} + +Control DragAndDropDetector::GetAttachedControl(uint32_t index) const +{ + return GetImplementation(*this).GetAttachedControl(index); +} + +const std::string& DragAndDropDetector::GetContent() const +{ + return GetImplementation(*this).GetContent(); +} + +const Vector2& DragAndDropDetector::GetCurrentScreenPosition() const +{ + return GetImplementation(*this).GetCurrentScreenPosition(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::StartedSignal() +{ + return GetImplementation(*this).StartedSignal(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::EnteredSignal() +{ + return GetImplementation(*this).EnteredSignal(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::ExitedSignal() +{ + return GetImplementation(*this).ExitedSignal(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::MovedSignal() +{ + return GetImplementation(*this).MovedSignal(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::DroppedSignal() +{ + return GetImplementation(*this).DroppedSignal(); +} + +DragAndDropDetector::DragAndDropSignal& DragAndDropDetector::EndedSignal() +{ + return GetImplementation(*this).EndedSignal(); +} + +DragAndDropDetector::DragAndDropDetector( Internal::DragAndDropDetector* detector ) +: BaseHandle( detector ) +{ +} + +} //namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.h b/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.h new file mode 100755 index 0000000..2bd34db --- /dev/null +++ b/dali-toolkit/devel-api/drag-drop-detector/drag-and-drop-detector.h @@ -0,0 +1,272 @@ +#ifndef __DALI_DRAG_AND_DROP_DETECTOR_H__ +#define __DALI_DRAG_AND_DROP_DETECTOR_H__ + +/* + * Copyright (c) 2018 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 +#include + +// INTERNAL INCLUDES +#include + +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal DALI_INTERNAL +{ +class DragAndDropDetector; +} + +/** + * @brief The DragAndDropDetector%s provides signals when draggable objects are dragged into other object. + * + * It provides signals for when the draggable object start drag, draggable object enters other object, moves around in other object, + * leaves other object, dropped into other object and finally when the drag ended. + * + * The basic usage is shown below: + * + * @code + * + * void Example() + * { + * DragAndDropDetector detector = DragAndDropDetector::New(); + * + * // Get notifications when the draggable item start drag + * detector.StartedSignal().Connect( &OnStarted ); + * + * // Get notifications when the draggable item enters other item + * detector.EnteredSignal().Connect( &OnEntered ); + * + * // Get notifications when the draggable item leaves other item + * detector.ExitedSignal().Connect( &OnExited ); + * + * // Get notifications when the draggable item is moved within other item + * detector.MovedSignal().Connect( &OnMoved ); + * + * // Get notifications when the draggable item is dropped + * detector.DroppedSignal().Connect( &OnDropped ); + * + * // Get notifications when the draggable object drag ended + * detector.EndedSignal().Connect( &OnEnded ); + * } + * + * void OnStarted( Control control, DragAndDropDetector detector ) + * { + * // Query the new values + * std::cout << "Position = " << detector.GetCurrentScreenPosition() << std::endl; + * } + * + * void OnEntered( Control control, DragAndDropDetector detector ) + * { + * // Change mode as required + * } + * + * void OnExited( Control control, DragAndDropDetector detector ) + * { + * // Change mode as required + * } + * + * void OnMoved( Control control, DragAndDropDetector detector ) + * { + * // Query the new values + * std::cout << "Position = " << detector.GetCurrentScreenPosition() << std::endl; + * } + * + * void OnDropped( Control control, DragAndDropDetector detector ) + * { + * // Query the new values + * std::cout << "Position = " << detector.GetCurrentScreenPosition() << ", Content = " << detector.GetContent() << std::endl; + * } + * + * void OnEnded( Control control, DragAndDropDetector detector ) + * { + * // Change mode as required + * } + * + * @endcode + */ +class DALI_TOOLKIT_API DragAndDropDetector : public BaseHandle +{ +public: + + // Typedefs + + using DragAndDropSignal = Signal< void ( Control, DragAndDropDetector ) >; ///< Drag & Drop signal + + /** + * @brief Create an initialized DragAndDropDetector. + * + * @return A handle to a newly allocated Dali DragAndDropDetector + */ + static DragAndDropDetector New(); + + /** + * @brief Create an uninitialized handle. + * + * This can be initialized with DragAndDropDetector::New(). + */ + DragAndDropDetector(); + + /** + * @brief Destructor + * + * This is non-virtual since derived Handle types must not contain data or virtual methods. + */ + ~DragAndDropDetector(); + + /** + * @brief Returns the dropped content. + * + * @return A reference to the string representing the dropped content. + */ + const std::string& GetContent() const; + + /** + * @brief Attaches a Control to the detector. + * + * @note You can attach several controls to a DragAndDropDetector. + * DragAndDropDetector will keep a handle to the control and keep it alive as long as + * DragAndDropDetector is deleted or Detach is called. + */ + void Attach(Control control); + + /** + * @brief Detaches the attached control from the detector. + * + * @pre The specified control has been attached to the DragAndDropDetector. + */ + void Detach(Control control); + + /** + * @brief Detaches all attached control from the detector. + * + * @pre At least one control has been attached to the DragAndDropDetector. + */ + void DetachAll(); + + /** + * @brief Returns the number of controls attached to the DragAndDropDetector. + * + * @pre The DragAndDropDetector has been initialized. + */ + uint32_t GetAttachedControlCount() const; + + /** + * @brief Returns a control by index. An empty handle if the index is not valid. + * + * @pre The DragAndDropDetector has been initialized. + */ + Control GetAttachedControl(uint32_t index) const; + + /** + * @brief Returns the current position of the dragged object. + * + * This is the dropped position when an object is dropped. + * @return The current screen position. + */ + const Vector2& GetCurrentScreenPosition() const; + + // Signals + /** + * @brief This is emitted when a dragged object start drag. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& StartedSignal(); + + /** + * @brief This is emitted when a dragged object enters other object. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& EnteredSignal(); + + /** + * @brief This is emitted when a dragged object leaves other object. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& ExitedSignal(); + + /** + * @brief This is emitted when a dragged object is moved within other object. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& MovedSignal(); + + /** + * @brief This is emitted when a dragged object is dropped within other object. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& DroppedSignal(); + + /** + * @brief This is emitted when a dragged object drag ended. + * + * A callback of the following type may be connected: + * @code + * void YourCallback( Control control, DragAndDropDetector detector ); + * @endcode + * @return The signal to connect to. + */ + DragAndDropSignal& EndedSignal(); + +public: // Not intended for application developers + + /** + * @brief This constructor is used by DragAndDropDetector::Get(). + * + * @param[in] detector A pointer to the drag and drop detector. + */ + explicit DALI_INTERNAL DragAndDropDetector( Internal::DragAndDropDetector* detector ); +}; + +} // namespace Toolkit + +} // namespace Dali + +#endif // __DALI_DRAG_AND_DROP_DETECTOR_H__ diff --git a/dali-toolkit/devel-api/file.list b/dali-toolkit/devel-api/file.list index 1cad2f5..14cb246 100755 --- a/dali-toolkit/devel-api/file.list +++ b/dali-toolkit/devel-api/file.list @@ -54,7 +54,8 @@ devel_api_src_files = \ $(devel_api_src_dir)/visual-factory/transition-data.cpp \ $(devel_api_src_dir)/visual-factory/visual-factory.cpp \ $(devel_api_src_dir)/visual-factory/visual-base.cpp \ - $(devel_api_src_dir)/controls/gaussian-blur-view/gaussian-blur-view.cpp + $(devel_api_src_dir)/controls/gaussian-blur-view/gaussian-blur-view.cpp \ + $(devel_api_src_dir)/drag-drop-detector/drag-and-drop-detector.cpp # Add devel header files here @@ -197,3 +198,6 @@ devel_api_gaussian_blur_view_header_files = \ devel_api_web_view_header_files = \ $(devel_api_src_dir)/controls/web-view/web-view.h + +devel_api_drag_and_drop_detector_header_files = \ + $(devel_api_src_dir)/drag-drop-detector/drag-and-drop-detector.h diff --git a/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.cpp b/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.cpp new file mode 100755 index 0000000..c26e4ae --- /dev/null +++ b/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.cpp @@ -0,0 +1,312 @@ +/* + * Copyright (c) 2018 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 + +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +Dali::Toolkit::DragAndDropDetector DragAndDropDetector::New() +{ + Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector(new DragAndDropDetector()); + + return detector; +} + +void DragAndDropDetector::Attach(Dali::Toolkit::Control& control) +{ + if(control) + { + if(!mControls.empty()) + { + auto match = std::find(mControls.begin(), mControls.end(), control); + if(match != mControls.end()) + { + return; + } + } + mControls.push_back(control); + control.TouchSignal().Connect(this, &DragAndDropDetector::OnDrag); + mFirstEnter.push_back(control.GetId()); + mPanGestureDetector.Attach(control); + mPanGestureDetector.DetectedSignal().Connect(this, &DragAndDropDetector::OnPan); + } + +} + +void DragAndDropDetector::Detach(Dali::Toolkit::Control& control) +{ + if(!mControls.empty()) + { + if(!control) + { + return; + } + + auto match = std::find(mControls.begin(), mControls.end(), control); + + if(match != mControls.end()) + { + match->TouchSignal().Disconnect(this, &DragAndDropDetector::OnDrag); + mPanGestureDetector.Detach(*match); + mFirstEnter.erase(std::find(mFirstEnter.begin(), mFirstEnter.end(), control.GetId())); + mControls.erase(match); + } + } +} + +void DragAndDropDetector::DetachAll() +{ + if(!mControls.empty()) + { + auto iter = mControls.begin(); + for(;iter != mControls.end();) + { + iter->TouchSignal().Disconnect(this, &DragAndDropDetector::OnDrag); + mPanGestureDetector.Detach(*iter); + iter = mControls.erase(iter); + } + } + + if(!mFirstEnter.empty()) + { + auto iter = mFirstEnter.begin(); + for(;iter != mFirstEnter.end();) + { + iter = mFirstEnter.erase(iter); + } + } +} + +uint32_t DragAndDropDetector::GetAttachedControlCount() const +{ + return mControls.size(); +} + +Dali::Toolkit::Control DragAndDropDetector::GetAttachedControl(uint32_t index) const +{ + Dali::Toolkit::Control control; + + if(index < mControls.size()) + { + control = mControls[index]; + } + + return control; +} + +void DragAndDropDetector::OnPan(Dali::Actor actor, const PanGesture& gesture) +{ + Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor); + + if(gesture.state == Gesture::Started) + { + mDragLocalPosition = gesture.position; + } + if(gesture.state == Gesture::Continuing) + { + Vector2 screenPosition = gesture.screenPosition; + control.GetParent().ScreenToLocal(mLocalPosition.x, mLocalPosition.y, screenPosition.x, screenPosition.y); + mShadowControl.SetPosition(mLocalPosition.x - mDragLocalPosition.x, mLocalPosition.y - mDragLocalPosition.y); + } + if(gesture.state == Gesture::Finished) + { + mDragControl.GetParent().Remove(mShadowControl); + EmitEndedSignal(control); + } +} + +bool DragAndDropDetector::OnDrag(Dali::Actor actor, const Dali::TouchData& data) +{ + Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor); + PointState::Type type = data.GetState(0); + if(type == PointState::DOWN) + { + mPointDown = true; + mDragControl = control; + mFirstEnter.clear(); + for( auto&& control : mControls) + { + mFirstEnter.push_back(control.GetId()); + } + float width = control.GetProperty(Dali::Actor::Property::SIZE_WIDTH); + float height = control.GetProperty(Dali::Actor::Property::SIZE_HEIGHT); + Vector3 actorPos = control.GetProperty(Dali::Actor::Property::POSITION); + + mShadowControl = Dali::Toolkit::Control::New(); + mShadowControl.SetPosition(actorPos); + mShadowControl.SetSize(width, height); + mShadowControl.SetBackgroundColor(Vector4(0.3f, 0.3f, 0.3f, 0.7f)); + mShadowControl.SetParentOrigin(control.GetCurrentParentOrigin()); + mShadowControl.SetAnchorPoint(control.GetCurrentAnchorPoint()); + control.GetParent().Add(mShadowControl); + SetPosition(data.GetScreenPosition(0)); + EmitStartedSignal(control); + } + + if(type == PointState::MOTION) + { + if(mDragControl != control && mPointDown) + { + auto found = std::find(mFirstEnter.begin(), mFirstEnter.end(), control.GetId()); + if(mFirstEnter.end() != found) + { + SetPosition(data.GetScreenPosition(0)); + mFirstEnter.erase(found); + EmitEnteredSignal(control); + } + else + { + SetPosition(data.GetScreenPosition(0)); + EmitMovedSignal(control); + } + } + } + + if(type == PointState::LEAVE) + { + if(mDragControl != control && mPointDown) + { + mFirstEnter.push_back(control.GetId()); + EmitExitedSignal(control); + } + } + + if(type == PointState::UP) + { + if(mDragControl != control && mPointDown) + { + SetPosition(data.GetScreenPosition(0)); + ClearContent(); + SetContent(mDragControl.GetName()); + EmitDroppedSignal(control); + } + + if(mShadowControl) + { + control.GetParent().Remove(mShadowControl); + } + mPointDown = false; + } + return true; +} + +const std::string& DragAndDropDetector::GetContent() const +{ + return mContent; +} + +const Vector2& DragAndDropDetector::GetCurrentScreenPosition() const +{ + return mScreenPosition; +} + +void DragAndDropDetector::SetContent( const std::string& content ) +{ + mContent = content; +} + +void DragAndDropDetector::ClearContent() +{ + mContent.clear(); +} + +void DragAndDropDetector::SetPosition( const Vector2& screenPosition ) +{ + mScreenPosition = screenPosition; +} + +void DragAndDropDetector::EmitStartedSignal(Dali::Toolkit::Control& control) +{ + if( !mStartedSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mStartedSignal.Emit( control, handle ); + } +} +void DragAndDropDetector::EmitEnteredSignal(Dali::Toolkit::Control& control) +{ + if ( !mEnteredSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mEnteredSignal.Emit( control, handle ); + } +} + +void DragAndDropDetector::EmitExitedSignal(Dali::Toolkit::Control& control) +{ + if ( !mExitedSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mExitedSignal.Emit( control, handle ); + } +} + +void DragAndDropDetector::EmitMovedSignal(Dali::Toolkit::Control& control) +{ + if ( !mMovedSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mMovedSignal.Emit( control, handle ); + } +} + +void DragAndDropDetector::EmitDroppedSignal(Dali::Toolkit::Control& control) +{ + if ( !mDroppedSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mDroppedSignal.Emit( control, handle ); + } +} + +void DragAndDropDetector::EmitEndedSignal(Dali::Toolkit::Control& control) +{ + if( !mEndedSignal.Empty() ) + { + Dali::Toolkit::DragAndDropDetector handle( this ); + mEndedSignal.Emit( control, handle ); + } +} + +DragAndDropDetector::DragAndDropDetector() +: mContent(), + mScreenPosition() +{ + mPanGestureDetector = Dali::PanGestureDetector::New(); + mPointDown = false; +} + +DragAndDropDetector::~DragAndDropDetector() +{ +} + +} // namespace Internal + +} //namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.h b/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.h new file mode 100755 index 0000000..e2e1c47 --- /dev/null +++ b/dali-toolkit/internal/drag-drop-detector/drag-and-drop-detector-impl.h @@ -0,0 +1,269 @@ +#ifndef __DALI_INTERNAL_DRAG_AND_DROP_DETECTOR_H__ +#define __DALI_INTERNAL_DRAG_AND_DROP_DETECTOR_H__ + +/* + * Copyright (c) 2018 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 +#include +#include + +#include +#include + +// INTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +using DragAndDropDetectorPtr = IntrusivePtr< DragAndDropDetector >; + +/** + * This class listens to Drag & Drop events. + */ +class DragAndDropDetector : public Dali::BaseObject, public ConnectionTracker +{ +public: + + using DragAndDropSignal = Dali::Toolkit::DragAndDropDetector::DragAndDropSignal; + + // Creation + + /** + * @copydoc Toolkit::DragAndDropDetector::New() + */ + static Dali::Toolkit::DragAndDropDetector New(); + + // Public API + + /** + * @copydoc Dali::DragAndDropDetector::GetContent() const + */ + const std::string& GetContent() const; + + /** + * @copydoc Dali::DragAndDropDetector::GetCurrentScreenPosition() const + */ + const Vector2& GetCurrentScreenPosition() const; + + /** + * Attaches control to DragAndDropDetector. + * @param[in] control control that will be attached to DragAndDropDetector. + */ + void Attach(Dali::Toolkit::Control& control); + + /** + * Detaches control to DragAndDropDetector. + * @param[in] control control that will be Detached from DragAndDropDetector. + */ + void Detach(Dali::Toolkit::Control& control); + + /** + * Detaches all control attached to DragAndDropDetector. + */ + void DetachAll(); + + /** + * Returns the number of controls attached to the DragAndDropDetector. + */ + uint32_t GetAttachedControlCount() const; + + /** + * Returns a control by index. An empty handle if the index is not valid. + */ + Dali::Toolkit::Control GetAttachedControl(uint32_t index) const; + + /** + * Sets the dragged content. + * @param[in] content A string that represents the content that has been dropped. + */ + void SetContent( const std::string& content ); + + /** + * Clears the stored content. + */ + void ClearContent(); + + /** + * Sets the position the drop occurred. + */ + void SetPosition( const Vector2& screenPosition ); + + /** + * Called when a draggable object start drag. + */ + void EmitStartedSignal(Dali::Toolkit::Control& control); + + /** + * Called when a draggable object enters other object. + */ + void EmitEnteredSignal(Dali::Toolkit::Control& control); + + /** + * Called when a draggable object leaves other object. + */ + void EmitExitedSignal(Dali::Toolkit::Control& control); + + /** + * Called when a draggable object leaves other object. + */ + void EmitMovedSignal(Dali::Toolkit::Control& control); + + /** + * Is called when a drop actually occurs. + */ + void EmitDroppedSignal(Dali::Toolkit::Control& control); + + /** + * Called when a draggable object drag ended. + */ + void EmitEndedSignal(Dali::Toolkit::Control& control); + +public: // Signals + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::StartedSignal + */ + DragAndDropSignal& StartedSignal() + { + return mStartedSignal; + } + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::EnteredSignal + */ + DragAndDropSignal& EnteredSignal() + { + return mEnteredSignal; + } + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::ExitedSignal + */ + DragAndDropSignal& ExitedSignal() + { + return mExitedSignal; + } + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::MovedSignal + */ + DragAndDropSignal& MovedSignal() + { + return mMovedSignal; + } + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::DroppedSignal + */ + DragAndDropSignal& DroppedSignal() + { + return mDroppedSignal; + } + + /** + * @copydoc Dali::Toolkit::DragAndDropDetector::DroppedSignal + */ + DragAndDropSignal& EndedSignal() + { + return mEndedSignal; + } + +public: + bool OnDrag(Dali::Actor actor, const Dali::TouchData& data); + void OnPan(Dali::Actor actor, const PanGesture& gesture); + +private: + + // Construction & Destruction + + /** + * Constructor. + */ + DragAndDropDetector(); + + /** + * Destructor. + */ + virtual ~DragAndDropDetector(); + + // Undefined + DragAndDropDetector( const DragAndDropDetector& ) = delete; + DragAndDropDetector& operator=( DragAndDropDetector& ); + +private: + + std::string mContent; ///< The current Drag & drop content. + + DragAndDropSignal mStartedSignal; + DragAndDropSignal mEnteredSignal; + DragAndDropSignal mExitedSignal; + DragAndDropSignal mMovedSignal; + DragAndDropSignal mDroppedSignal; + DragAndDropSignal mEndedSignal; + + std::vector mControls; //controls attached by Attach interface for drag&drop + Dali::Toolkit::Control mDragControl; //the current drag control + Dali::Toolkit::Control mShadowControl; //a shadow control for indicating where the control is, same size as the dragged control + std::vector mFirstEnter; //control id indicating if the cursor is enter + Dali::PanGestureDetector mPanGestureDetector; //pangesture for calculating the shadow actor position + + Vector2 mLocalPosition; + Vector2 mDragLocalPosition; + Vector2 mScreenPosition; ///< The screen position of the drop location. + + bool mPointDown; //bool flag to indicate if PointState::DOWN have been processed +}; + +} // namespace Internal + + +// Helpers for public-api forwarding methods + +inline Internal::DragAndDropDetector& GetImplementation(Dali::Toolkit::DragAndDropDetector& detector) +{ + DALI_ASSERT_ALWAYS( detector && "DragAndDropDetector handle is empty" ); + + BaseObject& handle = detector.GetBaseObject(); + + return static_cast(handle); +} + +inline const Internal::DragAndDropDetector& GetImplementation(const Dali::Toolkit::DragAndDropDetector& detector) +{ + DALI_ASSERT_ALWAYS( detector && "DragAndDropDetector handle is empty" ); + + const BaseObject& handle = detector.GetBaseObject(); + + return static_cast(handle); +} + +} // namespace Toolkit + +} // namespace Dali + +#endif // __DALI_INTERNAL_DRAG_AND_DROP_DETECTOR_H__ diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list index 8fab9fd..1799a2a 100755 --- a/dali-toolkit/internal/file.list +++ b/dali-toolkit/internal/file.list @@ -173,4 +173,5 @@ toolkit_src_files = \ $(toolkit_src_dir)/transition-effects/cube-transition-wave-effect-impl.cpp \ $(toolkit_src_dir)/scripting/script-impl.cpp \ $(toolkit_src_dir)/scripting/script-plugin-proxy.cpp \ - $(toolkit_src_dir)/text/xhtml-entities.cpp + $(toolkit_src_dir)/text/xhtml-entities.cpp \ + $(toolkit_src_dir)/drag-drop-detector/drag-and-drop-detector-impl.cpp