From: Umar Date: Thu, 13 Apr 2017 09:14:21 +0000 (+0100) Subject: [dali_1.2.35] Merge branch 'devel/master' X-Git-Tag: submit/trunk/20181001.110911~74 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e5c8f41c1f0613593e3f2f1a1376b36443ffeb52;hp=b1584015ee16a6053819b39f1da54c06f2affce6;p=platform%2Fcore%2Fuifw%2Fdali-core.git [dali_1.2.35] Merge branch 'devel/master' Change-Id: I00222685c5a9625fdc474ead1290f9900c146217 --- diff --git a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp index a8b39a9..dde1fec 100644 --- a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp +++ b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include @@ -257,8 +258,9 @@ int UtcDaliIntegrationKeyEvent(void) const int keyModifier(312); const unsigned long timeStamp(132); const Integration::KeyEvent::State keyState(Integration::KeyEvent::Up); + const std::string deviceName("hwKeyboard"); - Integration::KeyEvent keyEvent(keyName, keyString, keyCode, keyModifier, timeStamp, keyState); + Integration::KeyEvent keyEvent(keyName, keyString, keyCode, keyModifier, timeStamp, keyState, deviceName ); DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION ); DALI_TEST_CHECK( keyEvent.keyName == keyName ); DALI_TEST_CHECK( keyEvent.keyString == keyString ); @@ -266,6 +268,45 @@ int UtcDaliIntegrationKeyEvent(void) DALI_TEST_EQUALS( keyEvent.keyModifier, keyModifier, TEST_LOCATION ); DALI_TEST_EQUALS( keyEvent.time, timeStamp, TEST_LOCATION ); DALI_TEST_EQUALS( keyEvent.state, keyState, TEST_LOCATION); + DALI_TEST_EQUALS( keyEvent.deviceName, deviceName, TEST_LOCATION); } END_TEST; } + +int UtcDaliIntegrationKeyEventConvertor(void) +{ + TestApplication application; + + KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down); // set name to test, key string to i and modifier to shift + + Integration::KeyEvent keyEvent( event ); + + DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION ); + DALI_TEST_CHECK( keyEvent.keyName == TEST_STRING_1 ); + DALI_TEST_CHECK( keyEvent.keyString == "i" ); + DALI_TEST_EQUALS( keyEvent.keyCode, 99, TEST_LOCATION ); + DALI_TEST_EQUALS( keyEvent.keyModifier, SHIFT_MODIFIER, TEST_LOCATION ); + DALI_TEST_EQUALS( keyEvent.time, 0lu, TEST_LOCATION ); + DALI_TEST_EQUALS( keyEvent.state, Integration::KeyEvent::Down, TEST_LOCATION); + DALI_TEST_EQUALS( keyEvent.deviceName, "", TEST_LOCATION); + + END_TEST; +} + +int UtcDaliKeyEventSetDeviceName(void) +{ + TestApplication application; + + KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down); + + DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceName( event ), "", TEST_LOCATION); + + DevelKeyEvent::SetDeviceName( event, "finger" ); + + DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceName( event ), "finger", TEST_LOCATION); + + KeyEvent event2; + DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceName( event2 ), "", TEST_LOCATION); + + END_TEST; +} diff --git a/automated-tests/src/dali/utc-Dali-Stage.cpp b/automated-tests/src/dali/utc-Dali-Stage.cpp index 10496fd..b8c3504 100644 --- a/automated-tests/src/dali/utc-Dali-Stage.cpp +++ b/automated-tests/src/dali/utc-Dali-Stage.cpp @@ -20,8 +20,10 @@ #include #include +#include #include #include +#include #include #include @@ -42,6 +44,8 @@ void stage_test_cleanup(void) namespace { +const std::string DEFAULT_DEVICE_NAME("hwKeyboard"); + // Functor for EventProcessingFinished signal struct EventProcessingFinishedFunctor { @@ -60,6 +64,50 @@ struct EventProcessingFinishedFunctor bool& mEventProcessingFinished; }; +// Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases +struct KeyEventGeneratedSignalData +{ + KeyEventGeneratedSignalData() + : functorCalled(false) + {} + + void Reset() + { + functorCalled = false; + + receivedKeyEvent.keyModifier = 0; + receivedKeyEvent.keyPressedName.clear(); + receivedKeyEvent.keyPressed.clear(); + } + + bool functorCalled; + KeyEvent receivedKeyEvent; +}; + +// Functor that sets the data when called +struct KeyEventGeneratedReceivedFunctor +{ + KeyEventGeneratedReceivedFunctor( KeyEventGeneratedSignalData& data ) + : signalData( data ) + {} + + bool operator()( const KeyEvent& keyEvent ) + { + signalData.functorCalled = true; + signalData.receivedKeyEvent = keyEvent; + + return true; + } + + bool operator()() + { + signalData.functorCalled = true; + return true; + } + + KeyEventGeneratedSignalData& signalData; +}; + // Stores data that is populated in the key-event callback and will be read by the TET cases struct KeyEventSignalData { @@ -144,6 +192,11 @@ struct TouchFunctor signalData.receivedTouchData = touch; } + void operator()() + { + signalData.functorCalled = true; + } + TouchedSignalData& signalData; }; @@ -817,6 +870,63 @@ int UtcDaliStageEventProcessingFinishedN(void) END_TEST; } +int UtcDaliStageKeyEventGeneratedSignalP(void) +{ + TestApplication application; + Stage stage = Stage::GetCurrent(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor( data ); + DevelStage::KeyEventGeneratedSignal( stage ).Connect( &application, functor ); + + KeyEventGeneratedSignalData data2; + KeyEventGeneratedReceivedFunctor functor2( data2 ); + GetImplementation( stage ).ConnectSignal( &application, "keyEventGenerated", functor2 ); + + Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ); + application.ProcessEvent( event ); + + DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event.state == static_cast( data.receivedKeyEvent.state ) ); + + data.Reset(); + + Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ); + application.ProcessEvent( event2 ); + + DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event2.state == static_cast( data.receivedKeyEvent.state ) ); + + data.Reset(); + + Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ); + application.ProcessEvent( event3 ); + + DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event3.state == static_cast( data.receivedKeyEvent.state ) ); + + data.Reset(); + + Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ); + application.ProcessEvent( event4 ); + + DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event4.state == static_cast( data.receivedKeyEvent.state ) ); + END_TEST; +} + int UtcDaliStageSignalKeyEventP(void) { TestApplication application; @@ -826,7 +936,7 @@ int UtcDaliStageSignalKeyEventP(void) KeyEventReceivedFunctor functor( data ); stage.KeyEventSignal().Connect( &application, functor ); - Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down ); + Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ); application.ProcessEvent( event ); DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); @@ -837,7 +947,7 @@ int UtcDaliStageSignalKeyEventP(void) data.Reset(); - Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up ); + Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ); application.ProcessEvent( event2 ); DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); @@ -848,7 +958,7 @@ int UtcDaliStageSignalKeyEventP(void) data.Reset(); - Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ); + Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME ); application.ProcessEvent( event3 ); DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); @@ -859,7 +969,7 @@ int UtcDaliStageSignalKeyEventP(void) data.Reset(); - Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up ); + Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME ); application.ProcessEvent( event4 ); DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); @@ -1221,12 +1331,17 @@ int UtcDaliStageTouchSignalN(void) TouchFunctor functor( data ); stage.TouchSignal().Connect( &application, functor ); + TouchedSignalData data2; + TouchFunctor functor2( data2 ); + GetImplementation( stage ).ConnectSignal( &application, "touch", functor2 ); + // Render and notify. application.SendNotification(); application.Render(); // Confirm functor not called before there has been any touch event. DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION ); + DALI_TEST_EQUALS( false, data2.functorCalled, TEST_LOCATION ); // No actors, single touch, down, motion then up. { @@ -1235,7 +1350,11 @@ int UtcDaliStageTouchSignalN(void) DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u ); DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0)); + + DALI_TEST_EQUALS( true, data2.functorCalled, TEST_LOCATION ); + data.Reset(); + data2.Reset(); // Confirm there is no signal when the touchpoint is only moved. GenerateTouch( application, PointState::MOTION, Vector2( 1200.0f, 10.0f ) ); // Some motion diff --git a/dali/devel-api/common/stage-devel.cpp b/dali/devel-api/common/stage-devel.cpp new file mode 100644 index 0000000..d68a5a0 --- /dev/null +++ b/dali/devel-api/common/stage-devel.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2017 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. + * + */ + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ + +namespace DevelStage +{ + +KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage ) +{ + return GetImplementation( stage ).KeyEventGeneratedSignal(); +} + +} // namespace DevelStage + +} // namespace Dali diff --git a/dali/devel-api/common/stage-devel.h b/dali/devel-api/common/stage-devel.h new file mode 100644 index 0000000..f54e411 --- /dev/null +++ b/dali/devel-api/common/stage-devel.h @@ -0,0 +1,44 @@ +#ifndef DALI_STAGE_DEVEL_H +#define DALI_STAGE_DEVEL_H + +/* + * Copyright (c) 2017 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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ + +namespace DevelStage +{ + +typedef Signal< bool (const KeyEvent&) > KeyEventGeneratedSignalType; ///< Stage key event generated signal type + +/** + * @brief The user would connect to this signal to get a KeyEvent when KeyEvent is generated. + * + * @param[in] stage The stage to emit a signal + * @return The return is true if KeyEvent is consumed, otherwise false. + */ +DALI_IMPORT_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage ); + +} // namespace DevelStage + +} // namespace Dali + +#endif // DALI_STAGE_DEVEL_H diff --git a/dali/devel-api/events/key-event-devel.h b/dali/devel-api/events/key-event-devel.h new file mode 100644 index 0000000..87af795 --- /dev/null +++ b/dali/devel-api/events/key-event-devel.h @@ -0,0 +1,37 @@ +#ifndef DALI_KEY_EVENT_DEVEL_H +#define DALI_KEY_EVENT_DEVEL_H + +/* + * Copyright (c) 2017 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. + * + */ + +// INTERNAL_INCLUDES +#include + +namespace Dali +{ + +namespace DevelKeyEvent +{ + std::string GetDeviceName( KeyEvent& keyEvent ); + + void SetDeviceName( KeyEvent& keyEvent, std::string deviceName ); + +} + +} + +#endif //DALI_KEY_EVENT_DEVEL_H diff --git a/dali/devel-api/file.list b/dali/devel-api/file.list index 7d2eb05..84f9117 100644 --- a/dali/devel-api/file.list +++ b/dali/devel-api/file.list @@ -4,6 +4,7 @@ devel_api_src_files = \ $(devel_api_src_dir)/animation/animation-data.cpp \ $(devel_api_src_dir)/animation/path-constrainer.cpp \ $(devel_api_src_dir)/common/hash.cpp \ + $(devel_api_src_dir)/common/stage-devel.cpp \ $(devel_api_src_dir)/events/hit-test-algorithm.cpp \ $(devel_api_src_dir)/images/distance-field.cpp \ $(devel_api_src_dir)/images/texture-set-image.cpp \ @@ -32,7 +33,8 @@ devel_api_core_common_header_files = \ $(devel_api_src_dir)/common/map-wrapper.h \ $(devel_api_src_dir)/common/owner-container.h \ $(devel_api_src_dir)/common/ref-counted-dali-vector.h \ - $(devel_api_src_dir)/common/set-wrapper.h + $(devel_api_src_dir)/common/set-wrapper.h \ + $(devel_api_src_dir)/common/stage-devel.h devel_api_core_events_header_files = \ $(devel_api_src_dir)/events/hit-test-algorithm.h diff --git a/dali/integration-api/events/key-event-integ.cpp b/dali/integration-api/events/key-event-integ.cpp index 80dc7cc..ed46ccf 100644 --- a/dali/integration-api/events/key-event-integ.cpp +++ b/dali/integration-api/events/key-event-integ.cpp @@ -31,18 +31,33 @@ KeyEvent::KeyEvent() keyCode(-1), keyModifier(0), time(0), - state(KeyEvent::Down) + state(KeyEvent::Down), + deviceName("") { } -KeyEvent::KeyEvent(const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier, unsigned long timeStamp, const State& keyState) +KeyEvent::KeyEvent( const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier, + unsigned long timeStamp, const State& keyState, const std::string deviceName ) : Event(Key), keyName(keyName), keyString(keyString), keyCode(keyCode), keyModifier(keyModifier), time(timeStamp), - state(keyState) + state(keyState), + deviceName(deviceName) +{ +} + +KeyEvent::KeyEvent( const Dali::KeyEvent& event ) +: Event(Key), + keyName( event.keyPressedName ), + keyString( event.keyPressed ), + keyCode( event.keyCode ), + keyModifier( event.keyModifier ), + time( event.time ), + state( static_cast< Integration::KeyEvent::State >( event.state ) ), + deviceName("") { } diff --git a/dali/integration-api/events/key-event-integ.h b/dali/integration-api/events/key-event-integ.h index 26762ed..e448a30 100644 --- a/dali/integration-api/events/key-event-integ.h +++ b/dali/integration-api/events/key-event-integ.h @@ -23,6 +23,7 @@ // INTERNAL INCLUDES #include +#include namespace Dali DALI_IMPORT_API { @@ -58,15 +59,23 @@ struct KeyEvent : public Event * @param[in] keyString A string of input characters or key pressed * @param[in] keyCode The unique key code for the key pressed. * @param[in] keyModifier The key modifier for special keys like shift and alt - * @param[in] timeStamp The time (in ms) that the key event occurred. - * @param[in] keyState The state of the key event. + * @param[in] timeStamp The time (in ms) that the key event occurred. + * @param[in] keyState The state of the key event. + * @param[in] deviceName Name of device KeyEvent originated from */ KeyEvent(const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier, unsigned long timeStamp, - const State& keyState); + const State& keyState, + const std::string deviceName ); + + /* + * Constructor, creates a Integration::KeyEvent from a Dali::KeyEvent + * @param[in] event Dali::KeyEvent to convert from + */ + explicit KeyEvent( const Dali::KeyEvent& event ); /** * Virtual destructor @@ -106,6 +115,11 @@ struct KeyEvent : public Event */ State state; + /** + * Name of device KeyEvent originated from + */ + std::string deviceName; + }; } // namespace Integration diff --git a/dali/internal/event/animation/constraint-impl.h b/dali/internal/event/animation/constraint-impl.h index cb671d6..78f86f1 100644 --- a/dali/internal/event/animation/constraint-impl.h +++ b/dali/internal/event/animation/constraint-impl.h @@ -508,13 +508,16 @@ private: } DALI_ASSERT_DEBUG( NULL != sceneGraphConstraint ); - sceneGraphConstraint->SetRemoveAction( mRemoveAction ); + if( NULL != sceneGraphConstraint ) + { + sceneGraphConstraint->SetRemoveAction( mRemoveAction ); // object is being used in a separate thread; queue a message to apply the constraint - ApplyConstraintMessage( GetEventThreadServices(), *targetObject, *sceneGraphConstraint ); + ApplyConstraintMessage( GetEventThreadServices(), *targetObject, *sceneGraphConstraint ); - // Keep a raw-pointer to the scene-graph constraint - mSceneGraphConstraint = sceneGraphConstraint; + // Keep a raw-pointer to the scene-graph constraint + mSceneGraphConstraint = sceneGraphConstraint; + } } } diff --git a/dali/internal/event/common/stage-impl.cpp b/dali/internal/event/common/stage-impl.cpp index a9abac8..c036a5d 100644 --- a/dali/internal/event/common/stage-impl.cpp +++ b/dali/internal/event/common/stage-impl.cpp @@ -56,8 +56,10 @@ const float DEFAULT_STEREO_BASE( 65.0f ); // Signals const char* const SIGNAL_KEY_EVENT = "keyEvent"; +const char* const SIGNAL_KEY_EVENT_GENERATED = "keyEventGenerated"; const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished"; const char* const SIGNAL_TOUCHED = "touched"; +const char* const SIGNAL_TOUCH = "touch"; const char* const SIGNAL_WHEEL_EVENT = "wheelEvent"; const char* const SIGNAL_CONTEXT_LOST = "contextLost"; const char* const SIGNAL_CONTEXT_REGAINED = "contextRegained"; @@ -72,6 +74,8 @@ SignalConnectorType signalConnector4( mType, SIGNAL_WHEEL_EVENT, & SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_LOST, &Stage::DoConnectSignal ); SignalConnectorType signalConnector6( mType, SIGNAL_CONTEXT_REGAINED, &Stage::DoConnectSignal ); SignalConnectorType signalConnector7( mType, SIGNAL_SCENE_CREATED, &Stage::DoConnectSignal ); +SignalConnectorType signalConnector8( mType, SIGNAL_KEY_EVENT_GENERATED, &Stage::DoConnectSignal ); +SignalConnectorType signalConnector9( mType, SIGNAL_TOUCH, &Stage::DoConnectSignal ); } // unnamed namespace @@ -526,6 +530,10 @@ bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra { stage->KeyEventSignal().Connect( tracker, functor ); } + else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT_GENERATED ) ) + { + stage->KeyEventGeneratedSignal().Connect( tracker, functor ); + } else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) ) { stage->EventProcessingFinishedSignal().Connect( tracker, functor ); @@ -534,6 +542,10 @@ bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra { stage->TouchedSignal().Connect( tracker, functor ); } + else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCH ) ) + { + stage->TouchSignal().Connect( tracker, functor ); + } else if( 0 == strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) ) { stage->WheelEventSignal().Connect( tracker, functor ); @@ -566,6 +578,13 @@ void Stage::EmitKeyEventSignal(const KeyEvent& event) mKeyEventSignal.Emit( event ); } +bool Stage::EmitKeyEventGeneratedSignal(const KeyEvent& event) +{ + // Emit the KeyEventGenerated signal when KeyEvent is generated + + return mKeyEventGeneratedSignal.Emit( event ); +} + void Stage::EmitEventProcessingFinishedSignal() { mEventProcessingFinishedSignal.Emit(); @@ -594,6 +613,11 @@ Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal() return mKeyEventSignal; } +Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal() +{ + return mKeyEventGeneratedSignal; +} + Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal() { return mEventProcessingFinishedSignal; diff --git a/dali/internal/event/common/stage-impl.h b/dali/internal/event/common/stage-impl.h index 415f87b..ef2c2c4 100644 --- a/dali/internal/event/common/stage-impl.h +++ b/dali/internal/event/common/stage-impl.h @@ -21,6 +21,7 @@ // INTERNAL INCLUDES #include #include +#include #include #include #include @@ -307,6 +308,13 @@ public: void EmitKeyEventSignal(const KeyEvent& event); /** + * Used by the KeyEventProcessor to emit KeyEventGenerated signals. + * @param[in] event The key event. + * @return The return is true if KeyEvent is consumed, otherwise false. + */ + bool EmitKeyEventGeneratedSignal(const KeyEvent& event); + + /** * Emits the event processing finished signal. * * @see Dali::Stage::SignalEventProcessingFinished() @@ -372,6 +380,11 @@ public: Dali::Stage::SceneCreatedSignalType& SceneCreatedSignal(); /** + * @copydoc Dali::DevelStage::KeyEventGeneratedSignal() + */ + Dali::DevelStage::KeyEventGeneratedSignalType& KeyEventGeneratedSignal(); + + /** * Connects a callback function with the object's signals. * @param[in] object The object providing the signal. * @param[in] tracker Used to disconnect the signal. @@ -482,6 +495,7 @@ private: // The key event signal Dali::Stage::KeyEventSignalType mKeyEventSignal; + Dali::DevelStage::KeyEventGeneratedSignalType mKeyEventGeneratedSignal; // The event processing finished signal Dali::Stage::EventProcessingFinishedSignalType mEventProcessingFinishedSignal; diff --git a/dali/internal/event/events/key-event-processor.cpp b/dali/internal/event/events/key-event-processor.cpp index 5261d26..9d5b6de 100644 --- a/dali/internal/event/events/key-event-processor.cpp +++ b/dali/internal/event/events/key-event-processor.cpp @@ -19,6 +19,7 @@ #include // INTERNAL INCLUDES +#include #include #include #include @@ -41,10 +42,16 @@ KeyEventProcessor::~KeyEventProcessor() void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event) { + bool consumed = false; KeyEvent keyEvent(event.keyName, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast(event.state)); - + DevelKeyEvent::SetDeviceName( keyEvent, event.deviceName ); // Emit the key event signal from stage. - mStage.EmitKeyEventSignal(keyEvent); + consumed = mStage.EmitKeyEventGeneratedSignal( keyEvent ); + + if( !consumed ) + { + mStage.EmitKeyEventSignal(keyEvent); + } } } // namespace Internal diff --git a/dali/public-api/dali-core-version.cpp b/dali/public-api/dali-core-version.cpp index c6304cb..6d555e2 100644 --- a/dali/public-api/dali-core-version.cpp +++ b/dali/public-api/dali-core-version.cpp @@ -28,7 +28,7 @@ namespace Dali const unsigned int CORE_MAJOR_VERSION = 1; const unsigned int CORE_MINOR_VERSION = 2; -const unsigned int CORE_MICRO_VERSION = 34; +const unsigned int CORE_MICRO_VERSION = 35; const char * const CORE_BUILD_DATE = __DATE__ " " __TIME__; #ifndef EMSCRIPTEN diff --git a/dali/public-api/events/key-event.cpp b/dali/public-api/events/key-event.cpp index 0645ed1..7ed937f 100644 --- a/dali/public-api/events/key-event.cpp +++ b/dali/public-api/events/key-event.cpp @@ -18,6 +18,10 @@ // CLASS HEADER #include +// INTERNAL INCLUDES +#include +#include + namespace Dali { @@ -28,6 +32,17 @@ const unsigned int MODIFIER_CTRL = 0x2; const unsigned int MODIFIER_ALT = 0x4; const int KEY_INVALID_CODE = -1; +struct KeyEventImpl +{ + std::string deviceName; +}; + +typedef std::map< KeyEvent*, KeyEventImpl*> KeyEventMap; +typedef KeyEventMap::const_iterator KeyEventMapIter; + + +KeyEventMap keyEventImplMap; + } KeyEvent::KeyEvent() @@ -38,6 +53,8 @@ KeyEvent::KeyEvent() time(0), state(KeyEvent::Down) { + KeyEventImpl* impl = new KeyEventImpl; + keyEventImplMap[this] = impl; } KeyEvent::KeyEvent(const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier,unsigned long timeStamp, const State& keyState) @@ -48,10 +65,14 @@ KeyEvent::KeyEvent(const std::string& keyName, const std::string& keyString, int time(timeStamp), state(keyState) { + KeyEventImpl* impl = new KeyEventImpl; + keyEventImplMap[this] = impl; } KeyEvent::~KeyEvent() { + delete keyEventImplMap[this]; + keyEventImplMap.erase( this ); } bool KeyEvent::IsShiftModifier() const @@ -84,4 +105,31 @@ bool KeyEvent::IsAltModifier() const return false; } +std::string DevelKeyEvent::GetDeviceName( KeyEvent& keyEvent ) +{ + KeyEventMapIter search; + + search = keyEventImplMap.find( &keyEvent ); + + std::string result = ""; + + if( search != keyEventImplMap.end()) + { + result = search->second->deviceName; + } + + return result; +} + +void DevelKeyEvent::SetDeviceName( KeyEvent& keyEvent, std::string deviceName ) +{ + KeyEventMapIter search = keyEventImplMap.find( &keyEvent ); + + if( search != keyEventImplMap.end()) + { + search->second->deviceName = deviceName; + } +} + + } // namespace Dali diff --git a/dali/public-api/signals/base-signal.cpp b/dali/public-api/signals/base-signal.cpp index 9080179..c84393a 100644 --- a/dali/public-api/signals/base-signal.cpp +++ b/dali/public-api/signals/base-signal.cpp @@ -271,10 +271,19 @@ void BaseSignal::DeleteConnection( std::size_t connectionIndex ) SignalConnection* connection( mSignalConnections[ connectionIndex ] ); delete connection; - // IMPORTANT - do not remove from items from mSignalConnections, set to NULL instead. - // Signal Emit() methods require that connection count is not reduced while iterating - // i.e. DeleteConnection can be called from within callbacks, while iterating through mSignalConnections. - mSignalConnections[ connectionIndex ] = NULL; + if( mEmittingFlag ) + { + // IMPORTANT - do not remove from items from mSignalConnections, set to NULL instead. + // Signal Emit() methods require that connection count is not reduced while iterating + // i.e. DeleteConnection can be called from within callbacks, while iterating through mSignalConnections. + mSignalConnections[ connectionIndex ] = NULL; + } + else + { + // If application connects and disconnects without the signal never emitting, + // the mSignalConnections vector keeps growing and growing as CleanupConnections() is done from Emit. + mSignalConnections.Erase( mSignalConnections.Begin() + connectionIndex ); + } } void BaseSignal::CleanupConnections() diff --git a/packaging/dali.spec b/packaging/dali.spec index 716a7cf..f767ea1 100644 --- a/packaging/dali.spec +++ b/packaging/dali.spec @@ -1,6 +1,6 @@ Name: dali Summary: The OpenGLES Canvas Core Library -Version: 1.2.34 +Version: 1.2.35 Release: 1 Group: System/Libraries License: Apache-2.0 and BSD-2-Clause and MIT