/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 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.
#include <dali/internal/event/actors/layer-impl.h>
#include <dali/internal/event/actors/layer-list.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
-#include <dali/internal/event/actor-attachments/camera-attachment-impl.h>
#include <dali/internal/event/common/system-overlay-impl.h>
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/common/property-notification-manager.h>
#include <dali/internal/event/common/object-registry-impl.h>
#include <dali/integration-api/platform-abstraction.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/render-tasks/render-task-list.h>
-#ifdef DYNAMICS_SUPPORT
-#include <dali/internal/event/dynamics/dynamics-world-config-impl.h>
-#include <dali/internal/event/dynamics/dynamics-world-impl.h>
-#include <dali/integration-api/dynamics/dynamics-factory-intf.h>
-#include <dali/integration-api/dynamics/dynamics-world-settings.h>
-#endif
-
using Dali::Internal::SceneGraph::Node;
+namespace
+{
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
+#endif
+}
+
namespace Dali
{
// Signals
-const char* const SIGNAL_KEY_EVENT = "key-event";
-const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
+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_CONTEXT_LOST = "context-lost";
-const char* const SIGNAL_CONTEXT_REGAINED = "context-regained";
-const char* const SIGNAL_SCENE_CREATED = "scene-created";
+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";
+const char* const SIGNAL_SCENE_CREATED = "sceneCreated";
TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT, &Stage::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
SignalConnectorType signalConnector3( mType, SIGNAL_TOUCHED, &Stage::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_CONTEXT_LOST, &Stage::DoConnectSignal );
-SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_REGAINED, &Stage::DoConnectSignal );
-SignalConnectorType signalConnector6( mType, SIGNAL_SCENE_CREATED, &Stage::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_WHEEL_EVENT, &Stage::DoConnectSignal );
+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
// The stage owns the default layer
mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager, false/*not system-level*/ );
mRootLayer->SetName("RootLayer");
+ // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
+ // This stops actors parented to the stage having their relayout requests propagating
+ // up to the root layer, and down through other children unnecessarily.
+ mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
// Create the default camera actor first; this is needed by the RenderTaskList
CreateDefaultCameraActor();
if( mDefaultCamera )
{
- Remove(*(mDefaultCamera.Get()));
+ // its enough to release the handle so the object is released
+ // don't need to remove it from root actor as root actor will delete the object
+ mDefaultCamera.Reset();
}
if( mRootLayer )
mRootLayer->Remove( actor );
}
-void Stage::SetSize(float width, float height)
+void Stage::SurfaceResized(float width, float height)
{
+ mSurfaceSize.width = width;
+ mSurfaceSize.height = height;
+
// Internally we want to report the actual size of the stage.
- mSize.width = width;
- mSize.height = height;
+ mSize.width = width;
+ mSize.height = height - mTopMargin;
// Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
- mDefaultCamera->SetPerspectiveProjection( mSize );
+ mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
+
+ // Adjust the camera height to allow for top-margin
+ SetDefaultCameraPosition();
- // The depth of the stage gets set to the maximun of these values
- mRootLayer->SetSize( mSize );
+ mRootLayer->SetSize( mSize.width, mSize.height );
// Repeat for SystemOverlay actors
if( mSystemOverlay )
{
- mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
+ // Note that the SystemOverlay has a separate camera, configured for the full surface-size.
+ // This will remain unaffected by changes in SetDefaultCameraPosition()
+ mSystemOverlay->GetImpl()->SetSize( width, height );
}
SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int>( 0, 0, width, height ) );
+
+ // if single render task to screen then set its viewport parameters
+ if( 1 == mRenderTaskList->GetTaskCount() )
+ {
+ Dali::RenderTask mDefaultRenderTask = mRenderTaskList->GetTask(0);
+
+ if(!mDefaultRenderTask.GetTargetFrameBuffer())
+ {
+ mDefaultRenderTask.SetViewport( Viewport(0, 0, width, height) );
+ }
+ }
+
}
Vector2 Stage::GetSize() const
return mSize;
}
+void Stage::SetTopMargin( unsigned int margin )
+{
+ if (mTopMargin == margin)
+ {
+ return;
+ }
+ mTopMargin = margin;
+
+ mSize.width = mSurfaceSize.width;
+ mSize.height = mSurfaceSize.height - mTopMargin;
+
+ // Adjust the camera height to allow for top-margin
+ SetDefaultCameraPosition();
+
+ mRootLayer->SetSize( mSize.width, mSize.height );
+}
+
RenderTaskList& Stage::GetRenderTaskList() const
{
return *mRenderTaskList;
Add(*(mDefaultCamera.Get()));
}
+void Stage::SetDefaultCameraPosition()
+{
+ mDefaultCamera->SetY( -(static_cast<float>(mTopMargin) * 0.5f) );
+}
+
Actor& Stage::GetDefaultRootActor()
{
return *mRootLayer;
{
if( ! Equals( mStereoBase, stereoBase ) )
{
- DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)", mStereoBase, stereoBase );
+ DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)\n", mStereoBase, stereoBase );
mStereoBase = stereoBase;
switch( mViewMode )
mDpi = dpi;
}
-#ifdef DYNAMICS_SUPPORT
-
-DynamicsNotifier& Stage::GetDynamicsNotifier()
-{
- return mDynamicsNotifier;
-}
-
-DynamicsWorldPtr Stage::InitializeDynamics(DynamicsWorldConfigPtr config)
-{
- if( !mDynamicsFactory )
- {
- mDynamicsFactory = ThreadLocalStorage::Get().GetPlatformAbstraction().GetDynamicsFactory();
- }
-
- if( mDynamicsFactory && !mDynamicsWorld )
- {
- if( mDynamicsFactory->InitializeDynamics( *(config->GetSettings()) ) )
- {
- mDynamicsWorld = DynamicsWorld::New();
- mDynamicsWorld->Initialize( *this, *mDynamicsFactory, config );
- }
- }
- return mDynamicsWorld;
-}
-
-DynamicsWorldPtr Stage::GetDynamicsWorld()
-{
- return mDynamicsWorld;
-}
-
-void Stage::TerminateDynamics()
-{
- if( mDynamicsWorld )
- {
- mDynamicsWorld->Terminate(*this);
- mDynamicsWorld = NULL;
- }
-}
-
-#endif // DYNAMICS_SUPPORT
-
void Stage::KeepRendering( float durationSeconds )
{
// Send message to keep rendering
bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- Stage* stage = dynamic_cast<Stage*>(object);
+ Stage* stage = static_cast< Stage* >(object); // TypeRegistry guarantees that this is the correct type.
if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
{
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 );
+ }
else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
{
stage->ContextLostSignal().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();
}
-void Stage::EmitTouchedSignal( const TouchEvent& touch )
+void Stage::EmitTouchedSignal( const TouchEvent& touchEvent, const Dali::TouchData& touch )
{
- mTouchedSignal.Emit( touch );
+ mTouchedSignal.Emit( touchEvent );
+ mTouchSignal.Emit( touch );
}
+void Stage::EmitWheelEventSignal(const WheelEvent& event)
+{
+ // Emit the wheel event signal when no actor in the stage has gained the wheel input focus
+
+ mWheelEventSignal.Emit( event );
+}
void Stage::EmitSceneCreatedSignal()
{
return mKeyEventSignal;
}
+Dali::DevelStage::KeyEventGeneratedSignalType& Stage::KeyEventGeneratedSignal()
+{
+ return mKeyEventGeneratedSignal;
+}
+
Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
{
return mEventProcessingFinishedSignal;
Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
{
+ DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead.\n" );
return mTouchedSignal;
}
+Dali::Stage::TouchSignalType& Stage::TouchSignal()
+{
+ return mTouchSignal;
+}
+
+Dali::Stage::WheelEventSignalType& Stage::WheelEventSignal()
+{
+ return mWheelEventSignal;
+}
+
Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
{
return mContextLostSignal;
mContextRegainedSignal.Emit();
}
+
+void Stage::RequestRebuildDepthTree()
+{
+ DALI_LOG_INFO(gLogFilter, Debug::General, "RequestRebuildDepthTree()\n");
+ mDepthTreeDirty = true;
+}
+
+void Stage::RebuildDepthTree()
+{
+ // If the depth tree needs rebuilding, do it in this frame only.
+ if( mDepthTreeDirty )
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::Concise, "RebuildDepthTree() dirty:T\n");
+
+ ActorPtr actor( mRootLayer.Get() );
+ actor->RebuildDepthTree();
+ mDepthTreeDirty = false;
+ }
+}
+
+
Stage::Stage( AnimationPlaylist& playlist,
PropertyNotificationManager& propertyNotificationManager,
SceneGraph::UpdateManager& updateManager,
mBackgroundColor(Dali::Stage::DEFAULT_BACKGROUND_COLOR),
mViewMode( MONO ),
mStereoBase( DEFAULT_STEREO_BASE ),
-#ifdef DYNAMICS_SUPPORT
- mDynamicsFactory(NULL),
-#endif
+ mTopMargin( 0 ),
mSystemOverlay(NULL)
{
}
projects / platform / core / uifw / dali-core.git / blobdiff