reflexion 0.1.6 → 0.1.7

data/src/ios/opengl_view.mm

@@ -0,0 +1,131 @@
+// -*- objc -*-
+#import "opengl_view.h"
+
+
+#include <rays/opengl.h>
+#include <rays/exception.h>
+#include "reflex/exception.h"
+#import "native_window.h"
+
+
+//#define TRANSPARENT_BACKGROUND
+
+
+@implementation OpenGLViewController
+
+	- (void) viewDidLoad
+	{
+		[super viewDidLoad];
+
+		context = [[EAGLContext alloc] initWithAPI: kEAGLRenderingAPIOpenGLES1];
+		if (!context)
+			Reflex::reflex_error(__FILE__, __LINE__, "failed to create OpenGL context.");
+
+		GLKView* view = (GLKView*) self.view;
+		view.context             = context;
+		view.drawableDepthFormat = GLKViewDrawableDepthFormat24;
+		view.drawableMultisample = GLKViewDrawableMultisample4X;
+
+		//self.preferredFramesPerSecond = 60;
+
+		[self setupOpenGL];
+	}
+
+	- (void) dealloc
+	{
+		[self teardownOpenGL];
+		[super dealloc];
+	}
+
+	- (void) didReceiveMemoryWarning
+	{
+		[super didReceiveMemoryWarning];
+
+		if ([self isViewLoaded] && self.view.window == nil)
+		{
+			self.view = nil;
+			[self teardownOpenGL];
+		}
+	}
+
+	- (void) activateContext
+	{
+		[EAGLContext setCurrentContext: context];
+	}
+
+	- (void) setupOpenGL
+	{
+		[self activateContext];
+	}
+
+	- (void) teardownOpenGL
+	{
+		[self activateContext];
+
+		if (context && [EAGLContext currentContext] == context)
+		{
+			[EAGLContext setCurrentContext: nil];
+			context = nil;
+		}
+	}
+
+	- (void) glkView: (GLKView*) view drawInRect: (CGRect) rect
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[self activateContext];
+		[win draw];
+	}
+
+	- (void) keyDown: (UIEvent*) event
+	{
+		//[self interpretKeyEvents: [NSArray arrayWithObject: event]];
+
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win keyDown: event];
+	}
+
+	- (void) keyUp: (UIEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win keyUp: event];
+	}
+
+	- (void) touchesBegan: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win touchesBegan: touches withEvent: event];
+	}
+
+	- (void) touchesEnded: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win touchesEnded: touches withEvent: event];
+	}
+
+	- (void) touchesCancelled: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win touchesCancelled: touches withEvent: event];
+	}
+
+	- (void) touchesMoved: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) self.view.window;
+		if (!win) return;
+
+		[win touchesMoved: touches withEvent: event];
+	}
+
+@end// OpenGLViewController

data/src/{cocoa → ios}/reflex.mm

@@ -2,8 +2,8 @@
 #include "reflex/reflex.h"
 
 
-#import <Cocoa/Cocoa.h>
-#import "cocoaapplication.h"
+#include "reflex/exception.h"
+#import "app_delegate.h"
 
 
 namespace Reflex
@@ -24,27 +24,23 @@ namespace Reflex
 		return global::pool;
 	}
 
-	bool
+	void
 	init ()
 	{
-		if (global::pool) return false;
+		if (global::pool)
+			reflex_error(__FILE__, __LINE__, "already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
-
-		[CocoaApplication sharedApplication];
-
-		return true;
 	}
 
-	bool
+	void
 	fin ()
 	{
-		if (!global::pool) return false;
+		if (!global::pool)
+			reflex_error(__FILE__, __LINE__, "not initialized.");
 
 		[global::pool release];
 		global::pool = nil;
-
-		return true;
 	}
 
 

data/src/ios/window.mm

@@ -0,0 +1,303 @@
+// -*- objc -*-
+#include "reflex/window.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 makeKeyAndVisible];
+	}
+
+	void
+	Window::hide ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (++self->hide_count == 1)
+			not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Window::close ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	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->title = title;
+	}
+
+	const char*
+	Window::title () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return self->title.c_str();
+	}
+
+	void
+	Window::set_frame (coord x, coord y, coord width, coord height)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->native.frame = [NativeWindow frameRectForContentRect: CGRectMake(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
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		CGRect rect = 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/ios/window_data.h

@@ -0,0 +1,75 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_IOS_WINDOW_DATA_H__
+#define __REFLEX_IOS_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;
+
+		String title;
+
+		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;
+
+		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/osx/app_delegate.h

@@ -0,0 +1,17 @@
+// -*- objc -*-
+#import <AppKit/NSApplication.h>
+#include <reflex/application.h>
+
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+
+	{
+		@private
+			Reflex::Application::Ref* pref;
+	}
+
+	- (void) bind:   (Reflex::Application*) instance;
+
+	- (void) unbind: (Reflex::Application*) instance;
+
+@end// AppDelegate