reflexion 0.1.21 → 0.1.22

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

@@ -28,10 +28,10 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '~> 2'
 
-  s.add_runtime_dependency 'xot',   '~> 0.1.21'
-  s.add_runtime_dependency 'rucy',  '~> 0.1.21'
-  s.add_runtime_dependency 'beeps', '~> 0.1.21'
-  s.add_runtime_dependency 'rays',  '~> 0.1.21'
+  s.add_runtime_dependency 'xot',   '~> 0.1.22'
+  s.add_runtime_dependency 'rucy',  '~> 0.1.22'
+  s.add_runtime_dependency 'beeps', '~> 0.1.22'
+  s.add_runtime_dependency 'rays',  '~> 0.1.22'
 
   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/ios/window.mm

@@ -133,7 +133,7 @@ namespace Reflex
 	void
 	Window_set_resizable (Window* window, bool state)
 	{
-		not_implemented_error(__FILE__, __LINE__);
+		//not_implemented_error(__FILE__, __LINE__);
 	}
 
 	bool

data/src/osx/event.h

@@ -20,6 +20,14 @@ namespace Reflex
 	};// NativeKeyEvent
 
 
+	struct NativeFlagKeyEvent : public KeyEvent
+	{
+
+		NativeFlagKeyEvent (NSEvent* event);
+
+	};// NativeFlagKeyEvent
+
+
 	struct NativePointerEvent : public PointerEvent
 	{
 

data/src/osx/event.mm

@@ -3,6 +3,7 @@
 
 
 #include <assert.h>
+#include <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
 
 
@@ -17,6 +18,168 @@ namespace Reflex
 		return [chars UTF8String];
 	}
 
+	static KeyCode
+	get_code (UInt16 code)
+	{
+		switch (code)
+		{
+			case kVK_ANSI_A:              return KEY_A;
+			case kVK_ANSI_S:              return KEY_S;
+			case kVK_ANSI_D:              return KEY_D;
+			case kVK_ANSI_F:              return KEY_F;
+			case kVK_ANSI_H:              return KEY_H;
+			case kVK_ANSI_G:              return KEY_G;
+			case kVK_ANSI_Z:              return KEY_Z;
+			case kVK_ANSI_X:              return KEY_X;
+			case kVK_ANSI_C:              return KEY_C;
+			case kVK_ANSI_V:              return KEY_V;
+			case kVK_ANSI_B:              return KEY_B;
+			case kVK_ANSI_Q:              return KEY_Q;
+			case kVK_ANSI_W:              return KEY_W;
+			case kVK_ANSI_E:              return KEY_E;
+			case kVK_ANSI_R:              return KEY_R;
+			case kVK_ANSI_Y:              return KEY_Y;
+			case kVK_ANSI_T:              return KEY_T;
+			case kVK_ANSI_1:              return KEY_1;
+			case kVK_ANSI_2:              return KEY_2;
+			case kVK_ANSI_3:              return KEY_3;
+			case kVK_ANSI_4:              return KEY_4;
+			case kVK_ANSI_6:              return KEY_6;
+			case kVK_ANSI_5:              return KEY_5;
+			case kVK_ANSI_Equal:          return KEY_EQUAL;
+			case kVK_ANSI_9:              return KEY_9;
+			case kVK_ANSI_7:              return KEY_7;
+			case kVK_ANSI_Minus:          return KEY_MINUS;
+			case kVK_ANSI_8:              return KEY_8;
+			case kVK_ANSI_0:              return KEY_0;
+			case kVK_ANSI_RightBracket:   return KEY_RBRACKET;
+			case kVK_ANSI_O:              return KEY_O;
+			case kVK_ANSI_U:              return KEY_U;
+			case kVK_ANSI_LeftBracket:    return KEY_LBRACKET;
+			case kVK_ANSI_I:              return KEY_I;
+			case kVK_ANSI_P:              return KEY_P;
+			case kVK_ANSI_L:              return KEY_L;
+			case kVK_ANSI_J:              return KEY_J;
+			case kVK_ANSI_Quote:          return KEY_QUOTE;
+			case kVK_ANSI_K:              return KEY_K;
+			case kVK_ANSI_Semicolon:      return KEY_SEMICOLON;
+			case kVK_ANSI_Backslash:      return KEY_BACKSLASH;
+			case kVK_ANSI_Comma:          return KEY_COMMA;
+			case kVK_ANSI_Slash:          return KEY_SLASH;
+			case kVK_ANSI_N:              return KEY_N;
+			case kVK_ANSI_M:              return KEY_M;
+			case kVK_ANSI_Period:         return KEY_PERIOD;
+			case kVK_ANSI_Grave:          return KEY_GRAVE;
+			case kVK_ANSI_KeypadDecimal:  return KEY_NUM_DECIMAL;
+			case kVK_ANSI_KeypadMultiply: return KEY_NUM_MULTIPLY;
+			case kVK_ANSI_KeypadPlus:     return KEY_NUM_PLUS;
+			case kVK_ANSI_KeypadClear:    return KEY_NUM_CLEAR;
+			case kVK_ANSI_KeypadDivide:   return KEY_NUM_DIVIDE;
+			case kVK_ANSI_KeypadEnter:    return KEY_ENTER;
+			case kVK_ANSI_KeypadMinus:    return KEY_NUM_MINUS;
+			case kVK_ANSI_KeypadEquals:   return KEY_NUM_EQUAL;
+			case kVK_ANSI_Keypad0:        return KEY_NUM_0;
+			case kVK_ANSI_Keypad1:        return KEY_NUM_1;
+			case kVK_ANSI_Keypad2:        return KEY_NUM_2;
+			case kVK_ANSI_Keypad3:        return KEY_NUM_3;
+			case kVK_ANSI_Keypad4:        return KEY_NUM_4;
+			case kVK_ANSI_Keypad5:        return KEY_NUM_5;
+			case kVK_ANSI_Keypad6:        return KEY_NUM_6;
+			case kVK_ANSI_Keypad7:        return KEY_NUM_7;
+			case kVK_ANSI_Keypad8:        return KEY_NUM_8;
+			case kVK_ANSI_Keypad9:        return KEY_NUM_9;
+
+			case kVK_Return:        return KEY_RETURN;
+			case kVK_Tab:           return KEY_TAB;
+			case kVK_Space:         return KEY_SPACE;
+			case kVK_Delete:        return KEY_BACKSPACE;
+			case kVK_Escape:        return KEY_ESCAPE;
+			case kVK_Command:       return KEY_LCOMMAND;
+			case kVK_Shift:         return KEY_LSHIFT;
+			case kVK_CapsLock:      return KEY_CAPSLOCK;
+			case kVK_Option:        return KEY_LOPTION;
+			case kVK_Control:       return KEY_LCONTROL;
+			case kVK_RightCommand:  return KEY_RCOMMAND;
+			case kVK_RightShift:    return KEY_RSHIFT;
+			case kVK_RightOption:   return KEY_ROPTION;
+			case kVK_RightControl:  return KEY_RCONTROL;
+			case kVK_Function:      return KEY_FUNCTION;
+			case kVK_F17:           return KEY_F17;
+			case kVK_VolumeUp:      return KEY_VOLUME_UP;
+			case kVK_VolumeDown:    return KEY_VOLUME_DOWN;
+			case kVK_Mute:          return KEY_MUTE;
+			case kVK_F18:           return KEY_F18;
+			case kVK_F19:           return KEY_F19;
+			case kVK_F20:           return KEY_F20;
+			case kVK_F5:            return KEY_F5;
+			case kVK_F6:            return KEY_F6;
+			case kVK_F7:            return KEY_F7;
+			case kVK_F3:            return KEY_F3;
+			case kVK_F8:            return KEY_F8;
+			case kVK_F9:            return KEY_F9;
+			case kVK_F11:           return KEY_F11;
+			case kVK_F13:           return KEY_F13;
+			case kVK_F16:           return KEY_F16;
+			case kVK_F14:           return KEY_F14;
+			case kVK_F10:           return KEY_F10;
+			case kVK_F12:           return KEY_F12;
+			case kVK_F15:           return KEY_F15;
+			case kVK_Help:          return KEY_HELP;
+			case kVK_Home:          return KEY_HOME;
+			case kVK_PageUp:        return KEY_PAGEUP;
+			case kVK_ForwardDelete: return KEY_DELETE;
+			case kVK_F4:            return KEY_F4;
+			case kVK_End:           return KEY_END;
+			case kVK_F2:            return KEY_F2;
+			case kVK_PageDown:      return KEY_PAGEDOWN;
+			case kVK_F1:            return KEY_F1;
+			case kVK_LeftArrow:     return KEY_LEFT;
+			case kVK_RightArrow:    return KEY_RIGHT;
+			case kVK_DownArrow:     return KEY_DOWN;
+			case kVK_UpArrow:       return KEY_UP;
+
+			case kVK_ISO_Section: return KEY_SECTION;
+
+			case kVK_JIS_Yen:         return KEY_YEN;
+			case kVK_JIS_Underscore:  return KEY_UNDERSCORE;
+			case kVK_JIS_KeypadComma: return KEY_NUM_COMMA;
+			case kVK_JIS_Eisu:        return KEY_IME_EISU;
+			case kVK_JIS_Kana:        return KEY_IME_KANA;
+		}
+
+		return KEY_NONE;
+	}
+
+	static uint
+	get_modifier_flag_mask (const NSEvent* e)
+	{
+		switch ([e keyCode])
+		{
+			case kVK_Shift:
+			case kVK_RightShift:   return NSShiftKeyMask;
+			case kVK_Control:
+			case kVK_RightControl: return NSControlKeyMask;
+			case kVK_Option:
+			case kVK_RightOption:  return NSAlternateKeyMask;
+			case kVK_Command:
+			case kVK_RightCommand: return NSCommandKeyMask;
+			case kVK_CapsLock:     return NSAlphaShiftKeyMask;
+			case kVK_Function:     return NSFunctionKeyMask;
+		}
+		return 0;
+	}
+
+	static KeyEvent::Type
+	get_flag_key_event_type(const NSEvent* e)
+	{
+		uint mask = get_modifier_flag_mask(e);
+		if (mask == 0) return Reflex::KeyEvent::NONE;
+
+		return [e modifierFlags] & mask
+			?	Reflex::KeyEvent::DOWN
+			:	Reflex::KeyEvent::UP;
+	}
+
 	static uint
 	get_current_pointer_type ()
 	{
@@ -81,7 +244,16 @@ namespace Reflex
 
 	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Type type)
 	:	KeyEvent(
-			type, get_chars(e), [e keyCode], get_modifiers(e), [e isARepeat] ? 1 : 0)
+			type, get_chars(e), get_code([e keyCode]), get_modifiers(e),
+			[e isARepeat] ? 1 : 0)
+	{
+	}
+
+
+	NativeFlagKeyEvent::NativeFlagKeyEvent (NSEvent* e)
+	:	KeyEvent(
+			get_flag_key_event_type(e), "", get_code([e keyCode]), get_modifiers(e),
+			0)
 	{
 	}
 

data/src/osx/native_window.mm

@@ -280,7 +280,11 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 	- (void) flagsChanged: (NSEvent*) event
 	{
-		// TODO: implement later.
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		Reflex::NativeFlagKeyEvent e(event);
+		win->on_key(&e);
 	}
 
 	- (void) mouseDown: (NSEvent*) event

data/src/view.cpp

@@ -1279,6 +1279,24 @@ namespace Reflex
 		}
 	}
 
+	static void
+	scroll_and_zoom_positions (PointerEvent* e, const Point* scroll, float zoom)
+	{
+		static const Point ZERO = 0;
+
+		assert(zoom != 0);
+
+		if (!scroll) scroll = &ZERO;
+		if (*scroll == 0 && zoom == 1)
+			return;
+
+		for (size_t i = 0; i < e->size; ++i)
+		{
+			e->position(i) -= *scroll;
+			e->position(i) /= zoom;
+		}
+	}
+
 	void
 	View_call_pointer_event (View* view, const PointerEvent& event)
 	{
@@ -1288,14 +1306,14 @@ namespace Reflex
 		bool capturing = view->capture() & View::CAPTURE_POINTER;
 		if (capturing != event.capture) return;
 
-		const Bounds& frame = view->frame();
-
 		PointerEvent e = event;
-		filter_pointer_event(&e, event, frame);
+		filter_pointer_event(&e, event, view->frame());
 
 		if (!capturing && e.size == 0)
 			return;
 
+		scroll_and_zoom_positions(&e, view->self->pscroll.get(), view->zoom());
+
 		view->on_pointer(&e);
 
 		switch (e.type)
@@ -1989,18 +2007,23 @@ namespace Reflex
 	void
 	View::scroll_to (coord x, coord y, coord z)
 	{
-		Point old = self->scroll();
-		self->scroll().reset(x, y, z);
-		ScrollEvent e(x, y, z, x - old.x, y - old.y, z - old.z);
-		on_scroll(&e);
-
-		redraw();
+		scroll_to(Point(x, y, z));
 	}
 
 	void
 	View::scroll_to (const Point& scroll)
 	{
-		scroll_to(scroll.x, scroll.y, scroll.z);
+		if (scroll == this->scroll()) return;
+
+		Point old = self->scroll();
+		self->scroll() = scroll;
+
+		ScrollEvent e(
+			scroll.x,         scroll.y,         scroll.z,
+			scroll.x - old.x, scroll.y - old.y, scroll.z - old.z);
+		on_scroll(&e);
+
+		redraw();
 	}
 
 	void
@@ -2028,6 +2051,11 @@ namespace Reflex
 	void
 	View::set_zoom (float zoom)
 	{
+		if (zoom == self->zoom) return;
+
+		if (zoom == 0)
+			argument_error(__FILE__, __LINE__);
+
 		self->zoom = zoom;
 		redraw();
 	}