reflexion 0.1.49 → 0.1.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e490c3d3e75c2e07cd82f02772eb87b45729bd4dbf7444a01e82e631e2673a33
-  data.tar.gz: e52a6698bcc86a4509799637efc4019e76c39eecc5122a9a565455f18b7691e9
+  metadata.gz: 3f773bc073d0b238097405ee034cb7ae208307de725aebb5a6d3d1c21f38aa51
+  data.tar.gz: f746663ff6c04b5d81f0f16e7f175fecbea9a4ede0de64d97cd61e3265b9c593
 SHA512:
-  metadata.gz: 761419026cc6c7f939d714d67ee47c3d3798a7128666deb6100e470e5e80b0a17ead5747270ca33125bbf0338a39e27c9fa1810e13bde7182cc69e6d3bb12ef7
-  data.tar.gz: 4f6900e7f5279eceb728e4e003eae016e68af385bc9a6e9c88ca02d67ab22fe538ad2dd5565e4b177689b1392f01c928bff101d22322bd275446a74f31d9d1e0
+  metadata.gz: 065d20a7dc69dd9ed125b25767c00debab6afc4b79598cf3843536dea0f58258e56fb751d5e0684043c19d3cfe6dcf8e3ffd68977f5ad03076f3a0ea0594d49e
+  data.tar.gz: d2ef78f91a79970059f4073f9e3943d166961c26bc5a00ccbf474af8db89f08fdcb7edcc7c63d4ea710139f8d9e24cb3dda6160b82342acd850a273c5291bfd4

data/.doc/ext/reflex/device.cpp

@@ -0,0 +1,19 @@
+#include "reflex/device.h"
+#include "defs.h"
+
+
+static
+VALUE vibrate(VALUE self)
+{
+	Reflex::vibrate();
+	return self;
+}
+
+
+void
+Init_reflex_device ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	rb_define_singleton_method(mReflex, "vibrate", RUBY_METHOD_FUNC(vibrate), 0);
+}

data/.doc/ext/reflex/native.cpp

@@ -36,6 +36,8 @@ void Init_reflex_screen ();
 void Init_reflex_window ();
 void Init_reflex_view ();
 
+void Init_reflex_device ();
+
 void Init_reflex_image_view ();
 
 
@@ -85,6 +87,8 @@ extern "C" void
 	Init_reflex_window();
 	Init_reflex_view();
 
+	Init_reflex_device();
+
 	Init_reflex_image_view();
 
 	RUCY_CATCH

data/.doc/ext/reflex/window.cpp

@@ -166,6 +166,31 @@ VALUE is_resizable(VALUE self)
 	return value(THIS->has_flag(Reflex::Window::FLAG_RESIZABLE));
 }
 
+static const uint ORIENTATION_MASK =
+	Reflex::Window::FLAG_PORTRAIT | Reflex::Window::FLAG_LANDSCAPE;
+
+static
+VALUE set_orientations(VALUE self, VALUE orientations)
+{
+	using namespace Reflex;
+
+	CHECK;
+
+	uint flags = to<uint>(orientations);
+	THIS->set_flag(
+		(      flags   &  ORIENTATION_MASK) |
+		(THIS->flags() & ~ORIENTATION_MASK));
+}
+
+static
+VALUE get_orientations(VALUE self)
+{
+	using namespace Reflex;
+
+	CHECK;
+	return value(THIS->flags() & ORIENTATION_MASK);
+}
+
 static
 VALUE get_screen(VALUE self)
 {
@@ -345,11 +370,13 @@ Init_reflex_window ()
 	rb_define_method(cWindow, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
 	rb_define_method(cWindow, "frame", RUBY_METHOD_FUNC(get_frame), 0);
 	rb_define_method(cWindow, "closable=", RUBY_METHOD_FUNC(set_closable), 1);
-	cWindow.define_method("closable?",     is_closable);
+	cWindow.define_method("closable?",      is_closable);
 	rb_define_method(cWindow, "minimizable=", RUBY_METHOD_FUNC(set_minimizable), 1);
-	cWindow.define_method("minimizable?",  is_minimizable);
+	cWindow.define_method("minimizable?",   is_minimizable);
 	rb_define_method(cWindow, "resizable=", RUBY_METHOD_FUNC(set_resizable), 1);
-	cWindow.define_method("resizable?",    is_resizable);
+	cWindow.define_method("resizable?",     is_resizable);
+	rb_define_method(cWindow, "orientations=", RUBY_METHOD_FUNC(set_orientations), 1);
+	rb_define_method(cWindow, "orientations", RUBY_METHOD_FUNC(get_orientations), 0);
 	rb_define_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
 	rb_define_method(cWindow, "screen", RUBY_METHOD_FUNC(get_screen), 0);
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(get_root), 0);
@@ -373,6 +400,9 @@ Init_reflex_window ()
 	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cWindow, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
 	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+
+	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
+	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);
 }
 
 

data/ChangeLog.md

@@ -1,6 +1,12 @@
 # reflex ChangeLog
 
 
+## [v0.1.50] - 2023-07-30
+
+- add Window::FLAG_PORTRAIT and Window::FLAG_LANDSCAPE
+- add Reflex.vibrate()
+
+
 ## [v0.1.49] - 2023-07-11
 
 - Fix assertion fail if the view size is 0

data/VERSION

@@ -1 +1 @@
-0.1.49
+0.1.50

data/ext/reflex/device.cpp

@@ -0,0 +1,20 @@
+#include "reflex/device.h"
+#include "defs.h"
+
+
+static
+RUCY_DEF0(vibrate)
+{
+	Reflex::vibrate();
+	return self;
+}
+RUCY_END
+
+
+void
+Init_reflex_device ()
+{
+	Module mReflex = define_module("Reflex");
+
+	mReflex.define_singleton_method("vibrate", vibrate);
+}

data/ext/reflex/native.cpp

@@ -36,6 +36,8 @@ void Init_reflex_screen ();
 void Init_reflex_window ();
 void Init_reflex_view ();
 
+void Init_reflex_device ();
+
 void Init_reflex_image_view ();
 
 
@@ -85,6 +87,8 @@ extern "C" void
 	Init_reflex_window();
 	Init_reflex_view();
 
+	Init_reflex_device();
+
 	Init_reflex_image_view();
 
 	RUCY_CATCH

data/ext/reflex/window.cpp

@@ -184,6 +184,33 @@ RUCY_DEF0(is_resizable)
 }
 RUCY_END
 
+static const uint ORIENTATION_MASK =
+	Reflex::Window::FLAG_PORTRAIT | Reflex::Window::FLAG_LANDSCAPE;
+
+static
+RUCY_DEF1(set_orientations, orientations)
+{
+	using namespace Reflex;
+
+	CHECK;
+
+	uint flags = to<uint>(orientations);
+	THIS->set_flag(
+		(      flags   &  ORIENTATION_MASK) |
+		(THIS->flags() & ~ORIENTATION_MASK));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_orientations)
+{
+	using namespace Reflex;
+
+	CHECK;
+	return value(THIS->flags() & ORIENTATION_MASK);
+}
+RUCY_END
+
 static
 RUCY_DEF0(get_screen)
 {
@@ -384,12 +411,14 @@ Init_reflex_window ()
 	cWindow.define_method("title", get_title);
 	cWindow.define_method("frame=", set_frame);
 	cWindow.define_method("frame",  get_frame);
-	cWindow.define_method("closable=",    set_closable);
-	cWindow.define_method("closable?",     is_closable);
-	cWindow.define_method("minimizable=", set_minimizable);
-	cWindow.define_method("minimizable?",  is_minimizable);
-	cWindow.define_method("resizable=",   set_resizable);
-	cWindow.define_method("resizable?",    is_resizable);
+	cWindow.define_method("closable=",     set_closable);
+	cWindow.define_method("closable?",      is_closable);
+	cWindow.define_method("minimizable=",  set_minimizable);
+	cWindow.define_method("minimizable?",   is_minimizable);
+	cWindow.define_method("resizable=",    set_resizable);
+	cWindow.define_method("resizable?",     is_resizable);
+	cWindow.define_method("orientations=", set_orientations);
+	cWindow.define_method("orientations",  get_orientations);
 	cWindow.define_method("hidden", hidden);
 	cWindow.define_method("screen",  get_screen);
 	cWindow.define_method("root",    get_root);
@@ -413,6 +442,9 @@ Init_reflex_window ()
 	cWindow.define_method("on_pointer_move",   on_pointer_move);
 	cWindow.define_method("on_pointer_cancel", on_pointer_cancel);
 	cWindow.define_method("on_wheel", on_wheel);
+
+	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
+	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);
 }
 
 

data/include/reflex/device.h

@@ -0,0 +1,17 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_DEVICE_H__
+#define __REFLEX_DEVICE_H__
+
+
+namespace Reflex
+{
+
+
+	void vibrate ();
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/window.h

@@ -39,7 +39,11 @@ namespace Reflex
 
 				FLAG_RESIZABLE   = Xot::bit(2),
 
-				FLAG_LAST        = FLAG_RESIZABLE
+				FLAG_PORTRAIT    = Xot::bit(3),
+
+				FLAG_LANDSCAPE   = Xot::bit(4),
+
+				FLAG_LAST        = FLAG_LANDSCAPE
 
 			};// Flag
 
@@ -69,6 +73,10 @@ namespace Reflex
 
 			virtual Bounds   frame () const;
 
+			virtual void    set_flag (uint flags);
+
+			virtual uint        flags () const;
+
 			virtual void    add_flag (uint flags);
 
 			virtual void remove_flag (uint flags);

data/include/reflex.h

@@ -20,6 +20,8 @@
 #include <reflex/window.h>
 #include <reflex/view.h>
 
+#include <reflex/device.h>
+
 #include <reflex/image_view.h>
 
 

data/lib/reflex/window.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
 require 'xot/setter'
+require 'xot/bit_flag_accessor'
 require 'xot/universal_accessor'
 require 'xot/block_util'
 require 'xot/inspectable'
@@ -19,6 +20,11 @@ module Reflex
 
     extend Forwardable
 
+    bit_flag_accessor :orientations do
+      flag :portrait,  ORIENTATION_PORTRAIT
+      flag :landscape, ORIENTATION_LANDSCAPE
+    end
+
     def_delegators :root,
       :add_child,    :add,
       :remove_child, :remove,

data/src/ios/device.mm

@@ -0,0 +1,34 @@
+// -*- objc -*-
+#include "reflex/device.h"
+
+
+#import <UIKit/UIKit.h>
+
+
+namespace Reflex
+{
+
+
+	static UIImpactFeedbackGenerator* g_feedback_generator = nil;
+
+	static UIImpactFeedbackGenerator*
+	get_feedback_generator ()
+	{
+		if (g_feedback_generator == nil)
+		{
+			g_feedback_generator =
+				[[UIImpactFeedbackGenerator alloc]
+					initWithStyle: UIImpactFeedbackStyleLight];
+		}
+		return g_feedback_generator;
+	}
+
+	void
+	viberate ()
+	{
+		//[get_feedback_generator() prepare];
+		[get_feedback_generator() impactOccurred];
+	}
+
+
+}// Reflex

data/src/ios/view_controller.mm

@@ -440,6 +440,37 @@ ReflexViewController_get_show_fun ()
 		}
 	}
 
+#if 0
+	- (BOOL)shouldAutorotate
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return [super shouldAutorotate];
+
+		return win->has_flag(Reflex::Window::FLAG_RESIZABLE);
+	}
+
+	- (UIInterfaceOrientationMask)supportedInterfaceOrientations
+	{
+		Reflex::Window* win = self.window;
+		if (!win || !win->has_flag(Reflex::Window::FLAG_RESIZABLE))
+			return UIInterfaceOrientationMaskAll;
+
+		UIInterfaceOrientationMask mask = 0;
+
+		if (win->has_flag(Reflex::Window::FLAG_PORTRAIT))
+		{
+			mask |=
+				UIInterfaceOrientationMaskPortrait |
+				UIInterfaceOrientationMaskPortraitUpsideDown;
+		}
+
+		if (win->has_flag(Reflex::Window::FLAG_LANDSCAPE))
+			mask |= UIInterfaceOrientationMaskLandscape;
+
+		return mask;
+	}
+#endif
+
 	- (void) titleDidChange
 	{
 	}

data/src/ios/window.mm

@@ -2,6 +2,7 @@
 #include "window.h"
 
 
+#import <UIKit/UIKit.h>
 #include "reflex/exception.h"
 #include "screen.h"
 #import "view_controller.h"
@@ -52,7 +53,10 @@ namespace Reflex
 	uint
 	Window_default_flags ()
 	{
-		return 0;
+		return
+			Window::FLAG_RESIZABLE |
+			Window::FLAG_PORTRAIT  |
+			Window::FLAG_LANDSCAPE;
 	}
 
 	void
@@ -138,6 +142,96 @@ namespace Reflex
 		return Bounds(b.origin.x, b.origin.y, b.size.width, b.size.height);
 	}
 
+	static UIInterfaceOrientationMask g_orientation_mask =
+		UIInterfaceOrientationMaskAll;
+
+	static UIInterfaceOrientation
+	current_orientation (UIViewController* vc)
+	{
+		switch (UIDevice.currentDevice.orientation)
+		{
+			case UIDeviceOrientationPortrait:           return UIInterfaceOrientationPortrait;
+			case UIDeviceOrientationLandscapeLeft:      return UIInterfaceOrientationLandscapeLeft;
+			case UIDeviceOrientationLandscapeRight:     return UIInterfaceOrientationLandscapeRight;
+			case UIDeviceOrientationPortraitUpsideDown: return UIInterfaceOrientationPortraitUpsideDown;
+			default: return vc.preferredInterfaceOrientationForPresentation;
+		}
+	}
+
+	static UIInterfaceOrientationMask
+	to_mask (UIInterfaceOrientation orientation)
+	{
+		switch (orientation)
+		{
+			case UIInterfaceOrientationPortrait:           return UIInterfaceOrientationMaskPortrait;
+			case UIInterfaceOrientationLandscapeLeft:      return UIInterfaceOrientationMaskLandscapeLeft;
+			case UIInterfaceOrientationLandscapeRight:     return UIInterfaceOrientationMaskLandscapeRight;
+			case UIInterfaceOrientationPortraitUpsideDown: return UIInterfaceOrientationMaskPortraitUpsideDown;
+			default:                                       return 0;
+		}
+	}
+
+	static UIInterfaceOrientation
+	get_proper_orientation (UIViewController* vc, UIInterfaceOrientationMask mask)
+	{
+		UIInterfaceOrientation current = current_orientation(vc);
+		if (to_mask(current)                             & mask) return current;
+		if (UIInterfaceOrientationMaskPortrait           & mask) return UIInterfaceOrientationPortrait;
+		if (UIInterfaceOrientationMaskLandscapeLeft      & mask) return UIInterfaceOrientationLandscapeLeft;
+		if (UIInterfaceOrientationMaskLandscapeRight     & mask) return UIInterfaceOrientationLandscapeRight;
+		if (UIInterfaceOrientationMaskPortraitUpsideDown & mask) return UIInterfaceOrientationPortraitUpsideDown;
+		return UIInterfaceOrientationPortrait;
+	}
+
+	static void
+	update_orientation_mask (UIViewController* vc, UIInterfaceOrientationMask mask)
+	{
+		if (!vc) return;
+
+		if (@available(iOS 16.0, *))
+			[vc setNeedsUpdateOfSupportedInterfaceOrientations];
+		else
+		{
+			[UIDevice.currentDevice
+				setValue: [NSNumber numberWithInteger: get_proper_orientation(vc, mask)]
+				forKey:   @"orientation"];
+			[UIViewController attemptRotationToDeviceOrientation];
+		}
+	}
+
+	void
+	Window_set_orientation_mask (UIViewController* vc, UIInterfaceOrientationMask mask)
+	{
+		if (mask == g_orientation_mask) return;
+
+		g_orientation_mask = mask;
+		update_orientation_mask(vc, mask);
+	}
+
+	UIInterfaceOrientationMask
+	Window_get_orientation_mask ()
+	{
+		return g_orientation_mask;
+	}
+
+	static UIInterfaceOrientationMask
+	flags_to_orientation_mask (uint flags)
+	{
+		UIInterfaceOrientationMask mask = 0;
+
+		if (flags & Window::FLAG_PORTRAIT)
+		{
+			mask |=
+				UIInterfaceOrientationMaskPortrait |
+				UIInterfaceOrientationPortraitUpsideDown;
+		}
+
+		if (flags & Window::FLAG_LANDSCAPE)
+			mask |= UIInterfaceOrientationMaskLandscape;
+
+		return mask != 0 ? mask : UIInterfaceOrientationMaskAll;
+	}
+
 	void
 	Window_set_flags (Window* window, uint flags)
 	{
@@ -147,8 +241,9 @@ namespace Reflex
 		if (Xot::has_flag(flags, Window::FLAG_MINIMIZABLE))
 			argument_error(__FILE__, __LINE__, "FLAG_MINIMIZABLE is not supported");
 
-		if (Xot::has_flag(flags, Window::FLAG_RESIZABLE))
-			argument_error(__FILE__, __LINE__, "FLAG_RESIZABLE is not supported");
+		Window_set_orientation_mask(
+			get_vc(window),
+			flags_to_orientation_mask(flags & (Window::FLAG_PORTRAIT | Window::FLAG_LANDSCAPE)));
 	}
 
 	static UIScreen*
@@ -156,13 +251,9 @@ namespace Reflex
 	{
 		UIWindow* w = get_vc(&window).view.window;
 		if (@available(iOS 13.0, *))
-		{
 			return w.windowScene.screen;
-		}
 		else
-		{
 			return w.screen;
-		}
 	}
 
 	Screen

data/src/osx/device.mm

@@ -0,0 +1,19 @@
+// -*- objc -*-
+#include "reflex/device.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	vibrate ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/osx/window.mm

@@ -142,6 +142,12 @@ namespace Reflex
 	void
 	Window_set_flags (Window* window, uint flags)
 	{
+		if (Xot::has_flag(flags, Window::FLAG_PORTRAIT))
+			argument_error(__FILE__, __LINE__, "FLAG_PORTRAIT is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_LANDSCAPE))
+			argument_error(__FILE__, __LINE__, "FLAG_LANDSCAPE is not supported");
+
 		NativeWindow* native        = get_native(window);
 		NSWindowStyleMask styleMask =
 			Window_make_style_mask(window->self->flags, native.styleMask);

data/src/window.cpp

@@ -546,6 +546,20 @@ namespace Reflex
 		return Window_get_frame(*this);
 	}
 
+	void
+	Window::set_flag (uint flags)
+	{
+		Window_set_flags(this, flags);
+
+		self->flags = flags;
+	}
+
+	uint
+	Window::flags () const
+	{
+		return self->flags;
+	}
+
 	void
 	Window::add_flag (uint flags)
 	{

data/test/test_device.rb

@@ -0,0 +1,10 @@
+require_relative 'helper'
+
+
+class TestDevice < Test::Unit::TestCase
+
+  def test_vibrate()
+    assert_raise(Rucy::NativeError) {Reflex.vibrate}
+  end
+
+end# TestDevice

data/test/test_window.rb

@@ -121,6 +121,18 @@ class TestWindow < Test::Unit::TestCase
     assert_true  w.resizable?
   end
 
+  def test_orientations()
+    w = win
+    assert_equal [], w.orientations
+
+    assert_raise(ArgumentError) {w.orientations = [:portrait]}.then do |e|
+      assert_match /portrait.*not supported/i, e.message
+    end
+    assert_raise(ArgumentError) {w.orientations = [:landscape]}.then do |e|
+      assert_match /landscape.*not supported/i, e.message
+    end
+  end
+
   def test_screen()
     assert_not_nil win.screen
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflexion
 version: !ruby/object:Gem::Version
-  version: 0.1.49
+  version: 0.1.50
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-10 00:00:00.000000000 Z
+date: 2023-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -103,6 +103,7 @@ extra_rdoc_files:
 - ".doc/ext/reflex/application.cpp"
 - ".doc/ext/reflex/capture_event.cpp"
 - ".doc/ext/reflex/contact_event.cpp"
+- ".doc/ext/reflex/device.cpp"
 - ".doc/ext/reflex/draw_event.cpp"
 - ".doc/ext/reflex/ellipse_shape.cpp"
 - ".doc/ext/reflex/event.cpp"
@@ -136,6 +137,7 @@ files:
 - ".doc/ext/reflex/application.cpp"
 - ".doc/ext/reflex/capture_event.cpp"
 - ".doc/ext/reflex/contact_event.cpp"
+- ".doc/ext/reflex/device.cpp"
 - ".doc/ext/reflex/draw_event.cpp"
 - ".doc/ext/reflex/ellipse_shape.cpp"
 - ".doc/ext/reflex/event.cpp"
@@ -178,6 +180,7 @@ files:
 - ext/reflex/capture_event.cpp
 - ext/reflex/contact_event.cpp
 - ext/reflex/defs.h
+- ext/reflex/device.cpp
 - ext/reflex/draw_event.cpp
 - ext/reflex/ellipse_shape.cpp
 - ext/reflex/event.cpp
@@ -213,6 +216,7 @@ files:
 - include/reflex/application.h
 - include/reflex/debug.h
 - include/reflex/defs.h
+- include/reflex/device.h
 - include/reflex/event.h
 - include/reflex/exception.h
 - include/reflex/filter.h
@@ -352,6 +356,7 @@ files:
 - src/ios/app_delegate.mm
 - src/ios/application.h
 - src/ios/application.mm
+- src/ios/device.mm
 - src/ios/event.h
 - src/ios/event.mm
 - src/ios/reflex.mm
@@ -365,6 +370,7 @@ files:
 - src/osx/app_delegate.mm
 - src/osx/application.h
 - src/osx/application.mm
+- src/osx/device.mm
 - src/osx/event.h
 - src/osx/event.mm
 - src/osx/native_window.h
@@ -403,6 +409,7 @@ files:
 - test/test_application.rb
 - test/test_capture_event.rb
 - test/test_contact_event.rb
+- test/test_device.rb
 - test/test_draw_event.rb
 - test/test_event.rb
 - test/test_focus_event.rb
@@ -453,6 +460,7 @@ test_files:
 - test/test_application.rb
 - test/test_capture_event.rb
 - test/test_contact_event.rb
+- test/test_device.rb
 - test/test_draw_event.rb
 - test/test_event.rb
 - test/test_focus_event.rb