reflexion 0.1.6 → 0.1.7

data/src/osx/native_window.mm

@@ -0,0 +1,322 @@
+// -*- objc -*-
+#import "native_window.h"
+
+
+#include <assert.h>
+#import <Cocoa/Cocoa.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 const NSUInteger WINDOW_STYLE_MASK =
+	NSTitledWindowMask |
+	NSClosableWindowMask |
+	NSMiniaturizableWindowMask |
+	NSResizableWindowMask |
+	0;//NSTexturedBackgroundWindowMask
+
+
+@implementation NativeWindow
+
+	- (id) init
+	{
+		self = [super
+			initWithContentRect: NSMakeRect(0, 0, 0, 0)
+			styleMask: WINDOW_STYLE_MASK
+			backing: NSBackingStoreBuffered
+			defer: NO];
+		if (!self) return nil;
+
+		pref  = new Reflex::Window::Ref;
+		view  = nil;
+		timer = nil;
+
+		[self setDelegate: self];
+		[self setupContentView];
+		[self startTimer: 60];
+
+		return self;
+	}
+
+	- (void) dealloc
+	{
+		assert(pref && !REF);
+
+		if (view) [view release];
+
+		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) setupContentView
+	{
+		NSRect rect = [self contentRectForFrameRect: [self frame]];
+		rect.origin.x = rect.origin.y = 0;
+		view = [[OpenGLView alloc] initWithFrame: rect];
+		[self setContentView: view];
+	}
+
+	- (void) startTimer: (int) fps
+	{
+		[self stopTimer];
+
+		if (fps <= 0) return;
+
+		timer = [[NSTimer
+			timerWithTimeInterval: 1. / (double) fps
+			target: self
+			selector: @selector(update:)
+			userInfo: nil
+			repeats: YES] retain];
+		if (!timer) return;
+
+		[[NSRunLoop currentRunLoop]
+			addTimer: timer forMode: NSDefaultRunLoopMode];
+		[[NSRunLoop currentRunLoop]
+			addTimer: timer forMode: NSEventTrackingRunLoopMode];
+	}
+
+	- (void) stopTimer
+	{
+		if (!timer) return;
+
+		[timer invalidate];
+		timer = nil;
+	}
+
+	- (void) update: (NSTimer*) t
+	{
+		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);
+
+		if (REF->self->redraw)
+		{
+			[self display];
+			REF->self->redraw = false;
+		}
+	}
+
+	- (void) draw
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		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();
+		e.painter->clear();
+		REF->on_draw(&e);
+		e.painter->end();
+	}
+
+	- (BOOL) windowShouldClose: (id) sender
+	{
+		assert(pref);
+
+		if (!REF) return YES;
+
+		REF->close();
+		return NO;
+	}
+
+	- (void) windowWillClose: (NSNotification*) notification
+	{
+		[self stopTimer];
+		[self unbind: NULL];
+		[self setDelegate: nil];
+	}
+
+	- (void) windowWillMove: (NSNotification*) notification
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		REF->self->prev_position = REF->frame().position();
+	}
+
+	- (void) windowDidMove: (NSNotification*) notification
+	{
+		[self frameChanged];
+	}
+
+	- (NSSize) windowWillResize: (NSWindow*) sender toSize: (NSSize) frameSize
+	{
+		assert(pref);
+
+		if (!REF) return frameSize;
+
+		REF->self->prev_size = REF->frame().size();
+
+		return frameSize;
+	}
+
+	- (void) windowDidResize: (NSNotification*) notification
+	{
+		[self frameChanged];
+	}
+
+	- (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) keyDown: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::DOWN);
+		REF->on_key(&e);
+	}
+
+	- (void) keyUp: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::UP);
+		REF->on_key(&e);
+	}
+
+	- (void) mouseDown: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::DOWN);
+		REF->on_pointer(&e);
+	}
+
+	- (void) mouseUp: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::UP);
+		REF->on_pointer(&e);
+	}
+
+	- (void) mouseDragged: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
+		REF->on_pointer(&e);
+	}
+
+	- (void) mouseMoved: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
+		REF->on_pointer(&e);
+	}
+
+	- (void) scrollWheel: (NSEvent*) event
+	{
+		assert(pref);
+
+		if (!REF) return;
+
+		Reflex::NativeWheelEvent e(event, view);
+		REF->on_wheel(&e);
+	}
+
+	+ (NSRect) frameRectForContentRect: (NSRect) contentRect
+	{
+		return [NSWindow
+			frameRectForContentRect: contentRect
+			styleMask: WINDOW_STYLE_MASK];
+	}
+
+@end// NativeWindow

data/src/{cocoa/openglview.h → osx/opengl_view.h}

@@ -10,8 +10,4 @@
 
 	- (id) initWithFrame: (NSRect) frame antiAlias: (int) nsample;
 
-	- (void) makeCurrent;
-
-	- (void) flushBuffer;
-
 @end// OpenGLView

data/src/{cocoa/openglview.mm → osx/opengl_view.mm}

@@ -1,11 +1,11 @@
 // -*- objc -*-
-#import "openglview.h"
+#import "opengl_view.h"
 
 
 #include <vector>
 #import <Cocoa/Cocoa.h>
 #import <OpenGL/OpenGL.h>
-#import "cocoawindow.h"
+#import "native_window.h"
 
 
 //#define TRANSPARENT_BACKGROUND
@@ -36,7 +36,7 @@ make_pixelformat (int antialias_nsample = 0)
 	static const NSOpenGLPixelFormatAttribute ANTIALIAS[] =
 	{
 		NSOpenGLPFASampleBuffers, 1,
-		NSOpenGLPFASamples, antialias_nsample,
+		NSOpenGLPFASamples, (NSOpenGLPixelFormatAttribute) antialias_nsample,
 	};
 	static const size_t DEFAULT_SIZE   = sizeof(DEFAULT)   / sizeof(DEFAULT[0]);
 	static const size_t ANTIALIAS_SIZE = sizeof(ANTIALIAS) / sizeof(ANTIALIAS[0]);
@@ -63,7 +63,7 @@ make_pixelformat (int antialias_nsample = 0)
 		self = [super initWithFrame: frame pixelFormat: make_pixelformat(nsample)];
 		if (!self) return nil;
 
-		[[self openGLContext] makeCurrentContext];
+		[self activateContext];
 
 		GLint swapinterval = 1;
 		[[self openGLContext]
@@ -80,16 +80,11 @@ make_pixelformat (int antialias_nsample = 0)
 		return self;
 	}
 
-	- (void) makeCurrent
+	- (void) activateContext
 	{
 		[[self openGLContext] makeCurrentContext];
 	}
 
-	- (void) flushBuffer
-	{
-		[[NSOpenGLContext currentContext] flushBuffer];
-	}
-
 	- (BOOL) acceptsFirstResponder
 	{
 		return YES;
@@ -109,12 +104,12 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) drawRect: (NSRect) rect
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
-		[self makeCurrent];
+		[self activateContext];
 		[win draw];
-		[self flushBuffer];
+		[[NSOpenGLContext currentContext] flushBuffer];
 	}
 
 	- (void) viewDidMoveToWindow
@@ -130,14 +125,14 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) insertText: (id) str
 	{
-		NSLog(@"interText: %@", str);
+		//NSLog(@"interText: %@", str);
 	}
 
 	- (void) keyDown: (NSEvent*) event
 	{
 		[self interpretKeyEvents: [NSArray arrayWithObject: event]];
 
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
 		[win keyDown: event];
@@ -145,7 +140,7 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) keyUp: (NSEvent*) event
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
 		[win keyUp: event];
@@ -153,7 +148,7 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) mouseDown: (NSEvent*) event
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
 		[win mouseDown: event];
@@ -161,26 +156,74 @@ make_pixelformat (int antialias_nsample = 0)
 
 	- (void) mouseUp: (NSEvent*) event
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
 		[win mouseUp: event];
 	}
 
-	- (void) mouseMoved: (NSEvent*) event
+	- (void) mouseDragged: (NSEvent*) event
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
-		[win mouseMoved: event];
+		[win mouseDragged: event];
 	}
 
-	- (void) mouseDragged: (NSEvent*) event
+	- (void) rightMouseDown: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseDown: event];
+	}
+
+	- (void) rightMouseUp: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseUp: event];
+	}
+
+	- (void) rightMouseDragged: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseDragged: event];
+	}
+
+	- (void) otherMouseDown: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseDown: event];
+	}
+
+	- (void) otherMouseUp: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseUp: event];
+	}
+
+	- (void) otherMouseDragged: (NSEvent*) event
 	{
-		CocoaWindow* win = (CocoaWindow*) [self window];
+		NativeWindow* win = (NativeWindow*) [self window];
 		if (!win) return;
 
 		[win mouseDragged: event];
 	}
 
+	- (void) mouseMoved: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseMoved: event];
+	}
+
 @end// OpenGLView

data/src/osx/reflex.mm

@@ -0,0 +1,50 @@
+// -*- objc -*-
+#include "reflex/reflex.h"
+
+
+#import <Cocoa/Cocoa.h>
+#include "reflex/exception.h"
+#import "app_delegate.h"
+
+
+namespace Reflex
+{
+
+
+	namespace global
+	{
+
+		static NSAutoreleasePool* pool = nil;
+
+	}// global
+
+
+	bool
+	initialized ()
+	{
+		return global::pool;
+	}
+
+	void
+	init ()
+	{
+		if (global::pool)
+			reflex_error(__FILE__, __LINE__, "already initialized.");
+
+		global::pool = [[NSAutoreleasePool alloc] init];
+
+		[[NSApplication sharedApplication] setDelegate: [[[AppDelegate alloc] init] autorelease]];
+	}
+
+	void
+	fin ()
+	{
+		if (!global::pool)
+			reflex_error(__FILE__, __LINE__, "not initialized.");
+
+		[global::pool release];
+		global::pool = nil;
+	}
+
+
+}// Reflex