reflexion 0.1.40 → 0.1.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ea18222490d3f1689a552d31ee11f0e0c2386998c88420a117aca12175436ce
-  data.tar.gz: 5105528ff4c1f233d25d79a9aa8aef72239cf4256db5c1cb5c126a7359e7c31a
+  metadata.gz: fa7ec97efd9d68e5053ddc3bf852f718a66ff883a5bb8693f605dcf45e962732
+  data.tar.gz: f2fd1319de6f1032802ce96c6657e9ac7dc0327a10c9ef9b1ba2f910c117c57a
 SHA512:
-  metadata.gz: 2be5d8353933e987684d2f5f81cb4cf7a52cc1db615c31c4ec6ed70998d783c4d5d631c25c4ab9b02258b8c5d70c4988abe47ec8fa7e6b807dfd12acba66e5de
-  data.tar.gz: 91263b61d34e37ea8900ff626edc2a6fb0c302a49e2cfe531ec1c502a47c3409e8f7d7caf049e67fb9bc56efc3132e5d8d1f2290746498eba5d301305bfa6298
+  metadata.gz: 61d0f5a9fc7ec41480642825f071d103d211035a38bcfda25eb90789fb642cf2663dce3f18771cc3702482e0a78d0385c4601ab23b4654f677f946af6000b425
+  data.tar.gz: abd4d92237cd9d49795ce5010b38565d7f3a4abd0b73ae4b18ca1989e748e911144ac3b11bdc6869400599c8eac6f120f751f75484c821a483b7475aefcec78a

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

@@ -32,6 +32,7 @@ void Init_reflex_rect_shape ();
 void Init_reflex_ellipse_shape ();
 
 void Init_reflex_application ();
+void Init_reflex_screen ();
 void Init_reflex_window ();
 void Init_reflex_view ();
 
@@ -80,6 +81,7 @@ extern "C" void
 	Init_reflex_ellipse_shape();
 
 	Init_reflex_application();
+	Init_reflex_screen();
 	Init_reflex_window();
 	Init_reflex_view();
 

data/.doc/ext/reflex/screen.cpp

@@ -0,0 +1,53 @@
+#include "reflex/ruby/screen.h"
+
+
+#include <rays/ruby/bounds.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Screen)
+
+#define THIS  to<Reflex::Screen*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Screen, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Screen class.");
+}
+
+static
+VALUE get_frame(VALUE self)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+
+
+static Class cScreen;
+
+void
+Init_reflex_screen ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cScreen = rb_define_class_under(mReflex, "Screen", rb_cObject);
+	rb_define_alloc_func(cScreen, alloc);
+	rb_define_method(cScreen, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	screen_class ()
+	{
+		return cScreen;
+	}
+
+
+}// Reflex

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

@@ -3,6 +3,7 @@
 
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
+#include "reflex/ruby/screen.h"
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
@@ -38,6 +39,13 @@ VALUE hide(VALUE self)
 	return self;
 }
 
+static
+VALUE hidden(VALUE self)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+
 static
 VALUE close(VALUE self)
 {
@@ -98,44 +106,89 @@ VALUE get_frame(VALUE self)
 	return value(THIS->frame());
 }
 
+static
+VALUE set_closable(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_CLOSABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_CLOSABLE);
+
+	return state;
+}
+
+static
+VALUE is_closable(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_CLOSABLE));
+}
+
+static
+VALUE set_minimizable(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_MINIMIZABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_MINIMIZABLE);
+
+	return state;
+}
+
+static
+VALUE is_minimizable(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_MINIMIZABLE));
+}
+
 static
 VALUE set_resizable(VALUE self, VALUE state)
 {
 	CHECK;
-	THIS->set_resizable(to<bool>(state));
-	return value(THIS->is_resizable());
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_RESIZABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_RESIZABLE);
+
+	return state;
 }
 
 static
 VALUE is_resizable(VALUE self)
 {
 	CHECK;
-	return value(THIS->is_resizable());
+	return value(THIS->has_flag(Reflex::Window::FLAG_RESIZABLE));
 }
 
 static
-VALUE hidden(VALUE self)
+VALUE get_screen(VALUE self)
 {
 	CHECK;
-	return value(THIS->hidden());
+	return value(THIS->screen());
 }
 
 static
-VALUE root(VALUE self)
+VALUE get_root(VALUE self)
 {
 	CHECK;
 	return value(THIS->root());
 }
 
 static
-VALUE focus(VALUE self)
+VALUE get_focus(VALUE self)
 {
 	CHECK;
 	return value(THIS->focus());
 }
 
 static
-VALUE painter(VALUE self)
+VALUE get_painter(VALUE self)
 {
 	CHECK;
 	return value(THIS->painter());
@@ -277,12 +330,17 @@ Init_reflex_window ()
 	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
 	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);
+	rb_define_method(cWindow, "minimizable=", RUBY_METHOD_FUNC(set_minimizable), 1);
+	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, "hidden", RUBY_METHOD_FUNC(hidden), 0);
-	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 0);
-	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(focus), 0);
-	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(painter), 0);
+	rb_define_method(cWindow, "screen", RUBY_METHOD_FUNC(get_screen), 0);
+	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(get_root), 0);
+	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(get_focus), 0);
+	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(get_painter), 0);
 	rb_define_method(cWindow, "on_show", RUBY_METHOD_FUNC(on_show), 1);
 	rb_define_method(cWindow, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
 	rb_define_method(cWindow, "on_close", RUBY_METHOD_FUNC(on_close), 1);

data/ChangeLog.md

@@ -1,6 +1,21 @@
 # reflex ChangeLog
 
 
+## [v0.1.42] - 2023-06-02
+
+- Implement the Screen class for iOS
+- Implement Window_get_screen() for iOS
+- Implement window flags for iOS
+- Update reflexView's size on viewDidLayoutSubviews
+
+
+## [v0.1.41] - 2023-05-29
+
+- Add Reflex::Screen class
+- Add Window#closable and Window#minimizable accessors
+- Fix that non-closable, non-minimizable, or non-resizable buttons raise error on clicking them
+
+
 ## [v0.1.40] - 2023-05-27
 
 - required_ruby_version >= 3.0.0

data/VERSION

@@ -1 +1 @@
-0.1.40
+0.1.42

data/ext/reflex/native.cpp

@@ -32,6 +32,7 @@ void Init_reflex_rect_shape ();
 void Init_reflex_ellipse_shape ();
 
 void Init_reflex_application ();
+void Init_reflex_screen ();
 void Init_reflex_window ();
 void Init_reflex_view ();
 
@@ -80,6 +81,7 @@ extern "C" void
 	Init_reflex_ellipse_shape();
 
 	Init_reflex_application();
+	Init_reflex_screen();
 	Init_reflex_window();
 	Init_reflex_view();
 

data/ext/reflex/screen.cpp

@@ -0,0 +1,55 @@
+#include "reflex/ruby/screen.h"
+
+
+#include <rays/ruby/bounds.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Screen)
+
+#define THIS  to<Reflex::Screen*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Screen, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Screen class.");
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_frame)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+RUCY_END
+
+
+static Class cScreen;
+
+void
+Init_reflex_screen ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cScreen = mReflex.define_class("Screen");
+	cScreen.define_alloc_func(alloc);
+	cScreen.define_method("frame", get_frame);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	screen_class ()
+	{
+		return cScreen;
+	}
+
+
+}// Reflex

data/ext/reflex/window.cpp

@@ -3,6 +3,7 @@
 
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
+#include "reflex/ruby/screen.h"
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
@@ -41,6 +42,14 @@ RUCY_DEF0(hide)
 }
 RUCY_END
 
+static
+RUCY_DEF0(hidden)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+RUCY_END
+
 static
 RUCY_DEF0(close)
 {
@@ -109,12 +118,61 @@ RUCY_DEF0(get_frame)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_closable, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_CLOSABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_CLOSABLE);
+
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_closable)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_CLOSABLE));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_minimizable, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_MINIMIZABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_MINIMIZABLE);
+
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_minimizable)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_MINIMIZABLE));
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_resizable, state)
 {
 	CHECK;
-	THIS->set_resizable(to<bool>(state));
-	return value(THIS->is_resizable());
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_RESIZABLE);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_RESIZABLE);
+
+	return state;
 }
 RUCY_END
 
@@ -122,20 +180,20 @@ static
 RUCY_DEF0(is_resizable)
 {
 	CHECK;
-	return value(THIS->is_resizable());
+	return value(THIS->has_flag(Reflex::Window::FLAG_RESIZABLE));
 }
 RUCY_END
 
 static
-RUCY_DEF0(hidden)
+RUCY_DEF0(get_screen)
 {
 	CHECK;
-	return value(THIS->hidden());
+	return value(THIS->screen());
 }
 RUCY_END
 
 static
-RUCY_DEF0(root)
+RUCY_DEF0(get_root)
 {
 	CHECK;
 	return value(THIS->root());
@@ -143,7 +201,7 @@ RUCY_DEF0(root)
 RUCY_END
 
 static
-RUCY_DEF0(focus)
+RUCY_DEF0(get_focus)
 {
 	CHECK;
 	return value(THIS->focus());
@@ -151,7 +209,7 @@ RUCY_DEF0(focus)
 RUCY_END
 
 static
-RUCY_DEF0(painter)
+RUCY_DEF0(get_painter)
 {
 	CHECK;
 	return value(THIS->painter());
@@ -310,12 +368,17 @@ Init_reflex_window ()
 	cWindow.define_method("title", get_title);
 	cWindow.define_method("frame=", set_frame);
 	cWindow.define_method("frame",  get_frame);
-	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("hidden", hidden);
-	cWindow.define_method("root", root);
-	cWindow.define_method("focus", focus);
-	cWindow.define_method("painter", painter);
+	cWindow.define_method("screen",  get_screen);
+	cWindow.define_method("root",    get_root);
+	cWindow.define_method("focus",   get_focus);
+	cWindow.define_method("painter", get_painter);
 	cWindow.define_method("on_show",  on_show);
 	cWindow.define_method("on_hide",  on_hide);
 	cWindow.define_method("on_close", on_close);

data/include/reflex/ruby/screen.h

@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_SCREEN_H__
+#define __REFLEX_RUBY_SCREEN_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/screen.h>
+
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::Screen)
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class screen_class ();
+	// class Reflex::Screen
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Screen> ()
+	{
+		return Reflex::screen_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/screen.h

@@ -0,0 +1,43 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SCREEN_H__
+#define __REFLEX_SCREEN_H__
+
+
+#include <xot/pimpl.h>
+#include <rays/bounds.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class Screen
+	{
+
+		typedef Screen This;
+
+		public:
+
+			Screen ();
+
+			virtual ~Screen ();
+
+			virtual Bounds frame () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// Screen
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/window.h

@@ -11,6 +11,7 @@
 #include <rays/painter.h>
 #include <reflex/defs.h>
 #include <reflex/event.h>
+#include <reflex/screen.h>
 
 
 namespace Reflex
@@ -29,12 +30,27 @@ namespace Reflex
 
 			typedef Xot::Ref<This> Ref;
 
+			enum Flag
+			{
+
+				FLAG_CLOSABLE    = Xot::bit(0),
+
+				FLAG_MINIMIZABLE = Xot::bit(1),
+
+				FLAG_RESIZABLE   = Xot::bit(2),
+
+				FLAG_LAST        = FLAG_RESIZABLE
+
+			};// Flag
+
 			Window ();
 
 			virtual void show ();
 
 			virtual void hide ();
 
+			virtual bool hidden () const;
+
 			virtual void close (bool force = false);
 
 			virtual void redraw ();
@@ -53,11 +69,13 @@ namespace Reflex
 
 			virtual Bounds   frame () const;
 
-			virtual void set_resizable (bool state = true);
+			virtual void    add_flag (uint flags);
 
-			virtual bool  is_resizable () const;
+			virtual void remove_flag (uint flags);
 
-			virtual bool hidden () const;
+			virtual bool    has_flag (uint flags) const;
+
+			virtual Screen screen () const;
 
 			virtual       View* root ();
 

data/lib/reflex/screen.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+
+
+module Reflex
+
+
+  class Screen
+
+    extend Forwardable
+
+    def_delegators :frame,
+      :x, :y, :z, :w, :h, :d, :width, :height, :depth,
+      :left, :top, :back, :right, :bottom, :front,
+      :left_top, :right_top, :left_bottom, :right_bottom,
+      :lt, :lr, :lb, :rb,
+      :position, :pos, :size, :center
+
+  end# Screen
+
+
+end# Reflex

data/lib/reflex/window.rb

@@ -62,7 +62,9 @@ module Reflex
       :restitution=, :restitution
 
     universal_accessor :title, :frame,
-      resizable: {reader: :resizable?}
+      closable:    {reader: :closable?},
+      minimizable: {reader: :minimizable?},
+      resizable:   {reader: :resizable?}
 
     def initialize(options = nil, &block)
       super()

data/lib/reflex.rb

@@ -47,6 +47,7 @@ require 'reflex/model'
 require 'reflex/model_owner'
 
 require 'reflex/application'
+require 'reflex/screen'
 require 'reflex/window'
 require 'reflex/view'
 

data/reflex.gemspec

@@ -1,10 +1,7 @@
 # -*- mode: ruby -*-
 
 
-File.expand_path('lib', __dir__)
-  .tap {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
-
-require 'reflex/extension'
+require_relative 'lib/reflex/extension'
 
 
 Gem::Specification.new do |s|
@@ -28,10 +25,10 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_runtime_dependency 'xot',   '~> 0.1.37'
-  s.add_runtime_dependency 'rucy',  '~> 0.1.37'
-  s.add_runtime_dependency 'beeps', '~> 0.1.38'
-  s.add_runtime_dependency 'rays',  '~> 0.1.38'
+  s.add_runtime_dependency 'xot',   '~> 0.1.38'
+  s.add_runtime_dependency 'rucy',  '~> 0.1.38'
+  s.add_runtime_dependency 'beeps', '~> 0.1.39'
+  s.add_runtime_dependency 'rays',  '~> 0.1.39'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'test-unit'

data/src/ios/screen.h

@@ -0,0 +1,20 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_IOS_SCREEN_H__
+#define __REFLEX_SRC_IOS_SCREEN_H__
+
+
+#include "reflex/screen.h"
+
+
+namespace Reflex
+{
+
+
+	void Screen_initialize (Screen* pthis, UIScreen* screen);
+
+
+}// Reflex
+
+
+#endif//EOH