reflexion 0.1.12 → 0.1.13

data/src/ios/app_delegate.h

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

data/src/ios/app_delegate.mm

@@ -3,86 +3,124 @@
 
 
 #include <assert.h>
+#import  <CoreMotion/CoreMotion.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
-#include "application_data.h"
 
 
-#define REF (*pref)
+@implementation ReflexAppDelegate
 
-
-@implementation AppDelegate
+	{
+		Reflex::Application* application;
+		bool started;
+		UIWindow* window;
+		CMMotionManager* motion_manager;
+	}
 
 	- (id) init
 	{
 		self = [super init];
 		if (!self) return nil;
 
-		pref = new Reflex::Application::Ref;
+		application    = NULL;
+		started        = false;
+		window         = nil;
+		motion_manager = nil;
 
 		return self;
 	}
 
 	- (void) dealloc
 	{
-		assert(pref && !REF);
+		assert(!application);
 
-		delete pref;
+		[self stopUpdateDeviceMotion];
 
 		[super dealloc];
 	}
 
-	- (void) bind: (Reflex::Application*) instance
+	- (void) bind: (Reflex::Application*) app
 	{
-		assert(pref);
-
-		if (instance && instance->self->delegate)
+		if (!app)
 			Reflex::argument_error(__FILE__, __LINE__);
 
-		if (REF)
+		if (app->self->delegate)
 			Reflex::invalid_state_error(__FILE__, __LINE__);
 
-		REF = instance;
-		if (REF) REF->self->delegate = [self retain];
+		app->self->delegate = [self retain];
+		app->retain();
+
+		application = app;
 	}
 
-	- (void) unbind: (Reflex::Application*) instance
+	- (void) unbind
 	{
-		assert(pref);
+		if (!application) return;
 
-		if (!REF) return;
+		if (application->self->delegate)
+		{
+			[application->self->delegate release];
+			application->self->delegate = nil;
+		}
 
-		if (instance && instance != REF.get())
-			Reflex::invalid_state_error(__FILE__, __LINE__);
+		application->release();
+		application = NULL;
+	}
+
+	- (BOOL) callOnStart
+	{
+		if (!application || started)
+			return YES;
+
+		Reflex::Event e;
+		application->on_start(&e);
+		started = true;
 
-		if (REF->self->delegate) [REF->self->delegate release];
-		REF->self->delegate = nil;
-		REF.reset();
+		return !e.is_blocked();
 	}
 
 	- (BOOL) application: (UIApplication*) application
 		didFinishLaunchingWithOptions: (NSDictionary*) options
 	{
-		if (!Reflex::app())
-		{
-			Reflex::invalid_state_error(
-				__FILE__, __LINE__,
-				"no Application instance on application:didFinishLaunchingWithOptions:");
-		}
+		Reflex::Application* app = Reflex::app();
+		if (!self->application && app)
+			[self bind: app];
 
-		[self bind: Reflex::app()];
+		[self startUpdateDeviceMotion];
 
-		if (REF)
-		{
-			Reflex::Event e;
-			REF->on_start(&e);
-			if (e.is_blocked())
+		return [self callOnStart];
+	}
+
+	- (void) startUpdateDeviceMotion
+	{
+		CMMotionManager* man = [[[CMMotionManager alloc] init] autorelease];
+		if (!man || !man.deviceMotionAvailable)
+			return;
+
+		man.deviceMotionUpdateInterval = 1 / 60.0;
+		[man
+			startDeviceMotionUpdatesToQueue: NSOperationQueue.currentQueue
+			withHandler: ^(CMDeviceMotion* motion, NSError* error)
 			{
-				return NO;
+				if (!application) return;
+
+				Reflex::MotionEvent e(
+					Reflex::Point(motion.gravity.x, -motion.gravity.y, motion.gravity.z));
+				application->on_motion(&e);
 			}
-		}
+		];
+
+		motion_manager = [man retain];
+	}
+
+	- (void) stopUpdateDeviceMotion
+	{
+		if (!motion_manager || !motion_manager.deviceMotionActive)
+			return;
 
-		return YES;
+		[motion_manager stopDeviceMotionUpdates];
+		[motion_manager release];
+		motion_manager = nil;
 	}
 
 	- (void) applicationWillResignActive: (UIApplication*) application
@@ -103,10 +141,10 @@
 
 	- (void) applicationWillTerminate: (UIApplication*) application
 	{
-		if (REF)
+		if (self->application)
 		{
 			Reflex::Event e;
-			REF->on_quit(&e);
+			self->application->on_quit(&e);
 			if (e.is_blocked())
 			{
 				Reflex::not_implemented_error(
@@ -114,7 +152,7 @@
 			}
 		}
 
-		[self unbind: NULL];
+		[self unbind];
 	}
 
-@end// AppDelegate
+@end// ReflexAppDelegate

data/src/ios/application.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_IOS_APPLICATION_H__
+#define __REFLEX_SRC_IOS_APPLICATION_H__
+
+
+#include <reflex/application.h>
+
+
+@class ReflexAppDelegate;
+
+
+namespace Reflex
+{
+
+
+	struct Application::Data
+	{
+
+		ReflexAppDelegate* delegate;
+
+		String name;
+
+		Data ();
+
+	};// Application::Data
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/ios/application.mm

@@ -1,10 +1,9 @@
 // -*- objc -*-
-#include "reflex/application.h"
+#include "application.h"
 
 
 #include <assert.h>
 #include "reflex/exception.h"
-#include "application_data.h"
 #import "app_delegate.h"
 
 
@@ -18,48 +17,56 @@ namespace Reflex
 {
 
 
-	bool initialized ();
+	namespace global
+	{
 
+		static Application* instance = NULL;
 
-	static Application* instance = NULL;
+	}// global
 
 
 	Application*
 	app ()
 	{
-		return instance;
+		return global::instance;
 	}
 
 
 	Application::Application ()
 	{
-		if (!initialized())
-			reflex_error(__FILE__, __LINE__, "not initialized.");
-
-		if (instance)
+		if (global::instance)
 			reflex_error(__FILE__, __LINE__, "multiple application instances.");
 
-		instance = this;
+		global::instance = this;
 	}
 
 	Application::~Application ()
 	{
-		instance = NULL;
+		global::instance = NULL;
 	}
 
 	void
 	Application::start ()
 	{
-		UIApplicationMain(
-			*_NSGetArgc(), *_NSGetArgv(), nil, NSStringFromClass(AppDelegate.class));
+		UIApplication* app                 = UIApplication.sharedApplication;
+		id<UIApplicationDelegate> delegate = app.delegate;
+		if (!delegate)
+		{
+			UIApplicationMain(*_NSGetArgc(), *_NSGetArgv(), nil, @"ReflexAppDelegate");
+			return;
+		}
+
+		if ([delegate isKindOfClass: ReflexAppDelegate.class])
+		{
+			ReflexAppDelegate* reflex_delegate = (ReflexAppDelegate*) delegate;
+			[reflex_delegate bind: this];
+			[reflex_delegate callOnStart];
+		}
 	}
 
 	void
 	Application::quit ()
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
 		not_implemented_error(__FILE__, __LINE__);
 	}
 
@@ -81,34 +88,31 @@ namespace Reflex
 	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_motion (MotionEvent* e)
+	{
 	}
 
 	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;
+		return true;
 	}
 
 	bool
@@ -118,4 +122,10 @@ namespace Reflex
 	}
 
 
+	Application::Data::Data ()
+	:	delegate(nil)
+	{
+	}
+
+
 }// Reflex

data/src/ios/event.mm

@@ -17,12 +17,16 @@ namespace Reflex
 	}
 
 
-	NativePointerEvent::NativePointerEvent (NSSet* touches, UIEvent* e, UIView* view, Type type)
+	NativePointerEvent::NativePointerEvent (
+		NSSet* touches, UIEvent* e, UIView* view, Type type)
 	:	PointerEvent(type, POINTER_TOUCH, (coord) 0, (coord) 0, 0, 1, type == MOVE)
 	{
-		CGPoint p = correct_point(view, [touches anyObject]);
-		x = p.x;
-		y = p.y;
+		int index = 0;
+		for (UITouch* touch in touches) {
+			CGPoint p = correct_point(view, touch);
+			positions[index++].reset(p.x, p.y);
+		}
+		size = index;
 	}
 
 

data/src/ios/reflex.mm

@@ -3,7 +3,6 @@
 
 
 #include "reflex/exception.h"
-#import "app_delegate.h"
 
 
 namespace Reflex
@@ -18,12 +17,6 @@ namespace Reflex
 	}// global
 
 
-	bool
-	initialized ()
-	{
-		return global::pool;
-	}
-
 	void
 	init ()
 	{

data/src/ios/view_controller.h

@@ -0,0 +1,33 @@
+// -*- objc -*-
+#import <UIKit/UIKit.h>
+#import <GLKit/GLKit.h>
+
+
+@interface ReflexView : GLKView
+@end
+
+
+@interface ReflexViewController : UIViewController
+
+	@property(nonatomic, strong, readonly) ReflexView* reflexView;
+
+	- (ReflexView*) createReflexView;
+
+	- (void) viewDidResize;
+
+@end// ReflexViewController
+
+
+typedef ReflexViewController* (*ReflexViewController_CreateFun) ();
+
+typedef void (*ReflexViewController_ShowFun) (
+	UIViewController* root_vc, ReflexViewController* reflex_vc);
+
+
+void ReflexViewController_set_create_fun (ReflexViewController_CreateFun fun);
+
+void ReflexViewController_set_show_fun   (ReflexViewController_ShowFun   fun);
+
+ReflexViewController_CreateFun ReflexViewController_get_create_fun ();
+
+ReflexViewController_ShowFun   ReflexViewController_get_show_fun ();