reflexion 0.2.1 → 0.3

data/src/win32/event.h

@@ -0,0 +1,50 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_EVENT_H__
+#define __REFLEX_SRC_WIN32_EVENT_H__
+
+
+#include <xot/windows.h>
+#include "../event.h"
+
+
+namespace Reflex
+{
+
+
+	class NativeKeyEvent : public KeyEvent
+	{
+
+		public:
+
+			NativeKeyEvent (UINT msg, WPARAM wp, LPARAM lp, const char* chars = NULL);
+
+	};// NativeKeyEvent
+
+
+	class NativePointerEvent : public PointerEvent
+	{
+
+		public:
+
+			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp);
+
+			NativePointerEvent (HWND hwnd, const TOUCHINPUT* touches, size_t size);
+
+	};// NativePointerEvent
+
+
+	class NativeWheelEvent : public WheelEvent
+	{
+
+		public:
+
+			NativeWheelEvent (WPARAM wp_x, WPARAM wp_y, LPARAM lp);
+
+	};// NativeWheelEvent
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/win32/opengl.cpp

@@ -1,28 +1,35 @@
 #include "opengl.h"
 
 
+#include "reflex/exception.h"
+
+
 namespace Reflex
 {
 
 
-	OpenGL::OpenGL ()
-	:	hwnd(NULL), hdc(NULL), hrc(NULL)
+	OpenGLContext::OpenGLContext ()
 	{
 	}
 
-	OpenGL::~OpenGL ()
+	OpenGLContext::~OpenGLContext ()
 	{
 		fin();
 	}
 
-	bool
-	OpenGL::init (HWND hwnd_)
+	void
+	OpenGLContext::init (HWND hwnd_)
 	{
-		if (!hwnd_ || *this) return false;
+		if (!hwnd_)
+			argument_error(__FILE__, __LINE__);
+
+		if (*this)
+			invalid_state_error(__FILE__, __LINE__);
 
 		hwnd = hwnd_;
 		hdc  = GetDC(hwnd);
-		if (!hdc) return false;
+		if (!hdc)
+			system_error(__FILE__, __LINE__);
 
 		static const PIXELFORMATDESCRIPTOR PFD =
 		{
@@ -33,60 +40,80 @@ namespace Reflex
 		};
 
 		int pf = ChoosePixelFormat(hdc, &PFD);
-		if (pf == 0) return false;
+		if (pf == 0)
+			system_error(__FILE__, __LINE__);
 
 		if (!SetPixelFormat(hdc, pf, &PFD))
-			return false;
+			system_error(__FILE__, __LINE__);
 
 		hrc = wglCreateContext(hdc);
-		if (!hrc) return false;
+		if (!hrc)
+			system_error(__FILE__, __LINE__);
 
-		return make_current();
+		make_current();
 	}
 
-	bool
-	OpenGL::fin ()
+	void
+	OpenGLContext::fin ()
 	{
-		if (!*this) return false;
+		if (!*this) return;
 
 		if (hrc)
 		{
-			wglMakeCurrent(NULL, NULL);
-			wglDeleteContext(hrc);
+			if (hrc == wglGetCurrentContext())
+			{
+				if (!wglMakeCurrent(NULL, NULL))
+					system_error(__FILE__, __LINE__);
+			}
+
+			if (!wglDeleteContext(hrc))
+				system_error(__FILE__, __LINE__);
+
 			hrc = NULL;
 		}
 
 		if (hdc)
 		{
-			ReleaseDC(hwnd, hdc);
+			if (!ReleaseDC(hwnd, hdc))
+				system_error(__FILE__, __LINE__);
+
 			hdc = NULL;
 		}
 
 		hwnd = NULL;
-		return true;
 	}
 
-	bool
-	OpenGL::make_current ()
+	void
+	OpenGLContext::make_current ()
 	{
-		if (!*this) return false;
-		return wglMakeCurrent(hdc, hrc) != FALSE;
+		if (!*this) return;
+
+		if (!wglMakeCurrent(hdc, hrc))
+			system_error(__FILE__, __LINE__);
+	}
+
+	void
+	OpenGLContext::swap_buffers ()
+	{
+		if (!*this) return;
+
+		if (!SwapBuffers(hdc))
+			system_error(__FILE__, __LINE__);
 	}
 
 	bool
-	OpenGL::swap_buffers ()
+	OpenGLContext::is_active () const
 	{
-		if (!*this) return false;
-		return SwapBuffers(hdc) != FALSE;
+		return *this && hrc == wglGetCurrentContext();
 	}
 
-	OpenGL::operator bool () const
+	OpenGLContext::operator bool () const
 	{
 		return hwnd && hdc && hrc;
 	}
 
 	bool
-	OpenGL::operator ! () const
+	OpenGLContext::operator ! () const
 	{
 		return !operator bool();
 	}

data/src/win32/opengl.h

@@ -4,30 +4,32 @@
 #define __REFLEX_SRC_WIN32_OPENGL_H__
 
 
-#include <windows.h>
-#include <rays/opengl.h>
+#include <GL/glew.h>
+#include <xot/windows.h>
 
 
 namespace Reflex
 {
 
 
-	class OpenGL
+	class OpenGLContext
 	{
 
 		public:
 
-			OpenGL ();
+			OpenGLContext ();
 
-			~OpenGL ();
+			~OpenGLContext ();
 
-			bool init (HWND hwnd);
+			void init (HWND hwnd);
 
-			bool fin ();
+			void fin ();
 
-			bool make_current ();
+			void make_current ();
 
-			bool swap_buffers ();
+			void swap_buffers ();
+
+			bool is_active () const;
 
 			operator bool () const;
 
@@ -35,13 +37,13 @@ namespace Reflex
 
 		private:
 
-			HWND hwnd;
+			HWND hwnd = NULL;
 
-			HDC hdc;
+			HDC hdc   = NULL;
 
-			HGLRC hrc;
+			HGLRC hrc = NULL;
 
-	};// OpenGL
+	};// OpenGLContext
 
 
 }// Reflex

data/src/win32/reflex.cpp

@@ -1,7 +1,7 @@
 #include "reflex/reflex.h"
 
 
-#include <windows.h>
+#include "reflex/exception.h"
 
 
 namespace Reflex
@@ -11,33 +11,27 @@ namespace Reflex
 	namespace global
 	{
 
-		static bool init = false;
+		static bool initialized = false;
 
 	}// global
 
 
-	bool
-	initialized ()
-	{
-		return global::init;
-	}
-
-	bool
+	void
 	init ()
 	{
-		if (global::init) return false;
+		if (global::initialized)
+			reflex_error(__FILE__, __LINE__, "already initialized.");
 
-		global::init = true;
-		return true;
+		global::initialized = true;
 	}
 
-	bool
+	void
 	fin ()
 	{
-		if (!global::init) return false;
+		if (!global::initialized)
+			reflex_error(__FILE__, __LINE__, "not initialized.");
 
-		global::init = false;
-		return true;
+		global::initialized = false;
 	}
 
 

data/src/win32/screen.cpp

@@ -0,0 +1,61 @@
+#include "screen.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	struct Screen::Data
+	{
+
+		HMONITOR handle = NULL;
+
+	};// Screen::Data
+
+
+	void
+	Screen_initialize (Screen* pthis, HMONITOR hmonitor)
+	{
+		pthis->self->handle = hmonitor;
+	}
+
+
+	Screen::Screen ()
+	{
+	}
+
+	Screen::~Screen ()
+	{
+	}
+
+	Bounds
+	Screen::frame () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		MONITORINFO mi = {0};
+		mi.cbSize      = sizeof(mi);
+		if (!GetMonitorInfo(self->handle, &mi))
+			system_error(__FILE__, __LINE__);
+
+		const auto& r = mi.rcMonitor;
+		return Bounds(r.left, r.top, r.right - r.left, r.bottom - r.top);
+	}
+
+	Screen::operator bool () const
+	{
+		return self->handle;
+	}
+
+	bool
+	Screen::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/win32/screen.h

@@ -0,0 +1,21 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_SCREEN_H__
+#define __REFLEX_SRC_WIN32_SCREEN_H__
+
+
+#include <xot/windows.h>
+#include "reflex/screen.h"
+
+
+namespace Reflex
+{
+
+
+	void Screen_initialize (Screen* pthis, HMONITOR hmonitor);
+
+
+}// Reflex
+
+
+#endif//EOH