reflexion 0.1.22 → 0.1.23

data/src/event.cpp

@@ -1,9 +1,11 @@
-#include "reflex/event.h"
+#include "event.h"
 
 
 #include "reflex/timer.h"
 #include "reflex/shape.h"
 #include "reflex/exception.h"
+#include "view.h"
+#include "pointer.h"
 
 
 namespace Reflex
@@ -11,7 +13,7 @@ namespace Reflex
 
 
 	Event::Event ()
-	:	blocked(false)
+	:	blocked(false), time_(Xot::time())
 	{
 	}
 
@@ -27,6 +29,12 @@ namespace Reflex
 		return blocked;
 	}
 
+	double
+	Event::time () const
+	{
+		return time_;
+	}
+
 
 	UpdateEvent::UpdateEvent (double now, float dt)
 	:	now(now), dt(dt)
@@ -123,76 +131,220 @@ namespace Reflex
 
 
 	KeyEvent::KeyEvent ()
-	:	type(NONE), code(KEY_NONE), modifiers(MOD_NONE), repeat(0), capture(false)
+	:	type(NONE), code(KEY_NONE), modifiers(MOD_NONE), repeat(0), captured(false)
 	{
 	}
 
 	KeyEvent::KeyEvent (
 		Type type, const char* chars, int code, uint modifiers, int repeat)
 	:	type(type), chars(chars ? chars : ""), code(code), modifiers(modifiers),
-		repeat(repeat), capture(false)
+		repeat(repeat), captured(false)
 	{
 	}
 
 
-	PointerEvent::PointerEvent ()
-	:	type(NONE), pointer_type(POINTER_NONE),
-		size(0), modifiers(MOD_NONE), count(0), drag(false), capture(false),
-		x(0), y(0), z(0)
+	struct PointerEvent::Data
+	{
+
+		std::vector<Pointer> pointers;
+
+		bool captured;
+
+		Data (bool captured = false)
+		:	captured(captured)
+		{
+		}
+
+	};// PointerEvent::Data
+
+
+	void
+	PointerEvent_add_pointer (PointerEvent* pthis, const Pointer& pointer)
 	{
+		if (!pthis)
+			argument_error(__FILE__, __LINE__);
+
+		pthis->self->pointers.emplace_back(pointer);
 	}
 
-	PointerEvent::PointerEvent (
-		Type type, uint pointer_type, coord x, coord y, uint modifiers, uint count, bool drag)
-	:	type(type), pointer_type(pointer_type),
-		size(1), modifiers(modifiers), count(count), drag(drag), capture(false),
-		x(x), y(y), z(0)
+	void
+	PointerEvent_erase_pointer (PointerEvent* pthis, Pointer::ID id)
 	{
+		if (!pthis)
+			argument_error(__FILE__, __LINE__);
+
+		auto& pointers = pthis->self->pointers;
+		auto it = std::find_if(
+			pointers.begin(), pointers.end(),
+			[=](const auto& pointer)
+			{
+				return pointer.id() == id;
+			});
+
+		if (it == pointers.end()) return;
+
+		pointers.erase(it);
 	}
 
-	PointerEvent::PointerEvent (
-		Type type, uint pointer_type, const Point* positions_, size_t size,
-		uint modifiers, uint count, bool drag)
-	:	type(type), pointer_type(pointer_type),
-		size(size), modifiers(modifiers), count(count), drag(drag), capture(false)
+	Pointer&
+	PointerEvent_pointer_at (PointerEvent* pthis, size_t index)
 	{
-		if (!positions_ && size > 0)
+		if (!pthis)
 			argument_error(__FILE__, __LINE__);
 
-		if (size > MAX) size = MAX;
+		auto& pointers = pthis->self->pointers;
+		if (index >= pointers.size())
+			index_error(__FILE__, __LINE__);
 
-		if (positions_)
+		return pointers[index];
+	}
+
+	void
+	PointerEvent_each_pointer (
+		const PointerEvent* pthis, std::function<void(const Pointer&)> fun)
+	{
+		if (!pthis)
+			argument_error(__FILE__, __LINE__);
+
+		for (const auto& pointer : pthis->self->pointers)
+			fun(pointer);
+	}
+
+	static void
+	filter_and_offset_pointer_positions (PointerEvent* event, const Bounds& frame)
+	{
+		assert(event);
+
+		const Point& offset = frame.position();
+
+		std::vector<Pointer> pointers;
+		for (const auto& pointer : event->self->pointers)
 		{
-			for (size_t i = 0; i < size; ++i)
-				positions[i] = *(Coord3*) &positions_[i];
+			if (!frame.is_include(pointer.position()))
+				continue;
+
+			pointers.emplace_back(pointer);
+			Pointer_update_positions(&pointers.back(), [&](Point* pos)
+			{
+				*pos -= offset;
+			});
 		}
+
+		event->self->pointers = pointers;
 	}
 
-	Point&
-	PointerEvent::position (size_t i)
+	static void
+	scroll_and_zoom_pointer_positions (
+		PointerEvent* event, const Point& scroll, float zoom)
 	{
-		if (i >= size)
-			index_error(__FILE__, __LINE__);
+		assert(event);
+
+		if (zoom == 0)
+			argument_error(__FILE__, __LINE__);
+
+		if (scroll == 0 && zoom == 1)
+			return;
 
-		return *(Point*) &positions[i];
+		for (auto& pointer : event->self->pointers)
+		{
+			Pointer_update_positions(&pointer, [=](Point* pos)
+			{
+				*pos -= scroll;
+				*pos /= zoom;
+			});
+		}
 	}
 
-	const Point&
-	PointerEvent::position (size_t i) const
+	void
+	PointerEvent_update_for_child_view (PointerEvent* pthis, const View* view)
 	{
-		return const_cast<PointerEvent*>(this)->position(i);
+		if (!pthis || !view)
+			argument_error(__FILE__, __LINE__);
+
+		filter_and_offset_pointer_positions(pthis, view->frame());
+		scroll_and_zoom_pointer_positions(pthis, view->scroll(), view->zoom());
 	}
 
-	Point&
-	PointerEvent::operator [] (size_t i)
+	void
+	PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view)
 	{
-		return position(i);
+		if (!pthis || !view)
+			argument_error(__FILE__, __LINE__);
+
+		for (auto& pointer : pthis->self->pointers)
+		{
+			Pointer_update_positions(&pointer, [=](Point* pos)
+			{
+				*pos = view->from_window(*pos);
+			});
+		}
+
+		scroll_and_zoom_pointer_positions(pthis, view->scroll(), view->zoom());
 	}
 
-	const Point&
-	PointerEvent::operator [] (size_t i) const
+
+	PointerEvent::PointerEvent (bool captured)
+	:	self(new Data(captured))
+	{
+	}
+
+	PointerEvent::PointerEvent (const Pointer& pointer, bool captured)
+	:	self(new Data(captured))
+	{
+		self->pointers.emplace_back(pointer);
+	}
+
+	PointerEvent::PointerEvent (const Pointer* pointers, size_t size, bool captured)
+	:	self(new Data(captured))
+	{
+		for (size_t i = 0; i < size; ++i)
+			self->pointers.emplace_back(pointers[i]);
+	}
+
+	PointerEvent::PointerEvent (const This& obj)
+	:	self(new Data(*obj.self))
+	{
+	}
+
+	PointerEvent&
+	PointerEvent::operator = (const This& obj)
+	{
+		if (&obj == this) return *this;
+
+		Event::operator=(obj);
+		*self = *obj.self;
+		return *this;
+	}
+
+	PointerEvent::~PointerEvent ()
 	{
-		return position(i);
+	}
+
+	size_t
+	PointerEvent::size () const
+	{
+		return self->pointers.size();
+	}
+
+	bool
+	PointerEvent::empty () const
+	{
+		return size() == 0;
+	}
+
+	bool
+	PointerEvent::is_captured () const
+	{
+		return self->captured;
+	}
+
+	const Pointer&
+	PointerEvent::operator [] (size_t index) const
+	{
+		if (index >= self->pointers.size())
+			index_error(__FILE__, __LINE__);
+
+		return self->pointers[index];
 	}
 
 

data/src/event.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_EVENT_H__
+#define __REFLEX_SRC_EVENT_H__
+
+
+#include <functional>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	void PointerEvent_add_pointer    (PointerEvent* pthis, const Pointer& pointer);
+
+	void PointerEvent_erase_pointer  (PointerEvent* pthis, Pointer::ID id);
+
+	Pointer& PointerEvent_pointer_at (PointerEvent* pthis, size_t index);
+
+	void PointerEvent_each_pointer (
+		const PointerEvent* pthis, std::function<void(const Pointer&)> fun);
+
+	void PointerEvent_update_for_child_view (PointerEvent* pthis, const View* view);
+
+	void PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/ios/event.h

@@ -4,18 +4,30 @@
 #define __REFLEX_SRC_IOS_EVENT_H__
 
 
+#include <list>
 #import <UIKit/UIEvent.h>
-#include <reflex/event.h>
+#include "../event.h"
 
 
 namespace Reflex
 {
 
 
-	struct NativePointerEvent : public PointerEvent
+	typedef std::list<Pointer> PrevPointerList;
+
+
+	class NativePointerEvent : public PointerEvent
 	{
 
-		NativePointerEvent (NSSet* touches, UIEvent* event, UIView* view, Type type);
+		public:
+
+			NativePointerEvent (
+				NSSet* touches, UIEvent* event, UIView* view,
+				Pointer::ID* pointer_id);
+
+			NativePointerEvent (
+				NSSet* touches, UIEvent* event, UIView* view,
+				PrevPointerList* prev_pointers);
 
 	};// NativePointerEvent
 

data/src/ios/event.mm

@@ -3,30 +3,145 @@
 
 
 #include <assert.h>
+#include <algorithm>
+#include "../pointer.h"
 
 
 namespace Reflex
 {
 
 
-	static CGPoint
-	correct_point (UIView* view, UITouch* touch)
+	static uint
+	get_type (UITouch* touch)
 	{
-		assert(view && touch);
-		return [touch locationInView: view];
+		assert(touch);
+
+		NSInteger type = 0;
+		if (@available(iOS 9.0, *)) type = touch.type;
+
+		switch (type)
+		{
+			case UITouchTypeDirect: return Pointer::TOUCH;
+			case UITouchTypePencil: return Pointer::PEN;
+			default:                return Pointer::TYPE_NONE;
+		}
+	}
+
+	static Pointer::Action
+	get_action (UITouch* touch)
+	{
+		assert(touch);
+
+		switch (touch.phase)
+		{
+			case UITouchPhaseBegan:         return Pointer::DOWN;
+			case UITouchPhaseEnded:         return Pointer::UP;
+			case UITouchPhaseMoved:         return Pointer::MOVE;
+			case UITouchPhaseStationary:    return Pointer::STAY;
+			case UITouchPhaseCancelled:     return Pointer::CANCEL;
+			//case UITouchPhaseRegionEntered: return Pointer::MOVE;
+			//case UITouchPhaseRegionExited:  return Pointer::MOVE;
+			//case UITouchPhaseRegionMoved:   return Pointer::MOVE;
+			default:                        return Pointer::ACTION_NONE;
+		}
+	}
+
+	static Point
+	to_point (const CGPoint& point)
+	{
+		return Point(point.x, point.y);
+	}
+
+	static uint
+	get_modifiers (const UIEvent* event)
+	{
+		assert(event);
+
+		NSInteger flags = 0;
+		if (@available(iOS 13.4, *)) flags = event.modifierFlags;
+
+		return
+			(flags & UIKeyModifierAlphaShift) ? MOD_CAPS    : 0 |
+			(flags & UIKeyModifierShift)      ? MOD_SHIFT   : 0 |
+			(flags & UIKeyModifierControl)    ? MOD_CONTROL : 0 |
+			(flags & UIKeyModifierAlternate)  ? MOD_ALT     : 0 |
+			(flags & UIKeyModifierCommand)    ? MOD_COMMAND : 0 |
+			(flags & UIKeyModifierNumericPad) ? MOD_NUMPAD  : 0;
+	}
+
+	static void
+	attach_prev_pointer (
+		Pointer* pointer, PrevPointerList* prev_pointers, const Point& prev_position)
+	{
+		assert(pointer && prev_pointers);
+
+		auto it = std::find_if(
+			prev_pointers->begin(), prev_pointers->end(),
+			[&](const Reflex::Pointer& p) {return p.position() == prev_position;});
+
+		if (it != prev_pointers->end())
+		{
+			Reflex::Pointer_set_prev(pointer, &*it);
+			prev_pointers->erase(it);
+		}
+		else if (prev_pointers->size() == 1)
+		{
+			Reflex::Pointer_set_prev(pointer, &prev_pointers->front());
+			prev_pointers->clear();
+		}
+		else
+			Reflex::Pointer_set_prev(pointer, NULL);
+
+		if (pointer->prev())
+			Reflex::Pointer_set_id(pointer, pointer->prev()->id());
 	}
 
+	static Pointer
+	create_pointer (
+		UITouch* touch, UIEvent* event, UIView* view, double time,
+		Pointer::ID pointer_id, PrevPointerList* prev_pointers)
+	{
+		Reflex::Pointer::Action action = get_action(touch);
+		Reflex::Pointer pointer(
+			pointer_id,
+			get_type(touch),
+			action,
+			to_point([touch locationInView: view]),
+			get_modifiers(event),
+			(uint) touch.tapCount,
+			action == Pointer::MOVE,
+			time);
+
+		if (prev_pointers)
+		{
+			attach_prev_pointer(
+				&pointer, prev_pointers,
+				to_point([touch previousLocationInView: view]));
+		}
+
+		return pointer;
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		NSSet* touches, UIEvent* event, UIView* view,
+		Pointer::ID* pointer_id)
+	{
+		for (UITouch* touch in touches)
+		{
+			PointerEvent_add_pointer(
+				this, create_pointer(touch, event, view, time(), ++*pointer_id, NULL));
+		}
+	}
 
 	NativePointerEvent::NativePointerEvent (
-		NSSet* touches, UIEvent* e, UIView* view, Type type)
-	:	PointerEvent(type, POINTER_TOUCH, (coord) 0, (coord) 0, 0, 1, type == MOVE)
+		NSSet* touches, UIEvent* event, UIView* view,
+		PrevPointerList* prev_pointers)
 	{
-		int index = 0;
-		for (UITouch* touch in touches) {
-			CGPoint p = correct_point(view, touch);
-			positions[index++].reset(p.x, p.y);
+		for (UITouch* touch in touches)
+		{
+			PointerEvent_add_pointer(
+				this, create_pointer(touch, event, view, time(), 0, prev_pointers));
 		}
-		size = index;
 	}
 
 

data/src/ios/view_controller.mm

@@ -3,9 +3,9 @@
 
 
 #include <rays/opengl.h>
-#include <rays/exception.h>
 #include "reflex/exception.h"
 #include "../view.h"
+#include "../pointer.h"
 #include "event.h"
 #include "window.h"
 
@@ -14,7 +14,7 @@
 
 
 static ReflexViewController*
-createReflexViewController ()
+create_reflex_view_controller ()
 {
 	return [[ReflexViewController alloc] init];
 }
@@ -52,7 +52,7 @@ get_top_view_controller (UIViewController* vc)
 }
 
 static void
-showReflexViewController (
+show_reflex_view_controller (
 	UIViewController* root_vc, ReflexViewController* reflex_vc)
 {
 	UIViewController* top = get_top_view_controller(root_vc);
@@ -90,13 +90,13 @@ ReflexViewController_set_show_fun (ReflexViewController_ShowFun fun)
 ReflexViewController_CreateFun
 ReflexViewController_get_create_fun ()
 {
-	return global::create_fun ? global::create_fun : createReflexViewController;
+	return global::create_fun ? global::create_fun : create_reflex_view_controller;
 }
 
 ReflexViewController_ShowFun
 ReflexViewController_get_show_fun ()
 {
-	return global::show_fun ? global::show_fun : showReflexViewController;
+	return global::show_fun ? global::show_fun : show_reflex_view_controller;
 }
 
 
@@ -131,6 +131,10 @@ ReflexViewController_get_show_fun ()
 
 	{
 		Reflex::Window *pwindow, *ptr_for_rebind;
+		int update_count;
+		int touching_count;
+		Reflex::Pointer::ID pointer_id;
+		Reflex::PrevPointerList prev_pointers;
 	}
 
 	- (id) init
@@ -138,7 +142,11 @@ ReflexViewController_get_show_fun ()
 		self = [super init];
 		if (!self) return nil;
 
-		pwindow = ptr_for_rebind = NULL;
+		pwindow        =
+		ptr_for_rebind = NULL;
+		update_count   = 0;
+		touching_count = 0;
+		pointer_id     = 0;
 
 		return self;
 	}
@@ -312,6 +320,8 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
+		++update_count;
+
 		double now = Xot::time();
 		Reflex::UpdateEvent e(now, now - win->self->prev_time_update);
 		win->self->prev_time_update = now;
@@ -332,6 +342,9 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
+		if (update_count == 0)
+			[self update];
+
 		EAGLContext* context = self.reflexView.context;
 		if (!context) return;
 
@@ -386,9 +399,12 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(
-			touches, event, self.reflexView, Reflex::PointerEvent::DOWN);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(touches, event, self.reflexView, &pointer_id);
+		[self addToPrevPointers: e];
+
+		touching_count += e.size();
+
+		Window_call_pointer_event(win, &e);
 	}
 
 	- (void) touchesEnded: (NSSet*) touches withEvent: (UIEvent*) event
@@ -396,19 +412,20 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(
-			touches, event, self.reflexView, Reflex::PointerEvent::UP);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(touches, event, self.reflexView, &prev_pointers);
+
+		touching_count -= e.size();
+		if (touching_count == 0)
+			prev_pointers.clear();
+		else if (touching_count < 0)
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		Window_call_pointer_event(win, &e);
 	}
 
 	- (void) touchesCancelled: (NSSet*) touches withEvent: (UIEvent*) event
 	{
-		Reflex::Window* win = self.window;
-		if (!win) return;
-
-		Reflex::NativePointerEvent e(
-			touches, event, self.reflexView, Reflex::PointerEvent::UP);
-		win->on_pointer(&e);
+		[self touchesEnded: touches withEvent: event];
 	}
 
 	- (void) touchesMoved: (NSSet*) touches withEvent: (UIEvent*) event
@@ -416,9 +433,20 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(
-			touches, event, self.reflexView, Reflex::PointerEvent::MOVE);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(touches, event, self.reflexView, &prev_pointers);
+		[self addToPrevPointers: e];
+
+		Window_call_pointer_event(win, &e);
+	}
+
+	- (void) addToPrevPointers: (const Reflex::PointerEvent&) event
+	{
+		size_t size = event.size();
+		for (size_t i = 0; i < size; ++i)
+		{
+			prev_pointers.emplace_back(event[i]);
+			Reflex::Pointer_set_prev(&prev_pointers.back(), NULL);
+		}
 	}
 
 @end// ReflexViewController

data/src/osx/event.h

@@ -5,7 +5,7 @@
 
 
 #import <AppKit/NSEvent.h>
-#include <reflex/event.h>
+#include "../event.h"
 
 
 namespace Reflex
@@ -28,10 +28,13 @@ namespace Reflex
 	};// NativeFlagKeyEvent
 
 
-	struct NativePointerEvent : public PointerEvent
+	class NativePointerEvent : public PointerEvent
 	{
 
-		NativePointerEvent (NSEvent* event, NSView* view, Type type);
+		public:
+
+			NativePointerEvent (
+				NSEvent* event, NSView* view, Pointer::ID id, Pointer::Action action);
 
 	};// NativePointerEvent