reflexion 0.1.12 → 0.1.17

data/src/fixture.h

@@ -0,0 +1,85 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_FIXTURE_H__
+#define __REFLEX_SRC_FIXTURE_H__
+
+
+#include <memory>
+#include <xot/noncopyable.h>
+#include <reflex/defs.h>
+
+
+class b2Fixture;
+class b2Shape;
+
+
+namespace Reflex
+{
+
+
+	class Body;
+
+
+	class Fixture : public Xot::NonCopyable
+	{
+
+		public:
+
+			Fixture (Body* body, const b2Shape* b2shape, void* userdata = NULL);
+
+			~Fixture ();
+
+			void set_density (float density);
+
+			float    density () const;
+
+			void set_friction (float friction);
+
+			float    friction () const;
+
+			void set_restitution (float restitution);
+
+			float    restitution () const;
+
+			void set_sensor (bool state);
+
+			bool  is_sensor () const;
+
+			void set_category_bits (uint bits);
+
+			uint     category_bits () const;
+
+			void set_collision_mask (uint mask);
+
+			uint     collision_mask () const;
+
+			      b2Fixture* b2ptr ();
+
+			const b2Fixture* b2ptr () const;
+
+			void       set_next (Fixture* fixture);
+
+			      Fixture* next ();
+
+			const Fixture* next () const;
+
+		private:
+
+			b2Fixture* b2fixture;
+
+			std::unique_ptr<Fixture> pnext;
+
+	};// Fixture
+
+
+	void Fixture_copy_attributes (Fixture* to, const Fixture& from);
+
+	Fixture* Fixture_create_temporary ();
+
+	bool Fixture_is_temporary (const Fixture& fixture);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/image_view.cpp

@@ -39,13 +39,13 @@ namespace Reflex
 		return self->image;
 	}
 
-	Point
-	ImageView::content_size () const
+	Bounds
+	ImageView::content_bounds () const
 	{
 		if (self->image)
-			return Point(self->image.width(), self->image.height());
+			return Bounds(self->image.width(), self->image.height());
 		else
-			return Super::content_size();
+			return Super::content_bounds();
 	}
 
 	void

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