reflexion 0.1.6 → 0.1.7

data/src/image_view.cpp

@@ -0,0 +1,70 @@
+#include "reflex/image_view.h"
+
+
+#include <assert.h>
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	struct ImageView::Data
+	{
+
+		Image image;
+
+	};// ImageView::Data
+
+
+	ImageView::ImageView (const char* name)
+	:	Super(name)
+	{
+	}
+
+	ImageView::~ImageView ()
+	{
+	}
+
+	void
+	ImageView::set_image (Image image)
+	{
+		self->image = image;
+		redraw();
+	}
+
+	Image
+	ImageView::get_image () const
+	{
+		return self->image;
+	}
+
+	Rays::Point
+	ImageView::content_size () const
+	{
+		if (self->image)
+			return Point(self->image.width(), self->image.height());
+		else
+			return Super::content_size();
+	}
+
+	void
+	ImageView::on_draw (DrawEvent* e)
+	{
+		if (!self->image) return;
+
+		assert(e && e->painter);
+		Painter* p = e->painter;
+
+		Color f = p->fill(), s = p->stroke();
+		p->set_fill(1);
+		p->no_stroke();
+
+		p->image(self->image);
+
+		p->set_fill(f);
+		p->set_stroke(s);
+	}
+
+
+}// Reflex

data/src/ios/app_delegate.h

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

data/src/ios/app_delegate.mm

@@ -0,0 +1,120 @@
+// -*- objc -*-
+#import "app_delegate.h"
+
+
+#include <assert.h>
+#include "reflex/event.h"
+#include "reflex/exception.h"
+#include "application_data.h"
+
+
+#define REF (*pref)
+
+
+@implementation AppDelegate
+
+	- (id) init
+	{
+		self = [super init];
+		if (!self) return nil;
+
+		pref = new Reflex::Application::Ref;
+
+		return self;
+	}
+
+	- (void) dealloc
+	{
+		assert(pref && !REF);
+
+		delete pref;
+
+		[super dealloc];
+	}
+
+	- (void) bind: (Reflex::Application*) instance
+	{
+		assert(pref);
+
+		if (instance && instance->self->delegate)
+			Reflex::argument_error(__FILE__, __LINE__);
+
+		if (REF)
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		REF = instance;
+		if (REF) REF->self->delegate = [self retain];
+	}
+
+	- (void) unbind: (Reflex::Application*) instance
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		if (instance && instance != REF.get())
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		if (REF->self->delegate) [REF->self->delegate release];
+		REF->self->delegate = nil;
+		REF.reset();
+	}
+
+	- (BOOL) application: (UIApplication*) application
+		didFinishLaunchingWithOptions: (NSDictionary*) options
+	{
+		if (!Reflex::app())
+		{
+			Reflex::invalid_state_error(
+				__FILE__, __LINE__,
+				"no Application instance on application:didFinishLaunchingWithOptions:");
+		}
+
+		[self bind: Reflex::app()];
+
+		if (REF)
+		{
+			Reflex::Event e;
+			REF->on_start(&e);
+			if (e.is_blocked())
+			{
+				return NO;
+			}
+		}
+
+		return YES;
+	}
+
+	- (void) applicationWillResignActive: (UIApplication*) application
+	{
+	}
+
+	- (void) applicationDidEnterBackground: (UIApplication*) application
+	{
+	}
+
+	- (void) applicationWillEnterForeground: (UIApplication*) application
+	{
+	}
+
+	- (void) applicationDidBecomeActive: (UIApplication*) application
+	{
+	}
+
+	- (void) applicationWillTerminate: (UIApplication*) application
+	{
+		if (REF)
+		{
+			Reflex::Event e;
+			REF->on_quit(&e);
+			if (e.is_blocked())
+			{
+				Reflex::not_implemented_error(
+					__FILE__, __LINE__, "blocking to quit is not supported.");
+			}
+		}
+
+		[self unbind: NULL];
+	}
+
+@end// AppDelegate

data/src/ios/application.mm

@@ -0,0 +1,116 @@
+// -*- objc -*-
+#include "reflex/application.h"
+
+
+#include <assert.h>
+#include <crt_externs.h>
+#include "reflex/exception.h"
+#include "application_data.h"
+#import "app_delegate.h"
+
+
+namespace Reflex
+{
+
+
+	bool initialized ();
+
+
+	static Application* instance = NULL;
+
+
+	Application*
+	app ()
+	{
+		return instance;
+	}
+
+
+	Application::Application ()
+	{
+		if (!initialized())
+			reflex_error(__FILE__, __LINE__, "not initialized.");
+
+		if (instance)
+			reflex_error(__FILE__, __LINE__, "multiple application instances.");
+
+		instance = this;
+	}
+
+	Application::~Application ()
+	{
+		instance = NULL;
+	}
+
+	void
+	Application::start ()
+	{
+		UIApplicationMain(
+			*_NSGetArgc(), *_NSGetArgv(), nil, NSStringFromClass([AppDelegate class]));
+	}
+
+	void
+	Application::quit ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Application::set_name (const char* name)
+	{
+		if (!name)
+			argument_error(__FILE__, __LINE__);
+
+		self->name = name;
+	}
+
+	const char*
+	Application::name () const
+	{
+		return self->name.c_str();
+	}
+
+	void
+	Application::on_start (Event* e)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	void
+	Application::on_quit (Event* e)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	void
+	Application::on_preference (Event* e)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	void
+	Application::on_about (Event* e)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	Application::operator bool () const
+	{
+		return self && *self;
+	}
+
+	bool
+	Application::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/{cocoa/applicationdata.h → ios/application_data.h}

@@ -1,13 +1,13 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __REFLEX_COCOA_APPLICATIONDATA_H__
-#define __REFLEX_COCOA_APPLICATIONDATA_H__
+#ifndef __REFLEX_IOS_APPLICATION_DATA_H__
+#define __REFLEX_IOS_APPLICATION_DATA_H__
 
 
 #include <reflex/application.h>
 
 
-@class CocoaApplication;
+@class AppDelegate;
 
 
 namespace Reflex
@@ -17,18 +17,18 @@ namespace Reflex
 	struct Application::Data
 	{
 
-		CocoaApplication* cocoa;
+		AppDelegate* delegate;
 
 		String name;
 
 		Data ()
-		:	cocoa(nil)
+		:	delegate(nil)
 		{
 		}
 
 		operator bool () const
 		{
-			return cocoa;
+			return delegate;
 		}
 
 		bool operator ! () const

data/src/ios/event.h

@@ -0,0 +1,26 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_IOS_EVENT_H__
+#define __REFLEX_IOS_EVENT_H__
+
+
+#import <UIKit/UIEvent.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	struct NativePointerEvent : public PointerEvent
+	{
+
+		NativePointerEvent (NSSet* touches, UIEvent* event, UIView* view, Type type);
+
+	};// NativePointerEvent
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/ios/event.mm

@@ -0,0 +1,31 @@
+// -*- c++ -*-
+#include "event.h"
+
+
+#include <assert.h>
+
+
+namespace Reflex
+{
+
+
+	static CGPoint
+	correct_point (UIView* view, UITouch* touch)
+	{
+		assert(view && touch);
+		CGPoint p = [touch locationInView: view];
+		p.y = [view bounds].size.height - p.y;
+		return p;
+	}
+
+
+	NativePointerEvent::NativePointerEvent (NSSet* touches, UIEvent* e, UIView* view, Type type)
+	:	PointerEvent(type, POINTER_TOUCH, (coord) 0, (coord) 0)
+	{
+		CGPoint p = correct_point(view, [touches anyObject]);
+		x = p.x;
+		y = p.y;
+	}
+
+
+};// Reflex

data/src/ios/native_window.h

@@ -0,0 +1,37 @@
+// -*- objc -*-
+#import <UIKit/UIWindow.h>
+#include <reflex/window.h>
+
+
+@class OpenGLViewController;
+
+
+@interface NativeWindow : UIWindow
+
+	{
+		@private
+			Reflex::Window::Ref* pref;
+			OpenGLViewController* view_controller;
+	}
+
+	- (void) bind:   (Reflex::Window*) instance;
+
+	- (void) unbind: (Reflex::Window*) instance;
+
+	- (void) draw;
+
+	- (void) keyDown: (UIEvent*) event;
+
+	- (void) keyUp: (UIEvent*) event;
+
+	- (void) touchesBegan: (NSSet*) touches withEvent: (UIEvent*) event;
+
+	- (void) touchesEnded: (NSSet*) touches withEvent: (UIEvent*) event;
+
+	- (void) touchesCancelled: (NSSet*) touches withEvent: (UIEvent*) event;
+
+	- (void) touchesMoved: (NSSet*) touches withEvent: (UIEvent*) event;
+
+	+ (CGRect) frameRectForContentRect: (CGRect) contentRect;
+
+@end// NativeWindow

data/src/ios/native_window.mm

@@ -0,0 +1,220 @@
+// -*- objc -*-
+#import "native_window.h"
+
+
+#include <assert.h>
+#include <rays/bounds.h>
+#include "reflex/window.h"
+#include "reflex/exception.h"
+#include "event.h"
+#include "window_data.h"
+#import "opengl_view.h"
+
+
+#define REF (*pref)
+
+
+static CGRect device_frame ()
+{
+	return [[UIScreen mainScreen] applicationFrame];
+}
+
+
+@implementation NativeWindow
+
+	- (id) init
+	{
+		self = [super initWithFrame: device_frame()];
+		if (!self) return nil;
+
+		pref            = new Reflex::Window::Ref;
+		view_controller = [[OpenGLViewController alloc] initWithNibName: nil bundle: nil];
+
+		self.rootViewController = view_controller;
+
+		return self;
+	}
+
+	- (void) dealloc
+	{
+		assert(pref);
+
+		self.rootViewController = nil;
+		if (view_controller) [view_controller release];
+
+		[self unbind: NULL];
+		delete pref;
+
+		[super dealloc];
+	}
+
+	- (void) bind: (Reflex::Window*) instance
+	{
+		assert(pref);
+
+		if (instance && instance->self->native)
+			Reflex::argument_error(__FILE__, __LINE__);
+
+		if (REF)
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		REF = instance;
+		if (REF) REF->self->native = [self retain];
+	}
+
+	- (void) unbind: (Reflex::Window*) instance
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		if (instance && instance != REF.get())
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		if (REF->self->native) [REF->self->native release];
+		REF->self->native = nil;
+		REF.reset();
+	}
+
+	- (void) update
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		double now = Xot::time();
+		Reflex::UpdateEvent e(now - REF->self->prev_time_update);
+		REF->self->prev_time_update = now;
+
+		REF->on_update(&e);
+	}
+
+	- (void) draw
+	{
+		assert(pref);
+
+		if (!REF || !REF->self->redraw) return;
+
+		REF->self->redraw = false;
+
+		double now = Xot::time();
+		double dt  = now - REF->self->prev_time_draw;
+		double fps = 1. / dt;
+
+		fps                       = REF->self->prev_fps * 0.9 + fps * 0.1;// LPF
+		REF->self->prev_time_draw = now;
+		REF->self->prev_fps       = fps;
+
+		Reflex::DrawEvent e(dt, fps);
+
+		e.painter = REF->painter();
+		if (!e.painter)
+			Xot::invalid_state_error(__FILE__, __LINE__);
+
+		Rays::Bounds b = REF->frame();
+		e.bounds.reset(0, 0, b.width, b.height);
+
+		e.painter->begin();
+		REF->on_draw(&e);
+		e.painter->end();
+	}
+
+	- (void) frameChanged
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Rays::Bounds b           = REF->frame();
+		Rays::Point dpos         = b.position() - REF->self->prev_position;
+		Rays::Point dsize        = b.size()     - REF->self->prev_size;
+		REF->self->prev_position = b.position();
+		REF->self->prev_size     = b.size();
+
+		if (dpos != 0 || dsize != 0)
+		{
+			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
+			if (dpos  != 0) REF->on_move(&e);
+			if (dsize != 0)
+			{
+				Rays::Bounds b = REF->frame();
+				b.move_to(0, 0);
+				if (REF->painter()) REF->painter()->canvas(b);
+				if (REF->root())    REF->root()->set_frame(b);
+				REF->on_resize(&e);
+			}
+		}
+	}
+
+	- (void) becomeKeyWindow
+	{
+		[super becomeKeyWindow];
+		[self frameChanged];
+	}
+
+	- (void) keyDown: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		//Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::DOWN);
+		//REF->on_key(&e);
+	}
+
+	- (void) keyUp: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		//Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::UP);
+		//REF->on_key(&e);
+	}
+
+	- (void) touchesBegan: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(touches, event, view_controller.view, Reflex::PointerEvent::DOWN);
+		REF->on_pointer(&e);
+	}
+
+	- (void) touchesEnded: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(touches, event, view_controller.view, Reflex::PointerEvent::UP);
+		REF->on_pointer(&e);
+	}
+
+	- (void) touchesCancelled: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(touches, event, view_controller.view, Reflex::PointerEvent::UP);
+		REF->on_pointer(&e);
+	}
+
+	- (void) touchesMoved: (NSSet*) touches withEvent: (UIEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(touches, event, view_controller.view, Reflex::PointerEvent::MOVE);
+		REF->on_pointer(&e);
+	}
+
+	+ (CGRect) frameRectForContentRect: (CGRect) contentRect
+	{
+		return device_frame();
+	}
+
+@end// NativeWindow

data/src/ios/opengl_view.h

@@ -0,0 +1,13 @@
+// -*- objc -*-
+#import <UIKit/UIKit.h>
+#import <GLKit/GLKit.h>
+
+
+@interface OpenGLViewController : GLKViewController
+
+	{
+		@private
+			EAGLContext* context;
+	}
+
+@end// OpenGLViewController