/* === S Y N F I G ========================================================= */

/*!	\file selectdraghelper.h

**	\brief Helper to allow to select and drag items in a widget, eg. DrawingArea

**

**	$Id$

**

**	\legal

**	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley

**	Copyright (c) 2019 Rodolfo R Gomes

**

**	This package is free software; you can redistribute it and/or

**	modify it under the terms of the GNU General Public License as

**	published by the Free Software Foundation; either version 2 of

**	the License, or (at your option) any later version.

**

**	This package is distributed in the hope that it will be useful,

**	but WITHOUT ANY WARRANTY; without even the implied warranty of

**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

**	General Public License for more details.

**	\endlegal

*/

/* ========================================================================= */

#ifndef SYNFIG_STUDIO_SELECTDRAGHELPER_H

#define SYNFIG_STUDIO_SELECTDRAGHELPER_H

#include <vector></vector>

#include <cairomm context.h=""></cairomm>

#include <gdkmm rectangle.h=""></gdkmm>

#include <gdkmm event.h=""></gdkmm>

#include <etl handle=""></etl>

#include <synfigapp canvasinterface.h=""></synfigapp>

#include "app.h"

namespace synfigapp {

namespace Action {

class PassiveGrouper;

}

}

namespace studio {

template <class t=""></class>

class SelectDragHelper

{

public:

	enum State {POINTER_NONE, POINTER_DRAGGING, POINTER_SELECTING, POINTER_PANNING};

private:

	etl::handle<synfigapp::canvasinterface> canvas_interface;</synfigapp::canvasinterface>

	const std::string drag_action_name;

	synfigapp::Action::PassiveGrouper *action_group_drag;

	bool made_dragging_move;

	bool dragging_started_by_key;

	T hovered_item;

	std::vector<t> selected_items;</t>

	const T* active_item;

	State pointer_state;

	int pointer_tracking_start_x, pointer_tracking_start_y;

	int last_pointer_x, last_pointer_y;

	Gdk::Point active_item_start_position;

	void start_tracking_pointer(int x, int y);

	void start_tracking_pointer(double x, double y);

	void start_dragging(const T *pointed_item);

	void finish_dragging();

	void cancel_dragging();

	bool process_key_press_event(GdkEventKey *event);

	bool process_key_release_event(GdkEventKey *event);

	bool process_button_double_press_event(GdkEventButton *event);

	bool process_button_press_event(GdkEventButton *event);

	bool process_button_release_event(GdkEventButton *event);

	bool process_motion_event(GdkEventMotion *event);

	bool process_scroll_event(GdkEventScroll *event);

	sigc::signal<void> signal_selection_changed_;</void>

	sigc::signal<void> signal_hovered_item_changed_;</void>

	sigc::signal<void> signal_zoom_in_requested_;</void>

	sigc::signal<void> signal_zoom_out_requested_;</void>

	sigc::signal<void> signal_scroll_up_requested_;</void>

	sigc::signal<void> signal_scroll_down_requested_;</void>

	sigc::signal<void, int="" int,=""> signal_panning_requested_;</void,>

	sigc::signal<void> signal_redraw_needed_;</void>

	sigc::signal<void> signal_focus_requested_;</void>

	sigc::signal<void> signal_drag_started_;</void>

	sigc::signal<void> signal_drag_canceled_;</void>

	sigc::signal<void> signal_drag_finished_;</void>

	sigc::signal<void, const="" gdk::point="" int,="" t&,="" unsigned=""> signal_item_clicked_;</void,>

	sigc::signal<void, const="" gdk::point="" int,="" t&,="" unsigned=""> signal_item_double_clicked_;</void,>

	bool box_selection_enabled = true;

	bool multiple_selection_enabled = true;

	bool scroll_enabled = false;

	bool zoom_enabled = false;

	bool pan_enabled = false;

	bool drag_enabled = true;

public:

	SelectDragHelper(const char *drag_action_name);

	virtual ~SelectDragHelper() {delete action_group_drag;}

	void set_canvas_interface(etl::handle<synfigapp::canvasinterface> canvas_interface);</synfigapp::canvasinterface>

	etl::handle<synfigapp::canvasinterface>& get_canvas_interface();</synfigapp::canvasinterface>

	/// The item whose pointer/mouse is hovering over

	const T& get_hovered_item() const;

	/// Provides a list of selected items

	std::vector<t*> get_selected_items();</t*>

	/// Check if an item is selected

	bool is_selected(const T& item) const;

	/// The selected item user started to drag

	const T* get_active_item() const;

	State get_state() const;

	/// The point where user clicked

	void get_initial_tracking_point(int &px, int &py) const;

	/// The point where active item was initially placed

	void get_active_item_initial_point(int &px, int &py) const;

	//! Retrieve the position of a given item

	//! @param[out] position the location the provided item

	virtual void get_item_position(const T &item, Gdk::Point &position) = 0;

	//! Retrieve the item placed at a point

	//! @param[out] item the item in the given position

	//! @return true if an item was found, false otherwise

	virtual bool find_item_at_position(int pos_x, int pos_y, T & item) = 0;

	//! Retrieve all items inside a rectangular area

	//! @param rect the rectangle area

	//! @param[out] the list of items contained inside rect

	//! @return true if any item was found, false otherwise

	virtual bool find_items_in_rect(Gdk::Rectangle rect, std::vector<t> & list) = 0;</t>

	//! Retrieve all items in collection

	//! @param[out] items the complete item list

	virtual void get_all_items(std::vector<t> & items) = 0;</t>

	void drag_to(int pointer_x, int pointer_y);

	//! Do drag selected items

	/*!

	 * @param total_dx total pointer/mouse displacement along x-axis since drag start

	 * @param total_dy total pointer/mouse displacement along y-axis since drag start

	 * @param by_keys if the dragging action is being done by key pressing

	*/

	virtual void delta_drag(int total_dx, int total_dy, bool by_keys) = 0;

	//! Call this method to process mouse/pointer/keyboard events to map them

	//! to select/drag/panning/zoom/scrolling behaviours

	bool process_event(GdkEvent *event);

	void refresh();

	void clear();

	void select_all_items();

	bool get_box_selection_enabled() const;

	void set_box_selection_enabled(bool value);

	bool get_multiple_selection_enabled() const;

	void set_multiple_selection_enabled(bool value);

	bool get_scroll_enabled() const;

	void set_scroll_enabled(bool value);

	bool get_zoom_enabled() const;

	void set_zoom_enabled(bool value);

	bool get_pan_enabled() const;

	void set_pan_enabled(bool value);

	bool get_drag_enabled() const;

	void set_drag_enabled(bool value);

	sigc::signal<void>& signal_selection_changed() { return signal_selection_changed_; }</void>

	sigc::signal<void>& signal_hovered_item_changed() { return signal_hovered_item_changed_; }</void>

	sigc::signal<void>& signal_zoom_in_requested() { return signal_zoom_in_requested_; }</void>

	sigc::signal<void>& signal_zoom_out_requested() { return signal_zoom_out_requested_; }</void>

	sigc::signal<void>& signal_scroll_up_requested() { return signal_scroll_up_requested_; }</void>

	sigc::signal<void>& signal_scroll_down_requested() { return signal_scroll_down_requested_; }</void>

	sigc::signal<void, int="" int,="">& signal_panning_requested() { return signal_panning_requested_; }</void,>

	sigc::signal<void>& signal_redraw_needed() { return signal_redraw_needed_; }</void>

	sigc::signal<void>& signal_focus_requested() { return signal_focus_requested_; }</void>

	sigc::signal<void>& signal_drag_started() { return signal_drag_started_; }</void>

	sigc::signal<void>& signal_drag_canceled() { return signal_drag_canceled_; }</void>

	sigc::signal<void>& signal_drag_finished() { return signal_drag_finished_; }</void>

	sigc::signal<void, const="" gdk::point="" int,="" t&,="" unsigned="">& signal_item_clicked() { return signal_item_clicked_; }</void,>

	sigc::signal<void, const="" gdk::point="" int,="" t&,="" unsigned="">& signal_item_double_clicked() { return signal_item_double_clicked_; }</void,>

};

template <class t=""></class>

SelectDragHelper<t>::SelectDragHelper(const char* drag_action_name)</t>

	: drag_action_name(drag_action_name), action_group_drag(nullptr), active_item(nullptr), pointer_state(POINTER_NONE)

{

}

template<class t=""></class>

void SelectDragHelper<t>::set_canvas_interface(etl::handle<synfigapp::canvasinterface> canvas_interface)</synfigapp::canvasinterface></t>

{

	if (pointer_state == POINTER_DRAGGING) {

		cancel_dragging();

	}

	this->canvas_interface = canvas_interface;

}

template<class t=""></class>

etl::handle<synfigapp::canvasinterface>& SelectDragHelper<t>::get_canvas_interface()</t></synfigapp::canvasinterface>

{

	return canvas_interface;

}

template <class t=""></class>

const T& SelectDragHelper<t>::get_hovered_item() const</t>

{

	return hovered_item;

}

template<class t=""></class>

std::vector<t*> SelectDragHelper<t>::get_selected_items()</t></t*>

{

	const size_t nselection = selected_items.size();

	std::vector<t*> r;</t*>

	r.reserve(nselection);

	for (size_t n = 0; n < nselection; n++)

		r.push_back(&selected_items[n]);

	return r;

}

template<class t=""></class>

bool SelectDragHelper<t>::is_selected(const T& item) const {</t>

	return std::find(selected_items.begin(), selected_items.end(), item) != selected_items.end();

}

template<class t=""></class>

const T* SelectDragHelper<t>::get_active_item() const {</t>

	return active_item;

}

template<class t=""></class>

typename SelectDragHelper<t>::State SelectDragHelper<t>::get_state() const</t></t>

{

	return pointer_state;

}

template<class t=""></class>

void SelectDragHelper<t>::get_initial_tracking_point(int& px, int& py) const</t>

{

	px = pointer_tracking_start_x;

	py = pointer_tracking_start_y;

}

template<class t=""></class>

void SelectDragHelper<t>::get_active_item_initial_point(int& px, int& py) const</t>

{

	px = active_item_start_position.get_x();

	py = active_item_start_position.get_y();

}

template <class t=""></class>

bool

SelectDragHelper<t>::process_event(GdkEvent *event)</t>

{

	switch(event->type) {

	case GDK_SCROLL:

		return process_scroll_event(&event->scroll);

	case GDK_MOTION_NOTIFY:

		return process_motion_event(&event->motion);

	case GDK_2BUTTON_PRESS:

		return process_button_double_press_event(&event->button);

	case GDK_BUTTON_PRESS:

		return process_button_press_event(&event->button);

	case GDK_BUTTON_RELEASE:

		return process_button_release_event(&event->button);

	case GDK_KEY_RELEASE:

		return process_key_release_event(&event->key);

	case GDK_KEY_PRESS:

		return process_key_press_event(&event->key);

	default:

		break;

	}

	return false;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_key_press_event(GdkEventKey* event)</t>

{

	switch (event->keyval) {

	case GDK_KEY_Up:

	case GDK_KEY_Down: {

		if (!drag_enabled)

			return false;

		if (selected_items.size() == 0)

			break;

		if (pointer_state != POINTER_DRAGGING) {

			start_dragging(&selected_items.front());

			dragging_started_by_key = true;

		}

		int delta = 1;

		if (event->state & GDK_SHIFT_MASK)

			delta = 10;

		if (event->keyval == GDK_KEY_Up)

			delta = -delta;

		delta_drag(0, delta, true);

		return true;

	}

	case GDK_KEY_Left:

	case GDK_KEY_Right: {

		if (!drag_enabled)

			return false;

		if (selected_items.size() == 0)

			break;

		if (pointer_state != POINTER_DRAGGING) {

			start_dragging(&selected_items.front());

			dragging_started_by_key = true;

		}

		int delta = 1;

		if (event->state & GDK_SHIFT_MASK)

			delta *= 10;

		if (event->keyval == GDK_KEY_Left)

			delta = -delta;

		delta_drag(delta, 0, true);

		return true;

	}

	case GDK_KEY_a: {

		if ((event->state & Gdk::CONTROL_MASK) == Gdk::CONTROL_MASK) {

			// ctrl a

			cancel_dragging();

			select_all_items();

			return true;

		}

		break;

	}

	case GDK_KEY_d: {

		if ((event->state & Gdk::CONTROL_MASK) == Gdk::CONTROL_MASK) {

			// ctrl d

			cancel_dragging();

			selected_items.clear();

			signal_redraw_needed().emit();

			signal_selection_changed().emit();

			return true;

		}

		break;

	}

	}

	return false;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_key_release_event(GdkEventKey* event)</t>

{

	switch (event->keyval) {

	case GDK_KEY_Escape: {

		// cancel/undo current action

		if (pointer_state != POINTER_NONE) {

			cancel_dragging();

			pointer_state = POINTER_NONE;

			signal_redraw_needed().emit();

			return true;

		}

	}

	case GDK_KEY_Up:

	case GDK_KEY_Down:

	case GDK_KEY_Left:

	case GDK_KEY_Right: {

		if (pointer_state == POINTER_DRAGGING) {

			if (dragging_started_by_key)

				finish_dragging();

			dragging_started_by_key = false;

			return true;

		}

	}

	}

	return false;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_button_double_press_event(GdkEventButton* event)</t>

{

	T pointed_item;

	find_item_at_position(event->x, event->y, pointed_item);

	if (pointed_item.is_valid()) {

		int pointer_x = std::trunc(event->x);

		int pointer_y = std::trunc(event->y);

		signal_item_double_clicked().emit(pointed_item, event->button, Gdk::Point(pointer_x, pointer_y));

		return true;

	}

	return false;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_button_press_event(GdkEventButton* event)</t>

{

	bool some_action_done = false;

	signal_focus_requested().emit();

	if (event->button == 3) {

		// cancel/undo current action

		if (pointer_state != POINTER_NONE) {

			cancel_dragging();

			pointer_state = POINTER_NONE;

			signal_redraw_needed().emit();

			some_action_done = true;

		}

	} else if (event->button == 1) {

		if (pointer_state == POINTER_NONE) {

			start_tracking_pointer(event->x, event->y);

			T pointed_item;

			find_item_at_position(pointer_tracking_start_x, pointer_tracking_start_y, pointed_item);

			if (pointed_item.is_valid()) {

				auto already_selection_it = std::find(selected_items.begin(), selected_items.end(), pointed_item);

				bool is_already_selected = already_selection_it != selected_items.end();

				bool using_key_modifiers = (event->state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK)) != 0;

				if (using_key_modifiers && box_selection_enabled && multiple_selection_enabled) {

					pointer_state = POINTER_SELECTING;

				} else {

					T* pointed_item_ptr = nullptr;

					if (is_already_selected) {

						pointed_item_ptr = &*already_selection_it;

					} else {

						selected_items.clear();

						selected_items.push_back(pointed_item);

						pointed_item_ptr = &selected_items.front();

						signal_selection_changed().emit();

					}

					if (drag_enabled) {

						start_dragging(pointed_item_ptr);

						dragging_started_by_key = false;

						pointer_state = POINTER_DRAGGING;

					}

				}

				some_action_done = true;

			} else {

				if (box_selection_enabled && multiple_selection_enabled) {

					pointer_state = POINTER_SELECTING;

					some_action_done = true;

				}

			}

		}

	} else if (event->button == 2) {

		if (pointer_state == POINTER_DRAGGING)

			finish_dragging();

		start_tracking_pointer(event->x, event->y);

		pointer_state = POINTER_PANNING;

		some_action_done = true;

	}

	{

		T pointed_item;

		find_item_at_position(event->x, event->y, pointed_item);

		if (pointed_item.is_valid()) {

			int pointer_x = std::trunc(event->x);

			int pointer_y = std::trunc(event->y);

			signal_item_clicked().emit(pointed_item, event->button, Gdk::Point(pointer_x, pointer_y));

		}

	}

	return some_action_done;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_button_release_event(GdkEventButton* event)</t>

{

	int pointer_x = std::trunc(event->x);

	int pointer_y = std::trunc(event->y);

	if (event->button == 1) {

		bool selection_changed = false;

		if (pointer_state == POINTER_SELECTING) {

			std::vector<t> circled_items;</t>

			int x0 = std::min(pointer_tracking_start_x, pointer_x);

			int width = std::abs(pointer_tracking_start_x - pointer_x);

			int y0 = std::min(pointer_tracking_start_y, pointer_y);

			int height = std::abs(pointer_tracking_start_y - pointer_y);

			if (width < 1 && height < 1) {

				width = 1;

				height = 1;

			}

			Gdk::Rectangle rect(x0, y0, width, height);

			bool found = find_items_in_rect(rect, circled_items);

			if (!found) {

				if (selected_items.size() > 0 && (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) == 0) {

					selection_changed = true;

					selected_items.clear();

				}

			} else {

				if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {

					// toggle selection status of each point in rectangle

					for (const T& cp : circled_items) {

						auto already_selection_it = std::find(selected_items.begin(), selected_items.end(), cp);

						bool already_selected = already_selection_it != selected_items.end();

						if (already_selected) {

							selected_items.erase(already_selection_it);

							selection_changed = true;

						} else {

							selected_items.push_back(cp);

							selection_changed = true;

						}

					}

				} else if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) {

					// add to selection, if it aren't yet

					for (const T& cp : circled_items) {

						auto already_selection_it = std::find(selected_items.begin(), selected_items.end(), cp);

						bool already_selected = already_selection_it != selected_items.end();

						if (!already_selected) {

							selected_items.push_back(cp);

							selection_changed = true;

						}

					}

				} else {

					selected_items.clear();

					selected_items = circled_items;

					selection_changed = true;

				}

			}

		}

		else if (pointer_state == POINTER_DRAGGING) {

			if (event->button == 1) {

				if (made_dragging_move)

					finish_dragging();

				else {

					T saved_active_point = *active_item;

					selected_items.clear();

					selected_items.push_back(saved_active_point);

					selection_changed = true;

					cancel_dragging();

				}

			}

		}

		if (selection_changed) {

			signal_selection_changed().emit();

			signal_redraw_needed().emit();

		}

	}

	else if (event->button == 2) {

		if (pointer_state == POINTER_PANNING)

			pointer_state = POINTER_NONE;

	}

	if (event->button == 1 || event->button == 3) {

		if (pointer_state != POINTER_NONE) {

			pointer_state = POINTER_NONE;

			signal_redraw_needed().emit();

		}

	}

	return false;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_motion_event(GdkEventMotion* event)</t>

{

	bool processed = false;

	auto previous_hovered_point = hovered_item;

	hovered_item.invalidate();

	int pointer_x = std::trunc(event->x);

	int pointer_y = std::trunc(event->y);

	if (pointer_state != POINTER_DRAGGING)

		find_item_at_position(pointer_x, pointer_y, hovered_item);

	if (previous_hovered_point != hovered_item) {

		signal_hovered_item_changed().emit();

		signal_redraw_needed().emit();

	}

	if (pointer_state == POINTER_DRAGGING && !dragging_started_by_key) {

		guint any_pointer_button = Gdk::BUTTON1_MASK |Gdk::BUTTON2_MASK | Gdk::BUTTON3_MASK;

		if ((event->state & any_pointer_button) == 0) {

			// If some modal window is called, we lose the button-release event...

			cancel_dragging();

		} else {

			bool axis_lock = event->state & Gdk::SHIFT_MASK;

			if (axis_lock) {

				int dx = pointer_x - pointer_tracking_start_x;

				int dy = pointer_y - pointer_tracking_start_y;

				if (std::abs(dy) > std::abs(dx))

					pointer_x = pointer_tracking_start_x;

				else

					pointer_y = pointer_tracking_start_y;

			}

			drag_to(pointer_x, pointer_y);

		}

		processed = true;

	}

	else if (pointer_state == POINTER_PANNING) {

		const int dx = pointer_x - last_pointer_x;

		const int dy = pointer_y - last_pointer_y;

		const int total_dx = pointer_x - pointer_tracking_start_x;

		const int total_dy = pointer_y - pointer_tracking_start_y;

		signal_panning_requested().emit(dx, dy, total_dx, total_dy);

		processed = true;

	}

	if (pointer_state != POINTER_NONE) {

		signal_redraw_needed().emit();

	}

	last_pointer_x = pointer_x;

	last_pointer_y = pointer_y;

	return processed;

}

template<class t=""></class>

bool SelectDragHelper<t>::process_scroll_event(GdkEventScroll* event)</t>

{

	switch(event->direction) {

		case GDK_SCROLL_UP:

		case GDK_SCROLL_RIGHT: {

			if ((event->state & GDK_CONTROL_MASK) && zoom_enabled) {

				// Ctrl+scroll , perform zoom in

				signal_zoom_in_requested().emit();

			} else {

				if (!scroll_enabled)

					return false;

				// Scroll up

				signal_scroll_up_requested().emit();

			}

			return true;

		}

		case GDK_SCROLL_DOWN:

		case GDK_SCROLL_LEFT: {

			if ((event->state & GDK_CONTROL_MASK) && zoom_enabled) {

				// Ctrl+scroll , perform zoom out

				signal_zoom_out_requested().emit();

			} else {

				if (!scroll_enabled)

					return false;

				// Scroll down

				signal_scroll_down_requested().emit();

			}

			return true;

		}

		default:

			break;

	}

	return false;

}

template <class t=""></class>

void SelectDragHelper<t>::refresh() {</t>

	hovered_item.invalidate();

}

template <class t=""></class>

void SelectDragHelper<t>::clear() {</t>

	if (pointer_state == POINTER_DRAGGING) {

		cancel_dragging();

	}

	hovered_item.invalidate();

	if (!selected_items.empty()) {

		selected_items.clear();

		signal_selection_changed().emit();

	}

}

template <class t=""></class>

void SelectDragHelper<t>::start_tracking_pointer(double x, double y)</t>

{

	pointer_tracking_start_x = std::trunc(x);

	pointer_tracking_start_y = std::trunc(y);

	last_pointer_x = pointer_tracking_start_x;

	last_pointer_y = pointer_tracking_start_y;

}

template <class t=""></class>

void SelectDragHelper<t>::start_dragging(const T* pointed_item)</t>

{

	made_dragging_move = false;

	active_item = pointed_item;

	get_item_position(*active_item, active_item_start_position);

	if (canvas_interface) {

		action_group_drag = new synfigapp::Action::PassiveGrouper(canvas_interface->get_instance().get(), drag_action_name);

	}

	pointer_state = POINTER_DRAGGING;

	signal_drag_started().emit();

}

template <class t=""></class>

void SelectDragHelper<t>::drag_to(int pointer_x, int pointer_y)</t>

{

	made_dragging_move = true;

	int pointer_dx = pointer_x - pointer_tracking_start_x;

	int pointer_dy = pointer_y - pointer_tracking_start_y;

	delta_drag(pointer_dx, pointer_dy, false);

}

template <class t=""></class>

void SelectDragHelper<t>::finish_dragging()</t>

{

	delete action_group_drag;

	action_group_drag = nullptr;

	pointer_state = POINTER_NONE;

	signal_drag_finished().emit();

}

template <class t=""></class>

void SelectDragHelper<t>::cancel_dragging()</t>

{

	if (pointer_state != POINTER_DRAGGING)

		return;

	// Sadly group->cancel() just remove PassiverGroup indicator, not its actions, from stack

	if (action_group_drag) {

		bool has_any_content =  0 < action_group_drag->get_depth();

		delete action_group_drag;

		action_group_drag = nullptr;

		if (has_any_content && canvas_interface) {

			canvas_interface->get_instance()->undo();

			canvas_interface->get_instance()->clear_redo_stack();

		}

	}

	pointer_state = POINTER_NONE;

	signal_drag_canceled().emit();

	signal_redraw_needed().emit();

}

template <class t=""></class>

void SelectDragHelper<t>::select_all_items()</t>

{

	cancel_dragging();

	selected_items.clear();

	std::vector<t> all_items;</t>

	get_all_items(all_items);

	selected_items = std::move(all_items);

	signal_selection_changed().emit();

}

template <class t=""></class>

bool SelectDragHelper<t>::get_box_selection_enabled() const</t>

{

	return box_selection_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_box_selection_enabled(bool value)</t>

{

	box_selection_enabled = value;

}

template <class t=""></class>

bool SelectDragHelper<t>::get_multiple_selection_enabled() const</t>

{

	return multiple_selection_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_multiple_selection_enabled(bool value)</t>

{

	multiple_selection_enabled = value;

	if (!multiple_selection_enabled && selected_items.size() > 1) {

		selected_items.resize(1);

		if (active_item && active_item != &selected_items.front()) {

			cancel_dragging();

		}

	}

}

template <class t=""></class>

bool SelectDragHelper<t>::get_scroll_enabled() const</t>

{

	return scroll_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_scroll_enabled(bool value)</t>

{

	scroll_enabled = value;

}

template <class t=""></class>

bool SelectDragHelper<t>::get_zoom_enabled() const</t>

{

	return zoom_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_zoom_enabled(bool value)</t>

{

	zoom_enabled = value;

}

template <class t=""></class>

bool SelectDragHelper<t>::get_pan_enabled() const</t>

{

	return pan_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_pan_enabled(bool value)</t>

{

	pan_enabled = value;

}

template <class t=""></class>

bool SelectDragHelper<t>::get_drag_enabled() const</t>

{

	return drag_enabled;

}

template <class t=""></class>

void SelectDragHelper<t>::set_drag_enabled(bool value)</t>

{

	drag_enabled = value;

	if (!drag_enabled) {

		cancel_dragging();

	}

}

};

#endif // SYNFIG_STUDIO_SELECTDRAGHELPER_H