reflexion 0.1.1

data/src/win32/window.cpp

@@ -0,0 +1,480 @@
+#include "reflex/window.h"
+
+
+#include <windows.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/scoped_array.hpp>
+#include "reflex/reflex.h"
+#include "opengl.h"
+
+
+namespace Reflex
+{
+
+
+	struct Window::Data
+	{
+
+		Window* this_;
+
+		HWND hwnd;
+
+		int hidecount;
+
+		OpenGL opengl;
+
+		Data ()
+		:	this_(NULL), hwnd(NULL), hidecount(1)
+		{
+		}
+
+	};// Window::Data
+
+	typedef boost::shared_ptr<Window::Data> WindowData;
+
+
+	static const char* WINDOWCLASS   = "Reflex:WindowClass";
+
+	static const char* USERDATA_PROP = "Reflex:Window:HWND";
+
+	enum {UPDATE_TIMER_ID = 99999};
+
+
+	static LRESULT CALLBACK wndproc (HWND, UINT, WPARAM, LPARAM);
+
+
+	static bool
+	window_has_wndproc (HWND hwnd)
+	{
+		if (!hwnd) return false;
+
+		WNDPROC proc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC);
+		if (proc == wndproc)
+			return true;
+
+		// OpenGL SetPixelFormat() changes GWLP_WNDPROC, so checking
+		// it can not determine the hwnd is mine or not.
+
+		enum {BUFSIZE = 256};
+		char buf[BUFSIZE + 1];
+		if (
+			GetClassName(hwnd, &buf[0], BUFSIZE) == 0 &&
+			GetLastError() != 0)
+		{
+			return false;
+		}
+
+		return stricmp(buf, WINDOWCLASS) == 0;
+	}
+
+	static Window*
+	get_window_from_hwnd (HWND hwnd)
+	{
+		WindowData* data = NULL;
+		if (window_has_wndproc(hwnd))
+			data = (WindowData*) GetWindowLongPtr(hwnd, GWLP_USERDATA);
+		else
+			data = (WindowData*) GetProp(hwnd, USERDATA_PROP);
+
+		return data ? (*data)->this_ : NULL;
+	}
+
+	static bool
+	setup_window (Window* win, HWND hwnd)
+	{
+		if (!win || *win) return false;
+
+		WindowData* data = new WindowData(win->self);
+
+		bool ret = false;
+		if (window_has_wndproc(hwnd))
+		{
+			SetLastError(0);
+			SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) data);
+			ret = GetLastError() == 0;
+		}
+		else
+			ret = SetProp(hwnd, USERDATA_PROP, (HANDLE) data);
+
+		if (ret)
+		{
+			win->self->hwnd = hwnd;
+			win->self->opengl.init(hwnd);
+		}
+		else
+			delete data;
+
+		return ret;
+	}
+
+	static bool
+	cleanup_window (Window* win)
+	{
+		if (!win || !*win) return false;
+
+		HWND hwnd = win->self->hwnd;
+		WindowData* data = NULL;
+
+		bool has_wndproc = window_has_wndproc(hwnd);
+		if (has_wndproc)
+			data = (WindowData*) GetWindowLongPtr(hwnd, GWLP_USERDATA);
+		else
+			data = (WindowData*) GetProp(hwnd, USERDATA_PROP);
+
+		if (!data || data->get() != win->self.get())
+			return false;
+
+		bool ret = false;
+		if (has_wndproc)
+		{
+			SetLastError(0);
+			SetWindowLongPtr(hwnd, GWLP_USERDATA, 0);
+			ret = GetLastError() == 0;
+		}
+		else
+			ret = RemoveProp(hwnd, USERDATA_PROP) != NULL;
+
+		if (ret)
+		{
+			win->self->opengl.fin();
+			win->self->hwnd = NULL;
+			delete data;
+		}
+
+		return ret;
+	}
+
+	static LRESULT CALLBACK
+	window_proc (Window* win, HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		if (!win || !*win || win->self->hwnd != hwnd)
+			return DefWindowProc(hwnd, msg, wp, lp);
+
+		switch (msg)
+		{
+			case WM_CLOSE:
+			{
+				win->close();
+				return 0;
+			}
+
+			case WM_PAINT:
+			{
+				PAINTSTRUCT ps;
+				BeginPaint(hwnd, &ps);
+
+				if (win->self->opengl.make_current())
+				{
+					win->draw();
+					win->self->opengl.swap_buffers();
+				}
+
+				EndPaint(hwnd, &ps);
+				return 0;
+			}
+
+			case WM_MOVE:
+			{
+				coord l = 0, t = 0;
+				win->get_bounds(&l, &t);
+				win->moved(l, t);
+				break;
+			}
+
+			case WM_SIZE:
+			{
+				coord l = 0, t = 0, r = 0, b = 0;
+				win->get_bounds(&l, &t, &r, &b);
+				win->resized(r - l, b - t);
+				break;
+			}
+
+			case WM_ERASEBKGND:
+			{
+				// do nothing.
+				return 0;
+			}
+
+			case WM_TIMER:
+			{
+				if (wp == UPDATE_TIMER_ID)
+					win->update();
+				return 0;
+			}
+
+			case WM_SYSCOMMAND:
+			{
+#if 0
+				if (wp == SC_SCREENSAVE || wp == SC_MONITORPOWER)
+					return 0;
+#endif
+				break;
+			}
+		}
+
+		return DefWindowProc(hwnd, msg, wp, lp);
+	}
+
+	static LRESULT CALLBACK
+	wndproc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		static int window_total = 0;
+
+		Window* win = NULL;
+		if (msg == WM_NCCREATE)
+		{
+			CREATESTRUCT* cs = (CREATESTRUCT*) lp;
+			win = (Window*) cs->lpCreateParams;
+			setup_window(win, hwnd);
+
+			++window_total;
+		}
+
+		if (!win)
+			win = get_window_from_hwnd(hwnd);
+
+		LRESULT ret = window_proc(win, hwnd, msg, wp, lp);
+
+		if (msg == WM_NCDESTROY)
+		{
+			cleanup_window(win);
+
+			if (--window_total == 0)
+				Reflex::quit();
+		}
+
+		return ret;
+	}
+
+	static bool
+	register_windowclass ()
+	{
+		static bool registered = false;
+		if (registered) return true;
+
+		WNDCLASSEX wc;
+		memset(&wc, 0, sizeof(wc));
+
+		wc.cbSize        = sizeof(wc);
+		wc.lpszClassName = WINDOWCLASS;
+		wc.lpfnWndProc   = (WNDPROC) wndproc;
+		wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+		wc.hInstance     = GetModuleHandle(NULL);
+		//wc.hIcon         = LoadIcon(wc.hInstance, IDI_APP_LARGE);
+		//wc.hIconSm       = LoadIcon(wc.hInstance, IDI_APP_SMALL);
+		wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+		wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
+		wc.lpszMenuName  = NULL;
+		wc.cbWndExtra    = sizeof(Window*);
+
+		if (!RegisterClassEx(&wc))
+			return false;
+
+		return registered = true;
+	}
+
+	static bool
+	create_window (Window* win)
+	{
+		if (!win) return false;
+
+		if (!register_windowclass())
+			return false;
+
+		CreateWindowEx(
+			0, WINDOWCLASS, "",
+			WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+			0, 0, 0, 0, NULL, NULL, GetModuleHandle(NULL), win);
+		return *win;
+	}
+
+
+	Window::Window ()
+	{
+		self->this_ = this;
+
+		create_window(this);
+	}
+
+	Window::~Window ()
+	{
+		close();
+		self->this_ = NULL;
+	}
+
+	bool
+	Window::close ()
+	{
+		if (!self->hwnd || !IsWindow(self->hwnd))
+			return false;
+
+		return DestroyWindow(self->hwnd) != FALSE;
+	}
+
+	static bool
+	start_timer (HWND hwnd, UINT id, UINT interval)
+	{
+		if (!hwnd) return false;
+
+		return SetTimer(hwnd, id, interval, NULL) != 0;
+	}
+
+	static bool
+	stop_timer (HWND hwnd, UINT id)
+	{
+		if (!hwnd || id == 0) return false;
+
+		return KillTimer(hwnd, id) != FALSE;
+	}
+
+	bool
+	Window::show ()
+	{
+		if (!*this) return false;
+
+		if (--self->hidecount != 0) return true;
+
+		SetLastError(0);
+		ShowWindow(self->hwnd, SW_SHOW);
+		if (GetLastError() != 0) return false;
+
+		if (!UpdateWindow(self->hwnd))
+			return false;
+
+		start_timer(self->hwnd, UPDATE_TIMER_ID, 1000 / 60);
+		return true;
+	}
+
+	bool
+	Window::hide ()
+	{
+		if (!*this) return false;
+
+		if (++self->hidecount != 1) return true;
+
+		SetLastError(0);
+		ShowWindow(self->hwnd, SW_HIDE);
+		if (GetLastError() != 0) return false;
+
+		stop_timer(self->hwnd, UPDATE_TIMER_ID);
+		return true;
+	}
+
+	bool
+	Window::hidden () const
+	{
+		if (!*this) return true;
+
+		return self->hidecount > 0;
+	}
+
+	void
+	Window::update ()
+	{
+	}
+
+	void
+	Window::draw ()
+	{
+	}
+
+	bool
+	Window::redraw ()
+	{
+		if (!*this) return false;
+
+		#if 1
+			InvalidateRect(self->hwnd, NULL, FALSE);
+			return true;
+		#else
+			return FALSE != RedrawWindow(
+				self->hwnd, NULL, NULL, RDW_ERASE |  RDW_INVALIDATE | EDW_ALLCHILDREN);
+		#endif
+	}
+
+	bool
+	Window::get_title (String* title) const
+	{
+		if (!*this || !title) return false;
+
+		*title = "";
+
+		int size = GetWindowTextLength(self->hwnd);
+		if (size <= 0) return true;
+
+		boost::scoped_array<char> buf(new char[size + 1]);
+		if (GetWindowText(self->hwnd, &buf[0], size + 1) != size)
+			return false;
+
+		*title = &buf[0];
+		return true;
+	}
+
+	bool
+	Window::set_title (const char* title)
+	{
+		if (!*this || !title) return false;
+
+		return SetWindowText(self->hwnd, title) != FALSE;
+	}
+
+	bool
+	Window::get_bounds (coord* x, coord* y, coord* width, coord* height)
+	{
+		if (!*this || (!x && !y && !width && !height))
+			return false;
+
+		RECT rect;
+		if (!GetWindowRect(self->hwnd, &rect))
+			return false;
+
+		if (x)      *x      = rect.left;
+		if (y)      *y      = rect.top;
+		if (width)  *width  = rect.right  - rect.left + 1;
+		if (height) *height = rect.bottom - rect.top  + 1;
+		return true;
+	}
+
+	bool
+	Window::set_bounds (coord x, coord y, coord width, coord height)
+	{
+		if (!*this) return false;
+
+		coord xx, yy, ww, hh;
+		if (!get_bounds(&xx, &yy, &ww, &hh))
+			return false;
+
+		UINT flags = 0;
+		if (x     == xx && y      == yy) flags |= SWP_NOMOVE;
+		if (width == ww && height == hh) flags |= SWP_NOSIZE;
+
+		if (flags == (SWP_NOMOVE | SWP_NOSIZE)) return true;
+
+		return FALSE != SetWindowPos(
+			self->hwnd, NULL, (int) x, (int) y, (int) width, (int) height,
+			flags | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER);
+	}
+
+	void
+	Window::moved (coord x, coord y)
+	{
+	}
+
+	void
+	Window::resized (coord width, coord height)
+	{
+	}
+
+	Window::operator bool () const
+	{
+		return self && self->this_ && self->hwnd && IsWindow(self->hwnd);
+	}
+
+	bool
+	Window::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/window.cpp

@@ -0,0 +1,60 @@
+#include "reflex/window.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	Window::update ()
+	{
+	}
+
+	void
+	Window::draw ()
+	{
+	}
+
+	void
+	Window::moved (coord x, coord y)
+	{
+	}
+
+	void
+	Window::resized (coord width, coord height)
+	{
+	}
+
+	void
+	Window::key_down (const Key& key)
+	{
+	}
+
+	void
+	Window::key_up (const Key& key)
+	{
+	}
+
+	void
+	Window::points_down (const Points& points)
+	{
+	}
+
+	void
+	Window::points_up (const Points& points)
+	{
+	}
+
+	void
+	Window::points_moved (const Points& points)
+	{
+	}
+
+	bool
+	Window::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/support.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+require 'erb'
+require 'pp'
+
+
+def version ()
+  open("VERSION") {|f| f.readline.chomp}
+end
+
+def glob (*patterns)
+  paths = []
+  patterns.each do |pattern|
+    paths.concat Dir.glob(pattern)
+  end
+  paths
+end
+
+def erb (str)
+  ERB.new(str, nil, "%").result binding
+end
+
+def compile (path, out)
+  open(path) do |input|
+    open(out, "w") do |output|
+      output.write erb(input.read)
+    end
+  end
+#rescue
+end
+
+def convertions (paths, convs)
+  raise "empty conversion." if convs.empty?
+  paths = paths.map do |path|
+    convpath = path
+    convs.each do |from, to|
+      convpath = convpath.sub(/#{from.gsub('.', '\.')}$/, to)
+    end
+    [path, convpath]
+  end
+  Hash[*paths.flatten]
+end
+
+alias sh_original sh
+
+def sh (*args)
+  sh_original *args
+#rescue
+end
+
+def win32? ()
+  RUBY_PLATFORM =~ /mswin|ming|cygwin/
+end
+
+def cocoa? ()
+  RUBY_PLATFORM =~ /darwin/
+end

data/task/ext.rake

@@ -0,0 +1,42 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+require 'rucy/module'
+require 'rays/module'
+
+
+namespace :ext do
+
+  dir     = "#{EXTDIR}/#{NAME}"
+  name    = "#{NAME}/native"
+  outname = "#{name}.#{EXTEXT}"
+  out     = File.join EXTDIR, outname
+
+  extconf  = File.join dir, "extconf.rb"
+  makefile = File.join dir, "Makefile"
+  depend   = File.join dir, "depend"
+
+  cpps = Dir.glob("#{dir}/**/*.cpp")
+
+  task :build => makefile do
+    sh %( cd #{dir} && #{MAKE} )
+  end
+
+  task :clean do
+    sh %( cd #{dir} && #{MAKE} clean ) if File.exist? makefile
+    sh %( rm -f #{makefile} #{depend} )
+  end
+
+  file makefile => [extconf, depend] do
+    sh %( cd #{dir} && #{RUBY} #{File.basename extconf} )
+  end
+
+  file depend => ["lib:build"] + cpps do
+    incdirs = INCDIRS + Rucy.include_dirs + Rays.include_dirs;
+    incdirs = incdirs.map{|s| " -I#{s}"}.join
+    srcs = cpps.map{|cpp| File.basename cpp}.join ' '
+    dep = File.basename depend
+    sh %( cd #{dir} && #{CC} -M #{CFLAGS} #{incdirs} #{srcs} > #{dep} )
+  end
+
+end# :ext

data/task/gem.rake

@@ -0,0 +1,33 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+namespace :gem do
+
+  name = "#{NAME}ion"
+
+  gemspec = "#{NAME}.gemspec"
+  gem     = "#{name}-#{version}.gem"
+
+  task :build => gem
+
+  task :install => gem do
+    sh %( #{GEM} install #{gem} )
+  end
+
+  task :uninstall do
+    sh %( #{GEM} uninstall #{name} )
+  end
+
+  task :clean do
+    sh %( rm -f #{gem} )
+  end
+
+  task :upload => gem do
+    sh %( #{GEM} push #{gem} )
+  end
+
+  file gem => "lib:build" do
+    sh %( #{GEM} build #{gemspec} )
+  end
+
+end# :gem

data/task/git.rake

@@ -0,0 +1,22 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+namespace :git do
+
+  task :status do
+    sh %( #{GIT} status )
+  end
+
+  task :diff do
+    sh %( #{GIT} diff | cat )
+  end
+
+  task :push do
+    sh %( #{GIT} push )
+  end
+
+  task :pull do
+    sh %( #{GIT} pull )
+  end
+
+end# :git