#include <stdlib.h>
#include <dali/public-api/dali-core.h>
#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/devel-api/events/key-event-devel.h>
#include <dali-test-suite-utils.h>
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 );
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;
+}
#include <stdlib.h>
#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/common/stage-devel.h>
#include <dali/integration-api/context-notifier.h>
#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/public-api/events/key-event.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
namespace
{
+const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
+
// Functor for EventProcessingFinished signal
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
{
signalData.receivedTouchData = touch;
}
+ void operator()()
+ {
+ signalData.functorCalled = true;
+ }
+
TouchedSignalData& signalData;
};
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<Integration::KeyEvent::State>( 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<Integration::KeyEvent::State>( 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<Integration::KeyEvent::State>( 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<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
+ END_TEST;
+}
+
int UtcDaliStageSignalKeyEventP(void)
{
TestApplication application;
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 );
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 );
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 );
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 );
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.
{
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
--- /dev/null
+/*
+ * 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 <dali/devel-api/common/stage-devel.h>
+#include <dali/internal/event/common/stage-impl.h>
+
+namespace Dali
+{
+
+namespace DevelStage
+{
+
+KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage )
+{
+ return GetImplementation( stage ).KeyEventGeneratedSignal();
+}
+
+} // namespace DevelStage
+
+} // namespace Dali
--- /dev/null
+#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 <dali/public-api/common/stage.h>
+
+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
--- /dev/null
+#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 <dali/public-api/events/key-event.h>
+
+namespace Dali
+{
+
+namespace DevelKeyEvent
+{
+ std::string GetDeviceName( KeyEvent& keyEvent );
+
+ void SetDeviceName( KeyEvent& keyEvent, std::string deviceName );
+
+}
+
+}
+
+#endif //DALI_KEY_EVENT_DEVEL_H
$(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 \
$(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
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("")
{
}
// INTERNAL INCLUDES
#include <dali/integration-api/events/event.h>
+#include <dali/public-api/events/key-event.h>
namespace Dali DALI_IMPORT_API
{
* @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
*/
State state;
+ /**
+ * Name of device KeyEvent originated from
+ */
+ std::string deviceName;
+
};
} // namespace Integration
}
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;
+ }
}
}
// 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";
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
{
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 );
{
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 );
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();
return mKeyEventSignal;
}
+Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
+{
+ return mKeyEventGeneratedSignal;
+}
+
Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
{
return mEventProcessingFinishedSignal;
// INTERNAL INCLUDES
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/common/stage.h>
+#include <dali/devel-api/common/stage-devel.h>
#include <dali/public-api/object/base-object.h>
#include <dali/integration-api/context-notifier.h>
#include <dali/internal/common/owner-pointer.h>
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()
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.
// The key event signal
Dali::Stage::KeyEventSignalType mKeyEventSignal;
+ Dali::DevelStage::KeyEventGeneratedSignalType mKeyEventGeneratedSignal;
// The event processing finished signal
Dali::Stage::EventProcessingFinishedSignalType mEventProcessingFinishedSignal;
#include <dali/internal/event/events/key-event-processor.h>
// INTERNAL INCLUDES
+#include <dali/devel-api/events/key-event-devel.h>
#include <dali/public-api/events/key-event.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/common/stage-impl.h>
void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
{
+ bool consumed = false;
KeyEvent keyEvent(event.keyName, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<KeyEvent::State>(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
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
// CLASS HEADER
#include <dali/public-api/events/key-event.h>
+// INTERNAL INCLUDES
+#include <dali/devel-api/events/key-event-devel.h>
+#include <dali/devel-api/common/map-wrapper.h>
+
namespace Dali
{
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()
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)
time(timeStamp),
state(keyState)
{
+ KeyEventImpl* impl = new KeyEventImpl;
+ keyEventImplMap[this] = impl;
}
KeyEvent::~KeyEvent()
{
+ delete keyEventImplMap[this];
+ keyEventImplMap.erase( this );
}
bool KeyEvent::IsShiftModifier() 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
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()
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
projects / platform / core / uifw / dali-core.git / commitdiff