reflexion 0.5.3 → 0.7.0

data/src/event.cpp

@@ -54,6 +54,12 @@ namespace Reflex
 	{
 	}
 
+	Event
+	Event::dup () const
+	{
+		return Event(this);
+	}
+
 	void
 	Event::block (bool parent)
 	{
@@ -620,6 +626,73 @@ namespace Reflex
 	}
 
 
+	struct TextEvent::Data
+	{
+
+		Action action;
+
+		String text;
+
+		int selection_offset, selection_size;
+
+		Data (
+			Action action = ACTION_NONE, const char* text = NULL,
+			int selection_offset = -1, int selection_size = 0)
+		:	action(action), text(text ? text : ""),
+			selection_offset(selection_offset), selection_size(selection_size)
+		{
+		}
+
+	};// TextEvent::Data
+
+
+	TextEvent::TextEvent ()
+	{
+	}
+
+	TextEvent::TextEvent (
+		Action action, const char* text,
+		int selection_offset, int selection_size)
+	:	self(new Data(action, text, selection_offset, selection_size))
+	{
+	}
+
+	TextEvent::TextEvent (const TextEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	TextEvent
+	TextEvent::dup () const
+	{
+		return TextEvent(this);
+	}
+
+	TextEvent::Action
+	TextEvent::action () const
+	{
+		return self->action;
+	}
+
+	const char*
+	TextEvent::text () const
+	{
+		return self->text;
+	}
+
+	int
+	TextEvent::selection_offset () const
+	{
+		return self->selection_offset;
+	}
+
+	int
+	TextEvent::selection_size () const
+	{
+		return self->selection_size;
+	}
+
+
 	struct PointerEvent::Data
 	{
 
@@ -706,6 +779,8 @@ namespace Reflex
 		if (!child)
 			argument_error(__FILE__, __LINE__);
 
+		if (pthis->empty()) return;
+
 		const Bounds& frame = child->frame();
 
 		std::vector<Pointer> pointers;
@@ -724,7 +799,7 @@ namespace Reflex
 	}
 
 	void
-	PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view)
+	PointerEvent_to_view_coord (PointerEvent* pthis, const View* view)
 	{
 		if (!pthis)
 			argument_error(__FILE__, __LINE__);
@@ -828,6 +903,12 @@ namespace Reflex
 	{
 	}
 
+	WheelEvent::WheelEvent (
+		const Point& position, const Point& dposition, uint modifiers)
+	:	self(new Data(position, dposition, modifiers))
+	{
+	}
+
 	WheelEvent::WheelEvent (const WheelEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
@@ -870,503 +951,586 @@ namespace Reflex
 	}
 
 
-	struct MIDIEvent::Data
+	struct CaptureEvent::Data
 	{
 
-		MIDI::Ref midi;
+		uint begin, end;
 
-		uchar bytes[3] = {0};
+		Data (uint begin = 0, uint end = 0)
+		:	begin(begin), end(end)
+		{
+		}
 
-		bool captured  = false;
+	};// CaptureEvent::Data
 
-	};// MIDIEvent
 
+	CaptureEvent::CaptureEvent ()
+	{
+	}
 
-	bool
-	MIDIEvent_to_note_event (NoteEvent* result, const MIDIEvent& event)
+	CaptureEvent::CaptureEvent (uint begin, uint end)
+	:	self(new Data(begin, end))
 	{
-		auto a = event.action();
-		if (a != MIDIEvent::NOTE_ON && a != MIDIEvent::NOTE_OFF)
-			return false;
+	}
 
-		*result = NoteEvent(
-			a == MIDIEvent::NOTE_ON ? NoteEvent::ON : NoteEvent::OFF,
-			event.channel(), event.data1(), event.data2() / 127.f, event.time());
-		return true;
+	CaptureEvent::CaptureEvent (const CaptureEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
 	}
 
-	bool
-	MIDIEvent_to_control_change_event (
-		ControlChangeEvent* result, const MIDIEvent& event)
+	CaptureEvent
+	CaptureEvent::dup () const
 	{
-		if (event.action() != MIDIEvent::CONTROL_CHANGE)
-			return false;
+		return CaptureEvent(this);
+	}
 
-		*result = ControlChangeEvent(
-			event.channel(), event.data1(), event.data2() / 127.f, event.time());
-		return true;
+	uint
+	CaptureEvent::begin () const
+	{
+		return self->begin;
 	}
 
-	void
-	MIDIEvent_set_captured (MIDIEvent* pthis, bool captured)
+	uint
+	CaptureEvent::end () const
 	{
-		pthis->self->captured = captured;
+		return self->end;
 	}
 
 
-	MIDIEvent::MIDIEvent ()
+	struct TimerEvent::Data
+	{
+
+		Timer::Ref timer;
+
+		Data (Timer* timer = NULL)
+		:	timer(timer)
+		{
+		}
+
+	};// TimerEvent::Data
+
+
+	TimerEvent::TimerEvent ()
 	{
 	}
 
-	MIDIEvent::MIDIEvent (MIDI* midi, const uchar* bytes, double time)
-	:	Event(time)
+	TimerEvent::TimerEvent (Timer* timer)
+	:	self(new Data(timer))
 	{
-		self->midi = midi;
-		memcpy(self->bytes, bytes, sizeof(uchar) * 3);
 	}
 
-	MIDIEvent::MIDIEvent (const MIDIEvent* src)
+	TimerEvent::TimerEvent (const TimerEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
 	}
 
-	MIDIEvent
-	MIDIEvent::dup () const
+	TimerEvent
+	TimerEvent::dup () const
 	{
-		return MIDIEvent(this);
+		return TimerEvent(this);
 	}
 
-	MIDI*
-	MIDIEvent::midi () const
+	Timer*
+	TimerEvent::timer ()
 	{
-		return self->midi;
+		return self->timer;
 	}
 
-	MIDIEvent::Action
-	MIDIEvent::action () const
+	const Timer*
+	TimerEvent::timer () const
 	{
-		switch (self->bytes[0] >> 4)
-		{
-			case 0x9: return NOTE_ON;
-			case 0x8: return NOTE_OFF;
-			case 0xA: return KEY_PRESSURE;
-			case 0xB: return CONTROL_CHANGE;
-			case 0xC: return PROGRAM_CHANGE;
-			case 0xD: return CHANNEL_PRESSURE;
-			case 0xE: return PITCH_BEND_CHANGE;
-			case 0xF: return SYSTEM;
-			default:  return ACTION_NONE;
-		}
+		return const_cast<TimerEvent*>(this)->timer();
 	}
 
-	int
-	MIDIEvent::channel () const
+	View*
+	TimerEvent::owner () const
 	{
-		auto a = action();
-		if (a == ACTION_NONE || a == SYSTEM)
-			return -1;
+		return self->timer ? self->timer->owner() : NULL;
+	}
 
-		return self->bytes[0] & 0xF;
+	int
+	TimerEvent::id () const
+	{
+		return self->timer ? self->timer->id() : Timer::ID_INVALID;
 	}
 
-	uchar
-	MIDIEvent::data1 () const
+	float
+	TimerEvent::interval () const
 	{
-		return self->bytes[1];
+		return self->timer ? self->timer->interval() : -1;
 	}
 
-	uchar
-	MIDIEvent::data2 () const
+	int
+	TimerEvent::count () const
 	{
-		return self->bytes[2];
+		return self->timer ? self->timer->count() : 0;
 	}
 
 	bool
-	MIDIEvent::is_captured () const
+	TimerEvent::is_finished () const
 	{
-		return self->captured;
+		return self->timer ? self->timer->is_finished() : true;
 	}
 
 
-	struct NoteEvent::Data
+	struct ContactEvent::Data
 	{
 
-		Action action  = ACTION_NONE;
-
-		int channel    = 0;
-
-		int note       = 0;
-
-		float velocity = 0;
+		Action action;
 
-		bool captured  = false;
+		Shape* shape;
 
-	};// NoteEvent::Data
+		View* view;
 
+		Data (Action action = ACTION_NONE, Shape* shape = NULL, View* view = NULL)
+		:	action(action), shape(shape), view(view)
+		{
+		}
 
-	void
-	NoteEvent_set_captured (NoteEvent* pthis, bool captured)
-	{
-		pthis->self->captured = captured;
-	}
+	};// ContactEvent::Data
 
 
-	NoteEvent::NoteEvent ()
+	ContactEvent::ContactEvent ()
 	{
 	}
 
-	NoteEvent::NoteEvent (
-		Action action, int channel, int note, float velocity, double time)
-	:	Event(time)
+	ContactEvent::ContactEvent (Action action, Shape* shape)
+	:	self(new Data(action, shape, shape ? shape->owner() : NULL))
 	{
-		self->action   = action;
-		self->channel  = channel;
-		self->note     = note;
-		self->velocity = velocity;
 	}
 
-	NoteEvent::NoteEvent (const NoteEvent* src)
+	ContactEvent::ContactEvent (const ContactEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
 	}
 
-	NoteEvent
-	NoteEvent::dup () const
+	ContactEvent
+	ContactEvent::dup () const
 	{
-		return NoteEvent(this);
+		return ContactEvent(this);
 	}
 
-	NoteEvent::Action
-	NoteEvent::action () const
+	ContactEvent::Action
+	ContactEvent::action () const
 	{
 		return self->action;
 	}
 
-	int
-	NoteEvent::channel () const
+	Shape*
+	ContactEvent::shape ()
 	{
-		return self->channel;
+		return self->shape;
 	}
 
-	int
-	NoteEvent::note () const
+	const Shape*
+	ContactEvent::shape () const
 	{
-		return self->note;
+		return const_cast<ContactEvent*>(this)->shape();
 	}
 
-	float
-	NoteEvent::frequency () const
+	View*
+	ContactEvent::view ()
 	{
-		static const int A4 = 69;
-		return 440 * std::pow(2.0, (note() - A4) / 12.0);
+		return self->view;
 	}
 
-	float
-	NoteEvent::velocity () const
+	const View*
+	ContactEvent::view () const
 	{
-		return self->velocity;
-	}
-
-	bool
-	NoteEvent::is_captured () const
-	{
-		return self->captured;
+		return const_cast<ContactEvent*>(this)->view();
 	}
 
 
-	struct ControlChangeEvent::Data
+	struct MotionEvent::Data
 	{
 
-		int channel    = 0;
-
-		int controller = 0;
-
-		float value    = 0;
+		Point gravity;
 
-		bool captured  = false;
+		Data (const Point& gravity)
+		:	gravity(gravity)
+		{
+		}
 
-	};// ControlChangeEvent::Data
+	};// MotionEvent::Data
 
 
-	void
-	ControlChangeEvent_set_captured (ControlChangeEvent* pthis, bool captured)
+	MotionEvent::MotionEvent (const Point& gravity)
+	:	self(new Data(gravity))
 	{
-		pthis->self->captured = captured;
 	}
 
+	MotionEvent::MotionEvent (const MotionEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
 
-	ControlChangeEvent::ControlChangeEvent ()
+	MotionEvent
+	MotionEvent::dup () const
 	{
+		return MotionEvent(this);
 	}
 
-	ControlChangeEvent::ControlChangeEvent (
-		int channel, int controller, float value, double time)
-	:	Event(time)
+	const Point&
+	MotionEvent::gravity () const
 	{
-		self->channel    = channel;
-		self->controller = controller;
-		self->value      = value;
+		return self->gravity;
 	}
 
-	ControlChangeEvent::ControlChangeEvent (const ControlChangeEvent* src)
-	:	Event(src), self(new Data(*src->self))
+
+	struct FileEvent::Data
+	{
+
+		Action action;
+
+		StringList paths;
+
+		Data (Action action = ACTION_NONE, const StringList& paths = {})
+		:	action(action), paths(paths)
+		{
+		}
+
+	};// FileEvent::Data
+
+
+	FileEvent::FileEvent ()
 	{
 	}
 
-	ControlChangeEvent
-	ControlChangeEvent::dup () const
+	FileEvent::FileEvent (Action action, const StringList& paths)
+	:	self(new Data(action, paths))
 	{
-		return ControlChangeEvent(this);
 	}
 
-	int
-	ControlChangeEvent::channel () const
+	FileEvent::FileEvent (const FileEvent* src)
+	:	Event(src), self(new Data(*src->self))
 	{
-		return self->channel;
 	}
 
-	int
-	ControlChangeEvent::controller () const
+	FileEvent
+	FileEvent::dup () const
 	{
-		return self->controller;
+		return FileEvent(this);
 	}
 
-	float
-	ControlChangeEvent::value () const
+	FileEvent::Action
+	FileEvent::action () const
 	{
-		return self->value;
+		return self->action;
 	}
 
-	bool
-	ControlChangeEvent::is_captured () const
+	const StringList&
+	FileEvent::paths () const
 	{
-		return self->captured;
+		return self->paths;
 	}
 
 
-	struct CaptureEvent::Data
+	struct ColorEvent::Data
 	{
 
-		uint begin, end;
+		Color color;
 
-		Data (uint begin = 0, uint end = 0)
-		:	begin(begin), end(end)
-		{
-		}
-
-	};// CaptureEvent::Data
+	};// ColorEvent::Data
 
 
-	CaptureEvent::CaptureEvent ()
+	ColorEvent::ColorEvent ()
 	{
 	}
 
-	CaptureEvent::CaptureEvent (uint begin, uint end)
-	:	self(new Data(begin, end))
+	ColorEvent::ColorEvent (const Color& color)
 	{
+		self->color = color;
 	}
 
-	CaptureEvent::CaptureEvent (const CaptureEvent* src)
+	ColorEvent::ColorEvent (const ColorEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
 	}
 
-	CaptureEvent
-	CaptureEvent::dup () const
+	ColorEvent
+	ColorEvent::dup () const
 	{
-		return CaptureEvent(this);
+		return ColorEvent(this);
 	}
 
-	uint
-	CaptureEvent::begin () const
+	const Color&
+	ColorEvent::color () const
 	{
-		return self->begin;
+		return self->color;
 	}
 
-	uint
-	CaptureEvent::end () const
+
+	struct MIDIEvent::Data
 	{
-		return self->end;
-	}
 
+		MIDI::Ref midi;
 
-	struct TimerEvent::Data
-	{
+		uchar bytes[3] = {0};
 
-		Timer::Ref timer;
+		bool captured  = false;
 
-		Data (Timer* timer = NULL)
-		:	timer(timer)
-		{
-		}
+	};// MIDIEvent::Data
 
-	};// TimerEvent::Data
 
+	bool
+	MIDIEvent_to_note_event (NoteEvent* result, const MIDIEvent& event)
+	{
+		auto a = event.action();
+		if (a != MIDIEvent::NOTE_ON && a != MIDIEvent::NOTE_OFF)
+			return false;
+
+		*result = NoteEvent(
+			a == MIDIEvent::NOTE_ON ? NoteEvent::ON : NoteEvent::OFF,
+			event.channel(), event.data1(), event.data2() / 127.f, event.time());
+		return true;
+	}
 
-	TimerEvent::TimerEvent ()
+	bool
+	MIDIEvent_to_control_change_event (
+		ControlChangeEvent* result, const MIDIEvent& event)
 	{
+		if (event.action() != MIDIEvent::CONTROL_CHANGE)
+			return false;
+
+		*result = ControlChangeEvent(
+			event.channel(), event.data1(), event.data2() / 127.f, event.time());
+		return true;
 	}
 
-	TimerEvent::TimerEvent (Timer* timer)
-	:	self(new Data(timer))
+	void
+	MIDIEvent_set_captured (MIDIEvent* pthis, bool captured)
 	{
+		pthis->self->captured = captured;
 	}
 
-	TimerEvent::TimerEvent (const TimerEvent* src)
-	:	Event(src), self(new Data(*src->self))
+
+	MIDIEvent::MIDIEvent ()
 	{
 	}
 
-	TimerEvent
-	TimerEvent::dup () const
+	MIDIEvent::MIDIEvent (MIDI* midi, const uchar* bytes, double time)
+	:	Event(time)
 	{
-		return TimerEvent(this);
+		self->midi = midi;
+		memcpy(self->bytes, bytes, sizeof(uchar) * 3);
 	}
 
-	Timer*
-	TimerEvent::timer ()
+	MIDIEvent::MIDIEvent (const MIDIEvent* src)
+	:	Event(src), self(new Data(*src->self))
 	{
-		return self->timer;
 	}
 
-	const Timer*
-	TimerEvent::timer () const
+	MIDIEvent
+	MIDIEvent::dup () const
 	{
-		return const_cast<TimerEvent*>(this)->timer();
+		return MIDIEvent(this);
 	}
 
-	View*
-	TimerEvent::owner () const
+	MIDI*
+	MIDIEvent::midi () const
 	{
-		return self->timer ? self->timer->owner() : NULL;
+		return self->midi;
+	}
+
+	MIDIEvent::Action
+	MIDIEvent::action () const
+	{
+		switch (self->bytes[0] >> 4)
+		{
+			case 0x9: return NOTE_ON;
+			case 0x8: return NOTE_OFF;
+			case 0xA: return KEY_PRESSURE;
+			case 0xB: return CONTROL_CHANGE;
+			case 0xC: return PROGRAM_CHANGE;
+			case 0xD: return CHANNEL_PRESSURE;
+			case 0xE: return PITCH_BEND_CHANGE;
+			case 0xF: return SYSTEM;
+			default:  return ACTION_NONE;
+		}
 	}
 
 	int
-	TimerEvent::id () const
+	MIDIEvent::channel () const
 	{
-		return self->timer ? self->timer->id() : Timer::ID_INVALID;
+		auto a = action();
+		if (a == ACTION_NONE || a == SYSTEM)
+			return -1;
+
+		return self->bytes[0] & 0xF;
 	}
 
-	float
-	TimerEvent::interval () const
+	uchar
+	MIDIEvent::data1 () const
 	{
-		return self->timer ? self->timer->interval() : -1;
+		return self->bytes[1];
 	}
 
-	int
-	TimerEvent::count () const
+	uchar
+	MIDIEvent::data2 () const
 	{
-		return self->timer ? self->timer->count() : 0;
+		return self->bytes[2];
 	}
 
 	bool
-	TimerEvent::is_finished () const
+	MIDIEvent::is_captured () const
 	{
-		return self->timer ? self->timer->is_finished() : true;
+		return self->captured;
 	}
 
 
-	struct ContactEvent::Data
+	struct NoteEvent::Data
 	{
 
-		Action action;
+		Action action  = ACTION_NONE;
 
-		Shape* shape;
+		int channel    = 0;
 
-		View* view;
+		int note       = 0;
 
-		Data (Action action = ACTION_NONE, Shape* shape = NULL, View* view = NULL)
-		:	action(action), shape(shape), view(view)
-		{
-		}
+		float velocity = 0;
 
-	};// ContactEvent::Data
+		bool captured  = false;
 
+	};// NoteEvent::Data
 
-	ContactEvent::ContactEvent ()
+
+	void
+	NoteEvent_set_captured (NoteEvent* pthis, bool captured)
 	{
+		pthis->self->captured = captured;
 	}
 
-	ContactEvent::ContactEvent (Action action, Shape* shape)
-	:	self(new Data(action, shape, shape ? shape->owner() : NULL))
+
+	NoteEvent::NoteEvent ()
 	{
 	}
 
-	ContactEvent::ContactEvent (const ContactEvent* src)
+	NoteEvent::NoteEvent (
+		Action action, int channel, int note, float velocity, double time)
+	:	Event(time)
+	{
+		self->action   = action;
+		self->channel  = channel;
+		self->note     = note;
+		self->velocity = velocity;
+	}
+
+	NoteEvent::NoteEvent (const NoteEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
 	}
 
-	ContactEvent
-	ContactEvent::dup () const
+	NoteEvent
+	NoteEvent::dup () const
 	{
-		return ContactEvent(this);
+		return NoteEvent(this);
 	}
 
-	ContactEvent::Action
-	ContactEvent::action () const
+	NoteEvent::Action
+	NoteEvent::action () const
 	{
 		return self->action;
 	}
 
-	Shape*
-	ContactEvent::shape ()
+	int
+	NoteEvent::channel () const
 	{
-		return self->shape;
+		return self->channel;
 	}
 
-	const Shape*
-	ContactEvent::shape () const
+	int
+	NoteEvent::note () const
 	{
-		return const_cast<ContactEvent*>(this)->shape();
+		return self->note;
 	}
 
-	View*
-	ContactEvent::view ()
+	float
+	NoteEvent::frequency () const
 	{
-		return self->view;
+		static const int A4 = 69;
+		return 440 * std::pow(2.0, (note() - A4) / 12.0);
 	}
 
-	const View*
-	ContactEvent::view () const
+	float
+	NoteEvent::velocity () const
 	{
-		return const_cast<ContactEvent*>(this)->view();
+		return self->velocity;
 	}
 
+	bool
+	NoteEvent::is_captured () const
+	{
+		return self->captured;
+	}
 
-	struct MotionEvent::Data
+
+	struct ControlChangeEvent::Data
 	{
 
-		Point gravity;
+		int channel    = 0;
 
-		Data (const Point& gravity)
-		:	gravity(gravity)
-		{
-		}
+		int controller = 0;
 
-	};// MotionEvent::Data
+		float value    = 0;
 
+		bool captured  = false;
 
-	MotionEvent::MotionEvent (const Point& gravity)
-	:	self(new Data(gravity))
+	};// ControlChangeEvent::Data
+
+
+	void
+	ControlChangeEvent_set_captured (ControlChangeEvent* pthis, bool captured)
 	{
+		pthis->self->captured = captured;
 	}
 
-	MotionEvent::MotionEvent (const MotionEvent* src)
+
+	ControlChangeEvent::ControlChangeEvent ()
+	{
+	}
+
+	ControlChangeEvent::ControlChangeEvent (
+		int channel, int controller, float value, double time)
+	:	Event(time)
+	{
+		self->channel    = channel;
+		self->controller = controller;
+		self->value      = value;
+	}
+
+	ControlChangeEvent::ControlChangeEvent (const ControlChangeEvent* src)
 	:	Event(src), self(new Data(*src->self))
 	{
 	}
 
-	MotionEvent
-	MotionEvent::dup () const
+	ControlChangeEvent
+	ControlChangeEvent::dup () const
 	{
-		return MotionEvent(this);
+		return ControlChangeEvent(this);
 	}
 
-	const Point&
-	MotionEvent::gravity () const
+	int
+	ControlChangeEvent::channel () const
 	{
-		return self->gravity;
+		return self->channel;
+	}
+
+	int
+	ControlChangeEvent::controller () const
+	{
+		return self->controller;
+	}
+
+	float
+	ControlChangeEvent::value () const
+	{
+		return self->value;
+	}
+
+	bool
+	ControlChangeEvent::is_captured () const
+	{
+		return self->captured;
 	}