Merge pull request capstone-engine#3 from mparaniak/linux-timer

Merging mparaniak changes into fork.

Author: benvanik

.gitignore

@@ -39,3 +39,29 @@ DemoAndroid/assets/font
 DemoAndroid/assets/language
 DemoAndroid/assets/skin
 Demo.exe
+build
+TurboBadgerDemo
+accuracy
+boing
+clipboard
+defaults
+events
+fsaa
+gamma
+gears
+glfwinfo
+heightmap
+iconify
+joysticks
+modes
+peter
+reopen
+sharing
+simple
+splitview
+tearing
+threads
+title
+wave
+windows
+

Demo/platform/Application.cpp

@@ -1,6 +1,7 @@
 #include "animation/tb_widget_animation.h"
 #include "Application.h"
-
+#include "tb_system.h"
+#include <stdio.h>
 using namespace tb;
 
 void Application::Run()
@@ -10,7 +11,9 @@ void Application::Run()
 
 bool Application::Init()
 {
+
 	TBWidgetsAnimationManager::Init();
+
 	return true;
 }
 
@@ -26,6 +29,7 @@ void Application::Process()
 	TBAnimationManager::Update();
 	GetRoot()->InvokeProcessStates();
 	GetRoot()->InvokeProcess();
+
 }
 
 void Application::RenderFrame(int window_w, int window_h)
@@ -34,6 +38,7 @@ void Application::RenderFrame(int window_w, int window_h)
 	GetRoot()->InvokePaint(TBWidget::PaintProps());
 	g_renderer->EndPaint();
 
+	
 	// If animations are running, reinvalidate immediately
 	if (TBAnimationManager::HasAnimationsRunning())
 		GetRoot()->Invalidate();

Demo/platform/glfw_extra_linux.cpp

@@ -24,6 +24,8 @@
 
 GLFWtimerfun timerCallback;
 
+#ifndef TB_TARGET_LINUX
+
 void glfwWakeUpMsgLoop(GLFWwindow *window)
 {
 }
@@ -52,7 +54,10 @@ void glfwKillTimer()
 
 void glfwSetTimerCallback(GLFWtimerfun cbfun)
 {
+
 	timerCallback = cbfun;
 }
 
+#endif /* TB_TARGET_LINUX */
+
 #endif // defined(TB_TARGET_LINUX) || defined(TB_TARGET_MACOSX)

Demo/platform/port_glfw.cpp

@@ -76,7 +76,6 @@ void RootWidget::OnInvalid()
 	if (!m_backend->has_pending_update)
 	{
 		m_backend->has_pending_update = true;
-		glfwWakeUpMsgLoop(m_backend->mainWindow);
 	}
 }
 
@@ -312,6 +311,8 @@ static void scroll_callback(GLFWwindow *window, double x, double y)
 	If fire_time is 0, it should be fired ASAP.
 	If force is true, it will ask the platform to schedule it again, even if
 	the fire_time is the same as last time. */
+
+#ifndef TB_TARGET_LINUX 
 static void ReschedulePlatformTimer(double fire_time, bool force)
 {
 	static double set_fire_time = -1;
@@ -329,6 +330,7 @@ static void ReschedulePlatformTimer(double fire_time, bool force)
 	}
 }
 
+
 static void timer_callback()
 {
 	double next_fire_time = TBMessageHandler::GetNextMessageFireTime();
@@ -355,6 +357,7 @@ void TBSystem::RescheduleTimer(double fire_time)
 {
 	ReschedulePlatformTimer(fire_time, false);
 }
+#endif /* TB_TARGET_LINUX */
 
 static void window_refresh_callback(GLFWwindow *window)
 {
@@ -436,7 +439,11 @@ bool ApplicationBackendGLFW::Init(Application *app, int width, int height, const
     glfwSetScrollCallback(mainWindow, scroll_callback);
     glfwSetKeyCallback(mainWindow, key_callback);
     glfwSetCharCallback(mainWindow, char_callback);
+
+#ifndef TB_SYSTEM_LINUX
     glfwSetTimerCallback(timer_callback);
+#endif
+	
 #if (GLFW_VERSION_MAJOR >= 3 && GLFW_VERSION_MINOR >= 1)
 	glfwSetDropCallback(mainWindow, drop_callback);
 #endif
@@ -445,6 +452,7 @@ bool ApplicationBackendGLFW::Init(Application *app, int width, int height, const
 	m_root.SetRect(TBRect(0, 0, width, height));
 
 	// Create the application object for our demo
+	
 	m_application = app;
 	m_application->OnBackendAttached(this);
 
@@ -472,9 +480,15 @@ void ApplicationBackendGLFW::Run()
 {
 	do
 	{
+		#ifdef TB_TARGET_LINUX
+		TBSystem::PollEvents();
+
+		#endif 
+		glfwPollEvents();
+		
 		if (has_pending_update)
 			window_refresh_callback(mainWindow);
-        glfwWaitMsgLoop(mainWindow);
+
 	} while (!glfwWindowShouldClose(mainWindow));
 }
 

src/tb/tb_core.cpp

@@ -3,6 +3,7 @@
 // ==                     See tb_core.h for more information.                    ==
 // ================================================================================
 
+#include "tb_config.h"
 #include "tb_core.h"
 #include "tb_skin.h"
 #include "tb_widgets_reader.h"
@@ -33,6 +34,11 @@ bool tb_core_init(TBRenderer *renderer, const char *lng_file)
 #ifdef TB_IMAGE
 	g_image_manager = new TBImageManager();
 #endif
+
+	#ifdef TB_SYSTEM_LINUX
+	TBSystem::Init();
+	#endif
+	
 	return TBInitAddons();
 }
 
@@ -47,6 +53,10 @@ void tb_core_shutdown()
 	delete g_tb_skin;
 	delete g_font_manager;
 	delete g_tb_lng;
+
+	#ifdef TB_SYSTEM_LINUX
+	TBSystem::Shutdown();
+	#endif
 }
 
 bool tb_core_is_initialized()

src/tb/tb_system.h

@@ -24,6 +24,29 @@ namespace tb {
 /** TBSystem is porting interface for the underlaying OS. */
 class TBSystem
 {
+
+	/* Linux specific timer implementation */
+#ifdef TB_SYSTEM_LINUX
+
+private:
+	static int timer_fd;
+
+	/* True if since last reschedule timer has fired. Is false if and only
+	   there was no expiration since last reschedule */
+	static bool timer_state;
+public:
+
+	/** Initialize timer descriptor. Return 0 on success, errno otherwise **/
+	static int Init();
+
+	/** Close timer descriptor. Return 0 on success, errno otherwise **/
+	static int Shutdown();
+
+	/** Check for timer expiration. Return 0 on success
+		(it does NOT imply timer fired; Check timer_state) and errno otherwise **/	
+	static int PollEvents();
+
+#endif /* TB_SYSTEM_LINUX */
 public:
 	/** Get the system time in milliseconds since some undefined epoch. */
 	static double GetTimeMS();
@@ -47,6 +70,18 @@ class TBSystem
 
 	/** Get Dots Per Inch for the main screen. */
 	static int GetDPI();
+
+
+#ifdef TB_TARGET_LINUX
+
+/** Check whether timer has fired. For now only
+		does work on Linux. On other platforms it defaults to true **/
+	inline static bool GetTimerState(){return timer_state;}
+	
+#else
+	inline static bool GetTimerState(){return true;}
+#endif /* TB_TARGET_LINUX */
+	
 };
 
 /** TBClipboard is a porting interface for the clipboard. */

src/tb/tb_system_linux.cpp

@@ -4,14 +4,23 @@
 // ================================================================================
 
 #include "tb_system.h"
+#include "tb_msg.h"
 
 #ifdef TB_SYSTEM_LINUX
 
-#include <sys/time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
 
 #ifdef TB_RUNTIME_DEBUG_INFO
 
+
 void TBDebugOut(const char *str)
 {
 	printf("%s", str);
@@ -30,11 +39,118 @@ double TBSystem::GetTimeMS()
 	return now.tv_usec/1000 + now.tv_sec*1000;
 }
 
-// Implementation currently done in port_glut.cpp.
-// FIX: Implement here for linux-desktop/android/macos?
-//void TBSystem::RescheduleTimer(double fire_time)
-//{
-//}
+
+/** FIXME: Timer facility only available in Linux **/
+#ifdef TB_SYSTEM_LINUX
+
+int	TBSystem::timer_fd;
+bool TBSystem::timer_state;
+	
+int TBSystem::Init()
+{
+
+	timer_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK);
+
+	errno = 0;
+	
+	if(timer_fd < 0){
+		TBDebugOut("Failed to obtain timer descriptor!");
+		return errno;
+	}
+
+	return 0;
+}
+
+int	TBSystem::Shutdown()
+{
+
+	timer_state = false;
+	
+	errno = 0;
+
+	if(timer_fd >= 0)
+		close(timer_fd);
+
+	if(timer_fd < 0){
+
+		TBDebugOut("Failed to close timer descriptor!");
+		return errno;
+	}
+
+	return 0;
+}
+
+void TBSystem::RescheduleTimer(double fire_time)
+{
+
+	if(fire_time == TB_NOT_SOON)
+		return;
+
+	if(fire_time == 0){
+		timer_state = true;
+		return;
+	}
+	int status = 0;
+
+	struct timespec fire_spec;
+
+	fire_time /= 1000;
+	fire_spec.tv_sec = fire_time;
+	fire_spec.tv_nsec = (fire_time - fire_spec.tv_sec)*1e9;
+
+	struct timespec zero_spec = {0,0};
+	struct itimerspec timer_spec  = { .it_interval = zero_spec,
+									  .it_value = fire_spec };
+
+	timer_state = false;
+
+	errno = 0;
+	status = timerfd_settime(timer_fd,TFD_TIMER_ABSTIME,
+							 &timer_spec, NULL);
+	if(status < 0)
+		TBDebugOut("Failed to arm timer!");
+}
+
+int TBSystem::PollEvents()
+{
+
+	if(!timer_state){
+
+		ssize_t rc = 0;
+		uint64_t count = 0;
+		
+		errno = 0;
+		rc = read(timer_fd, &count, sizeof(count));
+		
+		if(rc > 0 && count > 0)
+			timer_state = true;
+		
+		else{
+
+			if(errno == EAGAIN || errno == EWOULDBLOCK);
+
+			else{
+				TBDebugPrint("Failed to read from timer file!:%s", strerror(errno));
+				return errno;
+			}
+		}
+	}
+	
+	if(timer_state){
+
+		timer_state = false;
+		
+		TBMessageHandler::ProcessMessages();
+		// If we still have things to do (because we didn't process all messages,
+		// or because there are new messages), we need to rescedule, so call RescheduleTimer.
+		TBSystem::RescheduleTimer(TBMessageHandler::GetNextMessageFireTime());
+
+	}
+
+
+	return 0;
+}
+#endif /* TB_SYSTEM_LINUX */
 
 int TBSystem::GetLongClickDelayMS()
 {