{
class GraphicsInterface;
+class SceneHolder;
} // namespace Adaptor
Dali::WindowContainer GetWindows();
Dali::SceneHolderList GetSceneHolders();
+ Dali::Internal::Adaptor::SceneHolder* GetWindow( Dali::Actor& actor );
+ void AddWindow( Internal::Adaptor::SceneHolder* window );
+ void RemoveWindow( Internal::Adaptor::SceneHolder* window );
+
Dali::Adaptor::AdaptorSignalType& ResizedSignal();
Dali::Adaptor::AdaptorSignalType& LanguageChangedSignal();
Dali::Adaptor::WindowCreatedSignalType& WindowCreatedSignal();
private:
Vector<CallbackBase*> mCallbacks;
- Dali::WindowContainer mWindows;
- Dali::SceneHolderList mSceneHolders;
+ std::vector<Internal::Adaptor::SceneHolder*> mWindows;
Dali::Adaptor::AdaptorSignalType mResizedSignal;
Dali::Adaptor::AdaptorSignalType mLanguageChangedSignal;
Dali::Adaptor::WindowCreatedSignalType mWindowCreatedSignal;
#include <algorithm>
-#include <toolkit-window.h>
+#include <toolkit-window-impl.h>
// Don't want to include the actual window.h which otherwise will be indirectly included by adaptor.h.
#define DALI_WINDOW_H
void Adaptor::Start( Dali::Window window )
{
- if ( window )
- {
- mWindows.push_back( window );
-
- mSceneHolders.emplace_back( static_cast<SceneHolder*>( &window.GetBaseObject() ) );
- }
+ AddWindow( &GetImplementation( window ) );
}
Integration::Scene Adaptor::GetScene( Dali::Window window )
{
DALI_ASSERT_ALWAYS( ! mWindows.empty() );
- return reinterpret_cast < Dali::RenderSurfaceInterface& >( mWindows.front().GetRenderSurface() );
+ return reinterpret_cast < Dali::RenderSurfaceInterface& >( mWindows.front()->GetRenderSurface() );
}
Dali::WindowContainer Adaptor::GetWindows()
{
- return mWindows;
+ Dali::WindowContainer windows;
+
+ for ( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ // Downcast to Dali::Window
+ Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( *iter ) );
+ if ( window )
+ {
+ windows.push_back( window );
+ }
+ }
+
+ return windows;
}
Dali::SceneHolderList Adaptor::GetSceneHolders()
{
- return mSceneHolders;
+ Dali::SceneHolderList sceneHolderList;
+
+ for( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ sceneHolderList.push_back( Dali::Integration::SceneHolder( *iter ) );
+ }
+
+ return sceneHolderList;
+}
+
+Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor )
+{
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor );
+
+ for( auto window : mWindows )
+ {
+ if ( scene == window->GetScene() )
+ {
+ return window;
+ }
+ }
+
+ return nullptr;
+}
+
+void Adaptor::AddWindow( Internal::Adaptor::SceneHolder* window )
+{
+ if ( window )
+ {
+ mWindows.push_back( window );
+
+ Dali::Integration::SceneHolder newWindow( window );
+ mWindowCreatedSignal.Emit( newWindow );
+ }
+}
+
+void Adaptor::RemoveWindow( Internal::Adaptor::SceneHolder* window )
+{
+ auto iter = std::find( mWindows.begin(), mWindows.end(), window );
+ if( iter != mWindows.end() )
+ {
+ mWindows.erase( iter );
+ }
}
Dali::Adaptor::AdaptorSignalType& Adaptor::ResizedSignal()
virtual ~SceneHolder();
+ void Add( Dali::Actor actor );
+
+ void Remove( Dali::Actor actor );
+
Dali::Layer GetRootLayer() const;
void SetBackgroundColor( Vector4 color );
#include <dali/integration-api/adaptors/adaptor.h>
#include <toolkit-adaptor-impl.h>
+using AdaptorImpl = Dali::Internal::Adaptor::Adaptor;
+
namespace Dali
{
SceneHolder::~SceneHolder()
{
+ if ( Dali::Adaptor::IsAvailable() )
+ {
+ AdaptorImpl::GetImpl( AdaptorImpl::Get() ).RemoveWindow( this );
+ }
+}
+
+void SceneHolder::Add( Dali::Actor actor )
+{
+ mScene.Add( actor );
+}
+
+void SceneHolder::Remove( Dali::Actor actor )
+{
+ mScene.Add( actor );
+}
+
+Dali::Layer SceneHolder::GetRootLayer() const
+{
+ return mScene.GetRootLayer();
}
void SceneHolder::SetBackgroundColor( Vector4 color )
return *this;
}
+Dali::Integration::SceneHolder SceneHolder::Get( Dali::Actor actor )
+{
+ Internal::Adaptor::SceneHolder* sceneHolderImpl = nullptr;
+
+ if ( Dali::Adaptor::IsAvailable() )
+ {
+ sceneHolderImpl = AdaptorImpl::GetImpl( AdaptorImpl::Get() ).GetWindow( actor );
+ }
+
+ return Dali::Integration::SceneHolder( sceneHolderImpl );
+}
+
void SceneHolder::Add( Actor actor )
{
+ GetImplementation( *this ).Add( actor );
}
void SceneHolder::Remove( Actor actor )
{
+ GetImplementation( *this ).Remove( actor );
}
Dali::Layer SceneHolder::GetRootLayer() const
{
- return Dali::Stage::GetCurrent().GetRootLayer();
+ return GetImplementation( *this ).GetRootLayer();
}
void SceneHolder::SetBackgroundColor( Vector4 color )
return GetImplementation( *this ).WheelEventSignal();
}
-SceneHolder SceneHolder::Get( Actor actor )
-{
- return SceneHolder();
-}
-
} // Integration
} // Dali
ToolkitTestApplication::ToolkitTestApplication( size_t surfaceWidth, size_t surfaceHeight, float horizontalDpi, float verticalDpi )
: TestApplication( surfaceWidth, surfaceHeight, horizontalDpi, verticalDpi, ResourcePolicy::DALI_DISCARDS_ALL_DATA, false /* Do not Initialize Core */ ),
+ mMainWindow( new Dali::Window ),
mAdaptor( &AdaptorImpl::New() ) // Need to create Adaptor first as many singletons in dali-adaptor need it
{
// Create Core next
// Override Scene creation in TestApplication by creating a window.
// The window will create a Scene & surface and set up the scene's surface appropriately.
- Window window( Window::New( PositionSize( 0, 0, surfaceWidth, surfaceHeight ), "" ) );
- mScene = AdaptorImpl::GetScene( window );
+ *mMainWindow = Window::New( PositionSize( 0, 0, surfaceWidth, surfaceHeight ), "" );
+ mScene = AdaptorImpl::GetScene( *mMainWindow );
mRenderSurface = dynamic_cast< TestRenderSurface* >( mScene.GetSurface() );
mScene.SetDpi( Vector2( horizontalDpi, verticalDpi ) );
Test::SetApplication( singletonService, *this );
// This will also emit the window created signals
- AdaptorImpl::GetImpl( *mAdaptor ).Start( window );
+ AdaptorImpl::GetImpl( *mAdaptor ).Start( *mMainWindow );
Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
lifecycleController.InitSignal().Emit();
{
class Adaptor;
+class Window;
/**
* Adds some functionality on top of TestApplication that is required by the Toolkit.
void RunIdles();
private:
+
+ std::unique_ptr<Dali::Window> mMainWindow;
std::unique_ptr< Adaptor > mAdaptor;
};
--- /dev/null
+#ifndef TOOLKIT_WINDOW_IMPL_H
+#define TOOLKIT_WINDOW_IMPL_H
+
+/*
+ * Copyright (c) 2019 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 <string>
+#include <dali/integration-api/adaptors/scene-holder.h>
+
+// INTERNAL INCLUDES
+#include <toolkit-window.h>
+#include <toolkit-scene-holder-impl.h>
+
+namespace Dali
+{
+
+typedef Dali::Rect<int> PositionSize;
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+class Window : public SceneHolder
+{
+public:
+
+ Window( const PositionSize& positionSize );
+ virtual ~Window() = default;
+ static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent);
+};
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
+
+
+#endif // TOOLKIT_WINDOW_IMPL_H
*/
// CLASS HEADER
-#include "toolkit-window.h"
+#include "toolkit-window-impl.h"
// EXTERNAL INCLUDES
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/common/stage.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/integration-api/adaptors/scene-holder.h>
-#include <toolkit-scene-holder-impl.h>
-
#define DALI_WINDOW_H
#include <dali/integration-api/adaptors/adaptor.h>
#include <toolkit-adaptor-impl.h>
{
namespace Adaptor
{
-class Window : public SceneHolder
-{
-public:
-
- Window( const PositionSize& positionSize )
- : SceneHolder( positionSize )
- {
- }
- virtual ~Window() = default;
+Window::Window( const PositionSize& positionSize )
+: SceneHolder( positionSize )
+{
+}
- static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
- {
- return new Window( positionSize );
- }
-};
+Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
+{
+ return new Window( positionSize );
+}
} // Adaptor
} // Internal
return static_cast<Internal::Adaptor::Window&>(object);
}
+inline const Internal::Adaptor::Window& GetImplementation(const Dali::Window& window)
+{
+ DALI_ASSERT_ALWAYS( window && "Window handle is empty" );
+ const BaseObject& object = window.GetBaseObject();
+ return static_cast<const Internal::Adaptor::Window&>(object);
+}
+
Window::Window()
{
}
Dali::Window result( window );
- Dali::Integration::SceneHolder sceneHolder( static_cast<Dali::Internal::Adaptor::SceneHolder*>( window ) );
- Dali::Internal::Adaptor::Adaptor::Get().WindowCreatedSignal().Emit( sceneHolder );
+ // This will also emit the window created signals
+ AdaptorImpl::GetImpl( AdaptorImpl::Get() ).AddWindow( window );
return result;
}
-Dali::Layer Window::GetRootLayer() const
-{
- return Dali::Stage::GetCurrent().GetRootLayer();
-}
-
Window::Window( Internal::Adaptor::Window* window )
: BaseHandle( window )
{
Window Get( Actor actor )
{
- return Window();
+ Internal::Adaptor::Window* windowImpl = nullptr;
+
+ if ( Dali::Adaptor::IsAvailable() )
+ {
+ windowImpl = static_cast<Internal::Adaptor::Window*>( AdaptorImpl::GetImpl( AdaptorImpl::Get() ).GetWindow( actor ) );
+ }
+
+ return Dali::Window( windowImpl );
}
EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window )
~Window();
Window(const Window& handle);
Window& operator=(const Window& rhs);
- Layer GetRootLayer() const;
Integration::Scene GetScene();
Integration::RenderSurface& GetRenderSurface();
explicit Window( Internal::Adaptor::Window* window );
};
+Internal::Adaptor::Window& GetImplementation(Dali::Window& window);
+const Internal::Adaptor::Window& GetImplementation(const Dali::Window& window);
+
namespace DevelWindow
{
typedef Signal< void () > EventProcessingFinishedSignalType;
Actor parent;
if(actor)
{
- rootActor = Integration::SceneHolder::Get( actor ).GetRootLayer();
+ Integration::SceneHolder window = Integration::SceneHolder::Get( actor );
+ if ( window )
+ {
+ rootActor = window.GetRootLayer();
+ }
+
parent = actor.GetParent();
}
if( !nextFocusableActor )
{
- nextFocusableActor = Integration::SceneHolder::Get( currentFocusActor ).GetRootLayer().FindChildById( actorId );
+ Integration::SceneHolder window = Integration::SceneHolder::Get( currentFocusActor );
+ if ( window )
+ {
+ nextFocusableActor = window.GetRootLayer().FindChildById( actorId );
+ }
}
}
}