reflexion 0.1.40 → 0.1.42

data/src/ios/screen.mm

@@ -0,0 +1,62 @@
+// -*- mode: objc -*-
+#include "screen.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	struct Screen::Data
+	{
+
+		UIScreen* screen = nil;
+
+		~Data ()
+		{
+			if (screen) [screen release];
+		}
+
+	};// Screen::Data
+
+
+	void
+	Screen_initialize (Screen* pthis, UIScreen* screen)
+	{
+		pthis->self->screen = [screen retain];
+	}
+
+
+	Screen::Screen ()
+	{
+	}
+
+	Screen::~Screen ()
+	{
+	}
+
+	Bounds
+	Screen::frame () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		CGRect b = self->screen.bounds;
+		return Bounds(b.origin.x, b.origin.y, b.size.width, b.size.height);
+	}
+
+	Screen::operator bool () const
+	{
+		return self->screen;
+	}
+
+	bool
+	Screen::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/ios/view_controller.h

@@ -17,6 +17,8 @@
 
 	- (void) stopTimer;
 
+	- (void) update;
+
 	- (void) viewDidResize;
 
 	- (void) titleDidChange;

data/src/ios/view_controller.mm

@@ -293,6 +293,12 @@ ReflexViewController_get_show_fun ()
 		[super viewDidDisappear: animated];
 	}
 
+	- (void)viewDidLayoutSubviews
+	{
+		[super viewDidLayoutSubviews];
+		self.reflexView.frame = self.view.bounds;
+	}
+
 	- (void) startTimer
 	{
 		[self startTimer: 60];

data/src/ios/window.h

@@ -17,9 +17,7 @@ namespace Reflex
 	struct WindowData : public Window::Data
 	{
 
-		ReflexViewController* view_controller;
-
-		WindowData ();
+		ReflexViewController* view_controller = nil;
 
 		bool is_valid () const
 		{

data/src/ios/window.mm

@@ -3,6 +3,7 @@
 
 
 #include "reflex/exception.h"
+#include "screen.h"
 #import "view_controller.h"
 
 
@@ -48,6 +49,12 @@ namespace Reflex
 		return new WindowData();
 	}
 
+	uint
+	Window_default_flags ()
+	{
+		return 0;
+	}
+
 	void
 	Window_initialize (Window* window)
 	{
@@ -127,24 +134,44 @@ namespace Reflex
 	Bounds
 	Window_get_frame (const Window& window)
 	{
-		CGRect rect = get_vc(&window).reflexView.bounds;
-		return Bounds(
-			rect.origin.x,
-			rect.origin.y,
-			rect.size.width,
-			rect.size.height);
+		CGRect b = get_vc(&window).reflexView.bounds;
+		return Bounds(b.origin.x, b.origin.y, b.size.width, b.size.height);
 	}
 
 	void
-	Window_set_resizable (Window* window, bool state)
+	Window_set_flags (Window* window, uint flags)
 	{
-		//not_implemented_error(__FILE__, __LINE__);
+		if (Xot::has_flag(flags, Window::FLAG_CLOSABLE))
+			argument_error(__FILE__, __LINE__, "FLAG_CLOSABLE is not supported");
+
+		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");
+	}
+
+	static UIScreen*
+	get_screen (const Window& window)
+	{
+		UIWindow* w = get_vc(&window).view.window;
+		if (@available(iOS 13.0, *))
+		{
+			return w.windowScene.screen;
+		}
+		else
+		{
+			return w.screen;
+		}
 	}
 
-	bool
-	Window_is_resizable (const Window& window)
+	Screen
+	Window_get_screen (const Window& window)
 	{
-		return false;
+		Screen s;
+		UIScreen* screen = get_screen(window);
+		Screen_initialize(&s, screen ? screen : UIScreen.mainScreen);
+		return s;
 	}
 
 	float
@@ -154,10 +181,4 @@ namespace Reflex
 	}
 
 
-	WindowData::WindowData ()
-	{
-		view_controller = nil;
-	}
-
-
 }// Reflex

data/src/osx/native_window.mm

@@ -12,13 +12,13 @@
 #import "opengl_view.h"
 
 
-static const NSUInteger WINDOW_STYLE_MASK =
-	NSTitledWindowMask |
-	NSClosableWindowMask |
-	NSMiniaturizableWindowMask |
-	NSResizableWindowMask |
-	0;//NSTexturedBackgroundWindowMask
-
+static NSWindowStyleMask
+default_style_mask ()
+{
+	return Reflex::Window_make_style_mask(
+		Reflex::Window_default_flags(),
+		NSTitledWindowMask | NSTexturedBackgroundWindowMask);
+}
 
 static int
 count_mouse_buttons (const Reflex::PointerEvent& e)
@@ -67,7 +67,7 @@ update_pixel_density (Reflex::Window* window)
 	{
 		self = [super
 			initWithContentRect: NSMakeRect(0, 0, 0, 0)
-			styleMask: WINDOW_STYLE_MASK
+			styleMask: default_style_mask()
 			backing: NSBackingStoreBuffered
 			defer: NO];
 		if (!self) return nil;
@@ -368,7 +368,7 @@ update_pixel_density (Reflex::Window* window)
 		if (clicking_count == 0)
 			++pointer_id;
 		else if (clicking_count < 0)
-			Reflex::invalid_state_error(__FILE__, __LINE__);
+			return;//Reflex::invalid_state_error(__FILE__, __LINE__);
 
 		Window_call_pointer_event(win, &e);
 	}
@@ -420,7 +420,7 @@ update_pixel_density (Reflex::Window* window)
 	{
 		return [NSWindow
 			frameRectForContentRect: contentRect
-			styleMask: WINDOW_STYLE_MASK];
+			styleMask: default_style_mask()];
 	}
 
 @end// NativeWindow

data/src/osx/screen.h

@@ -0,0 +1,21 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_OSX_SCREEN_H__
+#define __REFLEX_SRC_OSX_SCREEN_H__
+
+
+#import <AppKit/NSScreen.h>
+#include "reflex/screen.h"
+
+
+namespace Reflex
+{
+
+
+	void Screen_initialize (Screen* pthis, NSScreen* screen);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/osx/screen.mm

@@ -0,0 +1,62 @@
+// -*- mode: objc -*-
+#include "screen.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	struct Screen::Data
+	{
+
+		NSScreen* screen = nil;
+
+		~Data ()
+		{
+			if (screen) [screen release];
+		}
+
+	};// Screen::Data
+
+
+	void
+	Screen_initialize (Screen* pthis, NSScreen* screen)
+	{
+		pthis->self->screen = [screen retain];
+	}
+
+
+	Screen::Screen ()
+	{
+	}
+
+	Screen::~Screen ()
+	{
+	}
+
+	Bounds
+	Screen::frame () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		NSRect f = self->screen.frame;
+		return Bounds(f.origin.x, f.origin.y, f.size.width, f.size.height);
+	}
+
+	Screen::operator bool () const
+	{
+		return self->screen;
+	}
+
+	bool
+	Screen::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/osx/window.h

@@ -4,6 +4,7 @@
 #define __REFLEX_SRC_OSX_WINDOW_H__
 
 
+#import <AppKit/NSWindow.h>
 #include "../window.h"
 
 
@@ -17,12 +18,10 @@ namespace Reflex
 	struct WindowData : public Window::Data
 	{
 
-		NativeWindow* native;
+		NativeWindow* native = nil;
 
 		mutable String title_tmp;
 
-		WindowData ();
-
 		bool is_valid () const
 		{
 			return native;
@@ -35,6 +34,9 @@ namespace Reflex
 
 	const WindowData& Window_get_data (const Window* window);
 
+	NSWindowStyleMask Window_make_style_mask (
+		uint flags, NSWindowStyleMask styleMask = 0);
+
 
 }// Reflex
 

data/src/osx/window.mm

@@ -4,6 +4,7 @@
 
 #import <Cocoa/Cocoa.h>
 #include "reflex/exception.h"
+#include "screen.h"
 #import "native_window.h"
 
 
@@ -31,6 +32,27 @@ namespace Reflex
 		return Window_get_data(const_cast<Window*>(window));
 	}
 
+	NSWindowStyleMask
+	Window_make_style_mask (uint flags, NSWindowStyleMask styleMask)
+	{
+		if (Xot::has_flag(flags, Window::FLAG_CLOSABLE))
+			styleMask |=  NSWindowStyleMaskClosable;
+		else
+			styleMask &= ~NSWindowStyleMaskClosable;
+
+		if (Xot::has_flag(flags, Window::FLAG_MINIMIZABLE))
+			styleMask |=  NSWindowStyleMaskMiniaturizable;
+		else
+			styleMask &= ~NSWindowStyleMaskMiniaturizable;
+
+		if (Xot::has_flag(flags, Window::FLAG_RESIZABLE))
+			styleMask |=  NSWindowStyleMaskResizable;
+		else
+			styleMask &= ~NSWindowStyleMaskResizable;
+
+		return styleMask;
+	}
+
 	static NativeWindow*
 	get_native (const Window* window)
 	{
@@ -48,6 +70,15 @@ namespace Reflex
 		return new WindowData();
 	}
 
+	uint
+	Window_default_flags ()
+	{
+		return
+			Window::FLAG_CLOSABLE    |
+			Window::FLAG_MINIMIZABLE |
+			Window::FLAG_RESIZABLE;
+	}
+
 	void
 	Window_initialize (Window* window)
 	{
@@ -104,28 +135,28 @@ namespace Reflex
 	Window_get_frame (const Window& window)
 	{
 		NativeWindow* native = get_native(&window);
-		NSRect rect = [native contentRectForFrameRect: [native frame]];
-		return Bounds(
-			rect.origin.x,
-			rect.origin.y,
-			rect.size.width,
-			rect.size.height);
+		NSRect r = [native contentRectForFrameRect: [native frame]];
+		return Bounds(r.origin.x, r.origin.y, r.size.width, r.size.height);
 	}
 
 	void
-	Window_set_resizable (Window* window, bool state)
+	Window_set_flags (Window* window, uint flags)
 	{
-		NativeWindow* native = get_native(window);
-		if (state)
-			native.styleMask |= NSResizableWindowMask;
-		else
-			native.styleMask &= ~NSResizableWindowMask;
+		NativeWindow* native        = get_native(window);
+		NSWindowStyleMask styleMask =
+			Window_make_style_mask(window->self->flags, native.styleMask);
+
+		if (styleMask != native.styleMask)
+			native.styleMask = styleMask;
 	}
 
-	bool
-	Window_is_resizable (const Window& window)
+	Screen
+	Window_get_screen (const Window& window)
 	{
-		return get_native(&window).styleMask & NSResizableWindowMask;
+		Screen s;
+		NSScreen* screen = get_native(&window).screen;
+		if (screen) Screen_initialize(&s, screen);
+		return s;
 	}
 
 	float
@@ -135,10 +166,4 @@ namespace Reflex
 	}
 
 
-	WindowData::WindowData ()
-	{
-		native = nil;
-	}
-
-
 }// Reflex

data/src/window.cpp

@@ -22,6 +22,17 @@ namespace Reflex
 	using TargetPointerMap      = Window::Data::TargetPointerMap;
 
 
+	Window::Data::Data ()
+	:	flags(Window_default_flags())
+	{
+		prev_time_update = prev_time_draw = Xot::time();
+	}
+
+	Window::Data::~Data ()
+	{
+	}
+
+
 	Window::Data::PointerData::PointerData (uint view_index)
 	:	view_index(view_index)
 	{
@@ -450,6 +461,12 @@ namespace Reflex
 		self->hide_count = new_count;
 	}
 
+	bool
+	Window::hidden () const
+	{
+		return self->hide_count > 0;
+	}
+
 	void
 	Window::close (bool force)
 	{
@@ -512,21 +529,37 @@ namespace Reflex
 	}
 
 	void
-	Window::set_resizable (bool state)
+	Window::add_flag (uint flags)
 	{
-		Window_set_resizable(this, state);
+		uint value = self->flags;
+		Xot::add_flag(&value, flags);
+
+		Window_set_flags(this, value);
+
+		self->flags = value;
 	}
 
-	bool
-	Window::is_resizable () const
+	void
+	Window::remove_flag (uint flags)
 	{
-		return Window_is_resizable(*this);
+		uint value = self->flags;
+		Xot::remove_flag(&value, flags);
+
+		Window_set_flags(this, value);
+
+		self->flags = value;
 	}
 
 	bool
-	Window::hidden () const
+	Window::has_flag (uint flags) const
 	{
-		return self->hide_count > 0;
+		return Xot::has_flag(self->flags, flags);
+	}
+
+	Screen
+	Window::screen () const
+	{
+		return Window_get_screen(*this);
 	}
 
 	View*

data/src/window.h

@@ -51,14 +51,11 @@ namespace Reflex
 
 		CaptureMap captures;
 
-		Data ()
-		{
-			prev_time_update = prev_time_draw = Xot::time();
-		}
+		uint flags;
 
-		virtual ~Data ()
-		{
-		}
+		Data ();
+
+		virtual ~Data ();
 
 		virtual bool is_valid () const = 0;
 
@@ -77,6 +74,8 @@ namespace Reflex
 
 	Window::Data* Window_create_data ();
 
+	uint Window_default_flags ();
+
 	void Window_initialize (Window* window);
 
 	void Window_show (Window* window);
@@ -94,9 +93,9 @@ namespace Reflex
 
 	Bounds Window_get_frame (const Window& window);
 
-	void Window_set_resizable (Window* window, bool state);
+	Screen Window_get_screen (const Window& window);
 
-	bool Window_is_resizable (const Window& window);
+	void Window_set_flags (Window* window, uint flags);
 
 	void Window_set_focus (Window* window, View* view);
 

data/test/test_event.rb

@@ -7,6 +7,10 @@ class TestEvent < Test::Unit::TestCase
     Reflex::UpdateEvent.new 0, 0
   end
 
+  def test_initialize()
+    assert_raise(Reflex::ReflexError) {Reflex::Event.new}
+  end
+
   def test_dup()
     e1 = event
     e2 = e1.dup

data/test/test_screen.rb

@@ -0,0 +1,18 @@
+require_relative 'helper'
+
+
+class TestScreen < Test::Unit::TestCase
+
+  def screen()
+    Reflex::Window.new.screen
+  end
+
+  def test_initialize()
+    assert_raise(Reflex::ReflexError) {Reflex::Screen.new}
+  end
+
+  def test_frame()
+    assert_raise(Rucy::InvalidObjectError) {screen.frame}
+  end
+
+end# TestScreen

data/test/test_view.rb

@@ -28,21 +28,21 @@ class TestView < Test::Unit::TestCase
 
   def test_show_hide_hidden()
     v = view
-    assert_equal false, v.hidden?
+    assert_false v.hidden?
     v.hide
-    assert_equal true, v.hidden?
+    assert_true  v.hidden?
     v.show
-    assert_equal false, v.hidden?
+    assert_false v.hidden?
   end
 
   def test_hidden_count()
     v = view
     v.show
-    assert_equal false, v.hidden?
+    assert_false v.hidden?
     v.hide
-    assert_equal false, v.hidden?
+    assert_false v.hidden?
     v.hide
-    assert_equal true, v.hidden?
+    assert_true v.hidden?
   end
 
   def test_coord_conversion()

data/test/test_window.rb

@@ -12,17 +12,21 @@ class TestWindow < Test::Unit::TestCase
 
   def test_show_hide_hidden()
     w = win
-    assert_equal true,  w.hidden
+    assert_true  w.hidden
     w.show
-    assert_equal false, w.hidden
+    assert_false w.hidden
     w.hide
-    assert_equal true,  w.hidden
+    assert_true  w.hidden
+  end
+
+  def test_hidden_count()
+    w = win
     w.hide
-    assert_equal true,  w.hidden
+    assert_true  w.hidden
     w.show
-    assert_equal true,  w.hidden
+    assert_true  w.hidden
     w.show
-    assert_equal false, w.hidden
+    assert_false w.hidden
   end
 
   def test_coord_conversion()
@@ -66,6 +70,40 @@ class TestWindow < Test::Unit::TestCase
     w.frame = [bounds(1, 2, 3, 4, 5, 6)]; assert_equal [1, 2, 0, 4, 5, 0], w.frame.to_a(3)
   end
 
+  def test_closable?()
+    w = win
+    assert_true  w.closable?
+
+    w.closable = false
+    assert_false w.closable?
+
+    w.closable = true
+    assert_true  w.closable?
+
+    w.closable false
+    assert_false w.closable?
+
+    w.closable true
+    assert_true  w.closable?
+  end
+
+  def test_minimizable?()
+    w = win
+    assert_true  w.minimizable?
+
+    w.minimizable = false
+    assert_false w.minimizable?
+
+    w.minimizable = true
+    assert_true  w.minimizable?
+
+    w.minimizable false
+    assert_false w.minimizable?
+
+    w.minimizable true
+    assert_true  w.minimizable?
+  end
+
   def test_resizable?()
     w = win
     assert_true  w.resizable?
@@ -83,6 +121,10 @@ class TestWindow < Test::Unit::TestCase
     assert_true  w.resizable?
   end
 
+  def test_screen()
+    assert_not_nil win.screen
+  end
+
   def test_root()
     w = win
     assert_not_nil       w.root