reflexion 0.5.2 → 0.6.0

data/src/pin.cpp

@@ -0,0 +1,137 @@
+#include "reflex/pin.h"
+
+
+#include "reflex/exception.h"
+#include "view.h"
+#include "constraint.h"
+
+
+namespace Reflex
+{
+
+
+	struct Pin::Data
+	{
+
+		Xot::WeakRef<View> view;
+
+		std::unique_ptr<Point> pposition;
+
+	};// Pin::Data
+
+
+	template <typename T>
+	static T*
+	setup_constraint (
+		T* constraint,
+		View* view0, const Point* position0,
+		View* view1, const Point* position1)
+	{
+		if (!view0)
+			invalid_state_error(__FILE__, __LINE__, "the pin has no view");
+
+		Constraint_set_pins(constraint, view0, position0, view1, position1);
+		View_add_constraint(view0, constraint);
+		return constraint;
+	}
+
+
+	Pin::Pin ()
+	{
+	}
+
+	Pin::Pin (coord x, coord y)
+	:	Pin(NULL, Point(x, y))
+	{
+	}
+
+	Pin::Pin (const Point& position)
+	:	Pin(NULL, position)
+	{
+	}
+
+	Pin::Pin (View* view)
+	{
+		self->view = view;
+	}
+
+	Pin::Pin (View* view, coord x, coord y)
+	:	Pin(view, Point(x, y))
+	{
+	}
+
+	Pin::Pin (View* view, const Point& position)
+	{
+		self->view = view;
+		self->pposition.reset(new Point(position));
+	}
+
+	SnapConstraint*
+	Pin::snap (Pin target)
+	{
+		return setup_constraint(
+			Xot::Ref<SnapConstraint>(SnapConstraint_create()).get(),
+			view(), position(), target.view(), target.position());
+	}
+
+	LinkConstraint*
+	Pin::link (Pin target)
+	{
+		return setup_constraint(
+			Xot::Ref<LinkConstraint>(LinkConstraint_create()).get(),
+			view(), position(), target.view(), target.position());
+	}
+
+	WheelConstraint*
+	Pin::wheel (Pin target)
+	{
+		return setup_constraint(
+			Xot::Ref<WheelConstraint>(WheelConstraint_create()).get(),
+			view(), position(), target.view(), target.position());
+	}
+
+	ChaseConstraint*
+	Pin::chase (Pin target)
+	{
+		if (target.view() && target.view() == view())
+			argument_error(__FILE__, __LINE__, "can not chase itself");
+
+		ChaseConstraint* chase = setup_constraint(
+			Xot::Ref<ChaseConstraint>(ChaseConstraint_create()).get(),
+			view(), position(), NULL, NULL);
+		chase->set_target(target);
+		return chase;
+	}
+
+	View*
+	Pin::view ()
+	{
+		return self->view.get();
+	}
+
+	const View*
+	Pin::view () const
+	{
+		return const_cast<Pin*>(this)->view();
+	}
+
+	const Point*
+	Pin::position () const
+	{
+		return self->pposition ? self->pposition.get() : NULL;
+	}
+
+	Pin::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Pin::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex
+

data/src/pointer.cpp

@@ -29,13 +29,11 @@ namespace Reflex
 
 			DRAG          = Xot::bit(0, TYPE_LAST),
 
-			ENTER         = Xot::bit(1, TYPE_LAST),
+			FLOATABLE     = Xot::bit(1, TYPE_LAST),
 
-			EXIT          = Xot::bit(2, TYPE_LAST),
+			HAS_SYSTEM_ID = Xot::bit(2, TYPE_LAST),
 
-			HAS_SYSTEM_ID = Xot::bit(3, TYPE_LAST),
-
-			HAS_PREV_POS  = Xot::bit(4, TYPE_LAST),
+			HAS_PREV_POS  = Xot::bit(3, TYPE_LAST),
 
 		};// Flag
 
@@ -56,23 +54,15 @@ namespace Reflex
 		Data (
 			ID id = -1, uint types = TYPE_NONE, Action action = ACTION_NONE,
 			const Point& position = 0, uint modifiers = 0, uint click_count = 0,
-			bool drag = false, bool enter = false, bool exit = false,
+			bool drag = false,
 			double time = 0)
 		:	id(id), types(types), action(action),
 			position(position), modifiers(modifiers), click_count(click_count),
-			flags(make_flags(drag, enter, exit)),
+			flags(drag ? DRAG : 0),
 			time(time)
 		{
 		}
 
-		uint make_flags (bool drag, bool enter, bool exit)
-		{
-			return
-				(drag  ? DRAG  : 0) |
-				(enter ? ENTER : 0) |
-				(exit  ? EXIT  : 0);
-		}
-
 		bool is_valid () const
 		{
 			return id >= 0 && types != TYPE_NONE && action != ACTION_NONE;
@@ -96,6 +86,27 @@ namespace Reflex
 		it->self->id = id;
 	}
 
+	void
+	Pointer_set_action (Pointer* it, Pointer::Action action)
+	{
+		it->self->action = action;
+	}
+
+	void
+	Pointer_set_floatable (Pointer* it, bool floatable)
+	{
+		if (floatable)
+			Xot::add_flag(&it->self->flags, Pointer::Data::FLOATABLE);
+		else
+			Xot::remove_flag(&it->self->flags, Pointer::Data::FLOATABLE);
+	}
+
+	bool
+	Pointer_is_floatable (const Pointer& it)
+	{
+		return Xot::has_flag(it.self->flags, Pointer::Data::FLOATABLE);
+	}
+
 	void
 	Pointer_add_flag (Pointer* it, uint flag)
 	{
@@ -167,7 +178,7 @@ namespace Reflex
 		double time)
 	:	self(new Data(
 			id, types, action,
-			position, modifiers, click_count, drag, false, false,
+			position, modifiers, click_count, drag,
 			time))
 	{
 	}

data/src/pointer.h

@@ -16,6 +16,12 @@ namespace Reflex
 
 	void Pointer_set_id (Pointer* it, Pointer::ID id);
 
+	void Pointer_set_action (Pointer* it, Pointer::Action action);
+
+	void Pointer_set_floatable (Pointer* it, bool floatable);
+
+	bool Pointer_is_floatable (const Pointer& it);
+
 	void Pointer_add_flag (Pointer* it, uint flag);
 
 	void Pointer_remove_flag (Pointer* it, uint flag);

data/src/sdl/application.cpp

@@ -41,6 +41,11 @@ namespace Reflex
 		return new ApplicationData();
 	}
 
+	void
+	Application_set_menu (Application* app, Menu* menu)
+	{
+	}
+
 
 	static bool
 	dispatch_window_event (const SDL_Event& event)

data/src/sdl/clipboard.cpp

@@ -0,0 +1,39 @@
+#include "reflex/clipboard.h"
+
+
+#include <SDL.h>
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	set_clipboard (const Clipboard& clipboard)
+	{
+		const char* text = clipboard.text();
+		if (SDL_SetClipboardText(text ? text : "") != 0)
+			reflex_error(__FILE__, __LINE__, SDL_GetError());
+	}
+
+	Clipboard
+	get_clipboard ()
+	{
+		Clipboard clipboard;
+
+		if (SDL_HasClipboardText() == SDL_TRUE)
+		{
+			char* text = SDL_GetClipboardText();
+			if (text)
+			{
+				clipboard.set_text(text);
+				SDL_free(text);
+			}
+		}
+
+		return clipboard;
+	}
+
+
+}// Reflex

data/src/sdl/event.cpp

@@ -94,7 +94,7 @@ namespace Reflex
 	}
 
 	NativePointerEvent::NativePointerEvent (
-		const SDL_MouseButtonEvent& e, SDL_Window* window, Pointer::Action action)
+		SDL_Window* window, const SDL_MouseButtonEvent& e, Pointer::Action action)
 	{
 		PointerEvent_add_pointer(this, Pointer(
 			0,
@@ -108,7 +108,7 @@ namespace Reflex
 	}
 
 	NativePointerEvent::NativePointerEvent (
-		const SDL_MouseMotionEvent& e, SDL_Window* window)
+		SDL_Window* window, const SDL_MouseMotionEvent& e)
 	{
 		PointerEvent_add_pointer(this, Pointer(
 			0,
@@ -122,7 +122,7 @@ namespace Reflex
 	}
 
 	NativePointerEvent::NativePointerEvent (
-		const SDL_TouchFingerEvent& e, SDL_Window* window, Pointer::Action action)
+		SDL_Window* window, const SDL_TouchFingerEvent& e, Pointer::Action action)
 	{
 		uint mods = get_modifiers(SDL_GetModState());
 		double t  = time();
@@ -157,6 +157,23 @@ namespace Reflex
 		}
 	}
 
+	NativePointerEvent::NativePointerEvent (
+		SDL_Window* window, Pointer::Action action)
+	{
+		int x = 0, y = 0;
+		Uint32 state = SDL_GetMouseState(&x, &y);
+
+		PointerEvent_add_pointer(this, Pointer(
+			0,
+			get_current_pointer_type(state),
+			action,
+			Point(x, y),
+			get_modifiers(SDL_GetModState()),
+			0,
+			false,
+			time()));
+	}
+
 
 	NativeWheelEvent::NativeWheelEvent (
 		const SDL_MouseWheelEvent& e, SDL_Window* window)

data/src/sdl/event.h

@@ -28,16 +28,19 @@ namespace Reflex
 		public:
 
 			NativePointerEvent (
-				const SDL_MouseButtonEvent& event, SDL_Window* window,
+				SDL_Window* window, const SDL_MouseButtonEvent& event,
 				Pointer::Action action);
 
 			NativePointerEvent (
-				const SDL_MouseMotionEvent& event, SDL_Window* window);
+				SDL_Window* window, const SDL_MouseMotionEvent& event);
 
 			NativePointerEvent (
-				const SDL_TouchFingerEvent& event, SDL_Window* window,
+				SDL_Window* window, const SDL_TouchFingerEvent& event,
 				Pointer::Action action);
 
+			NativePointerEvent (
+				SDL_Window* window, Pointer::Action action);
+
 	};// NativePointerEvent
 
 

data/src/sdl/menu.cpp

@@ -0,0 +1,35 @@
+#include "../menu.h"
+
+
+namespace Reflex
+{
+
+
+	Menu::Data*
+	Menu_create_data ()
+	{
+		return new Menu::Data();
+	}
+
+	void
+	Menu_update (Menu* menu)
+	{
+	}
+
+	void
+	Menu_popup (Menu* menu, View* view, coord x, coord y)
+	{
+	}
+
+	void
+	Menu_child_added (Menu* parent, Menu* child, int index)
+	{
+	}
+
+	void
+	Menu_child_removed (Menu* parent, Menu* child)
+	{
+	}
+
+
+}// Reflex

data/src/sdl/window.cpp

@@ -283,6 +283,12 @@ namespace Reflex
 		return Bounds(x, y, w, h);
 	}
 
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
 	Screen
 	Window_get_screen (const Window& win)
 	{
@@ -383,6 +389,20 @@ namespace Reflex
 					case SDL_WINDOWEVENT_FOCUS_LOST:
 						Window_call_deactivate_event(win);
 						break;
+
+					case SDL_WINDOWEVENT_ENTER:
+					{
+						NativePointerEvent e(self->native, Pointer::ENTER);
+						Window_call_pointer_event(win, &e);
+						break;
+					}
+
+					case SDL_WINDOWEVENT_LEAVE:
+					{
+						NativePointerEvent e(self->native, Pointer::LEAVE);
+						Window_call_pointer_event(win, &e);
+						break;
+					}
 				}
 				break;
 			}
@@ -403,23 +423,21 @@ namespace Reflex
 
 			case SDL_MOUSEBUTTONDOWN:
 			{
-				NativePointerEvent e(
-					event.button, self->native, Pointer::DOWN);
+				NativePointerEvent e(self->native, event.button, Pointer::DOWN);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_MOUSEBUTTONUP:
 			{
-				NativePointerEvent e(
-					event.button, self->native, Pointer::UP);
+				NativePointerEvent e(self->native, event.button, Pointer::UP);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_MOUSEMOTION:
 			{
-				NativePointerEvent e(event.motion, self->native);
+				NativePointerEvent e(self->native, event.motion);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
@@ -433,21 +451,21 @@ namespace Reflex
 
 			case SDL_FINGERDOWN:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::DOWN);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::DOWN);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_FINGERUP:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::UP);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::UP);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_FINGERMOTION:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::MOVE);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::MOVE);
 				Window_call_pointer_event(win, &e);
 				break;
 			}