reflexion 0.1.12 → 0.1.13

data/src/osx/window.h

@@ -0,0 +1,42 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_OSX_WINDOW_H__
+#define __REFLEX_SRC_OSX_WINDOW_H__
+
+
+#include "../window.h"
+
+
+@class NativeWindow;
+
+
+namespace Reflex
+{
+
+
+	struct WindowData : public Window::Data
+	{
+
+		NativeWindow* native;
+
+		mutable String title_tmp;
+
+		WindowData ();
+
+		bool is_valid () const
+		{
+			return native;
+		}
+
+	};// WindowData
+
+
+	      WindowData& Window_get_data (Window* window);
+
+	const WindowData& Window_get_data (const Window* window);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/osx/window.mm

@@ -1,217 +1,110 @@
 // -*- objc -*-
-#include "reflex/window.h"
+#include "window.h"
 
 
 #import <Cocoa/Cocoa.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;
+@interface NativeWindow (Bind)
+	- (void) bind: (Reflex::Window*) window;
+@end
 
-		window->self->focus.reset(view);
 
-		FocusEvent e(FocusEvent::BLUR, view, current);
-
-		if (current)
-		{
-			current->on_blur(&e);
-			current->redraw();
-		}
+namespace Reflex
+{
 
-		if (view)
-		{
-			e.type = FocusEvent::FOCUS;
-			view->on_focus(&e);
-			view->redraw();
-		}
-	}
 
-	void
-	register_capture (View* view)
+	WindowData&
+	Window_get_data (Window* window)
 	{
-		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;
+		return (WindowData&) *window->self;
 	}
 
-	void
-	cleanup_capturing_views (Window* window)
+	const WindowData&
+	Window_get_data (const 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);
-		}
+		return Window_get_data(const_cast<Window*>(window));
 	}
 
-
-	Window::Window ()
+	static NativeWindow*
+	get_native (const Window* window)
 	{
-		[[[NativeWindow alloc] init] bind: this];
-
-		set_window(self->root.get(), this);
+		NativeWindow* p = Window_get_data(const_cast<Window*>(window)).native;
+		if (!p)
+			invalid_state_error(__FILE__, __LINE__);
 
-		self->painter.canvas(0, 0, 1, 1);
+		return p;
 	}
 
-	Window::~Window ()
-	{
-		//close();
 
-		set_window(self->root.get(), NULL);
+	Window::Data*
+	Window_create_data ()
+	{
+		return new WindowData();
 	}
 
 	void
-	Window::show ()
+	Window_initialize (Window* window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		int new_count = self->hide_count - 1;
-		if (new_count == 0)
-		{
-			Event e;
-			on_show(&e);
-			if (e.is_blocked()) return;
-
-			[self->native makeKeyAndOrderFront: nil];
-		}
-
-		self->hide_count = new_count;
+		[[[NativeWindow alloc] init] bind: window];
 	}
 
 	void
-	Window::hide ()
+	Window_show (Window* window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		int new_count = self->hide_count + 1;
-		if (new_count == 1)
-		{
-			Event e;
-			on_hide(&e);
-			if (e.is_blocked()) return;
-
-			[self->native orderOut: self->native];
-		}
-
-		self->hide_count = new_count;
+		[get_native(window) makeKeyAndOrderFront: nil];
 	}
 
 	void
-	Window::close ()
+	Window_hide (Window* window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		Event e;
-		on_close(&e);
-		if (e.is_blocked()) return;
-
-		[self->native close];
+		NativeWindow* native = get_native(window);
+		[native orderOut: native];
 	}
 
 	void
-	Window::redraw ()
+	Window_close (Window* window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		self->redraw = true;
+		[get_native(window) close];
 	}
 
 	void
-	Window::set_title (const char* title)
+	Window_set_title (Window* window, const char* title)
 	{
 		if (!title)
 			argument_error(__FILE__, __LINE__);
 
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		[self->native setTitle: [NSString stringWithUTF8String: title]];
+		[get_native(window) setTitle: [NSString stringWithUTF8String: title]];
 	}
 
 	const char*
-	Window::title () const
+	Window_get_title (const Window& window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
+		const WindowData& data = Window_get_data(&window);
 
-		NSString* s = [self->native title];
-		self->title_tmp = s ? [s UTF8String] : "";
-		return self->title_tmp.c_str();
+		NSString* s = [get_native(&window) title];
+		data.title_tmp = s ? [s UTF8String] : "";
+		return data.title_tmp.c_str();
 	}
 
 	void
-	Window::set_frame (coord x, coord y, coord width, coord height)
+	Window_set_frame (Window* window, 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);
+		[get_native(window) setFrame: frame display: NO animate: NO];
 	}
 
 	Bounds
-	Window::frame () const
+	Window_get_frame (const Window& window)
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
-		NSRect rect = [self->native contentRectForFrameRect: [self->native frame]];
+		NativeWindow* native = get_native(&window);
+		NSRect rect = [native contentRectForFrameRect: [native frame]];
 		return Bounds(
 			rect.origin.x,
 			rect.origin.y,
@@ -219,110 +112,10 @@ namespace Reflex
 			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
+	WindowData::WindowData ()
 	{
-		return self && *self;
+		native = nil;
 	}
 
 

data/src/selector.cpp

@@ -1,7 +1,9 @@
 #include "reflex/selector.h"
 
 
+#include <assert.h>
 #include "reflex/exception.h"
+#include "selector.h"
 
 
 namespace Reflex
@@ -45,10 +47,12 @@ namespace Reflex
 		const TagSet& tags      = self->tags;
 		const_iterator tags_end = tags.end();
 
-		iterator end = selector.end();
-		for (iterator tag = selector.begin(); tag != end; ++tag)
+		const_iterator end = selector.end();
+		for (const_iterator tag = selector.begin(); tag != end; ++tag)
+		{
 			if (tags.find(*tag) == tags_end)
 				return false;
+		}
 
 		return selector.self->name.empty() || selector.self->name == self->name;
 	}
@@ -56,13 +60,17 @@ namespace Reflex
 	void
 	Selector::set_name (const char* name)
 	{
-		self->name = name ? name : "";
+		if (name && *name != '\0')
+			self->name = name;
+		else
+			self->name.clear();
 	}
 
 	const char*
 	Selector::name () const
 	{
-		return self->name.c_str();
+		const String& s = self->name;
+		return !s.empty() ? s.c_str() : NULL;
 	}
 
 	void
@@ -72,7 +80,8 @@ namespace Reflex
 			argument_error(__FILE__, __LINE__);
 
 		iterator it = self->tags.find(tag);
-		if (it != self->tags.end()) return;
+		if (it != self->tags.end())
+			return;
 
 		self->tags.insert(tag);
 	}
@@ -80,15 +89,31 @@ namespace Reflex
 	void
 	Selector::remove_tag (const char* tag)
 	{
-		if (!tag || *tag == '\0')
+		if (!tag)
 			argument_error(__FILE__, __LINE__);
 
 		iterator it = self->tags.find(tag);
-		if (it == self->tags.end()) return;
+		if (it == self->tags.end())
+			return;
 
 		self->tags.erase(it);
 	}
 
+	void
+	Selector::clear_tags ()
+	{
+		self->tags.clear();
+	}
+
+	bool
+	Selector::has_tag (const char* tag) const
+	{
+		if (!tag || *tag == '\0')
+			return false;
+
+		return self->tags.find(tag) != self->tags.end();
+	}
+
 	Selector::iterator
 	Selector::begin ()
 	{
@@ -140,4 +165,204 @@ namespace Reflex
 	}
 
 
+	static Selector*
+	get_selector (SelectorPtr* this_, bool create = false)
+	{
+		assert(this_);
+
+		SelectorPtr& ptr = *this_;
+
+		if (create && !ptr) ptr.reset(new Selector());
+		return ptr.get();
+	}
+
+	static const Selector*
+	get_selector (const SelectorPtr* this_)
+	{
+		return get_selector(const_cast<SelectorPtr*>(this_));
+	}
+
+	void
+	SelectorPtr::set_name (const char* name)
+	{
+		get_selector(this, true)->set_name(name);
+	}
+
+	const char*
+	SelectorPtr::name () const
+	{
+		const Selector* sel = get_selector(this);
+		return sel ? sel->name() : NULL;
+	}
+
+	void
+	SelectorPtr::add_tag (const char* tag)
+	{
+		get_selector(this, true)->add_tag(tag);
+	}
+
+	void
+	SelectorPtr::remove_tag (const char* tag)
+	{
+		Selector* sel = get_selector(this);
+		if (sel) sel->remove_tag(tag);
+	}
+
+	void
+	SelectorPtr::clear_tags ()
+	{
+		Selector* sel = get_selector(this);
+		if (sel) sel->clear_tags();
+	}
+
+	bool
+	SelectorPtr::has_tag (const char* tag) const
+	{
+		const Selector* sel = get_selector(this);
+		return sel ? sel->has_tag(tag) : false;
+	}
+
+	static Selector::TagSet empty_tags;
+
+	Selector::iterator
+	SelectorPtr::tag_begin ()
+	{
+		assert(empty_tags.empty());
+
+		Selector* sel = get_selector(this);
+		return sel ? sel->begin() : empty_tags.begin();
+	}
+
+	Selector::const_iterator
+	SelectorPtr::tag_begin () const
+	{
+		return selector().begin();
+	}
+
+	Selector::iterator
+	SelectorPtr::tag_end ()
+	{
+		assert(empty_tags.empty());
+
+		Selector* sel = get_selector(this);
+		return sel ? sel->end() : empty_tags.end();
+	}
+
+	Selector::const_iterator
+	SelectorPtr::tag_end () const
+	{
+		return selector().end();
+	}
+
+	void
+	SelectorPtr::set_selector (const Selector& selector)
+	{
+		*get_selector(this, true) = selector;
+	}
+
+	Selector&
+	SelectorPtr::selector ()
+	{
+		return *get_selector(this, true);
+	}
+
+	const Selector&
+	SelectorPtr::selector () const
+	{
+		static const Selector EMPTY;
+
+		const Selector* sel = get_selector(this);
+		return sel ? *sel : EMPTY;
+	}
+
+
+	HasSelector::~HasSelector ()
+	{
+	}
+
+	void
+	HasSelector::set_name (const char* name)
+	{
+		get_selector_ptr()->set_name(name);
+	}
+
+	const char*
+	HasSelector::name () const
+	{
+		return get_selector_ptr()->name();
+	}
+
+	void
+	HasSelector::add_tag (const char* tag)
+	{
+		get_selector_ptr()->add_tag(tag);
+	}
+
+	void
+	HasSelector::remove_tag (const char* tag)
+	{
+		get_selector_ptr()->remove_tag(tag);
+	}
+
+	void
+	HasSelector::clear_tags ()
+	{
+		get_selector_ptr()->clear_tags();
+	}
+
+	bool
+	HasSelector::has_tag (const char* tag) const
+	{
+		return get_selector_ptr()->has_tag(tag);
+	}
+
+	Selector::iterator
+	HasSelector::tag_begin ()
+	{
+		return get_selector_ptr()->tag_begin();
+	}
+
+	Selector::const_iterator
+	HasSelector::tag_begin () const
+	{
+		return get_selector_ptr()->tag_begin();
+	}
+
+	Selector::iterator
+	HasSelector::tag_end ()
+	{
+		return get_selector_ptr()->tag_end();
+	}
+
+	Selector::const_iterator
+	HasSelector::tag_end () const
+	{
+		return get_selector_ptr()->tag_end();
+	}
+
+	void
+	HasSelector::set_selector (const Selector& selector)
+	{
+		get_selector_ptr()->set_selector(selector);
+	}
+
+	Selector&
+	HasSelector::selector ()
+	{
+		return get_selector_ptr()->selector();
+	}
+
+	const Selector&
+	HasSelector::selector () const
+	{
+		return get_selector_ptr()->selector();
+	}
+
+	const SelectorPtr*
+	HasSelector::get_selector_ptr () const
+	{
+		return const_cast<HasSelector*>(this)->get_selector_ptr();
+	}
+
+
 }// Reflex