reflexion 0.1.12 → 0.1.17

data/src/view.h

@@ -0,0 +1,56 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_VIEW_H__
+#define __REFLEX_SRC_VIEW_H__
+
+
+#include <reflex/view.h>
+
+
+namespace Reflex
+{
+
+
+	constexpr const char* VIEW_TAG_ROOT = "ROOT";
+
+
+	class Body;
+
+
+	void View_set_window (View* view, Window* window);
+
+	void View_set_frame (View* view, const Bounds& frame);
+
+	const Style& View_get_style (const View* view);
+
+	Body* View_get_body (View* view, bool create = true);
+
+	bool View_is_active (const View& view);
+
+	void View_update_tree (View* view, const UpdateEvent& event);
+
+	void View_draw_tree (
+		View* view, const DrawEvent& event,
+		const Point& offset, const Bounds& clip);
+
+	void View_update_styles (View* view, const Selector& selector);
+
+	void View_update_shapes (View* view);
+
+	void View_register_capture   (View* view);
+
+	void View_unregister_capture (View* view);
+
+	void View_call_key_event     (View* view, const KeyEvent& event);
+
+	void View_call_pointer_event (View* view, const PointerEvent& event);
+
+	void View_call_wheel_event   (View* view, const WheelEvent& event);
+
+	void View_call_contact_event (View* view, const ContactEvent& event);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/win32/window.cpp

@@ -1,10 +1,9 @@
 #include "reflex/window.h"
 
 
+#include <memory>
 #define NOMINMAX
 #include <windows.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_array.hpp>
 #include <rays/painter.h>
 #include "reflex/reflex.h"
 #include "reflex/view.h"
@@ -74,7 +73,7 @@ namespace Reflex
 
 	};// Window::Data
 
-	typedef boost::shared_ptr<Window::Data> WindowData;
+	typedef std::shared_ptr<Window::Data> WindowData;
 
 
 	static const char* WINDOWCLASS   = "Reflex:WindowClass";
@@ -440,7 +439,7 @@ namespace Reflex
 		int size = GetWindowTextLength(self->hwnd);
 		if (size <= 0) return "";
 
-		boost::scoped_array<char> buf(new char[size + 1]);
+		std::unique_ptr<char[]> buf(new char[size + 1]);
 		if (GetWindowText(self->hwnd, &buf[0], size + 1) != size)
 			return "";
 

data/src/window.cpp

@@ -1,26 +1,262 @@
-#include "reflex/window.h"
+#include "window.h"
 
 
-#include "reflex/view.h"
 #include "reflex/exception.h"
+#include "view.h"
 
 
 namespace Reflex
 {
 
 
+	void
+	Window_set_focus (Window* window, View* view)
+	{
+		if (!window || !view)
+			argument_error(__FILE__, __LINE__);
+
+		View* current = window->self->focus.get();
+		if (current == view) return;
+
+		window->self->focus.reset(view);
+
+		FocusEvent e(FocusEvent::BLUR, view, current);
+
+		if (current)
+		{
+			current->on_focus(&e);
+			current->redraw();
+		}
+
+		if (view)
+		{
+			e.type = FocusEvent::FOCUS;
+			view->on_focus(&e);
+			view->redraw();
+		}
+	}
+
+	void
+	Window_call_draw_event (Window* window, DrawEvent* event)
+	{
+		if (!window || !event)
+			argument_error(__FILE__, __LINE__);
+
+		Painter* painter = window->painter();
+		if (!painter)
+			Xot::invalid_state_error(__FILE__, __LINE__);
+
+		Rays::Bounds frame = window->frame();
+
+		event->painter = painter;
+		event->bounds.reset(0, 0, frame.width, frame.height);
+
+		painter->begin();
+		painter->push_state();
+		painter->clear();
+
+		window->on_draw(event);
+		if (!event->is_blocked())
+			Reflex::View_draw_tree(window->root(), *event, 0, frame.move_to(0));
+
+		painter->pop_state();
+		painter->end();
+	}
+
+	namespace global
+	{
+
+		static Window_CreateRootViewFun create_root_view_fun = NULL;
+
+	}// global
+
+	void
+	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
+	{
+		global::create_root_view_fun = fun;
+	}
+
+	static View*
+	create_root_view ()
+	{
+		return global::create_root_view_fun
+			?	global::create_root_view_fun()
+			:	new View();
+	}
+
+	void
+	View_register_capture (View* view)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		const Window* window = view->window();
+		if (!window)
+			invalid_state_error(__FILE__, __LINE__, "this view does not belong to any Window.");
+
+		window->self->capturing_views[view] = true;
+	}
+
+	void
+	View_unregister_capture (View* view)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		const Window* window = view->window();
+		if (!window) return;
+
+		auto it = window->self->capturing_views.find(view);
+		if (it == window->self->capturing_views.end()) return;
+
+		it->second = false;
+	}
+
+	static void
+	cleanup_capturing_views (Window* window)
+	{
+		auto end = window->self->capturing_views.end();
+		for (auto it = window->self->capturing_views.begin(); it != end;)
+		{
+			auto t = it++;
+			if (!t->second) window->self->capturing_views.erase(t);
+		}
+	}
+
+
+	Window::Window ()
+	:	self(Window_create_data())
+	{
+		Window_initialize(this);
+
+		self->root.reset(create_root_view());
+		self->root->set_name(VIEW_TAG_ROOT);
+		View_set_window(self->root.get(), this);
+
+		self->painter.canvas(0, 0, 1, 1);
+	}
+
+	Window::~Window ()
+	{
+		//close();
+
+		View_set_window(self->root.get(), NULL);
+	}
+
+	void
+	Window::show ()
+	{
+		int new_count = self->hide_count - 1;
+		if (new_count == 0)
+		{
+			Event e;
+			on_show(&e);
+			if (e.is_blocked()) return;
+
+			Window_show(this);
+		}
+
+		self->hide_count = new_count;
+	}
+
+	void
+	Window::hide ()
+	{
+		int new_count = self->hide_count + 1;
+		if (new_count == 1)
+		{
+			Event e;
+			on_hide(&e);
+			if (e.is_blocked()) return;
+
+			Window_hide(this);
+		}
+
+		self->hide_count = new_count;
+	}
+
+	void
+	Window::close ()
+	{
+		Event e;
+		on_close(&e);
+		if (e.is_blocked()) return;
+
+		Window_close(this);
+	}
+
+	void
+	Window::redraw ()
+	{
+		self->redraw = true;
+	}
+
+	void
+	Window::set_title (const char* title)
+	{
+		Window_set_title(this, title);
+	}
+
+	const char*
+	Window::title () const
+	{
+		return Window_get_title(*this);
+	}
+
+	void
+	Window::set_frame (coord x, coord y, coord width, coord height)
+	{
+		Window_set_frame(this, x, y, width, height);
+	}
+
+	void
+	Window::set_frame (const Bounds& bounds)
+	{
+		set_frame(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
+	Bounds
+	Window::frame () const
+	{
+		return Window_get_frame(*this);
+	}
+
+	bool
+	Window::hidden () const
+	{
+		return self->hide_count > 0;
+	}
+
+	View*
+	Window::root ()
+	{
+		return self->root.get();
+	}
+
 	const View*
 	Window::root () const
 	{
 		return const_cast<Window*>(this)->root();
 	}
 
+	View*
+	Window::focus ()
+	{
+		return self->focus.get();
+	}
+
 	const View*
 	Window::focus () const
 	{
 		return const_cast<Window*>(this)->focus();
 	}
 
+	Painter*
+	Window::painter ()
+	{
+		return &self->painter;
+	}
+
 	const Painter*
 	Window::painter () const
 	{
@@ -44,85 +280,131 @@ namespace Reflex
 	void
 	Window::on_show (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_hide (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_close (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_update (UpdateEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_draw (DrawEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_move (FrameEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_resize (FrameEvent* e)
+	{
+	}
+
+	void
+	Window::on_key (KeyEvent* e)
 	{
 		if (!e)
 			argument_error(__FILE__, __LINE__);
+
+		switch (e->type)
+		{
+			case KeyEvent::DOWN: on_key_down(e); break;
+			case KeyEvent::UP:   on_key_up(e);   break;
+			case KeyEvent::NONE:                 break;
+		}
+
+		auto end = self->capturing_views.end();
+		for (auto it = self->capturing_views.begin(); it != end; ++it)
+		{
+			KeyEvent event = *e;
+			event.capture = true;
+			View_call_key_event(const_cast<View*>(it->first.get()), event);
+		}
+
+		if (self->focus)
+			View_call_key_event(self->focus.get(), *e);
+
+		cleanup_capturing_views(this);
 	}
 
 	void
 	Window::on_key_down (KeyEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_key_up (KeyEvent* e)
+	{
+	}
+
+	void
+	Window::on_pointer (PointerEvent* e)
 	{
 		if (!e)
 			argument_error(__FILE__, __LINE__);
+
+		switch (e->type)
+		{
+			case PointerEvent::DOWN: on_pointer_down(e); break;
+			case PointerEvent::UP:   on_pointer_up(e);   break;
+			case PointerEvent::MOVE: on_pointer_move(e); break;
+			case PointerEvent::NONE:                     break;
+		}
+
+		auto end = self->capturing_views.end();
+		for (auto it = self->capturing_views.begin(); it != end; ++it)
+		{
+			PointerEvent event = *e;
+			event.capture = true;
+			for (size_t i = 0; i < event.size; ++i)
+				event[i] = it->first.get()->from_window(event[i]);
+			View_call_pointer_event(const_cast<View*>(it->first.get()), event);
+		}
+
+		View_call_pointer_event(root(), *e);
+
+		cleanup_capturing_views(this);
 	}
 
 	void
 	Window::on_pointer_down (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_pointer_up (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	Window::on_pointer_move (PointerEvent* e)
+	{
+	}
+
+	void
+	Window::on_wheel (WheelEvent* e)
 	{
 		if (!e)
 			argument_error(__FILE__, __LINE__);
+
+		View_call_wheel_event(root(), *e);
+	}
+
+	Window::operator bool () const
+	{
+		return self && *self;
 	}
 
 	bool