reflexion 0.1.20 → 0.1.24

data/src/event.h

@@ -0,0 +1,47 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_EVENT_H__
+#define __REFLEX_SRC_EVENT_H__
+
+
+#include <functional>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	void DrawEvent_set_view    (DrawEvent* pthis, View* view);
+
+	void DrawEvent_set_painter (DrawEvent* pthis, Painter* painter);
+
+	void DrawEvent_set_bounds  (DrawEvent* pthis, const Bounds& bounds);
+
+
+	void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
+
+
+	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_set_captured (PointerEvent* pthis, bool captured);
+
+	void PointerEvent_update_for_child_view (PointerEvent* pthis, const View* view);
+
+	void PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view);
+
+
+	void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/image_view.cpp

@@ -53,8 +53,8 @@ namespace Reflex
 	{
 		if (!self->image) return;
 
-		assert(e && e->painter);
-		Painter* p = e->painter;
+		assert(e && e->painter());
+		Painter* p = e->painter();
 
 		Color f = p->fill(), s = p->stroke();
 		p->set_fill(1);

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;
 
@@ -363,7 +376,7 @@ ReflexViewController_get_show_fun ()
 
 		if (dpos != 0 || dsize != 0)
 		{
-			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
+			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
 			if (dpos  != 0) win->on_move(&e);
 			if (dsize != 0)
 			{
@@ -371,7 +384,7 @@ ReflexViewController_get_show_fun ()
 				b.move_to(0, 0);
 
 				if (win->painter())
-					win->painter()->canvas(b, UIScreen.mainScreen.scale);
+					win->painter()->canvas(b, win->painter()->pixel_density());
 
 				if (win->root())
 					View_set_frame(win->root(), b);
@@ -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/ios/window.mm

@@ -130,6 +130,24 @@ namespace Reflex
 			rect.size.height);
 	}
 
+	void
+	Window_set_resizable (Window* window, bool state)
+	{
+		//not_implemented_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Window_is_resizable (const Window& window)
+	{
+		return false;
+	}
+
+	float
+	Window_get_pixel_density (const Window& window)
+	{
+		return UIScreen.mainScreen.scale;
+	}
+
 
 	WindowData::WindowData ()
 	{

data/src/osx/event.h

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