END_TEST;
}
-
-int UtcDaliWindowPartialUpdate(void)
-{
- Dali::Window window;
- try
- {
- std::vector<Rect<int>> damagedAreas;
- DevelWindow::SetDamagedAreas(window, damagedAreas);
- DALI_TEST_CHECK( false ); // Should not reach here!
- }
- catch( ... )
- {
- DALI_TEST_CHECK( true );
- }
-
- END_TEST;
-}
/**
* @copydoc Dali::NativeImageInterface::GetExtension()
*/
- NativeImageInterface::Extension* GetExtension();
+ NativeImageInterface::Extension* GetExtension() override;
private:
*
* The implementation should destroy the NativeImage resources.
*/
- DALI_INTERNAL virtual ~NativeImageSourceQueue();
+ DALI_INTERNAL ~NativeImageSourceQueue() override;
/**
* @brief Undefined copy constructor.
return GetImplementation( window ).GetNativeId();
}
-void SetDamagedAreas(Window window, std::vector<Dali::Rect<int>>& areas)
-{
- GetImplementation(window).SetDamagedAreas(areas);
-}
-
void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
{
GetImplementation( window ).AddFrameRenderedCallback( std::move( callback ), frameId );
DALI_ADAPTOR_API int32_t GetNativeId( Window window );
/**
- * @brief Sets damaged areas of the window.
- *
- * This API is for setting static damaged areas of the window for partial update.
- *
- * @param[in] window The window instance
- * @param[in] areas The damaged areas list to set
- */
-DALI_ADAPTOR_API void SetDamagedAreas(Window window, std::vector<Dali::Rect<int>>& areas);
-
-/**
* @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
*
* @param[in] window The window instance
mGraphics( nullptr ),
mDisplayConnection( nullptr ),
mScene(),
+ mFullSwapNextFrame( true ),
mDepthBufferRequired( Integration::DepthBufferAvailable::FALSE ),
mStencilBufferRequired( Integration::StencilBufferAvailable::FALSE )
{}
mScene = scene;
}
+ /**
+ * @brief Forces full surface swap next frame, resets current partial update state.
+ */
+ void SetFullSwapNextFrame()
+ {
+ mFullSwapNextFrame = true;
+ }
+
private:
/**
Dali::Internal::Adaptor::GraphicsInterface* mGraphics;
Dali::DisplayConnection* mDisplayConnection;
WeakHandle< Dali::Integration::Scene > mScene;
+ bool mFullSwapNextFrame; ///< Whether the full surface swap is required
private:
PositionSize surfacePositionSize = mSurface->GetPositionSize();
mScene.SurfaceResized( static_cast<float>( surfacePositionSize.width ), static_cast<float>( surfacePositionSize.height ) );
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
Dali::RenderSurfaceInterface* SceneHolder::GetSurface() const
{
mScene.SetBackgroundColor( color );
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
}
/**
* virtual destructor
*/
- virtual ~SceneHolder();
+ ~SceneHolder() override;
private: // The following methods can be overridden if required
/**
* Destructor.
*/
- virtual ~AccessibilityAdaptor();
+ ~AccessibilityAdaptor() override;
private:
/**
* Virtual destructor.
*/
- virtual ~AccessibilityGestureDetector();
+ ~AccessibilityGestureDetector() override;
/**
* Set the handler to handle accessibility gestures.
/**
* Destructor
*/
- virtual ~TtsPlayerGeneric();
+ ~TtsPlayerGeneric() override;
private:
/**
* Virtual destructor.
*/
- virtual ~Adaptor();
+ ~Adaptor() override;
/**
* @copydoc Dali::Adaptor::Get()
/**
* @return the Core instance
*/
- virtual Dali::Integration::Core& GetCore();
+ Dali::Integration::Core& GetCore() override;
/**
* @copydoc Dali::Adaptor::SetRenderRefreshRate()
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPlatformAbstractionInterface()
*/
- virtual Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface();
+ Dali::Integration::PlatformAbstraction& GetPlatformAbstractionInterface() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetDisplayConnectionInterface()
*/
- virtual Dali::DisplayConnection& GetDisplayConnectionInterface();
+ Dali::DisplayConnection& GetDisplayConnectionInterface() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetGraphicsInterface()
*/
- virtual GraphicsInterface& GetGraphicsInterface();
+ GraphicsInterface& GetGraphicsInterface() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetTriggerEventInterface()
*/
- virtual TriggerEventInterface& GetProcessCoreEventsTrigger();
+ TriggerEventInterface& GetProcessCoreEventsTrigger() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSocketFactoryInterface()
*/
- virtual SocketFactoryInterface& GetSocketFactoryInterface();
+ SocketFactoryInterface& GetSocketFactoryInterface() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetRenderSurfaceInterface()
*/
- virtual Dali::RenderSurfaceInterface* GetRenderSurfaceInterface();
+ Dali::RenderSurfaceInterface* GetRenderSurfaceInterface() override;
/**
* @copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetPerformanceInterface()
*/
- virtual PerformanceInterface* GetPerformanceInterface();
+ PerformanceInterface* GetPerformanceInterface() override;
/**
* copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetKernelTraceInterface()
*/
- virtual TraceInterface& GetKernelTraceInterface();
+ TraceInterface& GetKernelTraceInterface() override;
/**
* copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetSystemTraceInterface()
*/
- virtual TraceInterface& GetSystemTraceInterface();
+ TraceInterface& GetSystemTraceInterface() override;
/**
* copydoc Dali::Internal::Adaptor::AdaptorInternalServices::GetWindowContainerInterface()
*/
- virtual void GetWindowContainerInterface( WindowContainer& windows );
+ void GetWindowContainerInterface( WindowContainer& windows ) override;
public: // Signals
/**
* @copydoc Dali::Internal::Adaptor:CoreEventInterface:::ProcessCoreEvents()
*/
- virtual void ProcessCoreEvents();
+ void ProcessCoreEvents() override;
private: // From Dali::Internal::Adaptor::CoreEventInterface
/**
* @copydoc Dali::Internal::Adaptor::CoreEventInterface::QueueCoreEvent()
*/
- virtual void QueueCoreEvent(const Dali::Integration::Event& event);
+ void QueueCoreEvent(const Dali::Integration::Event& event) override;
private: // From Dali::Integration::RenderController
/**
* @copydoc Dali::Integration::RenderController::RequestUpdate()
*/
- virtual void RequestUpdate( bool forceUpdate );
+ void RequestUpdate( bool forceUpdate ) override;
/**
* @copydoc Dali::Integration::RenderController::RequestProcessEventsOnIdle()
*/
- virtual void RequestProcessEventsOnIdle( bool forceProcess );
+ void RequestProcessEventsOnIdle( bool forceProcess ) override;
public: // From Dali::Internal::Adaptor::WindowVisibilityObserver
/**
* Called when the window becomes fully or partially visible.
*/
- virtual void OnWindowShown();
+ void OnWindowShown() override;
/**
* Called when the window is fully hidden.
*/
- virtual void OnWindowHidden();
+ void OnWindowHidden() override;
private: // From Dali::Internal::Adaptor::DamageObserver
/**
* @copydoc Dali::Internal::Adaptor::DamageObserver::OnDamaged()
*/
- void OnDamaged( const DamageArea& area );
+ void OnDamaged( const DamageArea& area ) override;
private:
/**
* Called when the framework is initialised.
*/
- virtual void OnInit();
+ void OnInit() override;
/**
* Called when the framework is terminated.
*/
- virtual void OnTerminate();
+ void OnTerminate() override;
/**
* Called when the framework is paused.
*/
- virtual void OnPause();
+ void OnPause() override;
/**
* Called when the framework resumes from a paused state.
*/
- virtual void OnResume();
+ void OnResume() override;
/**
* Called when the framework received AppControlSignal.
* @param[in] The bundle data of AppControl event.
*/
- virtual void OnAppControl(void *data);
+ void OnAppControl(void *data) override;
/**
* Called when the framework informs the application that it should reset itself.
*/
- virtual void OnReset();
+ void OnReset() override;
/**
* Called when the framework informs the application that the language of the device has changed.
*/
- virtual void OnLanguageChanged();
+ void OnLanguageChanged() override;
/**
* Called when the framework informs the application that the region of the device has changed.
*/
- virtual void OnRegionChanged();
+ void OnRegionChanged() override;
/**
* Called when the framework informs the application that the battery level of the device is low.
*/
- virtual void OnBatteryLow( Dali::DeviceStatus::Battery::Status status );
+ void OnBatteryLow( Dali::DeviceStatus::Battery::Status status ) override;
/**
* Called when the framework informs the application that the memory level of the device is low.
*/
- virtual void OnMemoryLow( Dali::DeviceStatus::Memory::Status status );
+ void OnMemoryLow( Dali::DeviceStatus::Memory::Status status ) override;
/**
* Called when the framework informs the application that the platform surface is created.
*/
- virtual void OnSurfaceCreated( Any newSurface );
+ void OnSurfaceCreated( Any newSurface ) override;
/**
* Called when the framework informs the application that the platform surface is destroyed.
*/
- virtual void OnSurfaceDestroyed( Any newSurface );
+ void OnSurfaceDestroyed( Any newSurface ) override;
public:
/**
* Destructor
*/
- virtual ~Application();
+ ~Application() override;
// Undefined
Application(const Application&);
// clear previous frame damaged render items rects, buffer history is tracked on surface level
mDamagedRects.clear();
- // If user damaged areas are not set
- if (!eglImpl.DamageAreasSet())
- {
- // Collect damage rects
- mCore.PreRender( scene, mDamagedRects );
- }
+ // Collect damage rects
+ mCore.PreRender( scene, mDamagedRects );
// Render off-screen frame buffers first if any
mCore.RenderScene( windowRenderStatus, scene, true );
/**
* @copydoc ThreadControllerInterface::Initialize()
*/
- virtual void Initialize();
+ void Initialize() override;
/**
* @copydoc ThreadControllerInterface::Start()
*/
- virtual void Start();
+ void Start() override;
/**
* @copydoc ThreadControllerInterface::Pause()
*/
- virtual void Pause();
+ void Pause() override;
/**
* @copydoc ThreadControllerInterface::Resume()
*/
- virtual void Resume();
+ void Resume() override;
/**
* @copydoc ThreadControllerInterface::Stop()
*/
- virtual void Stop();
+ void Stop() override;
/**
* @copydoc ThreadControllerInterface::RequestUpdate()
*/
- virtual void RequestUpdate();
+ void RequestUpdate() override;
/**
* @copydoc ThreadControllerInterface::RequestUpdateOnce()
*/
- virtual void RequestUpdateOnce( UpdateMode updateMode );
+ void RequestUpdateOnce( UpdateMode updateMode ) override;
/**
* @copydoc ThreadControllerInterface::ReplaceSurface()
*/
- virtual void ReplaceSurface( Dali::RenderSurfaceInterface* surface );
+ void ReplaceSurface( Dali::RenderSurfaceInterface* surface ) override;
/**
* @copydoc ThreadControllerInterface::DeleteSurface()
*/
- virtual void DeleteSurface( Dali::RenderSurfaceInterface* surface );
+ void DeleteSurface( Dali::RenderSurfaceInterface* surface ) override;
/**
* @copydoc ThreadControllerInterface::ResizeSurface()
*/
- virtual void ResizeSurface();
+ void ResizeSurface() override;
/**
* @copydoc ThreadControllerInterface::WaitForGraphicsInitialization()
*/
- virtual void WaitForGraphicsInitialization();
+ void WaitForGraphicsInitialization() override;
/**
* @copydoc ThreadControllerInterface::SetRenderRefreshRate()
*/
- virtual void SetRenderRefreshRate( unsigned int numberOfFramesPerRender );
+ void SetRenderRefreshRate( unsigned int numberOfFramesPerRender ) override;
/**
* @copydoc ThreadControllerInterface::SetPreRenderCallback
/**
* @copydoc ThreadControllerInterface::AddSurface()
*/
- virtual void AddSurface( Dali::RenderSurfaceInterface* surface );
+ void AddSurface( Dali::RenderSurfaceInterface* surface ) override;
private:
/**
* @copydoc ThreadSynchronizationInterface::PostRenderComplete()
*/
- virtual void PostRenderComplete();
+ void PostRenderComplete() override;
/////////////////////////////////////////////////////////////////////////////////////////////////
//// Called by the Render Thread if post-rendering is required
/**
* @copydoc ThreadSynchronizationInterface::PostRenderStarted()
*/
- virtual void PostRenderStarted();
+ void PostRenderStarted() override;
/**
* @copydoc ThreadSynchronizationInterface::PostRenderStarted()
*/
- virtual void PostRenderWaitForCompletion();
+ void PostRenderWaitForCompletion() override;
private:
/**
* Virtual Destructor.
*/
- virtual ~LifecycleController();
+ ~LifecycleController() override;
private:
/**
* Called when the framework is Component Application Created.
*/
- virtual Any OnCreate();
+ Any OnCreate() override;
public:
CreateSignal mCreateSignal;
/**
* Called when the framework is initialised.
*/
- virtual void OnInit();
+ void OnInit() override;
/**
* Called when the framework is terminated.
*/
- virtual void OnTerminate();
+ void OnTerminate() override;
/**
* Called when the framework is paused.
*/
- virtual void OnPause();
+ void OnPause() override;
/**
* Called when the framework resumes from a paused state.
*/
- virtual void OnResume();
+ void OnResume() override;
/**
* Called every second
/**
* Destructor.
*/
- virtual ~ClipboardEventNotifier();
+ ~ClipboardEventNotifier() override;
// Undefined
ClipboardEventNotifier( const ClipboardEventNotifier& );
/**
* Destructor
*/
- virtual ~Clipboard();
+ ~Clipboard() override;
/**
* @copydoc Dali::Clipboard::SetItem()
/**
* @copydoc Dali::Integration::GlContextHelperAbstraction::MakeSurfacelessContextCurrent()
*/
- virtual void MakeSurfacelessContextCurrent() override;
+ void MakeSurfacelessContextCurrent() override;
/**
* @copydoc Dali::Integration::GlContextHelperAbstraction::MakeContextNull()
*/
- virtual void MakeContextNull() override;
+ void MakeContextNull() override;
/**
* @copydoc Dali::Integration::GlContextHelperAbstraction::WaitClient()
*/
- virtual void WaitClient() override;
+ void WaitClient() override;
private:
/**
* Destructor
*/
- virtual ~GraphicsFactory();
+ ~GraphicsFactory() override;
/**
* @copydoc Dali::Internal::Adaptor::GraphicsFactoryInterface::Create()
/**
* @copydoc Dali::Internal::Adaptor::GraphicsFactoryInterface::Destroy()
*/
- void Destroy();
+ void Destroy() override;
};
} // Adaptor
return mEglImageExtensions.get();
}
-void EglGraphics::SetDamagedAreas(std::vector<Dali::Rect<int>>& areas)
-{
- mEglImplementation->SetDamageAreas(areas);
-}
-
-void EglGraphics::SetFullSwapNextFrame()
-{
- mEglImplementation->SetFullSwapNextFrame();
-}
-
} // Adaptor
} // Internal
} // Dali
EglImageExtensions* GetImageExtensions();
/**
- * Sets fixed damaged areas for partial rendering. This overrides automatic partial rendering.
- */
- void SetDamagedAreas( std::vector<Dali::Rect<int>>& areas );
-
- /**
- * Instructs egl implementation to do full swap regardless of stored data, resets the data.
- */
- void SetFullSwapNextFrame();
-
- /**
* @copydoc Dali::Internal::Adaptor::GraphicsInterface::Destroy()
*/
void Destroy() override;
mIsKhrCreateContextSupported( false ),
mSwapBufferCountAfterResume( 0 ),
mEglSetDamageRegionKHR( 0 ),
- mEglSwapBuffersWithDamageKHR( 0 ),
- mBufferAge( 0 ),
- mFullSwapNextFrame( true )
+ mEglSwapBuffersWithDamageKHR( 0 )
{
}
// DALI_LOG_ERROR("EglImplementation::SwapBuffers()\n");
eglSwapBuffers( mEglDisplay, eglSurface );
- mFullSwapNextFrame = false;
#ifndef DALI_PROFILE_UBUNTU
if( mSwapBufferCountAfterResume < THRESHOLD_SWAPBUFFER_COUNT )
return age;
}
-bool EglImplementation::DamageAreasSet() const
+void EglImplementation::SetDamageRegion( EGLSurface& eglSurface, std::vector< Rect< int > >& damagedRects )
{
- return (mDamagedAreas.size() ? true : false);
-}
-
-void EglImplementation::SetDamageAreas( std::vector<Dali::Rect<int>>& damagedAreas )
-{
- mFullSwapNextFrame = true;
- mDamagedAreas = damagedAreas;
-}
-
-void EglImplementation::SetFullSwapNextFrame()
-{
- mFullSwapNextFrame = true;
-}
-
-void mergeRects(Rect<int>& mergingRect, const std::vector<Rect<int>>& rects)
-{
- uint32_t i = 0;
- if (mergingRect.IsEmpty())
- {
- for (;i < rects.size(); i++)
- {
- if (!rects[i].IsEmpty())
- {
- mergingRect = rects[i];
- break;
- }
- }
- }
-
- for (;i < rects.size(); i++)
- {
- mergingRect.Merge(rects[i]);
- }
-}
-
-void insertRects(std::list<std::vector<Rect<int>>>& damagedRectsList, const std::vector<Rect<int>>& damagedRects)
-{
- damagedRectsList.push_front(damagedRects);
- if (damagedRectsList.size() > 4) // past triple buffers + current
- {
- damagedRectsList.pop_back();
- }
-}
-
-void EglImplementation::SetDamage( EGLSurface& eglSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect )
-{
- if (!mPartialUpdateRequired)
+ if( !mPartialUpdateRequired )
{
return;
}
- if (eglSurface != EGL_NO_SURFACE) // skip if using surfaceless context
+ if( eglSurface != EGL_NO_SURFACE ) // skip if using surfaceless context
{
- EGLint width = 0;
- EGLint height = 0;
- eglQuerySurface(mEglDisplay, eglSurface, EGL_WIDTH, &width);
- eglQuerySurface(mEglDisplay, eglSurface, EGL_HEIGHT, &height);
- Rect<int> surfaceRect(0, 0, width, height);
-
- mSurfaceRect = surfaceRect;
-
- if (mFullSwapNextFrame)
- {
- mBufferAge = 0;
- insertRects(mBufferDamagedRects, std::vector<Rect<int>>(1, surfaceRect));
- clippingRect = Rect<int>();
- return;
- }
-
- EGLint bufferAge = GetBufferAge(eglSurface);
- if (mDamagedAreas.size())
- {
- mBufferAge = bufferAge;
- if (bufferAge == 0)
- {
- // Buffer age is reset
- clippingRect = Rect<int>();
- return;
- }
-
- mergeRects(clippingRect, mDamagedAreas);
- }
- else
- {
- // Buffer age 0 means the back buffer in invalid and requires full swap
- if (!damagedRects.size() || bufferAge != mBufferAge || bufferAge == 0)
- {
- // No damage or buffer is out of order or buffer age is reset
- mBufferAge = bufferAge;
- insertRects(mBufferDamagedRects, std::vector<Rect<int>>(1, surfaceRect));
- clippingRect = Rect<int>();
- return;
- }
-
- // We push current frame damaged rects here, zero index for current frame
- mBufferAge = bufferAge;
- insertRects(mBufferDamagedRects, damagedRects);
-
- // Merge damaged rects into clipping rect
- auto bufferDamagedRects = mBufferDamagedRects.begin();
- while (bufferAge-- >= 0 && bufferDamagedRects != mBufferDamagedRects.end())
- {
- const std::vector<Rect<int>>& rects = *bufferDamagedRects++;
- mergeRects(clippingRect, rects);
- }
- }
-
- if (!clippingRect.Intersect(surfaceRect) || clippingRect.Area() > surfaceRect.Area() * 0.8)
- {
- // clipping area too big or doesn't intersect surface rect
- clippingRect = Rect<int>();
- return;
- }
-
- // DALI_LOG_ERROR("eglSetDamageRegionKHR(%d, %d, %d, %d)\n", clippingRect.x, clippingRect.y, clippingRect.width, clippingRect.height);
- EGLBoolean result = mEglSetDamageRegionKHR(mEglDisplay, eglSurface, reinterpret_cast<int*>(&clippingRect), 1);
+ EGLBoolean result = mEglSetDamageRegionKHR( mEglDisplay, eglSurface, reinterpret_cast< int* >( damagedRects.data() ), 1 );
if (result == EGL_FALSE)
{
- DALI_LOG_ERROR("eglSetDamageRegionKHR(%d)\n", eglGetError());
+ DALI_LOG_ERROR( "eglSetDamageRegionKHR(%d)\n", eglGetError() );
}
}
}
{
if (eglSurface != EGL_NO_SURFACE ) // skip if using surfaceless context
{
- if (!mPartialUpdateRequired || mFullSwapNextFrame || mBufferAge == 0 || !damagedRects.size())
+ if (!mPartialUpdateRequired )
{
SwapBuffers(eglSurface);
return;
}
#endif //DALI_PROFILE_UBUNTU
- if (mDamagedAreas.size())
- {
- // DALI_LOG_ERROR("EglImplementation::SwapBuffers(%d)\n", mDamagedAreas.size());
- EGLBoolean result = mEglSwapBuffersWithDamageKHR(mEglDisplay, eglSurface, reinterpret_cast<int*>(mDamagedAreas.data()), mDamagedAreas.size());
- if (result == EGL_FALSE)
- {
- DALI_LOG_ERROR("eglSwapBuffersWithDamageKHR(%d)\n", eglGetError());
- }
-
-#ifndef DALI_PROFILE_UBUNTU
- if( mSwapBufferCountAfterResume < THRESHOLD_SWAPBUFFER_COUNT )
- {
- DALI_LOG_RELEASE_INFO( "EglImplementation::SwapBuffers finished.\n" );
- mSwapBufferCountAfterResume++;
- }
-#endif //DALI_PROFILE_UBUNTU
- return;
- }
-
- // current frame damaged rects were pushed by EglImplementation::SetDamage() to 0 index.
- EGLint bufferAge = mBufferAge;
- mCombinedDamagedRects.clear();
-
- // Combine damaged rects from previous frames (beginning from bufferAge index) with the current frame (0 index)
- auto bufferDamagedRects = mBufferDamagedRects.begin();
- while (bufferAge-- >= 0 && bufferDamagedRects != mBufferDamagedRects.end())
- {
- const std::vector<Rect<int>>& rects = *bufferDamagedRects++;
- mCombinedDamagedRects.insert(mCombinedDamagedRects.end(), rects.begin(), rects.end());
- }
-
- // Merge intersecting rects, form an array of non intersecting rects to help driver a bit
- // Could be optional and can be removed, needs to be checked with and without on platform
- const int n = mCombinedDamagedRects.size();
- for (int i = 0; i < n-1; i++)
- {
- if (mCombinedDamagedRects[i].IsEmpty())
- {
- continue;
- }
-
- for (int j = i+1; j < n; j++)
- {
- if (mCombinedDamagedRects[j].IsEmpty())
- {
- continue;
- }
-
- if (mCombinedDamagedRects[i].Intersects(mCombinedDamagedRects[j]))
- {
- mCombinedDamagedRects[i].Merge(mCombinedDamagedRects[j]);
- mCombinedDamagedRects[j].width = 0;
- mCombinedDamagedRects[j].height = 0;
- }
- }
- }
-
- int j = 0;
- for (int i = 0; i < n; i++)
- {
- if (!mCombinedDamagedRects[i].IsEmpty())
- {
- mCombinedDamagedRects[j++] = mCombinedDamagedRects[i];
- }
- }
-
- if (j != 0)
- {
- mCombinedDamagedRects.resize(j);
- }
-
- if (!mCombinedDamagedRects.size() || (mCombinedDamagedRects[0].Area() > mSurfaceRect.Area() * 0.8))
- {
- SwapBuffers(eglSurface);
- return;
- }
-
- // DALI_LOG_ERROR("EglImplementation::SwapBuffers(%d)\n", mCombinedDamagedRects.size());
- EGLBoolean result = mEglSwapBuffersWithDamageKHR(mEglDisplay, eglSurface, reinterpret_cast<int*>(mCombinedDamagedRects.data()), mCombinedDamagedRects.size());
+ EGLBoolean result = mEglSwapBuffersWithDamageKHR(mEglDisplay, eglSurface, reinterpret_cast<int*>(const_cast< std::vector< Rect< int > >& >( damagedRects ).data()), damagedRects.size());
if (result == EGL_FALSE)
{
DALI_LOG_ERROR("eglSwapBuffersWithDamageKHR(%d)\n", eglGetError());
}
}
+bool EglImplementation::IsPartialUpdateRequired() const
+{
+ return mPartialUpdateRequired;
+}
+
} // namespace Adaptor
} // namespace Internal
/**
* Destructor
*/
- virtual ~EglImplementation();
+ ~EglImplementation() override;
public:
* Create the OpenGL context for the shared resource.
* @return true if successful
*/
- virtual bool CreateContext();
+ bool CreateContext() override;
/**
* Create the OpenGL context for the window.
/**
* Make the OpenGL context current
*/
- virtual void MakeContextCurrent( EGLSurface eglSurface, EGLContext eglContext );
+ void MakeContextCurrent( EGLSurface eglSurface, EGLContext eglContext ) override;
/**
* clear the OpenGL context
/**
* Terminate GL
*/
- virtual void TerminateGles();
+ void TerminateGles() override;
/**
* Checks if GL is initialised
/**
* Performs an OpenGL swap buffers command
*/
- virtual void SwapBuffers( EGLSurface& eglSurface );
+ void SwapBuffers( EGLSurface& eglSurface ) override;
/**
* Gets current back buffer age
EGLint GetBufferAge( EGLSurface& eglSurface ) const;
/**
- * Gets if user set damaged areas
- */
- bool DamageAreasSet() const;
-
- /**
- * Sets damaged areas, overrides auto calculated ones
- */
- void SetDamageAreas( std::vector<Dali::Rect<int>>& damagedArea );
-
- /**
- * Forces full surface swap next frame, resets current partial update state.
- */
- void SetFullSwapNextFrame();
-
- /**
* Performs an OpenGL set damage command with damaged rects
*/
- virtual void SetDamage( EGLSurface& eglSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect );
+ void SetDamageRegion( EGLSurface& eglSurface, std::vector< Rect< int > >& damagedRects );
/**
* Performs an OpenGL swap buffers command with damaged rects
/**
* Performs an OpenGL copy buffers command
*/
- virtual void CopyBuffers( EGLSurface& eglSurface );
+ void CopyBuffers( EGLSurface& eglSurface ) override;
/**
* Performs an EGL wait GL command
*/
- virtual void WaitGL();
+ void WaitGL() override;
/**
* Choose config of egl
*/
void WaitClient();
+ /**
+ * @brief Returns whether the partial update is required.
+ * @return true if the partial update is required.
+ */
+ bool IsPartialUpdateRequired() const;
+
private:
Vector<EGLint> mContextAttribs;
PFNEGLSETDAMAGEREGIONKHRPROC mEglSetDamageRegionKHR;
PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC mEglSwapBuffersWithDamageKHR;
- EGLint mBufferAge;
- std::list<std::vector<Rect<int>>> mBufferDamagedRects;
- std::vector<Rect<int>> mCombinedDamagedRects;
- std::vector<Rect<int>> mDamagedAreas;
- Rect<int> mSurfaceRect;
- bool mFullSwapNextFrame;
};
} // namespace Adaptor
/**
* @copydoc Dali::Integration::GlSyncAbstraction::SyncObject::IsSynced()
*/
- virtual bool IsSynced();
+ bool IsSynced() override;
private:
#ifdef _ARCH_ARM_
/**
* @copydoc Dali::Integration::GlSyncAbstraction::CreateSyncObject()
*/
- virtual SyncObject* CreateSyncObject();
+ SyncObject* CreateSyncObject() override;
/**
* @copydoc Dali::Integration::GlSyncAbstraction::DestroySyncObject()
*/
- virtual void DestroySyncObject(SyncObject* syncObject);
+ void DestroySyncObject(SyncObject* syncObject) override;
private:
/**
virtual ~GlImplementation() {}
- void PreRender()
+ void PreRender() override
{
/* Do nothing in main implementation */
}
- void PostRender()
+ void PostRender() override
{
/* Do nothing in main implementation */
}
mIsSurfacelessContextSupported = isSupported;
}
- bool IsSurfacelessContextSupported() const
+ bool IsSurfacelessContextSupported() const override
{
return mIsSurfacelessContextSupported;
}
- bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const
+ bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const override
{
bool convert = ( ( imageGlFormat == GL_RGB ) && ( textureGlFormat == GL_RGBA ) );
if( mGlesVersion >= 30 )
/* OpenGL ES 2.0 */
- void ActiveTexture( GLenum texture )
+ void ActiveTexture( GLenum texture ) override
{
glActiveTexture( texture );
}
- void AttachShader( GLuint program, GLuint shader )
+ void AttachShader( GLuint program, GLuint shader ) override
{
glAttachShader( program, shader );
}
- void BindAttribLocation( GLuint program, GLuint index, const char* name )
+ void BindAttribLocation( GLuint program, GLuint index, const char* name ) override
{
glBindAttribLocation( program, index, name );
}
- void BindBuffer( GLenum target, GLuint buffer )
+ void BindBuffer( GLenum target, GLuint buffer ) override
{
glBindBuffer( target, buffer );
}
- void BindFramebuffer( GLenum target, GLuint framebuffer )
+ void BindFramebuffer( GLenum target, GLuint framebuffer ) override
{
glBindFramebuffer( target, framebuffer );
}
- void BindRenderbuffer( GLenum target, GLuint renderbuffer )
+ void BindRenderbuffer( GLenum target, GLuint renderbuffer ) override
{
glBindRenderbuffer( target, renderbuffer );
}
- void BindTexture( GLenum target, GLuint texture )
+ void BindTexture( GLenum target, GLuint texture ) override
{
glBindTexture( target, texture );
}
- void BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+ void BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) override
{
glBlendColor( red, green, blue, alpha );
}
- void BlendEquation( GLenum mode )
+ void BlendEquation( GLenum mode ) override
{
glBlendEquation( mode );
}
- void BlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
+ void BlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha ) override
{
glBlendEquationSeparate( modeRGB, modeAlpha );
}
- void BlendFunc( GLenum sfactor, GLenum dfactor )
+ void BlendFunc( GLenum sfactor, GLenum dfactor ) override
{
glBlendFunc( sfactor, dfactor );
}
- void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+ void BlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) override
{
glBlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha );
}
- void BufferData( GLenum target, GLsizeiptr size, const void* data, GLenum usage )
+ void BufferData( GLenum target, GLsizeiptr size, const void* data, GLenum usage ) override
{
glBufferData( target, size, data, usage );
}
- void BufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void* data )
+ void BufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void* data ) override
{
glBufferSubData( target, offset, size, data );
}
- GLenum CheckFramebufferStatus( GLenum target )
+ GLenum CheckFramebufferStatus( GLenum target ) override
{
return glCheckFramebufferStatus( target );
}
- void Clear( GLbitfield mask )
+ void Clear( GLbitfield mask ) override
{
glClear( mask );
}
- void ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+ void ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) override
{
glClearColor( red, green, blue, alpha );
}
- void ClearDepthf( GLclampf depth )
+ void ClearDepthf( GLclampf depth ) override
{
glClearDepthf( depth );
}
- void ClearStencil( GLint s )
+ void ClearStencil( GLint s ) override
{
glClearStencil( s );
}
- void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+ void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) override
{
glColorMask( red, green, blue, alpha );
}
- void CompileShader( GLuint shader )
+ void CompileShader( GLuint shader ) override
{
glCompileShader( shader );
}
- void CompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data )
+ void CompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) override
{
glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data );
}
- void CompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data )
+ void CompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) override
{
glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data );
}
- void CopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+ void CopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) override
{
glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
}
- void CopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+ void CopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) override
{
glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
}
- GLuint CreateProgram( void )
+ GLuint CreateProgram( void ) override
{
return glCreateProgram();
}
- GLuint CreateShader( GLenum type )
+ GLuint CreateShader( GLenum type ) override
{
return glCreateShader( type );
}
- void CullFace( GLenum mode )
+ void CullFace( GLenum mode ) override
{
glCullFace( mode );
}
- void DeleteBuffers( GLsizei n, const GLuint* buffers )
+ void DeleteBuffers( GLsizei n, const GLuint* buffers ) override
{
glDeleteBuffers( n, buffers );
}
- void DeleteFramebuffers( GLsizei n, const GLuint* framebuffers )
+ void DeleteFramebuffers( GLsizei n, const GLuint* framebuffers ) override
{
glDeleteFramebuffers( n, framebuffers );
}
- void DeleteProgram( GLuint program )
+ void DeleteProgram( GLuint program ) override
{
glDeleteProgram( program );
}
- void DeleteRenderbuffers( GLsizei n, const GLuint* renderbuffers )
+ void DeleteRenderbuffers( GLsizei n, const GLuint* renderbuffers ) override
{
glDeleteRenderbuffers( n, renderbuffers );
}
- void DeleteShader( GLuint shader )
+ void DeleteShader( GLuint shader ) override
{
glDeleteShader( shader );
}
- void DeleteTextures( GLsizei n, const GLuint* textures )
+ void DeleteTextures( GLsizei n, const GLuint* textures ) override
{
glDeleteTextures( n, textures );
}
- void DepthFunc( GLenum func )
+ void DepthFunc( GLenum func ) override
{
glDepthFunc( func );
}
- void DepthMask( GLboolean flag )
+ void DepthMask( GLboolean flag ) override
{
glDepthMask( flag );
}
- void DepthRangef( GLclampf zNear, GLclampf zFar )
+ void DepthRangef( GLclampf zNear, GLclampf zFar ) override
{
glDepthRangef( zNear, zFar );
}
- void DetachShader( GLuint program, GLuint shader )
+ void DetachShader( GLuint program, GLuint shader ) override
{
glDetachShader( program, shader );
}
- void Disable( GLenum cap )
+ void Disable( GLenum cap ) override
{
glDisable( cap );
}
- void DisableVertexAttribArray( GLuint index )
+ void DisableVertexAttribArray( GLuint index ) override
{
glDisableVertexAttribArray( index );
}
- void DrawArrays( GLenum mode, GLint first, GLsizei count )
+ void DrawArrays( GLenum mode, GLint first, GLsizei count ) override
{
glDrawArrays( mode, first, count );
}
- void DrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices )
+ void DrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices ) override
{
glDrawElements( mode, count, type, indices );
}
- void Enable( GLenum cap )
+ void Enable( GLenum cap ) override
{
glEnable( cap );
}
- void EnableVertexAttribArray( GLuint index )
+ void EnableVertexAttribArray( GLuint index ) override
{
glEnableVertexAttribArray( index );
}
- void Finish( void )
+ void Finish( void ) override
{
glFinish();
}
- void Flush( void )
+ void Flush( void ) override
{
glFlush();
}
- void FramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+ void FramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) override
{
glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
}
- void FramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+ void FramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) override
{
glFramebufferTexture2D( target, attachment, textarget, texture, level );
}
- void FrontFace( GLenum mode )
+ void FrontFace( GLenum mode ) override
{
glFrontFace( mode );
}
- void GenBuffers( GLsizei n, GLuint* buffers )
+ void GenBuffers( GLsizei n, GLuint* buffers ) override
{
glGenBuffers( n, buffers );
}
- void GenerateMipmap( GLenum target )
+ void GenerateMipmap( GLenum target ) override
{
glGenerateMipmap( target );
}
- void GenFramebuffers( GLsizei n, GLuint* framebuffers )
+ void GenFramebuffers( GLsizei n, GLuint* framebuffers ) override
{
glGenFramebuffers( n, framebuffers );
}
- void GenRenderbuffers( GLsizei n, GLuint* renderbuffers )
+ void GenRenderbuffers( GLsizei n, GLuint* renderbuffers ) override
{
glGenRenderbuffers( n, renderbuffers );
}
- void GenTextures( GLsizei n, GLuint* textures )
+ void GenTextures( GLsizei n, GLuint* textures ) override
{
glGenTextures( n, textures );
}
- void GetActiveAttrib( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name )
+ void GetActiveAttrib( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name ) override
{
glGetActiveAttrib( program, index, bufsize, length, size, type, name );
}
- void GetActiveUniform( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name )
+ void GetActiveUniform( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name ) override
{
glGetActiveUniform( program, index, bufsize, length, size, type, name );
}
- void GetAttachedShaders( GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders )
+ void GetAttachedShaders( GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders ) override
{
glGetAttachedShaders( program, maxcount, count, shaders );
}
- int GetAttribLocation( GLuint program, const char* name )
+ int GetAttribLocation( GLuint program, const char* name ) override
{
return glGetAttribLocation( program, name );
}
- void GetBooleanv( GLenum pname, GLboolean* params )
+ void GetBooleanv( GLenum pname, GLboolean* params ) override
{
glGetBooleanv( pname, params );
}
- void GetBufferParameteriv( GLenum target, GLenum pname, GLint* params )
+ void GetBufferParameteriv( GLenum target, GLenum pname, GLint* params ) override
{
glGetBufferParameteriv( target, pname, params );
}
- GLenum GetError( void )
+ GLenum GetError( void ) override
{
return glGetError();
}
- void GetFloatv( GLenum pname, GLfloat* params )
+ void GetFloatv( GLenum pname, GLfloat* params ) override
{
glGetFloatv( pname, params );
}
- void GetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params )
+ void GetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params ) override
{
glGetFramebufferAttachmentParameteriv( target, attachment, pname, params );
}
- void GetIntegerv( GLenum pname, GLint* params )
+ void GetIntegerv( GLenum pname, GLint* params ) override
{
glGetIntegerv( pname, params );
}
- void GetProgramiv( GLuint program, GLenum pname, GLint* params )
+ void GetProgramiv( GLuint program, GLenum pname, GLint* params ) override
{
glGetProgramiv( program, pname, params );
}
- void GetProgramInfoLog( GLuint program, GLsizei bufsize, GLsizei* length, char* infolog )
+ void GetProgramInfoLog( GLuint program, GLsizei bufsize, GLsizei* length, char* infolog ) override
{
glGetProgramInfoLog( program, bufsize, length, infolog );
}
- void GetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params )
+ void GetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params ) override
{
glGetRenderbufferParameteriv( target, pname, params );
}
- void GetShaderiv( GLuint shader, GLenum pname, GLint* params )
+ void GetShaderiv( GLuint shader, GLenum pname, GLint* params ) override
{
glGetShaderiv( shader, pname, params );
}
- void GetShaderInfoLog( GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog )
+ void GetShaderInfoLog( GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog ) override
{
glGetShaderInfoLog( shader, bufsize, length, infolog );
}
- void GetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision )
+ void GetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision ) override
{
glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision );
}
- void GetShaderSource( GLuint shader, GLsizei bufsize, GLsizei* length, char* source )
+ void GetShaderSource( GLuint shader, GLsizei bufsize, GLsizei* length, char* source ) override
{
glGetShaderSource( shader, bufsize, length, source );
}
- const GLubyte* GetString( GLenum name )
+ const GLubyte* GetString( GLenum name ) override
{
return glGetString( name );
}
- void GetTexParameterfv( GLenum target, GLenum pname, GLfloat* params )
+ void GetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) override
{
glGetTexParameterfv( target, pname, params );
}
- void GetTexParameteriv( GLenum target, GLenum pname, GLint* params )
+ void GetTexParameteriv( GLenum target, GLenum pname, GLint* params ) override
{
glGetTexParameteriv( target, pname, params );
}
- void GetUniformfv( GLuint program, GLint location, GLfloat* params )
+ void GetUniformfv( GLuint program, GLint location, GLfloat* params ) override
{
glGetUniformfv( program, location, params );
}
- void GetUniformiv( GLuint program, GLint location, GLint* params )
+ void GetUniformiv( GLuint program, GLint location, GLint* params ) override
{
glGetUniformiv( program, location, params );
}
- int GetUniformLocation( GLuint program, const char* name )
+ int GetUniformLocation( GLuint program, const char* name ) override
{
return glGetUniformLocation( program, name );
}
- void GetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params )
+ void GetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params ) override
{
glGetVertexAttribfv( index, pname, params );
}
- void GetVertexAttribiv( GLuint index, GLenum pname, GLint* params )
+ void GetVertexAttribiv( GLuint index, GLenum pname, GLint* params ) override
{
glGetVertexAttribiv( index, pname, params );
}
- void GetVertexAttribPointerv( GLuint index, GLenum pname, void** pointer )
+ void GetVertexAttribPointerv( GLuint index, GLenum pname, void** pointer ) override
{
glGetVertexAttribPointerv( index, pname, pointer );
}
- void Hint( GLenum target, GLenum mode )
+ void Hint( GLenum target, GLenum mode ) override
{
glHint( target, mode );
}
- GLboolean IsBuffer( GLuint buffer )
+ GLboolean IsBuffer( GLuint buffer ) override
{
return glIsBuffer( buffer );
}
- GLboolean IsEnabled( GLenum cap )
+ GLboolean IsEnabled( GLenum cap ) override
{
return glIsEnabled( cap );
}
- GLboolean IsFramebuffer( GLuint framebuffer )
+ GLboolean IsFramebuffer( GLuint framebuffer ) override
{
return glIsFramebuffer( framebuffer );
}
- GLboolean IsProgram( GLuint program )
+ GLboolean IsProgram( GLuint program ) override
{
return glIsProgram( program );
}
- GLboolean IsRenderbuffer( GLuint renderbuffer )
+ GLboolean IsRenderbuffer( GLuint renderbuffer ) override
{
return glIsRenderbuffer( renderbuffer );
}
- GLboolean IsShader( GLuint shader )
+ GLboolean IsShader( GLuint shader ) override
{
return glIsShader( shader );
}
- GLboolean IsTexture( GLuint texture )
+ GLboolean IsTexture( GLuint texture ) override
{
return glIsTexture( texture );
}
- void LineWidth( GLfloat width )
+ void LineWidth( GLfloat width ) override
{
glLineWidth( width );
}
- void LinkProgram( GLuint program )
+ void LinkProgram( GLuint program ) override
{
glLinkProgram( program );
}
- void PixelStorei( GLenum pname, GLint param )
+ void PixelStorei( GLenum pname, GLint param ) override
{
glPixelStorei( pname, param );
}
- void PolygonOffset( GLfloat factor, GLfloat units )
+ void PolygonOffset( GLfloat factor, GLfloat units ) override
{
glPolygonOffset( factor, units );
}
- void ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels )
+ void ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels ) override
{
glReadPixels( x, y, width, height, format, type, pixels );
}
- void ReleaseShaderCompiler( void )
+ void ReleaseShaderCompiler( void ) override
{
glReleaseShaderCompiler();
}
- void RenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
+ void RenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) override
{
glRenderbufferStorage( target, internalformat, width, height );
}
- void SampleCoverage( GLclampf value, GLboolean invert )
+ void SampleCoverage( GLclampf value, GLboolean invert ) override
{
glSampleCoverage( value, invert );
}
- void Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
+ void Scissor( GLint x, GLint y, GLsizei width, GLsizei height ) override
{
glScissor( x, y, width, height );
}
- void ShaderBinary( GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length )
+ void ShaderBinary( GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length ) override
{
glShaderBinary( n, shaders, binaryformat, binary, length );
}
- void ShaderSource( GLuint shader, GLsizei count, const char** string, const GLint* length )
+ void ShaderSource( GLuint shader, GLsizei count, const char** string, const GLint* length ) override
{
glShaderSource( shader, count, string, length );
}
- void StencilFunc( GLenum func, GLint ref, GLuint mask )
+ void StencilFunc( GLenum func, GLint ref, GLuint mask ) override
{
glStencilFunc( func, ref, mask );
}
- void StencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
+ void StencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask ) override
{
glStencilFuncSeparate( face, func, ref, mask );
}
- void StencilMask( GLuint mask )
+ void StencilMask( GLuint mask ) override
{
glStencilMask( mask );
}
- void StencilMaskSeparate( GLenum face, GLuint mask )
+ void StencilMaskSeparate( GLenum face, GLuint mask ) override
{
glStencilMaskSeparate( face, mask );
}
- void StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
+ void StencilOp( GLenum fail, GLenum zfail, GLenum zpass ) override
{
glStencilOp( fail, zfail, zpass );
}
- void StencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass )
+ void StencilOpSeparate( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) override
{
glStencilOpSeparate( face, fail, zfail, zpass );
}
- void TexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels )
+ void TexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) override
{
glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
}
- void TexParameterf( GLenum target, GLenum pname, GLfloat param )
+ void TexParameterf( GLenum target, GLenum pname, GLfloat param ) override
{
glTexParameterf( target, pname, param );
}
- void TexParameterfv( GLenum target, GLenum pname, const GLfloat* params )
+ void TexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) override
{
glTexParameterfv( target, pname, params );
}
- void TexParameteri( GLenum target, GLenum pname, GLint param )
+ void TexParameteri( GLenum target, GLenum pname, GLint param ) override
{
glTexParameteri( target, pname, param );
}
- void TexParameteriv( GLenum target, GLenum pname, const GLint* params )
+ void TexParameteriv( GLenum target, GLenum pname, const GLint* params ) override
{
glTexParameteriv( target, pname, params );
}
- void TexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels )
+ void TexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) override
{
glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
}
- void Uniform1f( GLint location, GLfloat x )
+ void Uniform1f( GLint location, GLfloat x ) override
{
glUniform1f( location, x );
}
- void Uniform1fv( GLint location, GLsizei count, const GLfloat* v )
+ void Uniform1fv( GLint location, GLsizei count, const GLfloat* v ) override
{
glUniform1fv( location, count, v );
}
- void Uniform1i( GLint location, GLint x )
+ void Uniform1i( GLint location, GLint x ) override
{
glUniform1i( location, x );
}
- void Uniform1iv( GLint location, GLsizei count, const GLint* v )
+ void Uniform1iv( GLint location, GLsizei count, const GLint* v ) override
{
glUniform1iv( location, count, v );
}
- void Uniform2f( GLint location, GLfloat x, GLfloat y )
+ void Uniform2f( GLint location, GLfloat x, GLfloat y ) override
{
glUniform2f( location, x, y );
}
- void Uniform2fv( GLint location, GLsizei count, const GLfloat* v )
+ void Uniform2fv( GLint location, GLsizei count, const GLfloat* v ) override
{
glUniform2fv( location, count, v );
}
- void Uniform2i( GLint location, GLint x, GLint y )
+ void Uniform2i( GLint location, GLint x, GLint y ) override
{
glUniform2i( location, x, y );
}
- void Uniform2iv( GLint location, GLsizei count, const GLint* v )
+ void Uniform2iv( GLint location, GLsizei count, const GLint* v ) override
{
glUniform2iv( location, count, v );
}
- void Uniform3f( GLint location, GLfloat x, GLfloat y, GLfloat z )
+ void Uniform3f( GLint location, GLfloat x, GLfloat y, GLfloat z ) override
{
glUniform3f( location, x, y, z );
}
- void Uniform3fv( GLint location, GLsizei count, const GLfloat* v )
+ void Uniform3fv( GLint location, GLsizei count, const GLfloat* v ) override
{
glUniform3fv( location, count, v );
}
- void Uniform3i( GLint location, GLint x, GLint y, GLint z )
+ void Uniform3i( GLint location, GLint x, GLint y, GLint z ) override
{
glUniform3i( location, x, y, z );
}
- void Uniform3iv( GLint location, GLsizei count, const GLint* v )
+ void Uniform3iv( GLint location, GLsizei count, const GLint* v ) override
{
glUniform3iv( location, count, v );
}
- void Uniform4f( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+ void Uniform4f( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) override
{
glUniform4f( location, x, y, z, w );
}
- void Uniform4fv( GLint location, GLsizei count, const GLfloat* v )
+ void Uniform4fv( GLint location, GLsizei count, const GLfloat* v ) override
{
glUniform4fv( location, count, v );
}
- void Uniform4i( GLint location, GLint x, GLint y, GLint z, GLint w )
+ void Uniform4i( GLint location, GLint x, GLint y, GLint z, GLint w ) override
{
glUniform4i( location, x, y, z, w );
}
- void Uniform4iv( GLint location, GLsizei count, const GLint* v )
+ void Uniform4iv( GLint location, GLsizei count, const GLint* v ) override
{
glUniform4iv( location, count, v );
}
- void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
glUniformMatrix2fv( location, count, transpose, value );
}
- void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
glUniformMatrix3fv( location, count, transpose, value );
}
- void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
glUniformMatrix4fv( location, count, transpose, value );
}
- void UseProgram( GLuint program )
+ void UseProgram( GLuint program ) override
{
glUseProgram( program );
}
- void ValidateProgram( GLuint program )
+ void ValidateProgram( GLuint program ) override
{
glValidateProgram( program );
}
- void VertexAttrib1f( GLuint indx, GLfloat x )
+ void VertexAttrib1f( GLuint indx, GLfloat x ) override
{
glVertexAttrib1f( indx, x );
}
- void VertexAttrib1fv( GLuint indx, const GLfloat* values )
+ void VertexAttrib1fv( GLuint indx, const GLfloat* values ) override
{
glVertexAttrib1fv( indx, values );
}
- void VertexAttrib2f( GLuint indx, GLfloat x, GLfloat y )
+ void VertexAttrib2f( GLuint indx, GLfloat x, GLfloat y ) override
{
glVertexAttrib2f( indx, x, y );
}
- void VertexAttrib2fv( GLuint indx, const GLfloat* values )
+ void VertexAttrib2fv( GLuint indx, const GLfloat* values ) override
{
glVertexAttrib2fv( indx, values );
}
- void VertexAttrib3f( GLuint indx, GLfloat x, GLfloat y, GLfloat z )
+ void VertexAttrib3f( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) override
{
glVertexAttrib3f( indx, x, y, z );
}
- void VertexAttrib3fv( GLuint indx, const GLfloat* values )
+ void VertexAttrib3fv( GLuint indx, const GLfloat* values ) override
{
glVertexAttrib3fv( indx, values );
}
- void VertexAttrib4f( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+ void VertexAttrib4f( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) override
{
glVertexAttrib4f( indx, x, y, z, w );
}
- void VertexAttrib4fv( GLuint indx, const GLfloat* values )
+ void VertexAttrib4fv( GLuint indx, const GLfloat* values ) override
{
glVertexAttrib4fv( indx, values );
}
- void VertexAttribPointer( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr )
+ void VertexAttribPointer( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr ) override
{
glVertexAttribPointer( indx, size, type, normalized, stride, ptr );
}
- void Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
+ void Viewport( GLint x, GLint y, GLsizei width, GLsizei height ) override
{
glViewport( x, y, width, height );
}
/* OpenGL ES 3.0 */
- void ReadBuffer( GLenum mode )
+ void ReadBuffer( GLenum mode ) override
{
mImpl->ReadBuffer( mode );
}
- void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices )
+ void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices ) override
{
mImpl->DrawRangeElements( mode, start, end, count, type, indices );
}
- void TexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels )
+ void TexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) override
{
mImpl->TexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
}
- void TexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels )
+ void TexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels ) override
{
mImpl->TexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
}
- void CopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+ void CopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) override
{
mImpl->CopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
}
- void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data )
+ void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data ) override
{
mImpl->CompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
}
- void CompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data )
+ void CompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data ) override
{
mImpl->CompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
}
- void GenQueries( GLsizei n, GLuint* ids )
+ void GenQueries( GLsizei n, GLuint* ids ) override
{
mImpl->GenQueries( n, ids );
}
- void DeleteQueries( GLsizei n, const GLuint* ids )
+ void DeleteQueries( GLsizei n, const GLuint* ids ) override
{
mImpl->DeleteQueries( n, ids );
}
- GLboolean IsQuery( GLuint id )
+ GLboolean IsQuery( GLuint id ) override
{
return mImpl->IsQuery( id );
}
- void BeginQuery( GLenum target, GLuint id )
+ void BeginQuery( GLenum target, GLuint id ) override
{
mImpl->BeginQuery( target, id );
}
- void EndQuery( GLenum target )
+ void EndQuery( GLenum target ) override
{
mImpl->EndQuery( target );
}
- void GetQueryiv( GLenum target, GLenum pname, GLint* params )
+ void GetQueryiv( GLenum target, GLenum pname, GLint* params ) override
{
mImpl->GetQueryiv( target, pname, params );
}
- void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params )
+ void GetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) override
{
mImpl->GetQueryObjectuiv( id, pname, params );
}
- GLboolean UnmapBuffer( GLenum target )
+ GLboolean UnmapBuffer( GLenum target ) override
{
return mImpl->UnmapBuffer( target );
}
- void GetBufferPointerv( GLenum target, GLenum pname, GLvoid** params )
+ void GetBufferPointerv( GLenum target, GLenum pname, GLvoid** params ) override
{
mImpl->GetBufferPointerv( target, pname, params );
}
- void DrawBuffers( GLsizei n, const GLenum* bufs )
+ void DrawBuffers( GLsizei n, const GLenum* bufs ) override
{
mImpl->DrawBuffers( n, bufs );
}
- void UniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix2x3fv( location, count, transpose, value );
}
- void UniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix3x2fv( location, count, transpose, value );
}
- void UniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix2x4fv( location, count, transpose, value );
}
- void UniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix4x2fv( location, count, transpose, value );
}
- void UniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix3x4fv( location, count, transpose, value );
}
- void UniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value )
+ void UniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override
{
mImpl->UniformMatrix4x3fv( location, count, transpose, value );
}
- void BlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
+ void BlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) override
{
mImpl->BlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
}
- void RenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
+ void RenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) override
{
mImpl->RenderbufferStorageMultisample( target, samples, internalformat, width, height );
}
- void FramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
+ void FramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) override
{
mImpl->FramebufferTextureLayer( target, attachment, texture, level, layer );
}
- GLvoid* MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access )
+ GLvoid* MapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) override
{
return mImpl->MapBufferRange( target, offset, length, access );
}
- void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length )
+ void FlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) override
{
mImpl->FlushMappedBufferRange( target, offset, length );
}
- void BindVertexArray( GLuint array )
+ void BindVertexArray( GLuint array ) override
{
mImpl->BindVertexArray( array );
}
- void DeleteVertexArrays( GLsizei n, const GLuint* arrays )
+ void DeleteVertexArrays( GLsizei n, const GLuint* arrays ) override
{
mImpl->DeleteVertexArrays( n, arrays );
}
- void GenVertexArrays( GLsizei n, GLuint* arrays )
+ void GenVertexArrays( GLsizei n, GLuint* arrays ) override
{
mImpl->GenVertexArrays( n, arrays );
}
- GLboolean IsVertexArray( GLuint array )
+ GLboolean IsVertexArray( GLuint array ) override
{
return mImpl->IsVertexArray( array );
}
- void GetIntegeri_v( GLenum target, GLuint index, GLint* data )
+ void GetIntegeri_v( GLenum target, GLuint index, GLint* data ) override
{
mImpl->GetIntegeri_v( target, index, data );
}
- void BeginTransformFeedback( GLenum primitiveMode )
+ void BeginTransformFeedback( GLenum primitiveMode ) override
{
mImpl->BeginTransformFeedback( primitiveMode );
}
- void EndTransformFeedback( void )
+ void EndTransformFeedback( void ) override
{
mImpl->EndTransformFeedback();
}
- void BindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
+ void BindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) override
{
mImpl->BindBufferRange( target, index, buffer, offset, size );
}
- void BindBufferBase( GLenum target, GLuint index, GLuint buffer )
+ void BindBufferBase( GLenum target, GLuint index, GLuint buffer ) override
{
mImpl->BindBufferBase( target, index, buffer );
}
- void TransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode )
+ void TransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode ) override
{
mImpl->TransformFeedbackVaryings( program, count, varyings, bufferMode );
}
- void GetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name )
+ void GetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) override
{
mImpl->GetTransformFeedbackVarying( program, index, bufSize, length, size, type, name );
}
- void VertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )
+ void VertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) override
{
mImpl->VertexAttribIPointer( index, size, type, stride, pointer );
}
- void GetVertexAttribIiv( GLuint index, GLenum pname, GLint* params )
+ void GetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) override
{
mImpl->GetVertexAttribIiv( index, pname, params );
}
- void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params )
+ void GetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) override
{
mImpl->GetVertexAttribIuiv( index, pname, params );
}
- void VertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w )
+ void VertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) override
{
mImpl->VertexAttribI4i( index, x, y, z, w );
}
- void VertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+ void VertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) override
{
mImpl->VertexAttribI4ui( index, x, y, z, w );
}
- void VertexAttribI4iv( GLuint index, const GLint* v )
+ void VertexAttribI4iv( GLuint index, const GLint* v ) override
{
mImpl->VertexAttribI4iv( index, v );
}
- void VertexAttribI4uiv( GLuint index, const GLuint* v )
+ void VertexAttribI4uiv( GLuint index, const GLuint* v ) override
{
mImpl->VertexAttribI4uiv( index, v );
}
- void GetUniformuiv( GLuint program, GLint location, GLuint* params )
+ void GetUniformuiv( GLuint program, GLint location, GLuint* params ) override
{
mImpl->GetUniformuiv( program, location, params );
}
- GLint GetFragDataLocation( GLuint program, const GLchar *name )
+ GLint GetFragDataLocation( GLuint program, const GLchar *name ) override
{
return mImpl->GetFragDataLocation( program, name );
}
- void Uniform1ui( GLint location, GLuint v0 )
+ void Uniform1ui( GLint location, GLuint v0 ) override
{
mImpl->Uniform1ui( location, v0 );
}
- void Uniform2ui( GLint location, GLuint v0, GLuint v1 )
+ void Uniform2ui( GLint location, GLuint v0, GLuint v1 ) override
{
mImpl->Uniform2ui( location, v0, v1 );
}
- void Uniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 )
+ void Uniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) override
{
mImpl->Uniform3ui( location, v0, v1, v2 );
}
- void Uniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
+ void Uniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) override
{
mImpl->Uniform4ui( location, v0, v1, v2, v3 );
}
- void Uniform1uiv( GLint location, GLsizei count, const GLuint* value )
+ void Uniform1uiv( GLint location, GLsizei count, const GLuint* value ) override
{
mImpl->Uniform1uiv( location, count, value );
}
- void Uniform2uiv( GLint location, GLsizei count, const GLuint* value )
+ void Uniform2uiv( GLint location, GLsizei count, const GLuint* value ) override
{
mImpl->Uniform2uiv( location, count, value );
}
- void Uniform3uiv( GLint location, GLsizei count, const GLuint* value )
+ void Uniform3uiv( GLint location, GLsizei count, const GLuint* value ) override
{
mImpl->Uniform3uiv( location, count, value );
}
- void Uniform4uiv( GLint location, GLsizei count, const GLuint* value )
+ void Uniform4uiv( GLint location, GLsizei count, const GLuint* value ) override
{
mImpl->Uniform4uiv( location, count, value );
}
- void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value )
+ void ClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) override
{
mImpl->ClearBufferiv( buffer, drawbuffer, value );
}
- void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value )
+ void ClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) override
{
mImpl->ClearBufferuiv( buffer, drawbuffer, value );
}
- void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value )
+ void ClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) override
{
mImpl->ClearBufferfv( buffer, drawbuffer, value );
}
- void ClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
+ void ClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) override
{
mImpl->ClearBufferfi( buffer, drawbuffer, depth, stencil );
}
- const GLubyte* GetStringi( GLenum name, GLuint index )
+ const GLubyte* GetStringi( GLenum name, GLuint index ) override
{
return mImpl->GetStringi( name, index );
}
- void CopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
+ void CopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) override
{
mImpl->CopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size );
}
- void GetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices )
+ void GetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices ) override
{
mImpl->GetUniformIndices( program, uniformCount, uniformNames, uniformIndices );
}
- void GetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params )
+ void GetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params ) override
{
mImpl->GetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params );
}
- GLuint GetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName )
+ GLuint GetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) override
{
return mImpl->GetUniformBlockIndex( program, uniformBlockName );
}
- void GetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params )
+ void GetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) override
{
mImpl->GetActiveUniformBlockiv( program, uniformBlockIndex, pname, params );
}
- void GetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName )
+ void GetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName ) override
{
mImpl->GetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName );
}
- void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding )
+ void UniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) override
{
mImpl->UniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding );
}
- void DrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instanceCount )
+ void DrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instanceCount ) override
{
mImpl->DrawArraysInstanced( mode, first, count, instanceCount );
}
- void DrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount )
+ void DrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount ) override
{
mImpl->DrawElementsInstanced( mode, count, type, indices, instanceCount );
}
- GLsync FenceSync( GLenum condition, GLbitfield flags )
+ GLsync FenceSync( GLenum condition, GLbitfield flags ) override
{
return mImpl->FenceSync( condition, flags );
}
- GLboolean IsSync( GLsync sync )
+ GLboolean IsSync( GLsync sync ) override
{
return mImpl->IsSync( sync );
}
- void DeleteSync( GLsync sync )
+ void DeleteSync( GLsync sync ) override
{
mImpl->DeleteSync( sync );
}
- GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
+ GLenum ClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
{
return mImpl->ClientWaitSync( sync, flags, timeout );
}
- void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
+ void WaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) override
{
mImpl->WaitSync( sync, flags, timeout );
}
- void GetInteger64v( GLenum pname, GLint64* params )
+ void GetInteger64v( GLenum pname, GLint64* params ) override
{
mImpl->GetInteger64v( pname, params );
}
- void GetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values )
+ void GetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) override
{
mImpl->GetSynciv( sync, pname, bufSize, length, values );
}
- void GetInteger64i_v( GLenum target, GLuint index, GLint64* data )
+ void GetInteger64i_v( GLenum target, GLuint index, GLint64* data ) override
{
mImpl->GetInteger64i_v( target, index, data );
}
- void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params )
+ void GetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) override
{
mImpl->GetBufferParameteri64v( target, pname, params );
}
- void GenSamplers( GLsizei count, GLuint* samplers )
+ void GenSamplers( GLsizei count, GLuint* samplers ) override
{
mImpl->GenSamplers( count, samplers );
}
- void DeleteSamplers( GLsizei count, const GLuint* samplers )
+ void DeleteSamplers( GLsizei count, const GLuint* samplers ) override
{
mImpl->DeleteSamplers( count, samplers );
}
- GLboolean IsSampler( GLuint sampler )
+ GLboolean IsSampler( GLuint sampler ) override
{
return mImpl->IsSampler( sampler );
}
- void BindSampler( GLuint unit, GLuint sampler )
+ void BindSampler( GLuint unit, GLuint sampler ) override
{
mImpl->BindSampler( unit, sampler );
}
- void SamplerParameteri( GLuint sampler, GLenum pname, GLint param )
+ void SamplerParameteri( GLuint sampler, GLenum pname, GLint param ) override
{
mImpl->SamplerParameteri( sampler, pname, param );
}
- void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param )
+ void SamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) override
{
mImpl->SamplerParameteriv( sampler, pname, param );
}
- void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param )
+ void SamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) override
{
mImpl->SamplerParameterf( sampler, pname, param );
}
- void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param )
+ void SamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) override
{
mImpl->SamplerParameterfv( sampler, pname, param );
}
- void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params )
+ void GetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) override
{
mImpl->GetSamplerParameteriv( sampler, pname, params );
}
- void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params )
+ void GetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) override
{
mImpl->GetSamplerParameterfv( sampler, pname, params );
}
- void VertexAttribDivisor( GLuint index, GLuint divisor )
+ void VertexAttribDivisor( GLuint index, GLuint divisor ) override
{
mImpl->VertexAttribDivisor( index, divisor );
}
- void BindTransformFeedback( GLenum target, GLuint id )
+ void BindTransformFeedback( GLenum target, GLuint id ) override
{
mImpl->BindTransformFeedback( target, id );
}
- void DeleteTransformFeedbacks( GLsizei n, const GLuint* ids )
+ void DeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) override
{
mImpl->DeleteTransformFeedbacks( n, ids );
}
- void GenTransformFeedbacks( GLsizei n, GLuint* ids )
+ void GenTransformFeedbacks( GLsizei n, GLuint* ids ) override
{
mImpl->GenTransformFeedbacks( n, ids );
}
- GLboolean IsTransformFeedback( GLuint id )
+ GLboolean IsTransformFeedback( GLuint id ) override
{
return mImpl->IsTransformFeedback( id );
}
- void PauseTransformFeedback( void )
+ void PauseTransformFeedback( void ) override
{
mImpl->PauseTransformFeedback();
}
- void ResumeTransformFeedback( void )
+ void ResumeTransformFeedback( void ) override
{
mImpl->ResumeTransformFeedback();
}
- void GetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary )
+ void GetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary ) override
{
mImpl->GetProgramBinary( program, bufSize, length, binaryFormat, binary );
}
- void ProgramBinary( GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length )
+ void ProgramBinary( GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length ) override
{
mImpl->ProgramBinary( program, binaryFormat, binary, length );
}
- void ProgramParameteri( GLuint program, GLenum pname, GLint value )
+ void ProgramParameteri( GLuint program, GLenum pname, GLint value ) override
{
mImpl->ProgramParameteri( program, pname, value );
}
- void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments )
+ void InvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) override
{
mImpl->InvalidateFramebuffer( target, numAttachments, attachments );
}
- void InvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height )
+ void InvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) override
{
mImpl->InvalidateSubFramebuffer( target, numAttachments, attachments, x, y, width, height );
}
- void TexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
+ void TexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) override
{
mImpl->TexStorage2D( target, levels, internalformat, width, height );
}
- void TexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
+ void TexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) override
{
mImpl->TexStorage3D( target, levels, internalformat, width, height, depth );
}
- void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params )
+ void GetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) override
{
mImpl->GetInternalformativ( target, internalformat, pname, bufSize, params );
}
/**
* @copydoc GlAbstraction::PreRender();
*/
- virtual void PreRender();
+ void PreRender() override;
/**
* @copydoc GlAbstraction::PostRender();
*/
- virtual void PostRender();
+ void PostRender() override;
/* OpenGL ES 2.0 API */
- virtual void Clear( GLbitfield mask );
-
- virtual void GenBuffers( GLsizei n, GLuint* buffers );
- virtual void DeleteBuffers( GLsizei n, const GLuint* buffers );
- virtual void BindBuffer( GLenum target, GLuint buffer );
-
- virtual void GenTextures( GLsizei n, GLuint* textures );
- virtual void DeleteTextures( GLsizei n, const GLuint* textures );
- virtual void ActiveTexture( GLenum texture );
- virtual void BindTexture( GLenum target, GLuint texture );
-
- virtual void DrawArrays( GLenum mode, GLint first, GLsizei count );
- virtual void DrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices );
-
- virtual void Uniform1f ( GLint location, GLfloat x );
- virtual void Uniform1fv( GLint location, GLsizei count, const GLfloat* v );
- virtual void Uniform1i ( GLint location, GLint x );
- virtual void Uniform1iv( GLint location, GLsizei count, const GLint* v );
- virtual void Uniform2f ( GLint location, GLfloat x, GLfloat y );
- virtual void Uniform2fv( GLint location, GLsizei count, const GLfloat* v );
- virtual void Uniform2i ( GLint location, GLint x, GLint y );
- virtual void Uniform2iv( GLint location, GLsizei count, const GLint* v );
- virtual void Uniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z );
- virtual void Uniform3fv( GLint location, GLsizei count, const GLfloat* v );
- virtual void Uniform3i ( GLint location, GLint x, GLint y, GLint z );
- virtual void Uniform3iv( GLint location, GLsizei count, const GLint* v );
- virtual void Uniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
- virtual void Uniform4fv( GLint location, GLsizei count, const GLfloat* v );
- virtual void Uniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w );
- virtual void Uniform4iv( GLint location, GLsizei count, const GLint* v );
- virtual void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value );
- virtual void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value );
- virtual void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value );
-
- virtual GLuint CreateProgram( void );
- virtual void DeleteProgram( GLuint program );
- virtual void UseProgram( GLuint program );
+ void Clear( GLbitfield mask ) override;
+
+ void GenBuffers( GLsizei n, GLuint* buffers ) override;
+ void DeleteBuffers( GLsizei n, const GLuint* buffers ) override;
+ void BindBuffer( GLenum target, GLuint buffer ) override;
+
+ void GenTextures( GLsizei n, GLuint* textures ) override;
+ void DeleteTextures( GLsizei n, const GLuint* textures ) override;
+ void ActiveTexture( GLenum texture ) override;
+ void BindTexture( GLenum target, GLuint texture ) override;
+
+ void DrawArrays( GLenum mode, GLint first, GLsizei count ) override;
+ void DrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices ) override;
+
+ void Uniform1f ( GLint location, GLfloat x ) override;
+ void Uniform1fv( GLint location, GLsizei count, const GLfloat* v ) override;
+ void Uniform1i ( GLint location, GLint x ) override;
+ void Uniform1iv( GLint location, GLsizei count, const GLint* v ) override;
+ void Uniform2f ( GLint location, GLfloat x, GLfloat y ) override;
+ void Uniform2fv( GLint location, GLsizei count, const GLfloat* v ) override;
+ void Uniform2i ( GLint location, GLint x, GLint y ) override;
+ void Uniform2iv( GLint location, GLsizei count, const GLint* v ) override;
+ void Uniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z ) override;
+ void Uniform3fv( GLint location, GLsizei count, const GLfloat* v ) override;
+ void Uniform3i ( GLint location, GLint x, GLint y, GLint z ) override;
+ void Uniform3iv( GLint location, GLsizei count, const GLint* v ) override;
+ void Uniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) override;
+ void Uniform4fv( GLint location, GLsizei count, const GLfloat* v ) override;
+ void Uniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w ) override;
+ void Uniform4iv( GLint location, GLsizei count, const GLint* v ) override;
+ void UniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override;
+ void UniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override;
+ void UniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) override;
+
+ GLuint CreateProgram( void ) override;
+ void DeleteProgram( GLuint program ) override;
+ void UseProgram( GLuint program ) override;
private: // Helpers
/**
* Virtual Destructor
*/
- virtual ~FeedbackPlayer();
+ ~FeedbackPlayer() override;
// Undefined
FeedbackPlayer(const FeedbackPlayer&);
/**
* @brief Destructor
*/
- virtual ~AnimatedImageLoading() = default;
+ ~AnimatedImageLoading() override = default;
/**
* @copydoc Dali::AnimatedImageLoading::LoadNextNFrames()
*
* Release the pixel buffer if exists.
*/
- ~PixelBuffer();
+ ~PixelBuffer() override;
public:
/**
* @copydoc Dali::NativeImageSource::GetTextureTarget()
*/
- virtual int GetTextureTarget() const;
+ int GetTextureTarget() const override;
/**
* @copydoc Dali::NativeImageSource::GetCustomFragmentPrefix()
*/
- virtual const char* GetCustomFragmentPrefix() const;
+ const char* GetCustomFragmentPrefix() const override;
/**
* @copydoc Dali::NativeImageSource::GetCustomSamplerTypename()
*/
- virtual const char* GetCustomSamplerTypename() const;
+ const char* GetCustomSamplerTypename() const override;
/**
* @copydoc Dali::NativeImageSource::GetNativeImageHandle()
*/
- virtual Any GetNativeImageHandle() const;
+ Any GetNativeImageHandle() const override;
/**
* @copydoc Dali::NativeImageSource::SourceChanged()
*/
- virtual bool SourceChanged() const;
+ bool SourceChanged() const override;
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PhysicalKeyboard();
+ ~PhysicalKeyboard() override;
private:
/**
* Destructor
*/
- virtual ~TizenPlatformAbstraction();
+ ~TizenPlatformAbstraction() override;
public: // PlatformAbstraction overrides
/**
* @copydoc PlatformAbstraction::GetClosestImageSize()
*/
- virtual ImageDimensions GetClosestImageSize( const std::string& filename,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+ ImageDimensions GetClosestImageSize( const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection ) override;
/**
* @copydoc PlatformAbstraction::GetClosestImageSize()
*/
- virtual ImageDimensions GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+ ImageDimensions GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection ) override;
/**
* @copydoc PlatformAbstraction::LoadImageSynchronously()
*/
- virtual Integration::ResourcePointer LoadImageSynchronously(const Integration::BitmapResourceType& resource, const std::string& resourcePath);
+ Integration::ResourcePointer LoadImageSynchronously(const Integration::BitmapResourceType& resource, const std::string& resourcePath) override;
/**
* @copydoc PlatformAbstraction::DecodeBuffer()
*/
- virtual Integration::BitmapPtr DecodeBuffer( const Integration::BitmapResourceType& resource, uint8_t * buffer, size_t size );
+ Integration::BitmapPtr DecodeBuffer( const Integration::BitmapResourceType& resource, uint8_t * buffer, size_t size ) override;
/**
* @copydoc PlatformAbstraction::LoadShaderBinaryFile()
*/
- virtual bool LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const;
+ bool LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const override;
/**
* @copydoc PlatformAbstraction::SaveShaderBinaryFile()
*/
- virtual bool SaveShaderBinaryFile( const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const;
+ bool SaveShaderBinaryFile( const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const override;
/**
* @copydoc PlatformAbstraction::StartTimer()
*/
- virtual uint32_t StartTimer( uint32_t milliseconds, CallbackBase* callback );
+ uint32_t StartTimer( uint32_t milliseconds, CallbackBase* callback ) override;
/**
* @copydoc PlatformAbstraction::CancelTimer()
*/
- virtual void CancelTimer ( uint32_t timerId );
+ void CancelTimer ( uint32_t timerId ) override;
/**
* Sets path for data/resource storage.
/**
* @copydoc ClientSendDataInterface::ClientSendDataInterface()
*/
- virtual void SendData( const char* const data, unsigned int bufferSizeInBytes, unsigned int clientId );
+ void SendData( const char* const data, unsigned int bufferSizeInBytes, unsigned int clientId ) override;
private:
/**
* @brief destructor
*/
- virtual ~SocketFactory()
+ ~SocketFactory() override
{
}
/**
* @copydoc SocketFactoryInterface::NewSocket()
*/
- virtual SocketInterface* NewSocket( SocketInterface::Protocol protocol );
+ SocketInterface* NewSocket( SocketInterface::Protocol protocol ) override;
/**
* @copydoc SocketFactoryInterface::DestroySocket()
*/
- virtual void DestroySocket( SocketInterface* socket );
+ void DestroySocket( SocketInterface* socket ) override;
};
/**
* @copydoc Dali::Internal::Adaptor::SocketIsOpen()
*/
- virtual bool SocketIsOpen() const;
+ bool SocketIsOpen() const override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::CloseSocket
*/
- virtual bool CloseSocket();
+ bool CloseSocket() override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Bind
*/
- virtual bool Bind( uint16_t port ) ;
+ bool Bind( uint16_t port ) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Listen
*/
- virtual bool Listen( int blacklog);
+ bool Listen( int blacklog) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Accept
*/
- virtual SocketInterface* Accept() const ;
+ SocketInterface* Accept() const override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Select
*/
- virtual SelectReturn Select( );
+ SelectReturn Select( ) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::ExitSelect
*/
- virtual void ExitSelect();
+ void ExitSelect() override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Recieve
*/
- virtual bool Read( void* buffer, unsigned int bufferSizeInBytes, unsigned int& bytesRead );
+ bool Read( void* buffer, unsigned int bufferSizeInBytes, unsigned int& bytesRead ) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::Send
*/
- virtual bool Write( const void* buffer, unsigned int bufferLength );
+ bool Write( const void* buffer, unsigned int bufferLength ) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::ReuseAddress
*/
- virtual bool ReuseAddress( bool reUse );
+ bool ReuseAddress( bool reUse ) override;
/**
* @copydoc Dali::Internal::Adaptor::SocketInterface::SetBufferSize
*
*/
- virtual bool SetBufferSize( SocketInterface::BufferType type, unsigned int bufferSizeInBytes );
+ bool SetBufferSize( SocketInterface::BufferType type, unsigned int bufferSizeInBytes ) override;
/**
* @brief Virtual destructor
/**
* Virtual Destructor.
*/
- virtual ~StyleMonitor();
+ ~StyleMonitor() override;
private:
/**
* @copydoc CallbackManager::AddIdleCallback()
*/
- virtual bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue );
+ bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue ) override;
/**
* @copydoc CallbackManager::RemoveIdleCallback()
*/
- virtual void RemoveIdleCallback( CallbackBase* callback );
+ void RemoveIdleCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::ProcessIdle()
*/
- virtual bool ProcessIdle();
+ bool ProcessIdle() override;
/**
* @copydoc CallbackManager::ProcessIdle()
*/
- virtual void ClearIdleCallbacks();
+ void ClearIdleCallbacks() override;
/**
* @copydoc CallbackManager::AddIdleEntererCallback()
*/
- virtual bool AddIdleEntererCallback( CallbackBase* callback );
+ bool AddIdleEntererCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::RemoveIdleEntererCallback()
*/
- virtual void RemoveIdleEntererCallback( CallbackBase* callback );
+ void RemoveIdleEntererCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::Start()
*/
- virtual void Start();
+ void Start() override;
/**
* @copydoc CallbackManager::Stop()
*/
- virtual void Stop();
+ void Stop() override;
private:
/**
* @brief Destructor.
*/
- virtual ~ColorController();
+ ~ColorController() override;
private:
/**
* Install the log function for the current thread.
*/
- virtual void InstallLogFunction() const;
+ void InstallLogFunction() const override;
/**
* Un-install the log function for the current thread.
/**
* Destructor
*/
- virtual ~KernelTrace();
+ ~KernelTrace() override;
/**
* @copydoc KernelTracerInterface::KernelTrace()
*/
- virtual void Trace( const PerformanceMarker& marker, const std::string& traceMessage );
+ void Trace( const PerformanceMarker& marker, const std::string& traceMessage ) override;
private:
/**
* Destructor.
*/
- virtual ~PerformanceLogger();
+ ~PerformanceLogger() override;
/**
* Add a performance marker
/**
* @copydoc PerformanceLogger::AddContext()
*/
- virtual ContextId AddContext( const char* name );
+ ContextId AddContext( const char* name ) override;
/**
* @copydoc PerformanceLogger::RemoveContext()
*/
- virtual void RemoveContext( ContextId contextId );
+ void RemoveContext( ContextId contextId ) override;
/**
* @copydoc PerformanceInterface::AddMarker( MarkerType markerType )
*/
- virtual void AddMarker( MarkerType markerType );
+ void AddMarker( MarkerType markerType ) override;
/**
* @copydoc PerformanceLogger::AddMarker( MarkerType markerType, ContextId contextId )
*/
- virtual void AddMarker( MarkerType markerType, ContextId contextId );
+ void AddMarker( MarkerType markerType, ContextId contextId ) override;
/**
* @copydoc PerformanceInterface::SetLogging()
/**
* @copydoc PerformanceLogger::SetLoggingFrequency()
*/
- virtual void SetLoggingFrequency( unsigned int logFrequency, ContextId contextId );
+ void SetLoggingFrequency( unsigned int logFrequency, ContextId contextId ) override;
/**
* @copydoc PerformanceLogger::EnableLogging()
*/
- virtual void EnableLogging( bool enable, ContextId contextId );
+ void EnableLogging( bool enable, ContextId contextId ) override;
public: //StatLogInterface
/**
* @copydoc StatLogInterface::LogContextStatistics()
*/
- virtual void LogContextStatistics( const char* const text );
+ void LogContextStatistics( const char* const text ) override;
private:
/**
* Destructor
*/
- virtual ~SoundPlayer();
+ ~SoundPlayer() override;
/**
* Emits the SoundPlayFinished signal.
/**
* Destructor
*/
- virtual ~SystemTrace();
+ ~SystemTrace() override;
/**
* @copydoc KernelTracerInterface::KernelTrace()
*/
- virtual void Trace( const PerformanceMarker& marker, const std::string& traceMessage );
+ void Trace( const PerformanceMarker& marker, const std::string& traceMessage ) override;
};
/**
* @copydoc Dali::Timer::Start()
*/
- virtual void Start();
+ void Start() override;
/**
* @copydoc Dali::Timer::Stop()
*/
- virtual void Stop();
+ void Stop() override;
/**
* @copydoc Dali::Timer::Pause()
*/
- virtual void Pause();
+ void Pause() override;
/**
* @copydoc Dali::Timer::Resume()
*/
- virtual void Resume();
+ void Resume() override;
/**
* @copydoc Dali::Timer::SetInterval()
*/
- virtual void SetInterval( unsigned int interval, bool restart );
+ void SetInterval( unsigned int interval, bool restart ) override;
/**
* @copydoc Dali::Timer::GetInterval()
*/
- virtual unsigned int GetInterval() const;
+ unsigned int GetInterval() const override;
/**
* @copydoc Dali::Timer::IsRunning()
*/
- virtual bool IsRunning() const;
+ bool IsRunning() const override;
/**
* Tick
/**
* @copydoc CallbackManager::AddIdleCallback()
*/
- virtual bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue );
+ bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue ) override;
/**
* @copydoc CallbackManager::RemoveIdleCallback()
*/
- virtual void RemoveIdleCallback( CallbackBase* callback );
+ void RemoveIdleCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::ProcessIdle()
*/
- virtual bool ProcessIdle();
+ bool ProcessIdle() override;
/**
* @copydoc CallbackManager::ProcessIdle()
*/
- virtual void ClearIdleCallbacks();
+ void ClearIdleCallbacks() override;
/**
* @copydoc CallbackManager::AddIdleEntererCallback()
*/
- virtual bool AddIdleEntererCallback( CallbackBase* callback );
+ bool AddIdleEntererCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::RemoveIdleEntererCallback()
*/
- virtual void RemoveIdleEntererCallback( CallbackBase* callback );
+ void RemoveIdleEntererCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::Start()
*/
- virtual void Start();
+ void Start() override;
/**
* @copydoc CallbackManager::Stop()
*/
- virtual void Stop();
+ void Stop() override;
private:
/**
* @copydoc Dali::Internal::Adaptor::Application::OnInit()
*/
- virtual void OnInit();
+ void OnInit() override;
/**
* @copydoc Dali::WidgetApplication::RegisterWidgetCreator()
/**
* @copydoc CallbackManager::AddIdleCallback()
*/
- virtual bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue );
+ bool AddIdleCallback( CallbackBase* callback, bool hasReturnValue ) override;
/**
* @copydoc CallbackManager::RemoveIdleCallback()
*/
- virtual void RemoveIdleCallback( CallbackBase* callback );
+ void RemoveIdleCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::ProcessIdle()
*/
- virtual bool ProcessIdle();
+ bool ProcessIdle() override;
/**
* @copydoc CallbackManager::ClearIdleCallbacks()
*/
- virtual void ClearIdleCallbacks();
+ void ClearIdleCallbacks() override;
/**
* @brief Adds a @p callback to be run when entering an idle state.
*
* @return true on success
*/
- virtual bool AddIdleEntererCallback( CallbackBase* callback );
+ bool AddIdleEntererCallback( CallbackBase* callback ) override;
/**
* @brief Removes a previously added the idle enterer callback.
*
* @param[in] callback The callback to be removed.
*/
- virtual void RemoveIdleEntererCallback( CallbackBase* callback );
+ void RemoveIdleEntererCallback( CallbackBase* callback ) override;
/**
* @copydoc CallbackManager::Start()
*/
- virtual void Start();
+ void Start() override;
/**
* @copydoc CallbackManager::Stop()
*/
- virtual void Stop();
+ void Stop() override;
private:
std::set<CallbackBase*> mCallbacks;
/**
* Obtain the LogContextFunction method (Android specific) used for tracing
*/
- virtual Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
+ Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
private:
/**
* Obtain the platform dependent LogContextFunction method used for tracing
*/
- virtual Dali::Integration::Trace::LogContextFunction GetLogContextFunction() { return nullptr; };
+ Dali::Integration::Trace::LogContextFunction GetLogContextFunction() { return nullptr; };
private:
/**
* Obtain the LogContextFunction method (Generic specific) used for tracing
*/
- virtual Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
+ Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
private:
/**
* Obtain the LogContextFunction method (Tizen specific) used for tracing
*/
- virtual Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
+ Dali::Integration::Trace::LogContextFunction GetLogContextFunction() final;
private:
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindow()
*/
- virtual Any GetNativeWindow() override;
+ Any GetNativeWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindowId()
*/
- virtual int GetNativeWindowId() override;
+ int GetNativeWindowId() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateEglWindow()
*/
- virtual EGLNativeWindowType CreateEglWindow( int width, int height ) override;
+ EGLNativeWindowType CreateEglWindow( int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::DestroyEglWindow()
*/
- virtual void DestroyEglWindow() override;
+ void DestroyEglWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowRotation()
*/
- virtual void SetEglWindowRotation( int angle ) override;
+ void SetEglWindowRotation( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowBufferTransform()
*/
- virtual void SetEglWindowBufferTransform( int angle ) override;
+ void SetEglWindowBufferTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowTransform()
*/
- virtual void SetEglWindowTransform( int angle ) override;
+ void SetEglWindowTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::ResizeEglWindow()
*/
- virtual void ResizeEglWindow( PositionSize positionSize ) override;
+ void ResizeEglWindow( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::IsEglWindowRotationSupported()
*/
- virtual bool IsEglWindowRotationSupported() override;
+ bool IsEglWindowRotationSupported() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Move()
*/
- virtual void Move( PositionSize positionSize ) override;
+ void Move( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Resize()
*/
- virtual void Resize( PositionSize positionSize ) override;
+ void Resize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::MoveResize()
*/
- virtual void MoveResize( PositionSize positionSize ) override;
+ void MoveResize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetClass()
*/
- virtual void SetClass( const std::string& name, const std::string& className ) override;
+ void SetClass( const std::string& name, const std::string& className ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Raise()
*/
- virtual void Raise() override;
+ void Raise() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Lower()
*/
- virtual void Lower() override;
+ void Lower() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Activate()
*/
- virtual void Activate() override;
+ void Activate() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAvailableAnlges()
*/
- virtual void SetAvailableAnlges( const std::vector< int >& angles ) override;
+ void SetAvailableAnlges( const std::vector< int >& angles ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPreferredAngle()
*/
- virtual void SetPreferredAngle( int angle ) override;
+ void SetPreferredAngle( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAcceptFocus()
*/
- virtual void SetAcceptFocus( bool accept ) override;
+ void SetAcceptFocus( bool accept ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Show()
*/
- virtual void Show() override;
+ void Show() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Hide()
*/
- virtual void Hide() override;
+ void Hide() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHintCount()
*/
- virtual unsigned int GetSupportedAuxiliaryHintCount() const override;
+ unsigned int GetSupportedAuxiliaryHintCount() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHint()
*/
- virtual std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
+ std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::AddAuxiliaryHint()
*/
- virtual unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
+ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::RemoveAuxiliaryHint()
*/
- virtual bool RemoveAuxiliaryHint( unsigned int id ) override;
+ bool RemoveAuxiliaryHint( unsigned int id ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAuxiliaryHintValue()
*/
- virtual bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
+ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintValue()
*/
- virtual std::string GetAuxiliaryHintValue( unsigned int id ) const override;
+ std::string GetAuxiliaryHintValue( unsigned int id ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintId()
*/
- virtual unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
+ unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetInputRegion()
*/
- virtual void SetInputRegion( const Rect< int >& inputRegion ) override;
+ void SetInputRegion( const Rect< int >& inputRegion ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetType()
*/
- virtual void SetType( Dali::Window::Type type ) override;
+ void SetType( Dali::Window::Type type ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetNotificationLevel()
*/
- virtual bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
+ bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNotificationLevel()
*/
- virtual Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
+ Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetOpaqueState()
*/
- virtual void SetOpaqueState( bool opaque ) override;
+ void SetOpaqueState( bool opaque ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetScreenOffMode()
*/
- virtual bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
+ bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenOffMode()
*/
- virtual Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
+ Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetBrightness()
*/
- virtual bool SetBrightness( int brightness ) override;
+ bool SetBrightness( int brightness ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetBrightness()
*/
- virtual int GetBrightness() const override;
+ int GetBrightness() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKey()
*/
- virtual bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
+ bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKey()
*/
- virtual bool UngrabKey( Dali::KEY key ) override;
+ bool UngrabKey( Dali::KEY key ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKeyList()
*/
- virtual bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
+ bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKeyList()
*/
- virtual bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
+ bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
*/
- virtual int GetScreenRotationAngle() override;
+ int GetScreenRotationAngle() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetWindowRotationAngle()
*/
- virtual void SetWindowRotationAngle( int degree ) override;
+ void SetWindowRotationAngle( int degree ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::WindowRotationCompleted()
*/
- virtual void WindowRotationCompleted( int degree, int width, int height ) override;
+ void WindowRotationCompleted( int degree, int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetTransparency()
*/
- virtual void SetTransparency( bool transparent ) override;
+ void SetTransparency( bool transparent ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
*/
- virtual void SetParent( WindowBase* parentWinBase ) override;
+ void SetParent( WindowBase* parentWinBase ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFrameRenderedSyncFence()
*/
- virtual int CreateFrameRenderedSyncFence() override;
+ int CreateFrameRenderedSyncFence() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFramePresentedSyncFence()
*/
- virtual int CreateFramePresentedSyncFence() override;
+ int CreateFramePresentedSyncFence() override;
private:
/**
* Destructor.
*/
- ~EventHandler();
+ ~EventHandler() override;
/**
* Called when the adaptor is paused.
/**
* Destructor
*/
- virtual ~Orientation();
+ ~Orientation() override;
public:
return mKeyboardRepeatSettingsChangedSignal;
}
+WindowBase::WindowRedrawRequestSignalType& WindowBase::WindowRedrawRequestSignal()
+{
+ return mWindowRedrawRequestSignal;
+}
+
} // namespace Adaptor
} // namespace Internal
typedef Signal< void ( const RotationEvent& ) > RotationSignalType;
typedef Signal< void ( DevelWindow::EffectState, DevelWindow::EffectType ) > TransitionEffectEventSignalType;
typedef Signal< void ( ) > KeyboardRepeatSettingsChangedSignalType;
+ typedef Signal< void ( ) > WindowRedrawRequestSignalType;
// Input events
typedef Signal< void ( Integration::Point&, uint32_t ) > TouchEventSignalType;
*/
KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal();
+ /**
+ * @brief This signal is emitted when the window redraw is requested.
+ */
+ WindowRedrawRequestSignalType& WindowRedrawRequestSignal();
+
protected:
// Undefined
AccessibilitySignalType mAccessibilitySignal;
TransitionEffectEventSignalType mTransitionEffectEventSignal;
KeyboardRepeatSettingsChangedSignalType mKeyboardRepeatSettingsChangedSignal;
+ WindowRedrawRequestSignalType mWindowRedrawRequestSignal;
};
} // namespace Adaptor
mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent );
mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect( this, &Window::OnKeyboardRepeatSettingsChanged );
+ mWindowBase->WindowRedrawRequestSignal().Connect( this, &Window::OnWindowRedrawRequest );
mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
{
mWindowBase->Raise();
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId );
}
{
mWindowBase->Lower();
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId );
}
{
mWindowBase->Activate();
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId );
}
mVisibilityChangedSignal.Emit( handle, true );
}
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
mVisibilityChangedSignal.Emit( handle, false );
}
-
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
-
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
{
mWindowBase->SetInputRegion( inputRegion );
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
-
DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
}
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
Dali::Window::WindowSize Window::GetSize() const
mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
Dali::Window::WindowPosition Window::GetPosition() const
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
Dali::Layer Window::GetRootLayer() const
DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible );
}
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
void Window::OnFocusChanged( bool focusIn )
Dali::Window handle( this );
mFocusChangeSignal.Emit( handle, focusIn );
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
void Window::OnOutputTransformed()
mKeyboardRepeatSettingsChangedSignal.Emit();
}
+void Window::OnWindowRedrawRequest()
+{
+ mAdaptor->RenderOnce();
+}
+
void Window::OnTouchPoint( Dali::Integration::Point& point, int timeStamp )
{
FeedTouchPoint( point, timeStamp );
{
mEventHandler->Pause();
}
-
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
}
void Window::OnResume()
mEventHandler->Resume();
}
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetFullSwapNextFrame();
- }
+ mSurface->SetFullSwapNextFrame();
}
void Window::RecalculateTouchPosition( Integration::Point& point )
return mWindowBase->GetNativeWindowId();
}
-void Window::SetDamagedAreas(std::vector<Dali::Rect<int>>& areas)
-{
- GraphicsInterface& graphics = mAdaptor->GetGraphicsInterface();
- EglGraphics* eglGraphics = static_cast<EglGraphics*>(&graphics);
- if (eglGraphics)
- {
- eglGraphics->SetDamagedAreas(areas);
- }
-}
-
} // Adaptor
} // Internal
*/
void SetAvailableOrientations( const Dali::Vector<Dali::Window::WindowOrientation>& orientations );
- /**
- * @copydoc Dali::DevelWindow::SetDamagedAreas()
- */
- void SetDamagedAreas(std::vector<Dali::Rect<int>>& areas);
-
public: // Dali::Internal::Adaptor::SceneHolder
/**
/**
* Destructor
*/
- virtual ~Window();
+ ~Window() override;
/**
* Second stage initialization
void OnKeyboardRepeatSettingsChanged();
/**
+ * @brief Called when the window redraw is requested.
+ */
+ void OnWindowRedrawRequest();
+
+ /**
* @brief Set available orientation to window base.
*/
void SetAvailableAnlges( const std::vector< int >& angles );
{
const int MINIMUM_DIMENSION_CHANGE( 1 ); ///< Minimum change for window to be considered to have moved
+const float FULL_UPDATE_RATIO( 0.8f ); ///< Force full update when the dirty area is larget than this ratio
#if defined(DEBUG_ENABLED)
Debug::Filter* gWindowRenderSurfaceLogFilter = Debug::Filter::New(Debug::Verbose, false, "LOG_WINDOW_RENDER_SURFACE");
#endif
+void MergeRects( Rect< int >& mergingRect, const std::vector< Rect< int > >& rects )
+{
+ uint32_t i = 0;
+ if( mergingRect.IsEmpty() )
+ {
+ for( ; i < rects.size(); i++ )
+ {
+ if( !rects[i].IsEmpty() )
+ {
+ mergingRect = rects[i];
+ break;
+ }
+ }
+ }
+
+ for( ; i < rects.size(); i++ )
+ {
+ mergingRect.Merge( rects[i] );
+ }
+}
+
+void InsertRects( WindowRenderSurface::DamagedRectsContainer& damagedRectsList, const std::vector< Rect< int > >& damagedRects )
+{
+ damagedRectsList.push_front( damagedRects );
+ if( damagedRectsList.size() > 4 ) // past triple buffers + current
+ {
+ damagedRectsList.pop_back();
+ }
+}
+
} // unnamed namespace
WindowRenderSurface::WindowRenderSurface( Dali::PositionSize positionSize, Any surface, bool isTransparent )
mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ),
mOutputTransformedSignal(),
mFrameCallbackInfoContainer(),
+ mBufferDamagedRects(),
mMutex(),
mRotationAngle( 0 ),
mScreenRotationAngle( 0 ),
+ mDpiHorizontal( 0 ),
+ mDpiVertical( 0 ),
mOwnSurface( false ),
mRotationSupported( false ),
mRotationFinished( true ),
mScreenRotationFinished( true ),
- mResizeFinished( true ),
- mDpiHorizontal( 0 ),
- mDpiVertical( 0 )
+ mResizeFinished( true )
{
DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n" );
Initialize( surface );
MakeContextCurrent();
- auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
-
if( resizingSurface )
{
// Window rotate or screen rotate
DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: Set resize\n" );
}
- if (eglGraphics)
- {
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- eglImpl.SetFullSwapNextFrame();
- }
+ SetFullSwapNextFrame();
}
- if (eglGraphics)
- {
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- eglImpl.SetDamage( mEGLSurface, damagedRects, clippingRect );
- }
+ SetBufferDamagedRects( damagedRects, clippingRect );
return true;
}
}
}
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- eglImpl.SwapBuffers( mEGLSurface, damagedRects );
+ SwapBuffers( damagedRects );
if( mRenderNotification )
{
}
}
+void WindowRenderSurface::SetBufferDamagedRects( const std::vector< Rect< int > >& damagedRects, Rect< int >& clippingRect )
+{
+ auto eglGraphics = static_cast< EglGraphics* >( mGraphics );
+ if ( eglGraphics )
+ {
+ Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
+ if( !eglImpl.IsPartialUpdateRequired() )
+ {
+ return;
+ }
+
+ Rect< int > surfaceRect( 0, 0, mPositionSize.width, mPositionSize.height );
+
+ if( mFullSwapNextFrame )
+ {
+ InsertRects( mBufferDamagedRects, std::vector< Rect< int > >( 1, surfaceRect ) );
+ clippingRect = Rect< int >();
+ return;
+ }
+
+ EGLint bufferAge = eglImpl.GetBufferAge( mEGLSurface );
+
+ // Buffer age 0 means the back buffer in invalid and requires full swap
+ if( !damagedRects.size() || bufferAge == 0 )
+ {
+ InsertRects( mBufferDamagedRects, std::vector< Rect< int > >( 1, surfaceRect ) );
+ clippingRect = Rect< int >();
+ return;
+ }
+
+ // We push current frame damaged rects here, zero index for current frame
+ InsertRects( mBufferDamagedRects, damagedRects );
+
+ // Merge damaged rects into clipping rect
+ auto bufferDamagedRects = mBufferDamagedRects.begin();
+ while( bufferAge-- >= 0 && bufferDamagedRects != mBufferDamagedRects.end() )
+ {
+ const std::vector< Rect< int > >& rects = *bufferDamagedRects++;
+ MergeRects( clippingRect, rects );
+ }
+
+ if( !clippingRect.Intersect( surfaceRect ) || clippingRect.Area() > surfaceRect.Area() * FULL_UPDATE_RATIO )
+ {
+ // clipping area too big or doesn't intersect surface rect
+ clippingRect = Rect< int >();
+ return;
+ }
+
+ std::vector< Rect< int > > damagedRegion;
+ damagedRegion.push_back( clippingRect );
+
+ eglImpl.SetDamageRegion( mEGLSurface, damagedRegion );
+ }
+}
+
+void WindowRenderSurface::SwapBuffers( const std::vector<Rect<int>>& damagedRects )
+{
+ auto eglGraphics = static_cast< EglGraphics* >( mGraphics );
+ if( eglGraphics )
+ {
+ Rect< int > surfaceRect( 0, 0, mPositionSize.width, mPositionSize.height );
+
+ Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
+
+ if( !eglImpl.IsPartialUpdateRequired() || mFullSwapNextFrame || !damagedRects.size() || (damagedRects[0].Area() > surfaceRect.Area() * FULL_UPDATE_RATIO) )
+ {
+ mFullSwapNextFrame = false;
+ eglImpl.SwapBuffers( mEGLSurface );
+ return;
+ }
+
+ mFullSwapNextFrame = false;
+
+ std::vector< Rect< int > > mergedRects = damagedRects;
+
+ // Merge intersecting rects, form an array of non intersecting rects to help driver a bit
+ // Could be optional and can be removed, needs to be checked with and without on platform
+ const int n = mergedRects.size();
+ for( int i = 0; i < n - 1; i++ )
+ {
+ if( mergedRects[i].IsEmpty() )
+ {
+ continue;
+ }
+
+ for( int j = i + 1; j < n; j++ )
+ {
+ if( mergedRects[j].IsEmpty() )
+ {
+ continue;
+ }
+
+ if( mergedRects[i].Intersects( mergedRects[j] ) )
+ {
+ mergedRects[i].Merge( mergedRects[j] );
+ mergedRects[j].width = 0;
+ mergedRects[j].height = 0;
+ }
+ }
+ }
+
+ int j = 0;
+ for( int i = 0; i < n; i++ )
+ {
+ if( !mergedRects[i].IsEmpty() )
+ {
+ mergedRects[j++] = mergedRects[i];
+ }
+ }
+
+ if( j != 0 )
+ {
+ mergedRects.resize( j );
+ }
+
+ if( !mergedRects.size() || ( mergedRects[0].Area() > surfaceRect.Area() * FULL_UPDATE_RATIO ) )
+ {
+ eglImpl.SwapBuffers( mEGLSurface );
+ }
+ else
+ {
+ eglImpl.SwapBuffers( mEGLSurface, mergedRects );
+ }
+ }
+}
+
} // namespace Adaptor
} // namespace internal
{
public:
- typedef Signal< void ( ) > OutputSignalType;
+ using OutputSignalType = Signal< void ( ) >;
+ using DamagedRectsContainer = std::list< std::vector< Rect< int > > >;
/**
* Uses an window surface to render to.
/**
* @copydoc Dali::RenderSurfaceInterface::GetPositionSize()
*/
- virtual PositionSize GetPositionSize() const override;
+ PositionSize GetPositionSize() const override;
/**
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
*/
- virtual void InitializeGraphics() override;
+ void InitializeGraphics() override;
/**
* @copydoc Dali::RenderSurfaceInterface::CreateSurface()
*/
- virtual void CreateSurface() override;
+ void CreateSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::DestroySurface()
*/
- virtual void DestroySurface() override;
+ void DestroySurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::ReplaceGraphicsSurface()
*/
- virtual bool ReplaceGraphicsSurface() override;
+ bool ReplaceGraphicsSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MoveResize()
*/
- virtual void MoveResize( Dali::PositionSize positionSize) override;
+ void MoveResize( Dali::PositionSize positionSize) override;
/**
* @copydoc Dali::RenderSurfaceInterface::StartRender()
*/
- virtual void StartRender() override;
+ void StartRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::PreRender()
*/
- virtual bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
+ bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::PostRender()
*/
- virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
+ void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::StopRender()
*/
- virtual void StopRender() override;
+ void StopRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::SetThreadSynchronization
*/
- virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) override;
+ void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::ReleaseLock()
*/
- virtual void ReleaseLock() override;
+ void ReleaseLock() override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetSurfaceType()
*/
- virtual Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
+ Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MakeContextCurrent()
*/
- virtual void MakeContextCurrent() override;
+ void MakeContextCurrent() override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetDepthBufferRequired()
*/
- virtual Integration::DepthBufferAvailable GetDepthBufferRequired() override;
+ Integration::DepthBufferAvailable GetDepthBufferRequired() override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetStencilBufferRequired()
*/
- virtual Integration::StencilBufferAvailable GetStencilBufferRequired() override;
+ Integration::StencilBufferAvailable GetStencilBufferRequired() override;
private:
*/
void OnFileDescriptorEventDispatched( FileDescriptorMonitor::EventType eventBitMask, int fileDescriptor );
+ /**
+ * @brief Set the buffer damage rects.
+ * @param[in] damagedRects List of damaged rects
+ * @param[in] clippingRect The rect to clip rendered scene
+ */
+ void SetBufferDamagedRects( const std::vector< Rect< int > >& damagedRects, Rect< int >& clippingRect );
+
+ /**
+ * @brief Swap buffers.
+ * @param[in] damagedRects List of damaged rects
+ */
+ void SwapBuffers( const std::vector<Rect<int>>& damagedRects );
+
protected:
// Undefined
ColorDepth mColorDepth; ///< Color depth of surface (32 bit or 24 bit)
OutputSignalType mOutputTransformedSignal;
FrameCallbackInfoContainer mFrameCallbackInfoContainer;
+ DamagedRectsContainer mBufferDamagedRects;
Dali::Mutex mMutex;
int mRotationAngle;
int mScreenRotationAngle;
+ uint32_t mDpiHorizontal;
+ uint32_t mDpiVertical;
bool mOwnSurface; ///< Whether we own the surface (responsible for deleting it)
bool mRotationSupported;
bool mRotationFinished;
bool mScreenRotationFinished;
bool mResizeFinished;
- uint32_t mDpiHorizontal;
- uint32_t mDpiVertical;
-
}; // class WindowRenderSurface
} // namespace Adaptor
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindow()
*/
- virtual Any GetNativeWindow() override;
+ Any GetNativeWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindowId()
*/
- virtual int GetNativeWindowId() override;
+ int GetNativeWindowId() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateEglWindow()
*/
- virtual EGLNativeWindowType CreateEglWindow( int width, int height ) override;
+ EGLNativeWindowType CreateEglWindow( int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::DestroyEglWindow()
*/
- virtual void DestroyEglWindow() override;
+ void DestroyEglWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowRotation()
*/
- virtual void SetEglWindowRotation( int angle ) override;
+ void SetEglWindowRotation( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowBufferTransform()
*/
- virtual void SetEglWindowBufferTransform( int angle ) override;
+ void SetEglWindowBufferTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowTransform()
*/
- virtual void SetEglWindowTransform( int angle ) override;
+ void SetEglWindowTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::ResizeEglWindow()
*/
- virtual void ResizeEglWindow( PositionSize positionSize ) override;
+ void ResizeEglWindow( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::IsEglWindowRotationSupported()
*/
- virtual bool IsEglWindowRotationSupported() override;
+ bool IsEglWindowRotationSupported() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Move()
*/
- virtual void Move( PositionSize positionSize ) override;
+ void Move( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Resize()
*/
- virtual void Resize( PositionSize positionSize ) override;
+ void Resize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::MoveResize()
*/
- virtual void MoveResize( PositionSize positionSize ) override;
+ void MoveResize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetClass()
*/
- virtual void SetClass( const std::string& name, const std::string& className ) override;
+ void SetClass( const std::string& name, const std::string& className ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Raise()
*/
- virtual void Raise() override;
+ void Raise() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Lower()
*/
- virtual void Lower() override;
+ void Lower() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Activate()
*/
- virtual void Activate() override;
+ void Activate() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAvailableAnlges()
*/
- virtual void SetAvailableAnlges( const std::vector< int >& angles ) override;
+ void SetAvailableAnlges( const std::vector< int >& angles ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPreferredAngle()
*/
- virtual void SetPreferredAngle( int angle ) override;
+ void SetPreferredAngle( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAcceptFocus()
*/
- virtual void SetAcceptFocus( bool accept ) override;
+ void SetAcceptFocus( bool accept ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Show()
*/
- virtual void Show() override;
+ void Show() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Hide()
*/
- virtual void Hide() override;
+ void Hide() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHintCount()
*/
- virtual unsigned int GetSupportedAuxiliaryHintCount() const override;
+ unsigned int GetSupportedAuxiliaryHintCount() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHint()
*/
- virtual std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
+ std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::AddAuxiliaryHint()
*/
- virtual unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
+ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::RemoveAuxiliaryHint()
*/
- virtual bool RemoveAuxiliaryHint( unsigned int id ) override;
+ bool RemoveAuxiliaryHint( unsigned int id ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAuxiliaryHintValue()
*/
- virtual bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
+ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintValue()
*/
- virtual std::string GetAuxiliaryHintValue( unsigned int id ) const override;
+ std::string GetAuxiliaryHintValue( unsigned int id ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintId()
*/
- virtual unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
+ unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetInputRegion()
*/
- virtual void SetInputRegion( const Rect< int >& inputRegion ) override;
+ void SetInputRegion( const Rect< int >& inputRegion ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetType()
*/
- virtual void SetType( Dali::Window::Type type ) override;
+ void SetType( Dali::Window::Type type ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetNotificationLevel()
*/
- virtual bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
+ bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNotificationLevel()
*/
- virtual Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
+ Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetOpaqueState()
*/
- virtual void SetOpaqueState( bool opaque ) override;
+ void SetOpaqueState( bool opaque ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetScreenOffMode()
*/
- virtual bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
+ bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenOffMode()
*/
- virtual Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
+ Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetBrightness()
*/
- virtual bool SetBrightness( int brightness ) override;
+ bool SetBrightness( int brightness ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetBrightness()
*/
- virtual int GetBrightness() const override;
+ int GetBrightness() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKey()
*/
- virtual bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
+ bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKey()
*/
- virtual bool UngrabKey( Dali::KEY key ) override;
+ bool UngrabKey( Dali::KEY key ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKeyList()
*/
- virtual bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
+ bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKeyList()
*/
- virtual bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
+ bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
*/
- virtual int GetScreenRotationAngle() override;
+ int GetScreenRotationAngle() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetWindowRotationAngle()
*/
- virtual void SetWindowRotationAngle( int degree ) override;
+ void SetWindowRotationAngle( int degree ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::WindowRotationCompleted()
*/
- virtual void WindowRotationCompleted( int degree, int width, int height ) override;
+ void WindowRotationCompleted( int degree, int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetTransparency()
*/
- virtual void SetTransparency( bool transparent ) override;
+ void SetTransparency( bool transparent ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
*/
- virtual void SetParent( WindowBase* parentWinBase ) override;
+ void SetParent( WindowBase* parentWinBase ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFrameRenderedSyncFence()
*/
- virtual int CreateFrameRenderedSyncFence() override;
+ int CreateFrameRenderedSyncFence() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFramePresentedSyncFence()
*/
- virtual int CreateFramePresentedSyncFence() override;
+ int CreateFramePresentedSyncFence() override;
private:
}
/////////////////////////////////////////////////////////////////////////////////////////////////
+// Window Redraw Request Event Callbacks
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static Eina_Bool EcoreEventWindowRedrawRequest(void *data, int type, void *event)
+{
+ Ecore_Wl2_Event_Window_Redraw_Request *windowRedrawRequest = static_cast<Ecore_Wl2_Event_Window_Redraw_Request *>(event);
+ WindowBaseEcoreWl2 *windowBase = static_cast<WindowBaseEcoreWl2 *>(data);
+ DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::EcoreEventWindowRedrawRequest, window[ %d ]\n", windowRedrawRequest->win );
+ if ( windowBase )
+ {
+ windowBase->OnEcoreEventWindowRedrawRequest();
+ }
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
// ElDBus Accessibility Callbacks
/////////////////////////////////////////////////////////////////////////////////////////////////
// Register Keyboard repeat event
mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_SEAT_KEYBOARD_REPEAT_CHANGED, EcoreEventSeatKeyboardRepeatChanged, this ) );
+ // Register Window redraw request event
+ mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL2_EVENT_WINDOW_REDRAW_REQUEST, EcoreEventWindowRedrawRequest, this ) );
+
// Register Vconf notify - font name and size
vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this );
vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this );
mKeyboardRepeatSettingsChangedSignal.Emit();
}
+void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
+{
+ mWindowRedrawRequestSignal.Emit();
+}
+
void WindowBaseEcoreWl2::KeymapChanged(void *data, int type, void *event)
{
Ecore_Wl2_Event_Seat_Keymap_Changed *changed = static_cast<Ecore_Wl2_Event_Seat_Keymap_Changed*>( event );
*/
void OnKeyboardRepeatSettingsChanged();
+ /**
+ * @brief Called when a window redraw is requested.
+ */
+ void OnEcoreEventWindowRedrawRequest();
+
#ifdef DALI_ELDBUS_AVAILABLE
/**
* @brief Called when Ecore ElDBus accessibility event is received.
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindow()
*/
- virtual Any GetNativeWindow() override;
+ Any GetNativeWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindowId()
*/
- virtual int GetNativeWindowId() override;
+ int GetNativeWindowId() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateEglWindow()
*/
- virtual EGLNativeWindowType CreateEglWindow( int width, int height ) override;
+ EGLNativeWindowType CreateEglWindow( int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::DestroyEglWindow()
*/
- virtual void DestroyEglWindow() override;
+ void DestroyEglWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowRotation()
*/
- virtual void SetEglWindowRotation( int angle ) override;
+ void SetEglWindowRotation( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowBufferTransform()
*/
- virtual void SetEglWindowBufferTransform( int angle ) override;
+ void SetEglWindowBufferTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowTransform()
*/
- virtual void SetEglWindowTransform( int angle ) override;
+ void SetEglWindowTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::ResizeEglWindow()
*/
- virtual void ResizeEglWindow( PositionSize positionSize ) override;
+ void ResizeEglWindow( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::IsEglWindowRotationSupported()
*/
- virtual bool IsEglWindowRotationSupported() override;
+ bool IsEglWindowRotationSupported() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Move()
*/
- virtual void Move( PositionSize positionSize ) override;
+ void Move( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Resize()
*/
- virtual void Resize( PositionSize positionSize ) override;
+ void Resize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::MoveResize()
*/
- virtual void MoveResize( PositionSize positionSize ) override;
+ void MoveResize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetClass()
*/
- virtual void SetClass( const std::string& name, const std::string& className ) override;
+ void SetClass( const std::string& name, const std::string& className ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Raise()
*/
- virtual void Raise() override;
+ void Raise() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Lower()
*/
- virtual void Lower() override;
+ void Lower() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Activate()
*/
- virtual void Activate() override;
+ void Activate() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAvailableAnlges()
*/
- virtual void SetAvailableAnlges( const std::vector< int >& angles ) override;
+ void SetAvailableAnlges( const std::vector< int >& angles ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPreferredAngle()
*/
- virtual void SetPreferredAngle( int angle ) override;
+ void SetPreferredAngle( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAcceptFocus()
*/
- virtual void SetAcceptFocus( bool accept ) override;
+ void SetAcceptFocus( bool accept ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Show()
*/
- virtual void Show() override;
+ void Show() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Hide()
*/
- virtual void Hide() override;
+ void Hide() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHintCount()
*/
- virtual unsigned int GetSupportedAuxiliaryHintCount() const override;
+ unsigned int GetSupportedAuxiliaryHintCount() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHint()
*/
- virtual std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
+ std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::AddAuxiliaryHint()
*/
- virtual unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
+ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::RemoveAuxiliaryHint()
*/
- virtual bool RemoveAuxiliaryHint( unsigned int id ) override;
+ bool RemoveAuxiliaryHint( unsigned int id ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAuxiliaryHintValue()
*/
- virtual bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
+ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintValue()
*/
- virtual std::string GetAuxiliaryHintValue( unsigned int id ) const override;
+ std::string GetAuxiliaryHintValue( unsigned int id ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintId()
*/
- virtual unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
+ unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetInputRegion()
*/
- virtual void SetInputRegion( const Rect< int >& inputRegion ) override;
+ void SetInputRegion( const Rect< int >& inputRegion ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetType()
*/
- virtual void SetType( Dali::Window::Type type ) override;
+ void SetType( Dali::Window::Type type ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetNotificationLevel()
*/
- virtual bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
+ bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNotificationLevel()
*/
- virtual Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
+ Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetOpaqueState()
*/
- virtual void SetOpaqueState( bool opaque ) override;
+ void SetOpaqueState( bool opaque ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetScreenOffMode()
*/
- virtual bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
+ bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenOffMode()
*/
- virtual Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
+ Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetBrightness()
*/
- virtual bool SetBrightness( int brightness ) override;
+ bool SetBrightness( int brightness ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetBrightness()
*/
- virtual int GetBrightness() const override;
+ int GetBrightness() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKey()
*/
- virtual bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
+ bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKey()
*/
- virtual bool UngrabKey( Dali::KEY key ) override;
+ bool UngrabKey( Dali::KEY key ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKeyList()
*/
- virtual bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
+ bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKeyList()
*/
- virtual bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
+ bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
*/
- virtual int GetScreenRotationAngle() override;
+ int GetScreenRotationAngle() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetWindowRotationAngle()
*/
- virtual void SetWindowRotationAngle( int degree ) override;
+ void SetWindowRotationAngle( int degree ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::WindowRotationCompleted()
*/
- virtual void WindowRotationCompleted( int degree, int width, int height ) override;
+ void WindowRotationCompleted( int degree, int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetTransparency()
*/
- virtual void SetTransparency( bool transparent ) override;
+ void SetTransparency( bool transparent ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
*/
- virtual void SetParent( WindowBase* parentWinBase ) override;
+ void SetParent( WindowBase* parentWinBase ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFrameRenderedSyncFence()
*/
- virtual int CreateFrameRenderedSyncFence() override;
+ int CreateFrameRenderedSyncFence() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFramePresentedSyncFence()
*/
- virtual int CreateFramePresentedSyncFence() override;
+ int CreateFramePresentedSyncFence() override;
private:
bool NativeRenderSurfaceEcoreWl::PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect )
{
- auto eglGraphics = static_cast<Internal::Adaptor::EglGraphics*>(mGraphics);
- if (eglGraphics)
- {
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- if (resizingSurface)
- {
- eglImpl.SetFullSwapNextFrame();
- }
-
- eglImpl.SetDamage(mEGLSurface, damagedRects, clippingRect);
- }
-
+ //TODO: Need to support partial update
return true;
}
/**
* @copydoc Dali::NativeRenderSurface::GetSurface()
*/
- virtual Any GetDrawable() override;
+ Any GetDrawable() override;
/**
* @copydoc Dali::NativeRenderSurface::SetRenderNotification()
*/
- virtual void SetRenderNotification( TriggerEventInterface* renderNotification ) override;
+ void SetRenderNotification( TriggerEventInterface* renderNotification ) override;
/**
* @copydoc Dali::NativeRenderSurface::WaitUntilSurfaceReplaced()
*/
- virtual void WaitUntilSurfaceReplaced() override;
+ void WaitUntilSurfaceReplaced() override;
public: // from Dali::RenderSurfaceInterface
/**
* @copydoc Dali::RenderSurfaceInterface::GetPositionSize()
*/
- virtual PositionSize GetPositionSize() const override;
+ PositionSize GetPositionSize() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
*/
- virtual void InitializeGraphics() override;
+ void InitializeGraphics() override;
/**
* @copydoc Dali::RenderSurfaceInterface::CreateSurface()
*/
- virtual void CreateSurface() override;
+ void CreateSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::DestroySurface()
*/
- virtual void DestroySurface() override;
+ void DestroySurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::ReplaceGraphicsSurface()
*/
- virtual bool ReplaceGraphicsSurface() override;
+ bool ReplaceGraphicsSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MoveResize()
*/
- virtual void MoveResize( Dali::PositionSize positionSize) override;
+ void MoveResize( Dali::PositionSize positionSize) override;
/**
* @copydoc Dali::RenderSurfaceInterface::StartRender()
*/
- virtual void StartRender() override;
+ void StartRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::PreRender()
*/
- virtual bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
+ bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::PostRender()
*/
- virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
+ void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::StopRender()
*/
- virtual void StopRender() override;
+ void StopRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::SetThreadSynchronization
*/
- virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization )override;
+ void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization )override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetSurfaceType()
*/
- virtual Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
+ Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MakeContextCurrent()
*/
- virtual void MakeContextCurrent() override;
+ void MakeContextCurrent() override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetDepthBufferRequired()
*/
- virtual Integration::DepthBufferAvailable GetDepthBufferRequired() override;
+ Integration::DepthBufferAvailable GetDepthBufferRequired() override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetStencilBufferRequired()
*/
- virtual Integration::StencilBufferAvailable GetStencilBufferRequired() override;
+ Integration::StencilBufferAvailable GetStencilBufferRequired() override;
private:
/**
* @copydoc Dali::RenderSurfaceInterface::ReleaseLock()
*/
- virtual void ReleaseLock() override;
+ void ReleaseLock() override;
/**
* @copydoc Dali::NativeRenderSurface::CreateNativeRenderable()
*/
- virtual void CreateNativeRenderable() override;
+ void CreateNativeRenderable() override;
/**
* @copydoc Dali::NativeRenderSurface::ReleaseDrawable()
*/
- virtual void ReleaseDrawable() override;
+ void ReleaseDrawable() override;
private: // Data
/**
* @copydoc Dali::Internal::Adaptor::PixmapRenderSurface::GetSurface()
*/
- virtual Any GetSurface() override;
+ Any GetSurface() override;
/**
* @copydoc Dali::Internal::Adaptor::PixmapRenderSurface::SetRenderNotification()
*/
- virtual void SetRenderNotification( TriggerEventInterface* renderNotification ) override;
+ void SetRenderNotification( TriggerEventInterface* renderNotification ) override;
public: // from Dali::RenderSurfaceInterface
/**
* @copydoc Dali::RenderSurfaceInterface::GetPositionSize()
*/
- virtual PositionSize GetPositionSize() const override;
+ PositionSize GetPositionSize() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
*/
- virtual void InitializeGraphics() override;
+ void InitializeGraphics() override;
/**
* @copydoc Dali::RenderSurfaceInterface::CreateSurface()
*/
- virtual void CreateSurface() override;
+ void CreateSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::DestroySurface()
*/
- virtual void DestroySurface() override;
+ void DestroySurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::ReplaceGraphicsSurface()
*/
- virtual bool ReplaceGraphicsSurface() override;
+ bool ReplaceGraphicsSurface() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MoveResize()
/**
* @copydoc Dali::RenderSurfaceInterface::StartRender()
*/
- virtual void StartRender() override;
+ void StartRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::PreRender()
*/
- virtual bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
+ bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::PostRender()
*/
- virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
+ void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::StopRender()
*/
- virtual void StopRender() override;
+ void StopRender() override;
/**
* @copydoc Dali::RenderSurfaceInterface::SetThreadSynchronization
*/
- virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) override;
+ void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) override;
/**
* @copydoc Dali::RenderSurfaceInterface::GetSurfaceType()
*/
- virtual Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
+ Dali::RenderSurfaceInterface::Type GetSurfaceType() override;
/**
* @copydoc Dali::RenderSurfaceInterface::MakeContextCurrent()
*/
- virtual void MakeContextCurrent() override;
+ void MakeContextCurrent() override;
private: // from PixmapRenderSurface
/**
* @copydoc Dali::RenderSurfaceInterface::ReleaseLock()
*/
- virtual void ReleaseLock() override;
+ void ReleaseLock() override;
/**
* @copydoc Dali::Internal::Adaptor::PixmapRenderSurface::Initialize()
*/
- virtual void Initialize( Any surface ) override;
+ void Initialize( Any surface ) override;
/**
* @copydoc Dali::Internal::Adaptor::PixmapRenderSurface::Initialize()
*/
- virtual void CreateRenderable() override;
+ void CreateRenderable() override;
/**
* @copydoc Dali::Internal::Adaptor::PixmapRenderSurface::Initialize()
*/
- virtual void UseExistingRenderable( unsigned int surfaceId ) override;
+ void UseExistingRenderable( unsigned int surfaceId ) override;
private:
{
if( selectionNotifyEvent->selection == ECORE_X_SELECTION_SECONDARY )
{
- mSelectionDataReceivedSignal.Emit( event );
+ mSelectionDataReceivedSignal.Emit( event );
}
}
}
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindow()
*/
- virtual Any GetNativeWindow() override;
+ Any GetNativeWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindowId()
*/
- virtual int GetNativeWindowId() override;
+ int GetNativeWindowId() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateEglWindow()
*/
- virtual EGLNativeWindowType CreateEglWindow( int width, int height ) override;
+ EGLNativeWindowType CreateEglWindow( int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::DestroyEglWindow()
*/
- virtual void DestroyEglWindow() override;
+ void DestroyEglWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowRotation()
*/
- virtual void SetEglWindowRotation( int angle ) override;
+ void SetEglWindowRotation( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowBufferTransform()
*/
- virtual void SetEglWindowBufferTransform( int angle ) override;
+ void SetEglWindowBufferTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowTransform()
*/
- virtual void SetEglWindowTransform( int angle ) override;
+ void SetEglWindowTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::ResizeEglWindow()
*/
- virtual void ResizeEglWindow( PositionSize positionSize ) override;
+ void ResizeEglWindow( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::IsEglWindowRotationSupported()
*/
- virtual bool IsEglWindowRotationSupported() override;
+ bool IsEglWindowRotationSupported() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Move()
*/
- virtual void Move( PositionSize positionSize ) override;
+ void Move( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Resize()
*/
- virtual void Resize( PositionSize positionSize ) override;
+ void Resize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::MoveResize()
*/
- virtual void MoveResize( PositionSize positionSize ) override;
+ void MoveResize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetClass()
*/
- virtual void SetClass( const std::string& name, const std::string& className ) override;
+ void SetClass( const std::string& name, const std::string& className ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Raise()
*/
- virtual void Raise() override;
+ void Raise() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Lower()
*/
- virtual void Lower() override;
+ void Lower() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Activate()
*/
- virtual void Activate() override;
+ void Activate() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAvailableAnlges()
*/
- virtual void SetAvailableAnlges( const std::vector< int >& angles ) override;
+ void SetAvailableAnlges( const std::vector< int >& angles ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPreferredAngle()
*/
- virtual void SetPreferredAngle( int angle ) override;
+ void SetPreferredAngle( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAcceptFocus()
*/
- virtual void SetAcceptFocus( bool accept ) override;
+ void SetAcceptFocus( bool accept ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Show()
*/
- virtual void Show() override;
+ void Show() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Hide()
*/
- virtual void Hide() override;
+ void Hide() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHintCount()
*/
- virtual unsigned int GetSupportedAuxiliaryHintCount() const override;
+ unsigned int GetSupportedAuxiliaryHintCount() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHint()
*/
- virtual std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
+ std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::AddAuxiliaryHint()
*/
- virtual unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
+ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::RemoveAuxiliaryHint()
*/
- virtual bool RemoveAuxiliaryHint( unsigned int id ) override;
+ bool RemoveAuxiliaryHint( unsigned int id ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAuxiliaryHintValue()
*/
- virtual bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
+ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintValue()
*/
- virtual std::string GetAuxiliaryHintValue( unsigned int id ) const override;
+ std::string GetAuxiliaryHintValue( unsigned int id ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintId()
*/
- virtual unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
+ unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetInputRegion()
*/
- virtual void SetInputRegion( const Rect< int >& inputRegion ) override;
+ void SetInputRegion( const Rect< int >& inputRegion ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetType()
*/
- virtual void SetType( Dali::Window::Type type ) override;
+ void SetType( Dali::Window::Type type ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetNotificationLevel()
*/
- virtual bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
+ bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNotificationLevel()
*/
- virtual Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
+ Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetOpaqueState()
*/
- virtual void SetOpaqueState( bool opaque ) override;
+ void SetOpaqueState( bool opaque ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetScreenOffMode()
*/
- virtual bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
+ bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenOffMode()
*/
- virtual Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
+ Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetBrightness()
*/
- virtual bool SetBrightness( int brightness ) override;
+ bool SetBrightness( int brightness ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetBrightness()
*/
- virtual int GetBrightness() const override;
+ int GetBrightness() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKey()
*/
- virtual bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
+ bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKey()
*/
- virtual bool UngrabKey( Dali::KEY key ) override;
+ bool UngrabKey( Dali::KEY key ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKeyList()
*/
- virtual bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
+ bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKeyList()
*/
- virtual bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
+ bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
*/
- virtual int GetScreenRotationAngle() override;
+ int GetScreenRotationAngle() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetWindowRotationAngle()
*/
- virtual void SetWindowRotationAngle( int degree ) override;
+ void SetWindowRotationAngle( int degree ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::WindowRotationCompleted()
*/
- virtual void WindowRotationCompleted( int degree, int width, int height ) override;
+ void WindowRotationCompleted( int degree, int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetTransparency()
*/
- virtual void SetTransparency( bool transparent ) override;
+ void SetTransparency( bool transparent ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
*/
- virtual void SetParent( WindowBase* parentWinBase ) override;
+ void SetParent( WindowBase* parentWinBase ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFrameRenderedSyncFence()
*/
- virtual int CreateFrameRenderedSyncFence() override;
+ int CreateFrameRenderedSyncFence() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFramePresentedSyncFence()
*/
- virtual int CreateFramePresentedSyncFence() override;
+ int CreateFramePresentedSyncFence() override;
private:
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindow()
*/
- virtual Any GetNativeWindow() override;
+ Any GetNativeWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNativeWindowId()
*/
- virtual int GetNativeWindowId() override;
+ int GetNativeWindowId() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateEglWindow()
*/
- virtual EGLNativeWindowType CreateEglWindow( int width, int height ) override;
+ EGLNativeWindowType CreateEglWindow( int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::DestroyEglWindow()
*/
- virtual void DestroyEglWindow() override;
+ void DestroyEglWindow() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowRotation()
*/
- virtual void SetEglWindowRotation( int angle ) override;
+ void SetEglWindowRotation( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowBufferTransform()
*/
- virtual void SetEglWindowBufferTransform( int angle ) override;
+ void SetEglWindowBufferTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetEglWindowTransform()
*/
- virtual void SetEglWindowTransform( int angle ) override;
+ void SetEglWindowTransform( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::ResizeEglWindow()
*/
- virtual void ResizeEglWindow( PositionSize positionSize ) override;
+ void ResizeEglWindow( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::IsEglWindowRotationSupported()
*/
- virtual bool IsEglWindowRotationSupported() override;
+ bool IsEglWindowRotationSupported() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Move()
*/
- virtual void Move( PositionSize positionSize ) override;
+ void Move( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Resize()
*/
- virtual void Resize( PositionSize positionSize ) override;
+ void Resize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::MoveResize()
*/
- virtual void MoveResize( PositionSize positionSize ) override;
+ void MoveResize( PositionSize positionSize ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetClass()
*/
- virtual void SetClass( const std::string& name, const std::string& className ) override;
+ void SetClass( const std::string& name, const std::string& className ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Raise()
*/
- virtual void Raise() override;
+ void Raise() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Lower()
*/
- virtual void Lower() override;
+ void Lower() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Activate()
*/
- virtual void Activate() override;
+ void Activate() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAvailableAnlges()
*/
- virtual void SetAvailableAnlges( const std::vector< int >& angles ) override;
+ void SetAvailableAnlges( const std::vector< int >& angles ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPreferredAngle()
*/
- virtual void SetPreferredAngle( int angle ) override;
+ void SetPreferredAngle( int angle ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAcceptFocus()
*/
- virtual void SetAcceptFocus( bool accept ) override;
+ void SetAcceptFocus( bool accept ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Show()
*/
- virtual void Show() override;
+ void Show() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::Hide()
*/
- virtual void Hide() override;
+ void Hide() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHintCount()
*/
- virtual unsigned int GetSupportedAuxiliaryHintCount() const override;
+ unsigned int GetSupportedAuxiliaryHintCount() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetSupportedAuxiliaryHint()
*/
- virtual std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
+ std::string GetSupportedAuxiliaryHint( unsigned int index ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::AddAuxiliaryHint()
*/
- virtual unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
+ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::RemoveAuxiliaryHint()
*/
- virtual bool RemoveAuxiliaryHint( unsigned int id ) override;
+ bool RemoveAuxiliaryHint( unsigned int id ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetAuxiliaryHintValue()
*/
- virtual bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
+ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintValue()
*/
- virtual std::string GetAuxiliaryHintValue( unsigned int id ) const override;
+ std::string GetAuxiliaryHintValue( unsigned int id ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetAuxiliaryHintId()
*/
- virtual unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
+ unsigned int GetAuxiliaryHintId( const std::string& hint ) const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetInputRegion()
*/
- virtual void SetInputRegion( const Rect< int >& inputRegion ) override;
+ void SetInputRegion( const Rect< int >& inputRegion ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetType()
*/
- virtual void SetType( Dali::Window::Type type ) override;
+ void SetType( Dali::Window::Type type ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetNotificationLevel()
*/
- virtual bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
+ bool SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetNotificationLevel()
*/
- virtual Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
+ Dali::Window::NotificationLevel::Type GetNotificationLevel() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetOpaqueState()
*/
- virtual void SetOpaqueState( bool opaque ) override;
+ void SetOpaqueState( bool opaque ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetScreenOffMode()
*/
- virtual bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
+ bool SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenOffMode()
*/
- virtual Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
+ Dali::Window::ScreenOffMode::Type GetScreenOffMode() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetBrightness()
*/
- virtual bool SetBrightness( int brightness ) override;
+ bool SetBrightness( int brightness ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetBrightness()
*/
- virtual int GetBrightness() const override;
+ int GetBrightness() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKey()
*/
- virtual bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
+ bool GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKey()
*/
- virtual bool UngrabKey( Dali::KEY key ) override;
+ bool UngrabKey( Dali::KEY key ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GrabKeyList()
*/
- virtual bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
+ bool GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::UngrabKeyList()
*/
- virtual bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
+ bool UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetDpi()
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
+ void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
*/
- virtual int GetScreenRotationAngle() override;
+ int GetScreenRotationAngle() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetWindowRotationAngle()
*/
- virtual void SetWindowRotationAngle( int degree ) override;
+ void SetWindowRotationAngle( int degree ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::WindowRotationCompleted()
*/
- virtual void WindowRotationCompleted( int degree, int width, int height ) override;
+ void WindowRotationCompleted( int degree, int width, int height ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetTransparency()
*/
- virtual void SetTransparency( bool transparent ) override;
+ void SetTransparency( bool transparent ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
*/
- virtual void SetParent( WindowBase* parentWinBase ) override;
+ void SetParent( WindowBase* parentWinBase ) override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFrameRenderedSyncFence()
*/
- virtual int CreateFrameRenderedSyncFence() override;
+ int CreateFrameRenderedSyncFence() override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::CreateFramePresentedSyncFence()
*/
- virtual int CreateFramePresentedSyncFence() override;
+ int CreateFramePresentedSyncFence() override;
private:
/**
* @copydoc Dali::NativeImageInterface::GetExtension()
*/
- NativeImageInterface::Extension* GetExtension();
+ NativeImageInterface::Extension* GetExtension() override;
private:
* The implementation should destroy the NativeImage resources.
* @SINCE_1_0.0
*/
- DALI_INTERNAL virtual ~NativeImageSource();
+ DALI_INTERNAL ~NativeImageSource() override;
/**
* @brief Undefined copy constructor.
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
/**
* @brief Set content info to WidgetView.