reflexion 0.1.19 → 0.1.23

data/lib/reflexion.rb

@@ -18,7 +18,7 @@ module Reflexion
   }
 
 
-  def call_event (event, *args, &block)
+  def call_event(event, *args, &block)
     $event = event
     Xot::BlockUtil.instance_eval_or_block_call *args, &block if block
     $event = nil
@@ -27,7 +27,7 @@ module Reflexion
 
   class App < Application
 
-    def on_motion (e)
+    def on_motion(e)
       super
       call_event e, e, &$motion
     end
@@ -39,29 +39,29 @@ module Reflexion
 
     attr_reader :event
 
-    def initialize (*args, &block)
+    def initialize(*args, &block)
       super
       $window = self
       call_event nil, self, &$setup
     end
 
-    def on_update (e)
+    def on_update(e)
       super
       redraw
       call_event e, e, &$update
     end
 
-    def on_draw (e)
+    def on_draw(e)
       super
       call_event e, e.painter, &$draw
     end
 
-    def on_key (e)
+    def on_key(e)
       super
       call_event e, e, &$key
     end
 
-    def on_pointer (e)
+    def on_pointer(e)
       super
       call_event e, e, &$pointer
     end
@@ -71,43 +71,43 @@ module Reflexion
 
   module_function
 
-  def window ()
+  def window()
     $window ||= MainWindow.new DEFAULTS
   end
 
-  def event ()
+  def event()
     $event
   end
 
-  def setup (&block)
+  def setup(&block)
     $setup = block
   end
 
-  def update (&block)
+  def update(&block)
     $update = block
   end
 
-  def draw (&block)
+  def draw(&block)
     $draw = block
   end
 
-  def key (&block)
+  def key(&block)
     $key = block
   end
 
-  def pointer (&block)
+  def pointer(&block)
     $pointer = block
   end
 
-  def motion (&block)
+  def motion(&block)
     $motion = block
   end
 
-  def start ()
+  def start()
     App.new {window.show}.start
   end
 
-  def quit ()
+  def quit()
     window.close
   end
 

data/reflex.gemspec

@@ -26,12 +26,12 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/xord/reflex"
 
   s.platform              = Gem::Platform::RUBY
-  s.required_ruby_version = '~> 2'
+  s.required_ruby_version = '>= 2.6.0'
 
-  s.add_runtime_dependency 'xot',   '~> 0.1.19'
-  s.add_runtime_dependency 'rucy',  '~> 0.1.18'
-  s.add_runtime_dependency 'beeps', '~> 0.1.18'
-  s.add_runtime_dependency 'rays',  '~> 0.1.19'
+  s.add_runtime_dependency 'xot',   '~> 0.1.23'
+  s.add_runtime_dependency 'rucy',  '~> 0.1.23'
+  s.add_runtime_dependency 'beeps', '~> 0.1.23'
+  s.add_runtime_dependency 'rays',  '~> 0.1.23'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/samples/reflexion/noise.rb

@@ -12,7 +12,7 @@ y = 0
 
 draw do
   stroke :white
-  lines *(0..200).map {|x|
+  line *(0..200).map {|x|
     xx = x * 5
     yy = 200 + Rays.perlin(x / 10.0, y / 100.0) * 100
     [xx, yy]

data/samples/tree.rb

@@ -48,7 +48,7 @@ class W < Reflex::Window
   end
 
   def on_pointer_move (e)
-    $scroll = [-e.x.floor, -e.y.floor]
+    $scroll = [e.x.floor, e.y.floor]
   end
 
 end# W

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;
 	}