reflexion 0.1.1

data/src/cocoa/defs.mm

@@ -0,0 +1,84 @@
+#include "defs.h"
+
+
+#import <Cocoa/Cocoa.h>
+
+
+namespace Reflex
+{
+
+
+	static const char*
+	get_chars (NSEvent* e)
+	{
+		NSString* chars = [e characters];//charactersIgnoringModifiers];
+		return [chars UTF8String];
+	}
+
+	static uint
+	get_current_point_type ()
+	{
+		NSUInteger buttons = [NSEvent pressedMouseButtons];
+		uint ret = 0;
+		if (buttons &  (1 << 0)) ret |= POINT_MOUSE_LEFT;
+		if (buttons &  (1 << 1)) ret |= POINT_MOUSE_RIGHT;
+		if (buttons >= (1 << 2)) ret |= POINT_MOUSE_MIDDLE;
+		return ret;
+	}
+
+	static uint
+	get_point_type (NSEvent* e)
+	{
+		switch ([e type])
+		{
+			case NSLeftMouseDown:
+			case NSLeftMouseUp:
+			case NSLeftMouseDragged:
+				return POINT_MOUSE_LEFT;
+
+			case NSRightMouseDown:
+			case NSRightMouseUp:
+			case NSRightMouseDragged:
+				return POINT_MOUSE_RIGHT;
+
+			case NSMouseMoved:
+				return get_current_point_type();
+		}
+		return 0;
+	}
+
+	static uint
+	get_modifiers (NSEvent* e)
+	{
+		NSUInteger flags = [e modifierFlags];
+		return
+			(flags & NSAlphaShiftKeyMask) ? MOD_CAPS     : 0 |
+			(flags & NSShiftKeyMask)      ? MOD_SHIFT    : 0 |
+			(flags & NSControlKeyMask)    ? MOD_CONTROL  : 0 |
+			(flags & NSAlternateKeyMask)  ? MOD_ALT      : 0 |
+			(flags & NSCommandKeyMask)    ? MOD_COMMAND  : 0 |
+			(flags & NSNumericPadKeyMask) ? MOD_NUMPAD   : 0 |
+			(flags & NSHelpKeyMask)       ? MOD_HELP     : 0 |
+			(flags & NSFunctionKeyMask)   ? MOD_FUNCTION : 0;
+	}
+
+
+	CocoaKey::CocoaKey (NSEvent* e)
+	:	Key(get_chars(e), [e keyCode], get_modifiers(e), [e isARepeat] ? 1 : 0)
+	{
+	}
+
+
+	CocoaPoints::CocoaPoints (NSEvent* e, NSView* view)
+	:	Points(
+			get_point_type(e), (coord) 0, (coord) 0, get_modifiers(e), [e clickCount],
+			[e type] == NSLeftMouseDragged || [e type] == NSRightMouseDragged)
+	{
+		NSPoint p = [e locationInWindow];
+		if (view) p = [view convertPoint: p fromView: nil];
+		x = p.x;
+		y = p.y;
+	}
+
+
+};// Reflex

data/src/cocoa/openglview.h

@@ -0,0 +1,17 @@
+// -*- objc -*-
+#import <AppKit/NSOpenGLView.h>
+
+
+@interface OpenGLView : NSOpenGLView
+
+	{}
+
+	- (id) initWithFrame: (NSRect) frame;
+
+	- (id) initWithFrame: (NSRect) frame antiAlias: (int) nsample;
+
+	- (void) makeCurrent;
+
+	- (void) flushBuffer;
+
+@end// OpenGLView

data/src/cocoa/openglview.mm

@@ -0,0 +1,186 @@
+// -*- objc -*-
+#import "openglview.h"
+
+
+#include <vector>
+#import <Cocoa/Cocoa.h>
+#import <OpenGL/OpenGL.h>
+#import "cocoawindow.h"
+
+
+//#define TRANSPARENT_BACKGROUND
+
+
+static bool
+is_valid_antialias_nsample (int n)
+{
+	return n == 0 || n == 2 || n == 4 || n == 6 || n == 8 || n == 16 || n == 32;
+}
+
+static NSOpenGLPixelFormat*
+make_pixelformat (int antialias_nsample = 0)
+{
+	if (!is_valid_antialias_nsample(antialias_nsample))
+		return nil;
+
+	static const NSOpenGLPixelFormatAttribute DEFAULT[] =
+	{
+		NSOpenGLPFAWindow,
+		//NSOpenGLPFAAccelerated,
+		NSOpenGLPFADoubleBuffer,
+		//NSOpenGLPFAColorSize, 24,
+		//NSOpenGLPFAAlphaSize, 8,
+		NSOpenGLPFADepthSize, 24,
+		//NSOpenGLPFANoRecovery,
+	};
+	static const NSOpenGLPixelFormatAttribute ANTIALIAS[] =
+	{
+		NSOpenGLPFASampleBuffers, 1,
+		NSOpenGLPFASamples, antialias_nsample,
+	};
+	static const size_t DEFAULT_SIZE   = sizeof(DEFAULT)   / sizeof(DEFAULT[0]);
+	static const size_t ANTIALIAS_SIZE = sizeof(ANTIALIAS) / sizeof(ANTIALIAS[0]);
+
+	std::vector<NSOpenGLPixelFormatAttribute> attr(
+		DEFAULT, DEFAULT + DEFAULT_SIZE);
+	if (antialias_nsample > 0)
+		attr.insert(attr.end(), ANTIALIAS, ANTIALIAS + ANTIALIAS_SIZE);
+	attr.push_back(0);
+
+	return [[[NSOpenGLPixelFormat alloc] initWithAttributes: &attr[0]] autorelease];
+}
+
+
+@implementation OpenGLView
+
+	- (id) initWithFrame: (NSRect) frame
+	{
+		return [self initWithFrame: frame antiAlias: 0];
+	}
+
+	- (id) initWithFrame: (NSRect) frame antiAlias: (int) nsample
+	{
+		self = [super initWithFrame: frame pixelFormat: make_pixelformat(nsample)];
+		if (!self) return nil;
+
+		[[self openGLContext] makeCurrentContext];
+
+		GLint swapinterval = 1;
+		[[self openGLContext]
+			setValues: &swapinterval
+			forParameter: NSOpenGLCPSwapInterval];
+
+#ifdef TRANSPARENT_BACKGROUND
+		GLint opacity = 0;
+		[[self openGLContext]
+			setValues: &opacity
+			forParameter: NSOpenGLCPSurfaceOpacity];
+#endif
+
+		return self;
+	}
+
+	- (void) makeCurrent
+	{
+		[[self openGLContext] makeCurrentContext];
+	}
+
+	- (void) flushBuffer
+	{
+		[[NSOpenGLContext currentContext] flushBuffer];
+	}
+
+	- (BOOL) acceptsFirstResponder
+	{
+		return YES;
+	}
+
+	- (BOOL) acceptsFirstMouse: (NSEvent*) event
+	{
+		return YES;
+	}
+
+#ifdef TRANSPARENT_BACKGROUND
+	- (BOOL) isOpaque
+	{
+		return YES;
+	}
+#endif
+
+	- (void) drawRect: (NSRect) rect
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[self makeCurrent];
+		[win draw];
+		[self flushBuffer];
+	}
+
+	- (void) viewDidMoveToWindow
+	{
+		[[self window] setAcceptsMouseMovedEvents: YES];
+		[[self window] makeFirstResponder: self];
+
+#ifdef TRANSPARENT_BACKGROUND
+		[[self window] setBackgroundColor: [NSColor clearColor]];
+		[[self window] setOpaque: NO];
+#endif
+	}
+
+	- (void) insertText: (id) str
+	{
+		NSLog(@"interText: %@", str);
+	}
+
+	- (void) keyDown: (NSEvent*) event
+	{
+		[self interpretKeyEvents: [NSArray arrayWithObject: event]];
+
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win keyDown: event];
+	}
+
+	- (void) keyUp: (NSEvent*) event
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win keyUp: event];
+	}
+
+	- (void) mouseDown: (NSEvent*) event
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win mouseDown: event];
+	}
+
+	- (void) mouseUp: (NSEvent*) event
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win mouseUp: event];
+	}
+
+	- (void) mouseMoved: (NSEvent*) event
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win mouseMoved: event];
+	}
+
+	- (void) mouseDragged: (NSEvent*) event
+	{
+		CocoaWindow* win = (CocoaWindow*) [self window];
+		if (!win) return;
+
+		[win mouseDragged: event];
+	}
+
+@end// OpenGLView

data/src/cocoa/reflex.mm

@@ -0,0 +1,68 @@
+// -*- objc -*-
+#include "reflex/reflex.h"
+
+
+#import <Cocoa/Cocoa.h>
+#import "cocoaapplication.h"
+
+
+namespace Reflex
+{
+
+
+	namespace global
+	{
+
+		static NSAutoreleasePool* pool = nil;
+
+	}// global
+
+
+	bool
+	init ()
+	{
+		if (global::pool) return false;
+
+		global::pool = [[NSAutoreleasePool alloc] init];
+
+		[CocoaApplication sharedApplication];
+
+		return true;
+	}
+
+	bool
+	fin ()
+	{
+		if (!global::pool) return false;
+
+		[global::pool release];
+		global::pool = nil;
+
+		return true;
+	}
+
+	bool
+	run (const char* name)
+	{
+		if (!global::pool || !NSApp) return false;
+
+		Application app;
+		if (!app) return false;
+
+		if (name && !app.set_name(name))
+			return false;
+
+		return app.run();
+	}
+
+	bool
+	quit ()
+	{
+		if (!global::pool || !NSApp) return false;
+
+		[NSApp terminate: nil];
+		return true;
+	}
+
+
+}// Reflex

data/src/cocoa/window.mm

@@ -0,0 +1,118 @@
+// -*- objc -*-
+#include "reflex/window.h"
+
+
+#import <Cocoa/Cocoa.h>
+#include "windowdata.h"
+#import "cocoawindow.h"
+
+
+namespace Reflex
+{
+
+
+	Window::Window ()
+	{
+		self->this_ = this;
+		self->self_ = [[CocoaWindow alloc] initWithWindowData: self];
+	}
+
+	Window::~Window ()
+	{
+		if (self->self_)
+		{
+			[self->self_ release];
+			self->self_ = nil;
+		}
+		self->this_ = NULL;
+	}
+
+	bool
+	Window::close ()
+	{
+		if (!*this) return false;
+		[self->self_ close];
+		return true;
+	}
+
+	bool
+	Window::show ()
+	{
+		if (!*this) return false;
+		if (--self->hidecount == 0)
+		{
+			[self->self_ makeKeyAndOrderFront: nil];
+		}
+		return true;
+	}
+
+	bool
+	Window::hide ()
+	{
+		if (!*this) return false;
+		if (++self->hidecount == 1)
+			[self->self_ orderOut: self->self_];
+		return true;
+	}
+
+	bool
+	Window::hidden () const
+	{
+		if (!*this) return false;
+		return self->hidecount > 0;
+	}
+
+	bool
+	Window::redraw ()
+	{
+		if (!*this) return false;
+		[self->self_ redraw];
+		return true;
+	}
+
+	bool
+	Window::get_title (String* title) const
+	{
+		if (!*this || !title) return false;
+		NSString* s = [self->self_ title];
+		*title = s ? [s UTF8String] : "";
+		return true;
+	}
+
+	bool
+	Window::set_title (const char* title)
+	{
+		if (!*this || !title) return false;
+		[self->self_ setTitle: [NSString stringWithUTF8String: title]];
+		return true;
+	}
+
+	bool
+	Window::get_bounds (coord* x, coord* y, coord* width, coord* height)
+	{
+		if (!*this || (!x && !y && !width && !height))
+			return false;
+		NSRect frame = [self->self_ frame];
+		if (x)      *x      = frame.origin.x;
+		if (y)      *y      = frame.origin.y;
+		if (width)  *width  = frame.size.width;
+		if (height) *height = frame.size.height;
+		return true;
+	}
+
+	bool
+	Window::set_bounds (coord x, coord y, coord width, coord height)
+	{
+		if (!*this) return false;
+		NSRect frame = NSMakeRect(x, y, width, height);
+		[self->self_ setFrame: frame display: NO animate: NO];
+		return true;
+	}
+
+	Window::operator bool () const
+	{
+		return self && *self;
+	}
+
+
+}// Reflex

data/src/cocoa/windowdata.h

@@ -0,0 +1,51 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_COCOA_WINDOWDATA_H__
+#define __REFLEX_COCOA_WINDOWDATA_H__
+
+
+#include <boost/shared_ptr.hpp>
+#include <reflex/window.h>
+
+
+@class CocoaWindow;
+
+
+namespace Reflex
+{
+
+
+	struct Window::Data
+	{
+
+		Window* this_;
+
+		CocoaWindow* self_;
+
+		int hidecount;
+
+		Data ()
+		:	this_(NULL), self_(nil), hidecount(1)
+		{
+		}
+
+		operator bool () const
+		{
+			return this_ && self_;
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+	};// Window::Data
+
+
+	typedef boost::shared_ptr<Reflex::Window::Data> WindowData;
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/defs.cpp

@@ -0,0 +1,47 @@
+#include "reflex/defs.h"
+
+
+namespace Reflex
+{
+
+
+	Key::Key ()
+	:	code(KEY_NONE), repeat(0), modifiers(MOD_NONE)
+	{
+	}
+
+	Key::Key (const char* chars, int code, uint modifiers, int repeat)
+	:	chars(chars), code(code), repeat(repeat), modifiers(modifiers)
+	{
+	}
+
+
+	Points::Points ()
+	:	type(POINT_NONE), size(0), modifiers(MOD_NONE), count(0), drag(false),
+		x(0), y(0)
+	{
+	}
+
+	Points::Points (
+		int type, coord x_, coord y_, uint modifiers, uint count, bool drag)
+	:	type(type), size(1), modifiers(modifiers), count(count), drag(drag),
+		x(x_), y(y_)
+	{
+	}
+
+	Points::Points (
+		int type, const Point* points_, size_t size_,
+		uint modifiers, uint count, bool drag)
+	:	type(type), size(size), modifiers(modifiers), count(count), drag(drag)
+	{
+		if (size > MAX) size = MAX;
+
+		if (points_)
+		{
+			for (size_t i = 0; i < size; ++i)
+				points[i] = points_[i];
+		}
+	}
+
+
+};// Reflex