reflexion 0.1.6 → 0.1.7

data/src/osx/window.mm

@@ -0,0 +1,308 @@
+// -*- objc -*-
+#include "reflex/window.h"
+
+
+#import <Cocoa/Cocoa.h>
+#include <rays/bounds.h>
+#include "reflex/event.h"
+#include "reflex/exception.h"
+#include "window_data.h"
+#import "native_window.h"
+
+
+namespace Reflex
+{
+
+
+	void set_window (View* view, Window* window);
+
+	void call_key_event (View* v, const KeyEvent& e);
+
+	void call_pointer_event (View* v, const PointerEvent& e);
+
+	void call_wheel_event (View* v, const WheelEvent& e);
+
+
+	void
+	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_blur(&e);
+			current->redraw();
+		}
+
+		if (view)
+		{
+			e.type = FocusEvent::FOCUS;
+			view->on_focus(&e);
+			view->redraw();
+		}
+	}
+
+	void
+	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
+	unregister_capture (View* view)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		const Window* window = view->window();
+		if (!window) return;
+
+		CapturingViews::iterator it = window->self->capturing_views.find(view);
+		if (it == window->self->capturing_views.end()) return;
+
+		it->second = false;
+	}
+
+	void
+	cleanup_capturing_views (Window* window)
+	{
+		CapturingViews::iterator end = window->self->capturing_views.end();
+		for (CapturingViews::iterator it = window->self->capturing_views.begin(); it != end;)
+		{
+			CapturingViews::iterator t = it++;
+			if (!t->second) window->self->capturing_views.erase(t);
+		}
+	}
+
+
+	Window::Window ()
+	{
+		[[[NativeWindow alloc] init] bind: this];
+
+		set_window(self->root.get(), this);
+
+		self->painter.canvas(0, 0, 1, 1);
+	}
+
+	Window::~Window ()
+	{
+		//close();
+
+		set_window(self->root.get(), NULL);
+	}
+
+	void
+	Window::show ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (--self->hide_count == 0)
+			[self->native makeKeyAndOrderFront: nil];
+	}
+
+	void
+	Window::hide ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (++self->hide_count == 1)
+			[self->native orderOut: self->native];
+	}
+
+	void
+	Window::close ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		[self->native close];
+	}
+
+	void
+	Window::redraw ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->redraw = true;
+	}
+
+	void
+	Window::set_title (const char* title)
+	{
+		if (!title)
+			argument_error(__FILE__, __LINE__);
+
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		[self->native setTitle: [NSString stringWithUTF8String: title]];
+	}
+
+	const char*
+	Window::title () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		NSString* s = [self->native title];
+		self->title_tmp = s ? [s UTF8String] : "";
+		return self->title_tmp.c_str();
+	}
+
+	void
+	Window::set_frame (coord x, coord y, coord width, coord height)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		NSRect frame =
+			[NativeWindow frameRectForContentRect: NSMakeRect(x, y, width, height)];
+		[self->native setFrame: frame display: NO animate: NO];
+	}
+
+	void
+	Window::set_frame (const Bounds& bounds)
+	{
+		set_frame(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
+	Bounds
+	Window::frame () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		NSRect rect = [self->native contentRectForFrameRect: [self->native frame]];
+		return Bounds(
+			rect.origin.x,
+			rect.origin.y,
+			rect.size.width,
+			rect.size.height);
+	}
+
+	bool
+	Window::hidden () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return self->hide_count > 0;
+	}
+
+	View*
+	Window::root ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return self->root.get();
+	}
+
+	View*
+	Window::focus ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return self->focus.get();
+	}
+
+	Painter*
+	Window::painter ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return &self->painter;
+	}
+
+	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;
+		}
+
+		CapturingViews::iterator end = self->capturing_views.end();
+		for (CapturingViews::iterator it = self->capturing_views.begin(); it != end; ++it)
+		{
+			KeyEvent event = *e;
+			event.capture = true;
+			call_key_event(const_cast<View*>(it->first.get()), event);
+		}
+
+		if (self->focus)
+			call_key_event(self->focus.get(), *e);
+
+		cleanup_capturing_views(this);
+	}
+
+	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;
+		}
+
+		CapturingViews::iterator end = self->capturing_views.end();
+		for (CapturingViews::iterator 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]);
+			call_pointer_event(const_cast<View*>(it->first.get()), event);
+		}
+
+		call_pointer_event(root(), *e);
+
+		cleanup_capturing_views(this);
+	}
+
+	void
+	Window::on_wheel (WheelEvent* e)
+	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
+
+		call_wheel_event(root(), *e);
+	}
+
+	Window::operator bool () const
+	{
+		return self && *self;
+	}
+
+
+}// Reflex

data/src/osx/window_data.h

@@ -0,0 +1,75 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_OSX_WINDOW_DATA_H__
+#define __REFLEX_OSX_WINDOW_DATA_H__
+
+
+#include <map>
+#include <xot/time.h>
+#include <rays/point.h>
+#include <rays/painter.h>
+#include <reflex/window.h>
+#include <reflex/view.h>
+
+
+@class NativeWindow;
+
+
+namespace Reflex
+{
+
+
+	typedef std::map<View::Ref, bool> CapturingViews;
+
+
+	struct Window::Data
+	{
+
+		NativeWindow* native;
+
+		int hide_count;
+
+		bool redraw;
+
+		Painter painter;
+
+		View::Ref root, focus;
+
+		Rays::Point prev_position, prev_size;
+
+		double prev_time_update, prev_time_draw, prev_fps;
+
+		String title_tmp;
+
+		CapturingViews capturing_views;
+
+		Data ()
+		:	native(nil), hide_count(1), redraw(true), root(create_root_view()), prev_fps(0)
+		{
+			prev_time_update = prev_time_draw = Xot::time();
+		}
+
+		operator bool () const
+		{
+			return native;
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+		static View* create_root_view ()
+		{
+			View* v = new View;
+			v->set_name("ROOT");
+			return v;
+		}
+
+	};// Window::Data
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/selector.cpp

@@ -0,0 +1,121 @@
+#include "reflex/selector.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	struct Selector::Data
+	{
+
+		String name;
+
+		TagSet tags;
+
+		bool operator == (const Data& rhs)
+		{
+			return name == rhs.name && tags == rhs.tags;
+		}
+
+	};// Selector::Data
+
+
+	Selector::Selector (const char* name)
+	{
+		if (name) set_name(name);
+	}
+
+	void
+	Selector::set_name (const char* name)
+	{
+		self->name = name ? name : "";
+	}
+
+	const char*
+	Selector::name () const
+	{
+		return self->name.empty() ? NULL : self->name.c_str();
+	}
+
+	void
+	Selector::add_tag (const char* tag)
+	{
+		if (!tag || *tag == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		iterator it = self->tags.find(tag);
+		if (it != self->tags.end()) return;
+
+		self->tags.insert(tag);
+	}
+
+	void
+	Selector::remove_tag (const char* tag)
+	{
+		if (!tag || *tag == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		iterator it = self->tags.find(tag);
+		if (it == self->tags.end()) return;
+
+		self->tags.erase(it);
+	}
+
+	Selector::iterator
+	Selector::begin ()
+	{
+		return self->tags.begin();
+	}
+
+	Selector::const_iterator
+	Selector::begin () const
+	{
+		return self->tags.begin();
+	}
+
+	Selector::iterator
+	Selector::end ()
+	{
+		return self->tags.end();
+	}
+
+	Selector::const_iterator
+	Selector::end () const
+	{
+		return self->tags.end();
+	}
+
+	bool
+	Selector::match (const This& obj) const
+	{
+		if (self->name.empty() && self->tags.empty())
+			return false;
+
+		const TagSet& obj_tags = obj.self->tags;
+		const_iterator obj_end = obj_tags.end();
+
+		iterator end = this->end();
+		for (iterator it = begin(); it != end; ++it)
+			if (obj_tags.find(*it) == obj_end)
+				return false;
+
+		return self->name.empty() || self->name == obj.self->name;
+	}
+
+	bool
+	operator == (const Selector& lhs, const Selector& rhs)
+	{
+		return *lhs.self == *rhs.self;
+	}
+
+	bool
+	operator != (const Selector& lhs, const Selector& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+
+}// Reflex