reflexion 0.1.12 → 0.1.17

data/src/osx/app_delegate.mm

@@ -6,90 +6,96 @@
 #import <Cocoa/Cocoa.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;
+	}
 
 	- (id) init
 	{
 		self = [super init];
 		if (!self) return nil;
 
-		pref = new Reflex::Application::Ref;
+		application = NULL;
+		started     = false;
 
 		return self;
 	}
 
 	- (void) dealloc
 	{
-		assert(pref && !REF);
-
-		delete pref;
+		assert(!application);
 
 		[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;
+	}
 
-		if (REF->self->delegate) [REF->self->delegate release];
-		REF->self->delegate = nil;
-		REF.reset();
+	- (BOOL) callOnStart
+	{
+		if (!application || started)
+			return YES;
+
+		Reflex::Event e;
+		application->on_start(&e);
+		started = true;
+
+		if (e.is_blocked()) [self quit];
+		return !e.is_blocked();
 	}
 
 	- (void) quit
 	{
-		assert(pref);
-
-		if (REF)
-			REF->quit();
+		if (application)
+			application->quit();
 		else
 			[NSApp terminate: nil];
 	}
 
 	- (void) showPreference
 	{
-		assert(pref);
+		if (!application) return;
 
-		if (REF)
-		{
-			Reflex::Event e;
-			REF->on_preference(&e);
-		}
+		Reflex::Event e;
+		application->on_preference(&e);
 	}
 
 	- (void) showAbout
 	{
-		assert(pref);
-
-		if (REF)
+		if (application)
 		{
 			Reflex::Event e;
-			REF->on_about(&e);
+			application->on_about(&e);
 		}
 		else
 			[NSApp orderFrontStandardAboutPanel: nil];
@@ -100,26 +106,18 @@
 		[NSApp setActivationPolicy: NSApplicationActivationPolicyRegular];
 		[NSApp activateIgnoringOtherApps: YES];
 
-		if (REF)
-		{
-			Reflex::Event e;
-			REF->on_start(&e);
-			if (e.is_blocked())
-			{
-				[self quit];
-				return;
-			}
-		}
+		if (![self callOnStart])
+			return;
 
 		[self setupMenu];
 	}
 
 	- (NSApplicationTerminateReply) applicationShouldTerminate: (NSApplication*) application
 	{
-		if (REF)
+		if (self->application)
 		{
 			Reflex::Event e;
-			REF->on_quit(&e);
+			self->application->on_quit(&e);
 			if (e.is_blocked()) return NSTerminateCancel;
 		}
 
@@ -133,13 +131,12 @@
 
 	- (void) applicationWillTerminate: (NSNotification*) notification
 	{
-		[self unbind: NULL];
+		[self unbind];
 	}
 
 	- (BOOL) setupApplicationMenu: (NSMenu*) parent
 	{
-		assert(pref);
-		if (!REF || !parent) return NO;
+		if (!application || !parent) return NO;
 
 		NSMenu* menu = [[[NSMenu alloc]
 			initWithTitle: @"Application"]
@@ -147,8 +144,8 @@
 		if ([NSApp respondsToSelector: @selector(setAppleMenu:)])
 			[NSApp performSelector: @selector(setAppleMenu:) withObject: menu];
 
-		NSString* name = !REF->self->name.empty() ?
-			[NSString stringWithUTF8String: REF->self->name.c_str()] : @"";
+		NSString* name = !application->self->name.empty() ?
+			[NSString stringWithUTF8String: application->self->name.c_str()] : @"";
 		if ([name length] > 0)
 			name = [@" " stringByAppendingString: name];
 
@@ -261,4 +258,4 @@
 		return YES;
 	}
 
-@end// AppDelegate
+@end// ReflexAppDelegate

data/src/osx/application.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_OSX_APPLICATION_H__
+#define __REFLEX_SRC_OSX_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/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,54 +37,73 @@ 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];
-		[self startTimer: 60];
+		[self startTimer];
 
 		return self;
 	}
 
 	- (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];
+		// ruby value references native window weakly.
+		data.native = self;
+
+		// 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__);
+	- (void) unbind
+	{
+		[self rebind];
+		if (!pwindow) return;
 
-		if (REF->self->native) [REF->self->native release];
-		REF->self->native = nil;
-		REF.reset();
+		Window_get_data(pwindow).native = nil;
+
+		pwindow->release();
+		pwindow = NULL;
+	}
+
+	- (Reflex::Window*) window
+	{
+		[self rebind];
+		return pwindow;
 	}
 
 	- (void) setupContentView
@@ -102,6 +114,11 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		[self setContentView: view];
 	}
 
+	- (void) startTimer
+	{
+		[self startTimer: 60];
+	}
+
 	- (void) startTimer: (int) fps
 	{
 		[self stopTimer];
@@ -116,9 +133,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 +149,64 @@ 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;
-
-		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);
+		fps = win->self->prev_fps * 0.9 + fps * 0.1;// LPF
 
-		e.painter->begin();
-		e.painter->clear();
+		win->self->prev_time_draw = now;
+		win->self->prev_fps       = fps;
 
-		REF->on_draw(&e);
-		if (!e.is_blocked())
-			draw_view_tree(REF->root(), e, 0, REF->frame().dup().move_to(0));
-
-		e.painter->end();
+		Reflex::DrawEvent e(dt, fps);
+		Window_call_draw_event(win, &e);
 	}
 
 	- (BOOL) windowShouldClose: (id) sender
 	{
-		assert(pref);
-
-		if (!REF) return YES;
+		Reflex::Window* win = self.window;
+		if (!win) 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);
+		Reflex::Window* win = self.window;
+		if (!win) return;
 
-		if (!REF) return;
-
-		REF->self->prev_position = REF->frame().position();
+		win->self->prev_position = win->frame().position();
 	}
 
 	- (void) windowDidMove: (NSNotification*) notification
@@ -217,11 +216,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 +231,101 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (void) frameChanged
 	{
-		assert(pref);
-
-		if (!REF) return;
+		Reflex::Window* win = self.window;
+		if (!win) 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