reflexion 0.1.12 → 0.1.13

data/src/osx/application.mm

@@ -1,11 +1,10 @@
 // -*- objc -*-
-#include "reflex/application.h"
+#include "application.h"
 
 
 #include <assert.h>
 #import <AppKit/NSApplication.h>
 #include "reflex/exception.h"
-#include "application_data.h"
 #import "app_delegate.h"
 
 
@@ -13,56 +12,66 @@ 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() || !NSApp)
-			reflex_error(__FILE__, __LINE__, "not initialized.");
-
-		if (instance)
+		if (global::instance)
 			reflex_error(__FILE__, __LINE__, "multiple application instances.");
 
-		AppDelegate* delegate = (AppDelegate*) [NSApp delegate];
-		if (!delegate)
-			invalid_state_error(__FILE__, __LINE__);
-
-		[delegate bind: this];
-
-		instance = this;
+		global::instance = this;
 	}
 
 	Application::~Application ()
 	{
-		instance = NULL;
+		global::instance = NULL;
+	}
+
+	static ReflexAppDelegate*
+	setup_app_delegate (NSApplication* app)
+	{
+		id<NSApplicationDelegate> delegate = [app delegate];
+		if (!delegate)
+		{
+			delegate = [[[ReflexAppDelegate alloc] init] autorelease];
+			[app setDelegate: delegate];
+		}
+
+		if (![delegate isKindOfClass: ReflexAppDelegate.class])
+			reflex_error(__FILE__, __LINE__);
+
+		return (ReflexAppDelegate*) delegate;
 	}
 
 	void
 	Application::start ()
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
+		NSApplication* app          = [NSApplication sharedApplication];
+		ReflexAppDelegate* delegate = setup_app_delegate(app);
+		[delegate bind: this];
 
-		[NSApp run];
+		if (![app isRunning])
+			[app run];
+		else
+			[delegate callOnStart];
 	}
 
 	void
 	Application::quit ()
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
 		[NSApp terminate: nil];
 	}
 
@@ -72,54 +81,44 @@ namespace Reflex
 		if (!name)
 			argument_error(__FILE__, __LINE__);
 
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
 		self->name = name;
 	}
 
 	const char*
 	Application::name () const
 	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
-
 		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_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__);
-
 		[NSApp orderFrontStandardAboutPanel: nil];
 	}
 
 	Application::operator bool () const
 	{
-		return self && *self;
+		return true;
 	}
 
 	bool
@@ -129,4 +128,10 @@ namespace Reflex
 	}
 
 
+	Application::Data::Data ()
+	:	delegate(nil)
+	{
+	}
+
+
 }// Reflex

data/src/osx/native_window.h

@@ -1,24 +1,9 @@
 // -*- objc -*-
 #import <AppKit/NSWindow.h>
-#include <reflex/window.h>
-
-
-@class OpenGLView;
 
 
 @interface NativeWindow : NSWindow <NSWindowDelegate>
 
-	{
-		@private
-			Reflex::Window::Ref* pref;
-			OpenGLView* view;
-			NSTimer* timer;
-	}
-
-	- (void) bind:   (Reflex::Window*) instance;
-
-	- (void) unbind: (Reflex::Window*) instance;
-
 	- (void) draw;
 
 	+ (NSRect) frameRectForContentRect: (NSRect) contentRect;

data/src/osx/native_window.mm

@@ -4,27 +4,14 @@
 
 #include <assert.h>
 #import <Cocoa/Cocoa.h>
-#include "reflex/bounds.h"
-#include "reflex/window.h"
+#include "rays/bounds.h"
 #include "reflex/exception.h"
+#include "../view.h"
 #include "event.h"
-#include "window_data.h"
+#include "window.h"
 #import "opengl_view.h"
 
 
-#define REF (*pref)
-
-
-namespace Reflex
-{
-
-	void update_view_tree (View* v, const UpdateEvent& e);
-
-	void draw_view_tree (View* v, const DrawEvent& e, const Point& offset, const Bounds& clip);
-
-}// Reflex
-
-
 static const NSUInteger WINDOW_STYLE_MASK =
 	NSTitledWindowMask |
 	NSClosableWindowMask |
@@ -35,6 +22,12 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 @implementation NativeWindow
 
+	{
+		Reflex::Window *pwindow, *ptr_for_rebind;
+		OpenGLView* view;
+		NSTimer* timer;
+	}
+
 	- (id) init
 	{
 		self = [super
@@ -44,9 +37,9 @@ static const NSUInteger WINDOW_STYLE_MASK =
 			defer: NO];
 		if (!self) return nil;
 
-		pref  = new Reflex::Window::Ref;
-		view  = nil;
-		timer = nil;
+		pwindow = ptr_for_rebind = NULL;
+		view    = nil;
+		timer   = nil;
 
 		[self setDelegate: self];
 		[self setupContentView];
@@ -57,41 +50,66 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (void) dealloc
 	{
-		assert(pref && !REF);
+		assert(!pwindow);
 
 		if (view) [view release];
 
-		delete pref;
-
 		[super dealloc];
 	}
 
-	- (void) bind: (Reflex::Window*) instance
+	- (void) bind: (Reflex::Window*) window
 	{
-		assert(pref);
-
-		if (instance && instance->self->native)
+		if (!window)
 			Reflex::argument_error(__FILE__, __LINE__);
 
-		if (REF)
+		Reflex::WindowData& data = Window_get_data(window);
+		if (data.native)
 			Reflex::invalid_state_error(__FILE__, __LINE__);
 
-		REF = instance;
-		if (REF) REF->self->native = [self retain];
+		data.native = [self retain];
+
+		// Reflex::Window is not constructed completely,
+		// so can not call ClassWrapper::retain().
+		window->Xot::template RefCountable<>::retain();
+
+		// defer calling ClassWrapper::retain() to rebind.
+		ptr_for_rebind = window;
 	}
 
-	- (void) unbind: (Reflex::Window*) instance
+	- (void) rebind
 	{
-		assert(pref);
+		if (!pwindow && ptr_for_rebind)
+		{
+			pwindow = ptr_for_rebind;
+			pwindow->retain();
 
-		if (!REF) return;
+			ptr_for_rebind->Xot::template RefCountable<>::release();
+			ptr_for_rebind = NULL;
+		}
 
-		if (instance && instance != REF.get())
-			Reflex::invalid_state_error(__FILE__, __LINE__);
+		assert(pwindow && !ptr_for_rebind);
+	}
+
+	- (void) unbind
+	{
+		[self rebind];
+		if (!pwindow) return;
+
+		Reflex::WindowData& data = Window_get_data(pwindow);
+		if (data.native)
+		{
+			[data.native release];
+			data.native = nil;
+		}
 
-		if (REF->self->native) [REF->self->native release];
-		REF->self->native = nil;
-		REF.reset();
+		pwindow->release();
+		pwindow = NULL;
+	}
+
+	- (Reflex::Window*) window
+	{
+		[self rebind];
+		return pwindow;
 	}
 
 	- (void) setupContentView
@@ -116,9 +134,9 @@ static const NSUInteger WINDOW_STYLE_MASK =
 			repeats: YES] retain];
 		if (!timer) return;
 
-		[[NSRunLoop currentRunLoop]
+		[[NSRunLoop mainRunLoop]
 			addTimer: timer forMode: NSDefaultRunLoopMode];
-		[[NSRunLoop currentRunLoop]
+		[[NSRunLoop mainRunLoop]
 			addTimer: timer forMode: NSEventTrackingRunLoopMode];
 	}
 
@@ -132,82 +150,79 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (void) update: (NSTimer*) t
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		double now = Xot::time();
-		Reflex::UpdateEvent e(now - REF->self->prev_time_update);
-		REF->self->prev_time_update = now;
+		Reflex::UpdateEvent e(now, now - win->self->prev_time_update);
+		win->self->prev_time_update = now;
 
-		REF->on_update(&e);
+		win->on_update(&e);
 		if (!e.is_blocked())
-			Reflex::update_view_tree(REF->root(), e);
+			Reflex::View_update_tree(win->root(), e);
 
-		if (REF->self->redraw)
+		if (win->self->redraw)
 		{
-			[self display];
-			REF->self->redraw = false;
+			view.needsDisplay = YES;
+			win->self->redraw = false;
 		}
 	}
 
 	- (void) draw
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		double now = Xot::time();
-		double dt  = now - REF->self->prev_time_draw;
+		double dt  = now - win->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;
+		fps = win->self->prev_fps * 0.9 + fps * 0.1;// LPF
+
+		win->self->prev_time_draw = now;
+		win->self->prev_fps       = fps;
 
 		Reflex::DrawEvent e(dt, fps);
 
-		e.painter = REF->painter();
+		e.painter = win->painter();
 		if (!e.painter)
 			Xot::invalid_state_error(__FILE__, __LINE__);
 
-		Rays::Bounds b = REF->frame();
-		e.bounds.reset(0, 0, b.width, b.height);
+		Rays::Bounds frame = win->frame();
+		e.bounds.reset(0, 0, frame.width, frame.height);
 
 		e.painter->begin();
 		e.painter->clear();
 
-		REF->on_draw(&e);
+		win->on_draw(&e);
 		if (!e.is_blocked())
-			draw_view_tree(REF->root(), e, 0, REF->frame().dup().move_to(0));
+			Reflex::View_draw_tree(win->root(), e, 0, frame.move_to(0));
 
 		e.painter->end();
 	}
 
 	- (BOOL) windowShouldClose: (id) sender
 	{
-		assert(pref);
+		Reflex::Window* win = self.window;
+		if (!win) return YES;
 
-		if (!REF) return YES;
-
-		REF->close();
+		win->close();
 		return NO;
 	}
 
 	- (void) windowWillClose: (NSNotification*) notification
 	{
 		[self stopTimer];
-		[self unbind: NULL];
+		[self unbind];
 		[self setDelegate: nil];
 	}
 
 	- (void) windowWillMove: (NSNotification*) notification
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
-		REF->self->prev_position = REF->frame().position();
+		win->self->prev_position = win->frame().position();
 	}
 
 	- (void) windowDidMove: (NSNotification*) notification
@@ -217,11 +232,10 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (NSSize) windowWillResize: (NSWindow*) sender toSize: (NSSize) frameSize
 	{
-		assert(pref);
-
-		if (!REF) return frameSize;
+		Reflex::Window* win = self.window;
+		if (!win) return frameSize;
 
-		REF->self->prev_size = REF->frame().size();
+		win->self->prev_size = win->frame().size();
 
 		return frameSize;
 	}
@@ -233,99 +247,101 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (void) frameChanged
 	{
-		assert(pref);
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
-		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();
+		Rays::Bounds b           = win->frame();
+		Rays::Point dpos         = b.position() - win->self->prev_position;
+		Rays::Point dsize        = b.size()     - win->self->prev_size;
+		win->self->prev_position = b.position();
+		win->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 (dpos  != 0) win->on_move(&e);
 			if (dsize != 0)
 			{
-				Rays::Bounds b = REF->frame();
+				Rays::Bounds b = win->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);
+
+				if (win->painter())
+					win->painter()->canvas(b, self.backingScaleFactor);
+
+				if (win->root())
+					View_set_frame(win->root(), b);
+
+				win->on_resize(&e);
 			}
 		}
 	}
 
 	- (void) keyDown: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::DOWN);
-		REF->on_key(&e);
+		win->on_key(&e);
 	}
 
 	- (void) keyUp: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::UP);
-		REF->on_key(&e);
+		win->on_key(&e);
 	}
 
-	- (void) mouseDown: (NSEvent*) event
+	- (void) flagsChanged: (NSEvent*) event
 	{
-		assert(pref);
+		// TODO: implement later.
+	}
 
-		if (!REF) return;
+	- (void) mouseDown: (NSEvent*) event
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::DOWN);
-		REF->on_pointer(&e);
+		win->on_pointer(&e);
 	}
 
 	- (void) mouseUp: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::UP);
-		REF->on_pointer(&e);
+		win->on_pointer(&e);
 	}
 
 	- (void) mouseDragged: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
-		REF->on_pointer(&e);
+		win->on_pointer(&e);
 	}
 
 	- (void) mouseMoved: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
-		REF->on_pointer(&e);
+		win->on_pointer(&e);
 	}
 
 	- (void) scrollWheel: (NSEvent*) event
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
 		Reflex::NativeWheelEvent e(event, view);
-		REF->on_wheel(&e);
+		win->on_wheel(&e);
 	}
 
 	+ (NSRect) frameRectForContentRect: (NSRect) contentRect

data/src/osx/opengl_view.h

@@ -4,8 +4,6 @@
 
 @interface OpenGLView : NSOpenGLView
 
-	{}
-
 	- (id) initWithFrame: (NSRect) frame;
 
 	- (id) initWithFrame: (NSRect) frame antiAlias: (int) nsample;

data/src/osx/opengl_view.mm

@@ -63,11 +63,12 @@ make_pixelformat (int antialias_nsample = 0)
 		self = [super initWithFrame: frame pixelFormat: make_pixelformat(nsample)];
 		if (!self) return nil;
 
+		[self setWantsBestResolutionOpenGLSurface: YES];
 		[self activateContext];
 
-		GLint swapinterval = 1;
+		GLint swapInterval = 1;
 		[[self openGLContext]
-			setValues: &swapinterval
+			setValues: &swapInterval
 			forParameter: NSOpenGLCPSwapInterval];
 
 #ifdef TRANSPARENT_BACKGROUND
@@ -130,7 +131,7 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) keyDown: (NSEvent*) event
 	{
-		[self interpretKeyEvents: [NSArray arrayWithObject: event]];
+		//[self interpretKeyEvents: [NSArray arrayWithObject: event]];
 
 		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
@@ -146,6 +147,14 @@ make_pixelformat (int antialias_nsample = 0)
 		[win keyUp: event];
 	}
 
+	- (void) flagsChanged: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win flagsChanged: event];
+	}
+
 	- (void) mouseDown: (NSEvent*) event
 	{
 		NativeWindow* win = (NativeWindow*) [self window];

data/src/osx/reflex.mm

@@ -4,7 +4,6 @@
 
 #import <Cocoa/Cocoa.h>
 #include "reflex/exception.h"
-#import "app_delegate.h"
 
 
 namespace Reflex
@@ -19,12 +18,6 @@ namespace Reflex
 	}// global
 
 
-	bool
-	initialized ()
-	{
-		return global::pool;
-	}
-
 	void
 	init ()
 	{
@@ -32,8 +25,6 @@ namespace Reflex
 			reflex_error(__FILE__, __LINE__, "already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
-
-		[[NSApplication sharedApplication] setDelegate: [[[AppDelegate alloc] init] autorelease]];
 	}
 
 	void