../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
dali-toolkit-test-utils/toolkit-style-monitor.cpp
dali-toolkit-test-utils/toolkit-singleton-service.cpp
+ dali-toolkit-test-utils/toolkit-test-application.cpp
dali-toolkit-test-utils/toolkit-timer.cpp
+ dali-toolkit-test-utils/toolkit-trigger-event-factory.cpp
dali-toolkit-test-utils/toolkit-tts-player.cpp
dali-toolkit-test-utils/toolkit-native-image-source.cpp
dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
dali-toolkit-test-utils/toolkit-video-player.cpp
dali-toolkit-test-utils/toolkit-web-engine.cpp
dali-toolkit-test-utils/toolkit-window.cpp
- dali-toolkit-test-utils/toolkit-trigger-event-factory.cpp
dali-toolkit-test-utils/dali-test-suite-utils.cpp
dali-toolkit-test-utils/dali-toolkit-test-suite-utils.cpp
dali-toolkit-test-utils/dummy-control.cpp
uint32_t surfaceHeight,
uint32_t horizontalDpi,
uint32_t verticalDpi,
- ResourcePolicy::DataRetention policy)
+ ResourcePolicy::DataRetention policy,
+ bool initialize )
: mCore( NULL ),
mSurfaceWidth( surfaceWidth ),
mSurfaceHeight( surfaceHeight ),
mLastVSyncTime(0u),
mDataRetentionPolicy( policy )
{
- Initialize();
+ if( initialize )
+ {
+ Initialize();
+ }
}
void TestApplication::Initialize()
{
+ CreateCore();
+ CreateScene();
+ InitializeCore();
+}
+
+void TestApplication::CreateCore()
+{
// We always need the first update!
mStatus.keepUpdating = Integration::KeepUpdating::STAGE_KEEP_RENDERING;
Dali::Integration::Trace::InstallLogContextFunction( logContextFunction );
Dali::Integration::Trace::LogContext( true, "Test" );
+}
+void TestApplication::CreateScene()
+{
mRenderSurface = new TestRenderSurface( Dali::PositionSize( 0, 0, mSurfaceWidth, mSurfaceHeight ) );
mScene = Dali::Integration::Scene::New( Vector2( static_cast<float>( mSurfaceWidth ), static_cast<float>( mSurfaceHeight ) ) );
mScene.SetSurface( *mRenderSurface );
-
mScene.SetDpi( Vector2( static_cast<float>( mDpi.x ), static_cast<float>( mDpi.y ) ) );
mCore->SurfaceResized( mRenderSurface );
+}
+void TestApplication::InitializeCore()
+{
mCore->SceneCreated();
mCore->Initialize();
}
static const uint32_t DEFAULT_SURFACE_WIDTH = 480;
static const uint32_t DEFAULT_SURFACE_HEIGHT = 800;
-#ifdef _CPP11
static constexpr uint32_t DEFAULT_HORIZONTAL_DPI = 220;
static constexpr uint32_t DEFAULT_VERTICAL_DPI = 217;
-#else
- static const uint32_t DEFAULT_HORIZONTAL_DPI = 220;
- static const uint32_t DEFAULT_VERTICAL_DPI = 217;
-#endif
static const uint32_t DEFAULT_RENDER_INTERVAL = 1;
uint32_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
uint32_t horizontalDpi = DEFAULT_HORIZONTAL_DPI,
uint32_t verticalDpi = DEFAULT_VERTICAL_DPI,
- ResourcePolicy::DataRetention policy = ResourcePolicy::DALI_DISCARDS_ALL_DATA);
+ ResourcePolicy::DataRetention policy = ResourcePolicy::DALI_DISCARDS_ALL_DATA,
+ bool initialize = true );
void Initialize();
+ void CreateCore();
+ void CreateScene();
+ void InitializeCore();
virtual ~TestApplication();
static void LogMessage( Dali::Integration::Log::DebugPriority level, std::string& message );
static void LogContext( bool start, const char* tag );
class ThreadSynchronizationInterface;
class Window;
+namespace Integration
+{
+class Scene;
+}
+
using WindowContainer = std::vector<Window>;
namespace Internal
namespace Adaptor
{
-class Adaptor: public BaseObject
+class Adaptor
{
public:
+ static Dali::Adaptor& New();
static Dali::Adaptor& Get();
Adaptor();
~Adaptor();
-public:
- static Dali::RenderSurfaceInterface& GetSurface();
- static Dali::WindowContainer GetWindows();
- static Dali::Adaptor::AdaptorSignalType& AdaptorSignal();
- static Dali::Adaptor::WindowCreatedSignalType& WindowCreatedSignal();
- static bool mAvailable;
- static Vector<CallbackBase*> mCallbacks;
- static Dali::WindowContainer mWindows;
- static Dali::Adaptor::WindowCreatedSignalType* mWindowCreatedSignal;
+ void Start( Dali::Window window );
+
+ bool AddIdle( CallbackBase* callback, bool hasReturnValue );
+ void RemoveIdle( CallbackBase* callback );
+ void RunIdles();
+
+ static Integration::Scene GetScene( Dali::Window window );
+
+ Dali::RenderSurfaceInterface& GetSurface();
+ Dali::WindowContainer GetWindows();
+
+ Dali::Adaptor::AdaptorSignalType& ResizedSignal();
+ Dali::Adaptor::AdaptorSignalType& LanguageChangedSignal();
+ Dali::Adaptor::WindowCreatedSignalType& WindowCreatedSignal();
+
+ static Adaptor& GetImpl( Dali::Adaptor& adaptor ) { return *adaptor.mImpl; }
+ static const Adaptor& GetImpl( const Dali::Adaptor& adaptor ) { return *adaptor.mImpl; }
+
+private:
+
+ Vector<CallbackBase*> mCallbacks;
+ Dali::WindowContainer mWindows;
+ Dali::Adaptor::AdaptorSignalType mResizedSignal;
+ Dali::Adaptor::AdaptorSignalType mLanguageChangedSignal;
+ Dali::Adaptor::WindowCreatedSignalType mWindowCreatedSignal;
};
} // namespace Adaptor
*
*/
+#include <algorithm>
+
#include <toolkit-window.h>
// Don't want to include the actual window.h which otherwise will be indirectly included by adaptor.h.
#include <dali/integration-api/adaptors/scene-holder.h>
-#include <dali/public-api/object/base-object.h>
-
#include <toolkit-adaptor-impl.h>
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/scene.h>
#include <test-application.h>
#include <test-render-surface.h>
namespace Dali
{
+namespace
+{
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// LogFactoryStub
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class LogFactory : public LogFactoryInterface
+{
+public:
+ LogFactory() = default;
+ virtual ~LogFactory() = default;
+
+private:
+ void InstallLogFunction() const override
+ {
+ Dali::Integration::Log::InstallLogFunction( &TestApplication::LogMessage );
+ }
+};
+LogFactory* gLogFactory = NULL; // For some reason, destroying this when the Adaptor is destroyed causes a crash in some test cases when running all of them.
+} //unnamed namespace
+
namespace Internal
{
namespace Adaptor
{
-bool Adaptor::mAvailable = false;
-Vector<CallbackBase*> Adaptor::mCallbacks = Vector<CallbackBase*>();
-Dali::WindowContainer Adaptor::mWindows;
-Dali::Adaptor::WindowCreatedSignalType* Adaptor::mWindowCreatedSignal = nullptr;
+///////////////////////////////////////////////////////////////////////////////
+//
+// Dali::Internal::Adaptor::Adaptor Stub
+//
+///////////////////////////////////////////////////////////////////////////////
-Dali::Adaptor& Adaptor::Get()
+Dali::Adaptor* gAdaptor = nullptr;
+
+Dali::Adaptor& Adaptor::New()
{
- Dali::Adaptor* adaptor = new Dali::Adaptor;
- Adaptor::mAvailable = true;
- return *adaptor;
+ DALI_ASSERT_ALWAYS( ! gAdaptor );
+ gAdaptor = new Dali::Adaptor;
+ return *gAdaptor;
}
-Dali::RenderSurfaceInterface& Adaptor::GetSurface()
+Dali::Adaptor& Adaptor::Get()
{
- Dali::RenderSurfaceInterface* renderSurface = reinterpret_cast <Dali::RenderSurfaceInterface*>( new Dali::TestRenderSurface( Dali::PositionSize( 0, 0, 480, 800 ) ) );
- return *renderSurface;
+ DALI_ASSERT_ALWAYS( gAdaptor );
+ return *gAdaptor;
}
-Dali::WindowContainer Adaptor::GetWindows()
+Adaptor::Adaptor()
{
- return Adaptor::mWindows;
}
-Dali::Adaptor::AdaptorSignalType& Adaptor::AdaptorSignal()
+Adaptor::~Adaptor()
{
- Dali::Adaptor::AdaptorSignalType* signal = new Dali::Adaptor::AdaptorSignalType;
- return *signal;
+ gAdaptor = nullptr;
}
-Dali::Adaptor::WindowCreatedSignalType& Adaptor::WindowCreatedSignal()
+void Adaptor::Start( Dali::Window window )
{
- if ( !Adaptor::mWindowCreatedSignal )
+ if ( window )
{
- Adaptor::mWindowCreatedSignal = new Dali::Adaptor::WindowCreatedSignalType;
+ mWindows.push_back( window );
+ mWindowCreatedSignal.Emit( window );
}
+}
- return *Adaptor::mWindowCreatedSignal;
+Integration::Scene Adaptor::GetScene( Dali::Window window )
+{
+ return window.GetScene();
}
-} // namespace Adaptor
-} // namespace Internal
+bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue )
+{
+ mCallbacks.PushBack( callback );
+ return true;
+}
-Adaptor& Adaptor::New( Window window )
+void Adaptor::RemoveIdle( CallbackBase* callback )
{
- return Internal::Adaptor::Adaptor::Get();
+ mCallbacks.Erase( std::find_if( mCallbacks.Begin(), mCallbacks.End(),
+ [ &callback ] ( CallbackBase* current ) { return callback == current; } ) );
}
-Adaptor& Adaptor::New( Window window, Configuration::ContextLoss configuration )
+void Adaptor::RunIdles()
{
- return Internal::Adaptor::Adaptor::Get();
+ for( auto& callback : mCallbacks )
+ {
+ CallbackBase::Execute( *callback );
+ }
+
+ mCallbacks.Clear();
}
-Adaptor& Adaptor::New( Window window, const Dali::RenderSurfaceInterface& surface )
+Dali::RenderSurfaceInterface& Adaptor::GetSurface()
{
- return Internal::Adaptor::Adaptor::Get();
+ DALI_ASSERT_ALWAYS( ! mWindows.empty() );
+
+ return reinterpret_cast < Dali::RenderSurfaceInterface& >( mWindows.front().GetRenderSurface() );
}
-Adaptor& Adaptor::New( Window window, const Dali::RenderSurfaceInterface& surface, Configuration::ContextLoss configuration )
+Dali::WindowContainer Adaptor::GetWindows()
{
- return Internal::Adaptor::Adaptor::Get();
+ return mWindows;
}
-Adaptor& Adaptor::New( Dali::Integration::SceneHolder window )
+Dali::Adaptor::AdaptorSignalType& Adaptor::ResizedSignal()
{
- return Internal::Adaptor::Adaptor::Get();
+ return mResizedSignal;
}
-Adaptor& Adaptor::New( Dali::Integration::SceneHolder window, Configuration::ContextLoss configuration )
+Dali::Adaptor::AdaptorSignalType& Adaptor::LanguageChangedSignal()
{
- return Internal::Adaptor::Adaptor::Get();
+ return mLanguageChangedSignal;
}
-Adaptor& Adaptor::New( Dali::Integration::SceneHolder window, const Dali::RenderSurfaceInterface& surface )
+Dali::Adaptor::WindowCreatedSignalType& Adaptor::WindowCreatedSignal()
{
- return Internal::Adaptor::Adaptor::Get();
+ return mWindowCreatedSignal;
}
-Adaptor& Adaptor::New( Dali::Integration::SceneHolder window, const Dali::RenderSurfaceInterface& surface, Configuration::ContextLoss configuration )
+} // namespace Adaptor
+} // namespace Internal
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Dali::Adaptor Stub
+//
+///////////////////////////////////////////////////////////////////////////////
+
+Adaptor::Adaptor()
+: mImpl( new Internal::Adaptor::Adaptor )
{
- return Internal::Adaptor::Adaptor::Get();
}
Adaptor::~Adaptor()
{
+ Internal::Adaptor::gAdaptor = nullptr;
+ delete mImpl;
}
void Adaptor::Start()
bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue )
{
- const bool isAvailable = IsAvailable();
-
- if( isAvailable )
- {
- Internal::Adaptor::Adaptor::mCallbacks.PushBack( callback );
- }
-
- return isAvailable;
+ return mImpl->AddIdle( callback, hasReturnValue );
}
void Adaptor::RemoveIdle( CallbackBase* callback )
{
- const bool isAvailable = IsAvailable();
-
- if( isAvailable )
- {
- for( Vector<CallbackBase*>::Iterator it = Internal::Adaptor::Adaptor::mCallbacks.Begin(),
- endIt = Internal::Adaptor::Adaptor::mCallbacks.End();
- it != endIt;
- ++it )
- {
- if( callback == *it )
- {
- Internal::Adaptor::Adaptor::mCallbacks.Remove( it );
- return;
- }
- }
- }
+ mImpl->RemoveIdle( callback );
}
void Adaptor::ReplaceSurface( Window window, Dali::RenderSurfaceInterface& surface )
Adaptor::AdaptorSignalType& Adaptor::ResizedSignal()
{
- return Internal::Adaptor::Adaptor::AdaptorSignal();
+ return mImpl->ResizedSignal();
}
Adaptor::AdaptorSignalType& Adaptor::LanguageChangedSignal()
{
- return Internal::Adaptor::Adaptor::AdaptorSignal();
+ return mImpl->LanguageChangedSignal();
}
Adaptor::WindowCreatedSignalType& Adaptor::WindowCreatedSignal()
{
- return Internal::Adaptor::Adaptor::WindowCreatedSignal();
+ return mImpl->WindowCreatedSignal();
}
Dali::RenderSurfaceInterface& Adaptor::GetSurface()
{
- return Internal::Adaptor::Adaptor::GetSurface();
+ return mImpl->GetSurface();
}
Dali::WindowContainer Adaptor::GetWindows() const
{
- return Internal::Adaptor::Adaptor::GetWindows();
+ return mImpl->GetWindows();
}
Any Adaptor::GetNativeWindowHandle()
bool Adaptor::IsAvailable()
{
- return Internal::Adaptor::Adaptor::mAvailable;
+ return Internal::Adaptor::gAdaptor;
}
void Adaptor::NotifySceneCreated()
{
}
-class LogFactory : public LogFactoryInterface
-{
-public:
- virtual void InstallLogFunction() const
- {
- Dali::Integration::Log::LogFunction logFunction(&TestApplication::LogMessage);
- Dali::Integration::Log::InstallLogFunction(logFunction);
- }
-
- LogFactory()
- {
- }
- virtual ~LogFactory()
- {
- }
-};
-
-LogFactory* gLogFactory = NULL;
const LogFactoryInterface& Adaptor::GetLogFactory()
{
if( gLogFactory == NULL )
return *gLogFactory;
}
-Adaptor::Adaptor()
-: mImpl( NULL )
-{
- Dali::PositionSize win_size;
- win_size.width = 640;
- win_size.height = 800;
-
- Dali::Window window = Dali::Window::New( win_size, "" );
- Internal::Adaptor::Adaptor::mWindows.push_back( window );
-}
-
} // namespace Dali
--- /dev/null
+/*
+ * 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.
+ *
+ */
+
+// CLASS HEADER
+#include <toolkit-test-application.h>
+
+// INTERNAL INCLUDES
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
+#include <dali/integration-api/adaptors/adaptor.h>
+#include <toolkit-adaptor-impl.h>
+#include <toolkit-singleton-service.h>
+#include <toolkit-lifecycle-controller.h>
+
+namespace Dali
+{
+
+using AdaptorImpl = Dali::Internal::Adaptor::Adaptor;
+
+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 */ ),
+ mAdaptor( &AdaptorImpl::New() ) // Need to create Adaptor first as many singletons in dali-adaptor need it
+{
+ // Create Core next
+ CreateCore();
+
+ // 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 );
+ mRenderSurface = dynamic_cast< TestRenderSurface* >( mScene.GetSurface() );
+ mScene.SetDpi( Vector2( horizontalDpi, verticalDpi ) );
+
+ // Core needs to be initialized next before we start the adaptor
+ InitializeCore();
+
+ auto singletonService = SingletonService::Get();
+ Test::SetApplication( singletonService, *this );
+
+ // This will also emit the window created signals
+ AdaptorImpl::GetImpl( *mAdaptor ).Start( window );
+
+ Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
+ lifecycleController.InitSignal().Emit();
+
+ // set the DPI value for font rendering
+ TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
+ if( fontClient )
+ {
+ fontClient.SetDpi( mDpi.x, mDpi.y );
+ }
+}
+
+ToolkitTestApplication::~ToolkitTestApplication()
+{
+ // Need to delete core before we delete the adaptor.
+ delete mCore;
+ mCore = NULL;
+
+ // Set mRenderSurface to null, it will be deleted by the window that owns it
+ mRenderSurface = nullptr;
+}
+
+void ToolkitTestApplication::RunIdles()
+{
+ AdaptorImpl::GetImpl( *mAdaptor.get() ).RunIdles();
+}
+
+} // namespace Dali
*
*/
+// EXTERNAL INCLUDES
+#include <memory>
+
// INTERNAL INCLUDES
#include <dali-test-suite-utils.h>
-#include <dali/devel-api/text-abstraction/font-client.h>
-#include <dali/integration-api/adaptors/adaptor.h>
-#include <toolkit-adaptor-impl.h>
-#include <toolkit-singleton-service.h>
-#include <toolkit-lifecycle-controller.h>
namespace Dali
{
+class Adaptor;
+
/**
* Adds some functionality on top of TestApplication that is required by the Toolkit.
+ *
+ * This includes creation and destruction of the Adaptor and Window classes.
*/
class ToolkitTestApplication : public TestApplication
{
ToolkitTestApplication( size_t surfaceWidth = DEFAULT_SURFACE_WIDTH,
size_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
float horizontalDpi = DEFAULT_HORIZONTAL_DPI,
- float verticalDpi = DEFAULT_VERTICAL_DPI )
- : TestApplication( surfaceWidth, surfaceHeight, horizontalDpi, verticalDpi )
- {
- auto singletonService = SingletonService::Get();
- Test::SetApplication( singletonService, *this );
-
- // set the DPI value for font rendering
- Dali::TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
- if( fontClient )
- {
- fontClient.SetDpi( mDpi.x, mDpi.y );
- }
-
- bool isAdaptorAvailable = Dali::Internal::Adaptor::Adaptor::Get().IsAvailable();
- if ( isAdaptorAvailable )
- {
- Dali::LifecycleController lifecycleController = Dali::LifecycleController::Get();
- lifecycleController.InitSignal().Emit();
-
- Dali::Window window = Dali::Internal::Adaptor::Adaptor::mWindows.front();
- if ( window )
- {
- Dali::Internal::Adaptor::Adaptor::WindowCreatedSignal().Emit( window );
- }
- }
- }
+ float verticalDpi = DEFAULT_VERTICAL_DPI );
- ~ToolkitTestApplication()
- {
- // Need to delete core before we delete the adaptor.
- delete mCore;
- mCore = NULL;
- }
-
- //ToolkitOrientation& GetOrientation()
- //{
- //return mOrientation;
- //}
-
- /**
- * @brief Creates an adaptor implementation for those controls like the
- * text-field and the text-editor which connects a callback to the idle signal.
- */
- void CreateAdaptor()
- {
- Adaptor::Get();
- }
+ ~ToolkitTestApplication();
/**
* @brief Executes the idle callbacks.
* Some controls like the text-field and the text-editor connect callbacks to the
* idle signal.
*/
- void RunIdles()
- {
- if( Adaptor::IsAvailable() )
- {
- for( Vector<CallbackBase*>::Iterator it = Internal::Adaptor::Adaptor::mCallbacks.Begin(),
- endIt = Internal::Adaptor::Adaptor::mCallbacks.End();
- it != endIt;
- ++it )
- {
- CallbackBase* callback = *it;
-
- CallbackBase::Execute( *callback );
- }
-
- Internal::Adaptor::Adaptor::mCallbacks.Clear();
- }
- }
+ void RunIdles();
private:
- //ToolkitOrientation mOrientation;
+ std::unique_ptr< Adaptor > mAdaptor;
};
} // namespace Dali
*
*/
+// CLASS HEADER
+#include "toolkit-window.h"
+
// EXTERNAL INCLUDES
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/object/base-object.h>
// INTERNAL INCLUDES
-#include "toolkit-window.h"
+#include "test-render-surface.h"
namespace Dali
{
{
namespace Adaptor
{
-
class Window : public Dali::BaseObject
{
public:
- Window()
+ Window( const PositionSize& positionSize )
+ : mScene( Dali::Integration::Scene::New( Size( positionSize.width, positionSize.height ) ) ),
+ mRenderSurface( new TestRenderSurface( positionSize ) )
{
+ mScene.SetSurface( *mRenderSurface );
}
virtual ~Window()
{
+ delete mRenderSurface;
+ mRenderSurface = nullptr;
}
static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
{
- return new Window();
+ return new Window( positionSize );
}
- static Dali::Window Get( Dali::Actor actor )
- {
- return Dali::Window();
- }
+ Integration::Scene mScene;
+ TestRenderSurface* mRenderSurface;
};
} // Adaptor
} // Internal
+inline Internal::Adaptor::Window& GetImplementation(Dali::Window& window)
+{
+ DALI_ASSERT_ALWAYS( window && "Window handle is empty" );
+ BaseObject& object = window.GetBaseObject();
+ return static_cast<Internal::Adaptor::Window&>(object);
+}
+
Window::Window()
{
}
{
}
+Integration::Scene Window::GetScene()
+{
+ return GetImplementation( *this ).mScene;
+}
+
+Integration::RenderSurface& Window::GetRenderSurface()
+{
+ return *GetImplementation( *this ).mRenderSurface;
+}
+
namespace DevelWindow
{
Window Get( Actor actor )
{
- return Internal::Adaptor::Window::Get( actor );
+ return Window();
+}
+
+EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window )
+{
+ return GetImplementation( window ).mScene.EventProcessingFinishedSignal();
}
KeyEventSignalType& KeyEventSignal( Window window )
{
- return Dali::Stage::GetCurrent().KeyEventSignal();
+ return GetImplementation( window ).mScene.KeyEventSignal();
}
TouchSignalType& TouchSignal( Window window )
{
- return Dali::Stage::GetCurrent().TouchSignal();
+ return GetImplementation( window ).mScene.TouchSignal();
+}
+
+WheelEventSignalType& WheelEventSignal( Window window )
+{
+ return GetImplementation( window ).mScene.WheelEventSignal();
}
} // namespace DevelWindow
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
+#include <dali/integration-api/scene.h>
namespace Dali
{
class Actor;
class Layer;
-class KeyEvent;
+struct KeyEvent;
class TouchData;
+struct WheelEvent;
typedef Dali::Rect<int> PositionSize;
static Window New(PositionSize windowPosition, const std::string& name, bool isTransparent = false);
static Window New(PositionSize windowPosition, const std::string& name, const std::string& className, bool isTransparent = false);
+
Window();
~Window();
Window(const Window& handle);
Window& operator=(const Window& rhs);
Layer GetRootLayer() const;
+ Integration::Scene GetScene();
+ Integration::RenderSurface& GetRenderSurface();
+
public:
explicit Window( Internal::Adaptor::Window* window );
};
namespace DevelWindow
{
-
+typedef Signal< void () > EventProcessingFinishedSignalType;
typedef Signal< void (const KeyEvent&) > KeyEventSignalType;
typedef Signal< void (const TouchData&) > TouchSignalType;
+typedef Signal< void (const WheelEvent&) > WheelEventSignalType;
Dali::Window Get( Actor actor );
+
+EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window );
KeyEventSignalType& KeyEventSignal( Dali::Window window );
TouchSignalType& TouchSignal( Dali::Window window );
+WheelEventSignalType& WheelEventSignal( Window window );
}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * 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.
int UtcDaliAsyncImageLoaderDownCastP(void)
{
+ ToolkitTestApplication application;
+
AsyncImageLoader asyncImageLoader = AsyncImageLoader::New();
BaseHandle object(asyncImageLoader);
int UtcDaliAsyncImageLoaderDownCastN(void)
{
+ ToolkitTestApplication application;
+
BaseHandle unInitializedObject;
AsyncImageLoader asyncImageLoader = AsyncImageLoader::DownCast( unInitializedObject );
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * 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.
int UtcDaliCheckBoxButtonConstructorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox;
int UtcDaliCheckBoxButtonCopyConstructorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
// Initialize an object, ref count == 1
CheckBoxButton checkBox = CheckBoxButton::New();
int UtcDaliCheckBoxButtonAssignmentOperatorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
int UtcDaliCheckBoxButtonNewP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
int UtcDaliCheckBoxButtonDownCastP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
int UtcDaliCheckBoxButtonDownCastN(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
BaseHandle unInitializedObject;
int UtcDaliCheckBoxSetLabelP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
int UtcDaliCheckBoxSetDisabledPropertyP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
Stage::GetCurrent().Add( checkBox );
int UtcDaliCheckBoxSetLabelDisabledP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
Stage::GetCurrent().Add( checkBox );
DALI_TEST_EQUALS( checkBox.GetLabelText(), "activate", TEST_LOCATION );
END_TEST;
-}
\ No newline at end of file
+}
int UtcDaliDragAndDropDetectorStartSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control = Control::New();
int UtcDaliDragAndDropDetectorEnteredSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
int UtcDaliDragAndDropDetectorMovedSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
int UtcDaliDragAndDropDetectorExitedSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
int UtcDaliDragAndDropDetectorDroppedSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
int UtcDaliDragAndDropDetectorEndedSignal(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
int UtcDaliDragAndDropDetectorGetContent(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Dali::Toolkit::DragAndDropDetector detector = Dali::Toolkit::DragAndDropDetector::New();
Control control1 = Control::New();
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * 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.
int UtcDaliImageAtlasUploadWithObserver01(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageAtlas atlas = ImageAtlas::New( 200, 200 );
int UtcDaliImageAtlasUploadWithObserver02(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageAtlas atlas = ImageAtlas::New( 200, 200 );
gCountOfTestFuncCall = 0;
int UtcDaliImageAtlasUploadWithObserver03(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
gCountOfTestFuncCall = 0;
TestUploadObserver* uploadObserver = new TestUploadObserver;
int UtcDaliImageAtlasRemove(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
unsigned int size = 100;
ImageAtlas atlas = ImageAtlas::New( size, size );
Vector4 textureRect1;
int UtcDaliImageViewNewP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageView imageView = ImageView::New();
int UtcDaliImageViewNewImageP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
BufferImage image = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
ImageView imageView = ImageView::New( image );
int UtcDaliImageViewNewUrlP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageView imageView = ImageView::New( TEST_IMAGE_FILE_NAME );
DALI_TEST_CHECK( imageView );
int UtcDaliImageViewConstructorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageView imageView;
int UtcDaliImageViewCopyConstructorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
// Initialize an object, ref count == 1
ImageView imageView = ImageView::New();
int UtcDaliImageViewAssignmentOperatorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageView imageView = ImageView::New();
int UtcDaliImageViewDownCastP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
ImageView imageView = ImageView::New();
int UtcDaliImageViewDownCastN(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
BaseHandle unInitializedObject;
#include <dali/public-api/rendering/renderer.h>
#include <dali/devel-api/adaptor-framework/clipboard.h>
#include <dali/devel-api/adaptor-framework/key-devel.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali-toolkit-test-suite-utils.h>
int utcDaliTextEditorInputStyleChanged01(void)
{
- ToolkitTestApplication application;
- tet_infoline(" utcDaliTextEditorInputStyleChanged01");
-
// The text-editor emits signals when the input style changes. These changes of style are
// detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
// can't be emitted during the size negotiation as the callbacks may update the UI.
// The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
- // This creates an implementation of the adaptor stub and a queue of idle callbacks.
- application.CreateAdaptor();
+ // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextEditorInputStyleChanged01");
// Load some fonts.
int utcDaliTextEditorInputStyleChanged02(void)
{
- ToolkitTestApplication application;
- tet_infoline(" utcDaliTextEditorInputStyleChanged02");
-
// The text-editor emits signals when the input style changes. These changes of style are
// detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
// can't be emitted during the size negotiation as the callbacks may update the UI.
// The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
- // This creates an implementation of the adaptor stub and a queue of idle callbacks.
- application.CreateAdaptor();
+ // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextEditorInputStyleChanged02");
// Load some fonts.
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/devel-api/adaptor-framework/key-devel.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
int utcDaliTextFieldInputStyleChanged01(void)
{
- ToolkitTestApplication application;
- tet_infoline(" utcDaliTextFieldInputStyleChanged01");
-
// The text-field emits signals when the input style changes. These changes of style are
// detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
// can't be emitted during the size negotiation as the callbacks may update the UI.
// The text-field adds an idle callback to the adaptor to emit the signals after the size negotiation.
- // This creates an implementation of the adaptor stub and a queue of idle callbacks.
- application.CreateAdaptor();
+ // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextFieldInputStyleChanged01");
// Load some fonts.
int utcDaliTextFieldInputStyleChanged02(void)
{
- ToolkitTestApplication application;
- tet_infoline(" utcDaliTextFieldInputStyleChanged02");
-
// The text-field emits signals when the input style changes. These changes of style are
// detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
// can't be emitted during the size negotiation as the callbacks may update the UI.
// The text-field adds an idle callback to the adaptor to emit the signals after the size negotiation.
- // This creates an implementation of the adaptor stub and a queue of idle callbacks.
- application.CreateAdaptor();
+ // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextFieldInputStyleChanged02");
// Load some fonts.
#include <dali-toolkit/devel-api/controls/text-controls/text-style-properties-devel.h>
#include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
#include <dali/devel-api/text-abstraction/bitmap-font.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali-toolkit/devel-api/text/bitmap-font.h>
using namespace Dali;
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * 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.
int UtcDaliTransitionDataNew(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map = CreateMap();
Dali::Toolkit::TransitionData transition = TransitionData::New( map );
int UtcDaliTransitionDataDownCast(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map = CreateMap();
int UtcDaliTransitionDataCopyConstructor(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map = CreateMap();
int UtcDaliTransitionDataAssignmentOperator(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map = CreateMap();
int UtcDaliTransitionDataCount(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map = CreateMap();
TransitionData transitionData = TransitionData::New( map );
int UtcDaliTransitionDataMap1P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation of a visual property using stylesheet equivalent maps\n");
int UtcDaliTransitionDataMap2P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation of a visual property using programmatic maps\n");
int UtcDaliTransitionDataMap2Pb(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation of a visual property using programmatic maps\n");
int UtcDaliTransitionDataMap3P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation of an actor's position property using bezier curve\n");
int UtcDaliTransitionDataMap4P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation of a visual's transform property using programmatic maps\n");
int UtcDaliTransitionDataMap5P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation visual opacity using stylesheet equivalent maps\n");
int UtcDaliTransitionDataMap6P(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing animation visual opacity using stylesheet equivalent maps\n");
int UtcDaliTransitionDataMap1N(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map;
map["target"] = "Actor1";
int UtcDaliTransitionDataMapN3(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing visual lookup with no renderers\n");
int UtcDaliTransitionDataMapN4(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing visual doesn't animate with duff bezier data \n");
int UtcDaliTransitionDataMapN5(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing visual doesn't animate with duff bezier data \n");
int UtcDaliTransitionDataMapN6(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
tet_printf("Testing visual doesn't animate with duff bezier data \n");
int UtcDaliTransitionDataArrayP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map1;
map1["target"] = "Actor1";
int UtcDaliTransitionDataGetAnimatorP(void)
{
- TestApplication application;
+ ToolkitTestApplication application;
Property::Map map1;
map1["target"] = "Actor1";
#include <toolkit-event-thread-callback.h>
#include <dali-toolkit-test-suite-utils.h>
#include <dali/devel-api/object/handle-devel.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
projects / platform / core / uifw / dali-toolkit.git / commitdiff