reflexion 0.1.3 → 0.1.4

data/src/cocoa/window.mm

@@ -3,6 +3,7 @@
 
 
 #import <Cocoa/Cocoa.h>
+#include <rays/bounds.h>
 #include "windowdata.h"
 #import "cocoawindow.h"
 
@@ -11,38 +12,32 @@ namespace Reflex
 {
 
 
+	void set_owner_window (View* view, Window* owner);
+
+
 	Window::Window ()
 	{
-		self->this_ = this;
-		self->self_ = [[CocoaWindow alloc] initWithWindowData: self];
+		[[[[CocoaWindow alloc] init] autorelease] bind: this];
+
+		set_owner_window(self->root.get(), this);
+
+		self->painter.canvas(0, 0, 1, 1);
 	}
 
 	Window::~Window ()
 	{
-		if (self->self_)
-		{
-			[self->self_ release];
-			self->self_ = nil;
-		}
-		self->this_ = NULL;
-	}
+		//close();
 
-	bool
-	Window::close ()
-	{
-		if (!*this) return false;
-		[self->self_ close];
-		return true;
+		set_owner_window(self->root.get(), NULL);
 	}
 
 	bool
 	Window::show ()
 	{
 		if (!*this) return false;
+
 		if (--self->hidecount == 0)
-		{
-			[self->self_ makeKeyAndOrderFront: nil];
-		}
+			[self->cocoa makeKeyAndOrderFront: nil];
 		return true;
 	}
 
@@ -50,63 +45,98 @@ namespace Reflex
 	Window::hide ()
 	{
 		if (!*this) return false;
+
 		if (++self->hidecount == 1)
-			[self->self_ orderOut: self->self_];
+			[self->cocoa orderOut: self->cocoa];
 		return true;
 	}
 
 	bool
-	Window::hidden () const
+	Window::close ()
 	{
 		if (!*this) return false;
-		return self->hidecount > 0;
+
+		[self->cocoa close];
+		return true;
 	}
 
 	bool
 	Window::redraw ()
 	{
 		if (!*this) return false;
-		[self->self_ redraw];
+
+		self->redraw = true;
 		return true;
 	}
 
 	bool
-	Window::get_title (String* title) const
+	Window::set_title (const char* title)
 	{
 		if (!*this || !title) return false;
-		NSString* s = [self->self_ title];
-		*title = s ? [s UTF8String] : "";
+
+		[self->cocoa setTitle: [NSString stringWithUTF8String: title]];
 		return true;
 	}
 
+	const char*
+	Window::title () const
+	{
+		if (!*this) return "";
+
+		NSString* s = [self->cocoa title];
+		self->title_tmp = s ? [s UTF8String] : "";
+		return self->title_tmp.c_str();
+	}
+
 	bool
-	Window::set_title (const char* title)
+	Window::set_bounds (coord x, coord y, coord width, coord height)
 	{
-		if (!*this || !title) return false;
-		[self->self_ setTitle: [NSString stringWithUTF8String: title]];
+		if (!*this) return false;
+
+		NSRect frame =
+			[CocoaWindow frameRectForContentRect: NSMakeRect(x, y, width, height)];
+		[self->cocoa setFrame: frame display: NO animate: NO];
 		return true;
 	}
 
 	bool
-	Window::get_bounds (coord* x, coord* y, coord* width, coord* height)
+	Window::set_bounds (const Bounds& bounds)
 	{
-		if (!*this || (!x && !y && !width && !height))
-			return false;
-		NSRect frame = [self->self_ frame];
-		if (x)      *x      = frame.origin.x;
-		if (y)      *y      = frame.origin.y;
-		if (width)  *width  = frame.size.width;
-		if (height) *height = frame.size.height;
-		return true;
+		return set_bounds(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
+	Bounds
+	Window::bounds () const
+	{
+		Bounds b;
+		if (!*this) return b;
+
+		NSRect frame = [self->cocoa contentRectForFrameRect: [self->cocoa frame]];
+		b.x      = frame.origin.x;
+		b.y      = frame.origin.y;
+		b.width  = frame.size.width;
+		b.height = frame.size.height;
+		return b;
 	}
 
 	bool
-	Window::set_bounds (coord x, coord y, coord width, coord height)
+	Window::hidden () const
 	{
 		if (!*this) return false;
-		NSRect frame = NSMakeRect(x, y, width, height);
-		[self->self_ setFrame: frame display: NO animate: NO];
-		return true;
+
+		return self->hidecount > 0;
+	}
+
+	View*
+	Window::root ()
+	{
+		return self->root.get();
+	}
+
+	Painter*
+	Window::painter ()
+	{
+		return &self->painter;
 	}
 
 	Window::operator bool () const

data/src/cocoa/windowdata.h

@@ -4,8 +4,9 @@
 #define __REFLEX_COCOA_WINDOWDATA_H__
 
 
-#include <boost/shared_ptr.hpp>
+#include <rays/painter.h>
 #include <reflex/window.h>
+#include <reflex/view.h>
 
 
 @class CocoaWindow;
@@ -18,20 +19,27 @@ namespace Reflex
 	struct Window::Data
 	{
 
-		Window* this_;
-
-		CocoaWindow* self_;
+		CocoaWindow* cocoa;
 
 		int hidecount;
 
+		bool redraw;
+
+		Painter painter;
+
+		View::Ref root;
+
+		String title_tmp;
+
 		Data ()
-		:	this_(NULL), self_(nil), hidecount(1)
+		:	cocoa(nil), hidecount(1), redraw(true), root(new View)
 		{
+			root->set_name("root");
 		}
 
 		operator bool () const
 		{
-			return this_ && self_;
+			return cocoa;
 		}
 
 		bool operator ! () const
@@ -42,9 +50,6 @@ namespace Reflex
 	};// Window::Data
 
 
-	typedef boost::shared_ptr<Reflex::Window::Data> WindowData;
-
-
 }// Reflex
 
 

data/src/defs.cpp

@@ -32,7 +32,7 @@ namespace Reflex
 	Points::Points (
 		int type, const Point* points_, size_t size_,
 		uint modifiers, uint count, bool drag)
-	:	type(type), size(size), modifiers(modifiers), count(count), drag(drag)
+	:	type(type), size(size_), modifiers(modifiers), count(count), drag(drag)
 	{
 		if (size > MAX) size = MAX;
 

data/src/exception.cpp

@@ -1,21 +1,6 @@
 #include "reflex/exception.h"
 
 
-#define VA_STRING(format, result) \
-	String result; \
-	do \
-	{ \
-		if (format) \
-		{ \
-			va_list args; \
-			va_start(args, format); \
-			result = Xot::stringf(format, args); \
-			va_end(args); \
-		} \
-	} \
-	while (false)
-
-
 namespace Reflex
 {
 
@@ -23,7 +8,7 @@ namespace Reflex
 	ReflexException::ReflexException (const char* format, ...)
 	:	Super("")
 	{
-		VA_STRING(format, s);
+		XOT_STRINGF(format, s);
 		text = s;
 	}
 
@@ -39,9 +24,9 @@ namespace Reflex
 
 
 	void
-	error (const char* format, ...)
+	reflex_error (const char* format, ...)
 	{
-		VA_STRING(format, s);
+		XOT_STRINGF(format, s);
 		throw ReflexException(s.c_str());
 	}
 

data/src/helpers.h

@@ -0,0 +1,12 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_HELPERS_H__
+#define __REFLEX_HELPERS_H__
+
+
+namespace Reflex
+{
+}// Reflex
+
+
+#endif//EOH

data/src/reflex.cpp

@@ -14,15 +14,21 @@ namespace Reflex
 	bool
 	run (const char* name)
 	{
-		if (!initialized() || app()) return false;
+		if (!initialized()) return false;
 
-		Application a;
-		if (!a) return false;
+		Application::Ref ref;
+		if (!app())
+		{
+			ref = new Application;
+			if (!ref || !*ref) return false;
+		}
 
-		if (name && !a.set_name(name))
+		if (!app()) return false;
+
+		if (name && !app()->set_name(name))
 			return false;
 
-		return a.run();
+		return app()->run();
 	}
 
 	bool

data/src/view.cpp

@@ -0,0 +1,326 @@
+#include "reflex/view.h"
+
+
+#include <string.h>
+#include <rays/bounds.h>
+#include <rays/painter.h>
+#include <reflex/window.h>
+
+
+namespace Reflex
+{
+
+
+	typedef std::vector<View::Ref> ViewList;
+
+	static ViewList empty_list;
+
+
+	struct View::Data
+	{
+
+		typedef ViewList::      iterator       iterator;
+
+		typedef ViewList::const_iterator const_iterator;
+
+		String name;
+
+		Bounds bounds;
+
+		int hidecount;
+
+		View* parent;
+
+		Window* window;
+
+		ViewList* pchildren_;
+
+		Data ()
+		:	hidecount(0), parent(NULL), pchildren_(NULL)
+		{
+		}
+
+		~Data ()
+		{
+			delete pchildren_;
+		}
+
+		bool set_parent (View* parent_)
+		{
+			if (parent_ && parent) return false;
+
+			parent = parent_;
+			window = parent_ ? parent_->window() : NULL;
+			return true;
+		}
+
+		ViewList* children ()
+		{
+			if (pchildren_ == NULL) pchildren_ = new ViewList();
+			return pchildren_;
+		}
+
+		iterator begin ()
+		{
+			if (!pchildren_) return empty_list.begin();
+			return pchildren_->begin();
+		}
+
+		const_iterator begin () const
+		{
+			if (!pchildren_) return empty_list.begin();
+			return pchildren_->begin();
+		}
+
+		iterator end ()
+		{
+			if (!pchildren_) return empty_list.end();
+			return pchildren_->end();
+		}
+
+		const_iterator end () const
+		{
+			if (!pchildren_) return empty_list.end();
+			return pchildren_->end();
+
+		}
+
+	};// View::Data
+
+
+	void
+	set_owner_window (View* view, Window* owner)
+	{
+		if (!view) return;
+		view->self->window = owner;
+	}
+
+	void
+	update_view_tree (View* view, float dt)
+	{
+		if (!view) return;
+
+		view->update(dt);
+
+		View::Data::iterator end = view->self->end();
+		for (View::Data::iterator it = view->self->begin(); it != end; ++it)
+			update_view_tree(it->get(), dt);
+	}
+
+	void
+	draw_view_tree (View* view, Painter* p, coord left, coord top)
+	{
+		if (!view || !p) return;
+
+		const Bounds& b = view->bounds();
+		left += b.x;
+		top  += b.y;
+
+		p->push_matrix();
+		p->translate(b.x, b.y);
+		p->set_clip(left, top, b.width, b.height);
+
+		view->draw(p, Bounds(0, 0, b.width, b.height));
+
+		View::Data::iterator end = view->self->end();
+		for (View::Data::iterator it = view->self->begin(); it != end; ++it)
+			draw_view_tree(it->get(), p, left, top);
+
+		p->pop_matrix();
+	}
+
+
+	View::View ()
+	{
+	}
+
+	View::~View ()
+	{
+	}
+
+	bool
+	View::show ()
+	{
+		--self->hidecount;
+		return true;
+	}
+
+	bool
+	View::hide ()
+	{
+		++self->hidecount;
+		return true;
+	}
+
+	bool
+	View::redraw ()
+	{
+		Window* w = window();
+		return w && w->redraw();
+	}
+
+	bool
+	View::add_child (View* child)
+	{
+		if (!child) return false;
+
+		View* parent = child->parent();
+		if (parent) return parent == this;
+
+		Data::iterator it = std::find(self->begin(), self->end(), child);
+		if (it != self->end()) return false;
+
+		if (!child->self->set_parent(this))
+			return false;
+
+		self->children()->push_back(child);
+		return true;
+	}
+
+	bool
+	View::remove_child (View* child)
+	{
+		if (!self->pchildren_ || !child || child->parent() != this)
+			return false;
+
+		Data::iterator it = std::find(self->begin(), self->end(), child);
+		if (it == self->end()) return false;
+
+		if (!child->self->set_parent(NULL))
+			return false;
+
+		self->pchildren_->erase(it);
+		return true;
+	}
+
+	View*
+	View::find_child (const char* name, size_t index, bool recursive)
+	{
+		if (recursive && index > 0) return NULL;
+
+		for (Data::iterator it = self->begin(); it != self->end(); ++it)
+		{
+			if (
+				strcmp((*it)->name(), name) == 0 &&
+				index-- == 0)
+			{
+				return (View*) it->get();
+			}
+
+			This* p = NULL;
+			if (recursive && (p = dynamic_cast<This*>(it->get())))
+			{
+				View* child = p->find_child(name, 0, true);
+				if (child) return child;
+			}
+		}
+
+		return NULL;
+	}
+
+	const View*
+	View::find_child (const char* name, size_t index, bool recursive) const
+	{
+		return const_cast<This*>(this)->find_child(name, index, recursive);
+	}
+
+	bool
+	View::set_name (const char* name)
+	{
+		self->name = name ? name : "";
+		return true;
+	}
+
+	const char*
+	View::name () const
+	{
+		return self->name.c_str();
+	}
+
+	bool
+	View::set_bounds (coord x, coord y, coord width, coord height)
+	{
+		Bounds& b = self->bounds;
+		b.x      = x;
+		b.y      = y;
+		b.width  = width;
+		b.height = height;
+		return true;
+	}
+
+	bool
+	View::set_bounds (const Bounds& bounds)
+	{
+		self->bounds = bounds;
+		return true;
+	}
+
+	const Bounds&
+	View::bounds () const
+	{
+		return self->bounds;
+	}
+
+	bool
+	View::hidden () const
+	{
+		return self->hidecount > 0;
+	}
+
+	View*
+	View::parent ()
+	{
+		return self->parent;
+	}
+
+	const View*
+	View::parent () const
+	{
+		return const_cast<This*>(this)->parent();
+	}
+
+	Window*
+	View::window ()
+	{
+		return self->window;
+	}
+
+	const Window*
+	View::window () const
+	{
+		return const_cast<View*>(this)->window();
+	}
+
+	void
+	View::update (float dt)
+	{
+	}
+
+	void
+	View::draw (Painter* p, const Bounds& b)
+	{
+	}
+
+	void
+	View::moved (coord dx, coord dy)
+	{
+	}
+
+	void
+	View::resized (coord dwidth, coord dheight)
+	{
+	}
+
+	View::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	View::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/win32/application.cpp

@@ -34,7 +34,7 @@ namespace Reflex
 
 	Application::Application ()
 	{
-		if (instance) error("multiple application instance.");
+		if (instance) reflex_error("multiple application instance.");
 
 		instance = this;
 	}
@@ -81,19 +81,18 @@ namespace Reflex
 	}
 
 	bool
-	Application::get_name (String* name) const
+	Application::set_name (const char* name)
 	{
 		if (!*this || !name) return false;
-		*name = self->name;
+		self->name = name;
 		return true;
 	}
 
-	bool
-	Application::set_name (const char* name)
+	const char*
+	Application::name () const
 	{
-		if (!*this || !name) return false;
-		self->name = name;
-		return true;
+		if (!*this) return "";
+		return self->name.c_str();
 	}
 
 	Application::operator bool () const

data/src/win32/defs.h

@@ -4,7 +4,7 @@
 #define __REFLEX_WIN32_DEFS_H__
 
 
-#import <windows.h>
+#include <windows.h>
 #include <reflex/defs.h>