void RemoveIdle( CallbackBase* callback );
/**
+ * @brief Processes the idle callbacks.
+ *
+ * @note This function is intended to be used in the case there is no instance of a Dali::Application i.e. DALi is used in a implementation of a plugin of an application.
+ */
+ void ProcessIdle();
+
+ /**
* @brief Replaces the rendering surface
*
* @param[in] window The window to replace the surface for
mCallbackManager->RemoveIdleCallback( callback );
}
+void Adaptor::ProcessIdle()
+{
+ bool idleProcessed = mCallbackManager->ProcessIdle();
+ mNotificationOnIdleInstalled = mNotificationOnIdleInstalled && !idleProcessed;
+}
+
void Adaptor::SetPreRenderCallback( CallbackBase* callback )
{
mThreadController->SetPreRenderCallback( callback );
virtual void RemoveIdle( CallbackBase* callback );
/**
+ * @copydoc Dali::Adaptor::ProcessIdle()
+ */
+ virtual void ProcessIdle();
+
+ /**
* Sets a pre-render callback.
*/
void SetPreRenderCallback( CallbackBase* callback );
mImpl->RemoveIdle( callback );
}
+void Adaptor::ProcessIdle()
+{
+ mImpl->ProcessIdle();
+}
+
void Adaptor::ReplaceSurface( Window window, Dali::RenderSurfaceInterface& surface )
{
Internal::Adaptor::SceneHolder* sceneHolder = &Dali::GetImplementation( window );
\r
// EXTERNAL INCLUDES\r
#include <dali/integration-api/debug.h>\r
+#include <windows.h>\r
\r
// INTERNAL INCLUDES\r
#include <dali/internal/window-system/windows/platform-implement-win.h>\r
\r
void Run()\r
{\r
- WindowsPlatformImplementation::RunLoop();\r
+ MSG nMsg = { 0 };\r
+\r
+ while (GetMessage(&nMsg, 0, NULL, NULL))\r
+ {\r
+ if (WIN_CALLBACK_EVENT == nMsg.message)\r
+ {\r
+ Dali::CallbackBase *callback = (Dali::CallbackBase*)nMsg.wParam;\r
+ Dali::CallbackBase::Execute(*callback);\r
+ }\r
+\r
+ TranslateMessage(&nMsg);\r
+ DispatchMessage(&nMsg);\r
+\r
+ mCallbackManager->ClearIdleCallbacks();\r
+\r
+ if (WM_CLOSE == nMsg.message)\r
+ {\r
+ break;\r
+ }\r
+ }\r
}\r
\r
void Quit()\r
}
}
+bool AndroidCallbackManager::ProcessIdle()
+{
+ // @todo To be implemented.
+ return false;
+}
+
+void AndroidCallbackManager::ClearIdleCallbacks()
+{
+ // @todo To be implemented.
+}
+
bool AndroidCallbackManager::AddIdleEntererCallback( CallbackBase* callback )
{
if( !mRunning )
virtual void RemoveIdleCallback( CallbackBase* callback );
/**
+ * @copydoc CallbackManager::ProcessIdle()
+ */
+ virtual bool ProcessIdle();
+
+ /**
+ * @copydoc CallbackManager::ProcessIdle()
+ */
+ virtual void ClearIdleCallbacks();
+
+ /**
* @copydoc CallbackManager::AddIdleEntererCallback()
*/
virtual bool AddIdleEntererCallback( CallbackBase* callback );
virtual void RemoveIdleCallback( CallbackBase* callback ) = 0;
/**
+ * @brief Processes the idle callbacks.
+ *
+ * @return whether a DALi callback has been processed.
+ */
+ virtual bool ProcessIdle() = 0;
+
+ /**
+ * @brief Clears the container of callbacks.
+ */
+ virtual void ClearIdleCallbacks() = 0;
+
+ /**
* @brief Adds a @p callback to be run when entering an idle state.
* @note Must be called from the main thread only.
*
}
}
+bool EcoreCallbackManager::ProcessIdle()
+{
+ // @todo To be implemented.
+ return false;
+}
+
+void EcoreCallbackManager::ClearIdleCallbacks()
+{
+ // @todo To be implemented.
+}
+
bool EcoreCallbackManager::AddIdleEntererCallback( CallbackBase* callback )
{
if( !mRunning )
virtual void RemoveIdleCallback( CallbackBase* callback );
/**
+ * @copydoc CallbackManager::ProcessIdle()
+ */
+ virtual bool ProcessIdle();
+
+ /**
+ * @copydoc CallbackManager::ProcessIdle()
+ */
+ virtual void ClearIdleCallbacks();
+
+ /**
* @copydoc CallbackManager::AddIdleEntererCallback()
*/
virtual bool AddIdleEntererCallback( CallbackBase* callback );
return false;\r
}\r
\r
+ mCallbacks.insert(callback);\r
+\r
WindowsPlatformImplementation::PostWinThreadMessage( WIN_CALLBACK_EVENT, reinterpret_cast<uint64_t>(callback), 0 );\r
+\r
return true;\r
}\r
\r
//Wait for deal\r
}\r
\r
+bool WinCallbackManager::ProcessIdle()\r
+{\r
+ const bool idleProcessed = !mCallbacks.empty();\r
+\r
+ for (CallbackBase* cb : mCallbacks)\r
+ {\r
+ Dali::CallbackBase::Execute(*cb);\r
+ }\r
+ mCallbacks.clear();\r
+\r
+ return idleProcessed;\r
+}\r
+\r
+void WinCallbackManager::ClearIdleCallbacks()\r
+{\r
+ mCallbacks.clear();\r
+}\r
+\r
bool WinCallbackManager::AddIdleEntererCallback( CallbackBase* callback )\r
{\r
return AddIdleCallback( callback, true );\r
*/
// EXTERNAL INCLUDES
-#include <list>
+#include <set>
// INTERNAL INCLUDES
#include <dali/internal/system/common/callback-manager.h>
-
namespace Dali
{
virtual void RemoveIdleCallback( CallbackBase* callback );
/**
+ * @copydoc CallbackManager::ProcessIdle()
+ */
+ virtual bool ProcessIdle();
+
+ /**
+ * @copydoc CallbackManager::ClearIdleCallbacks()
+ */
+ virtual void ClearIdleCallbacks();
+
+ /**
* @brief Adds a @p callback to be run when entering an idle state.
* @note Must be called from the main thread only.
*
virtual void Stop();
private:
+ std::set<CallbackBase*> mCallbacks;
bool mRunning; ///< flag is set to true if when running
};
// INTERNAL INCLUDES
#include <dali/internal/window-system/windows/event-system-win.h>
+namespace
+{
static constexpr float INCH = 25.4;
-
-using namespace std;
+}
namespace Dali
{
namespace WindowsPlatformImplementation
{
-void RunLoop()
-{
- MSG nMsg = { 0 };
-
- while( GetMessage( &nMsg, 0, NULL, NULL ) )
- {
- if( WIN_CALLBACK_EVENT == nMsg.message )
- {
- Dali::CallbackBase *callback = ( Dali::CallbackBase* )nMsg.wParam;
- Dali::CallbackBase::Execute( *callback );
- }
-
- TranslateMessage( &nMsg );
- DispatchMessage( &nMsg );
-
- if( WM_CLOSE == nMsg.message )
- {
- break;
- }
- }
-}
-
LRESULT CALLBACK WinProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
- WindowImpl::ProcWinMessge( reinterpret_cast<uint64_t>( hWnd ), uMsg, wParam, lParam );
+ WindowImpl::ProcWinMessage( reinterpret_cast<uint64_t>( hWnd ), uMsg, wParam, lParam );
LRESULT ret = DefWindowProc( hWnd, uMsg, wParam, lParam );
return ret;
mHWndToListener.erase( mHWnd );
}
-void WindowImpl::ProcWinMessge( uint64_t hWnd, uint32_t uMsg, uint64_t wParam, uint64_t lParam )
+void WindowImpl::ProcWinMessage( uint64_t hWnd, uint32_t uMsg, uint64_t wParam, uint64_t lParam )
{
std::map<uint64_t, WindowImpl*>::iterator x = mHWndToListener.find( hWnd );
namespace WindowsPlatformImplementation\r
{\r
\r
-void RunLoop();\r
-\r
bool PostWinThreadMessage(\r
_In_ uint32_t Msg,\r
_In_ uint32_t wParam,\r
\r
virtual ~WindowImpl();\r
\r
- static void ProcWinMessge( uint64_t hWnd, uint32_t uMsg, uint64_t wParam, uint64_t lParam );\r
+ static void ProcWinMessage( uint64_t hWnd, uint32_t uMsg, uint64_t wParam, uint64_t lParam );\r
\r
void GetDPI( float &xDpi, float &yDpi );\r
\r