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

/*!	\file devicetracker.cpp

**	\brief Template File

**

**	$Id$

**

**	\legal

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

**  Copyright (c) 2009 Gerco Ballintijn

**

**	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

*/

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

// FIXME: The code here doesn't use the GTKmm layer but uses GTK+ directly

// since the GTKmm wrapper for Gdk::Device is incomplete. When the wrapper

// gets fixed, this code should be updated accoordingly.

/* === H E A D E R S ======================================================= */

#ifdef USING_PCH

#	include "pch.h"

#else

#ifdef HAVE_CONFIG_H

#	include <config.h></config.h>

#endif

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

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

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

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

#include <synfig general.h=""></synfig>

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

#include "devicetracker.h"

#include <gui localization.h=""></gui>

#endif

/* === U S I N G =========================================================== */

using namespace synfigapp;

using namespace studio;

/* === M A C R O S ========================================================= */

/* === G L O B A L S ======================================================= */

/* === P R O C E D U R E S ================================================= */

/* === M E T H O D S ======================================================= */

void

DeviceTracker::list_devices(DeviceList &out_devices)

{

	out_devices.clear();

	Glib::RefPtr<gdk::seat> seat = Gdk::DisplayManager::get()->get_default_display()->get_default_seat();</gdk::seat>

	if (seat->get_keyboard())

		out_devices.push_back(seat->get_keyboard());

	if (seat->get_pointer())

		out_devices.push_back(seat->get_pointer());

	DeviceList slaves = seat->get_slaves(Gdk::SEAT_CAPABILITY_ALL);

	out_devices.reserve(out_devices.size() + slaves.size());

	out_devices.insert(out_devices.end(), slaves.begin(), slaves.end());

}

DeviceTracker::DeviceTracker()

{

	DeviceList devices;

	list_devices(devices);

	for(DeviceList::const_iterator i = devices.begin(); i != devices.end(); ++i) {

		const Glib::RefPtr<gdk::device> &device = *i;</gdk::device>

		bool unknown_type = false;

		InputDevice::Type type = InputDevice::TYPE_MOUSE;

		switch(device->get_source()) {

		case Gdk::SOURCE_MOUSE:  type = InputDevice::TYPE_MOUSE;  break;

		case Gdk::SOURCE_PEN:    type = InputDevice::TYPE_PEN;    break;

		case Gdk::SOURCE_ERASER: type = InputDevice::TYPE_ERASER; break;

		case Gdk::SOURCE_CURSOR: type = InputDevice::TYPE_CURSOR; break;

		default: unknown_type = true; break;

		}

		InputDevice::Handle input_device;

		input_device = synfigapp::Main::add_input_device(device->get_name(), type);

		// Disable all extended devices by default.

		// This tries to fix several bugs reported in track and forums

		if (!unknown_type) {

			input_device->set_mode(InputDevice::MODE_DISABLED);

			//synfigapp::Main::select_input_device(input_device);

		}

	}

	// Once all devices are disabled be sure that the core pointer is the

	// one selected. The user should decide later whether enable and save the

	// rest of input devices found.

	Glib::RefPtr<gdk::seat> seat = Gdk::DisplayManager::get()->get_default_display()->get_default_seat();</gdk::seat>

	if (seat->get_pointer())

		synfigapp::Main::select_input_device(seat->get_pointer()->get_name());

}

DeviceTracker::~DeviceTracker()

	{ }

void

DeviceTracker::save_preferences()

{

	DeviceList devices;

	list_devices(devices);

	for(DeviceList::const_iterator i = devices.begin(); i != devices.end(); ++i) {

		const Glib::RefPtr<gdk::device> &device = *i;</gdk::device>

		InputDevice::Handle synfig_device = synfigapp::Main::find_input_device(device->get_name());

		if (!synfig_device)

			continue;

		InputDevice::Mode mode = InputDevice::MODE_DISABLED;

		switch(device->get_mode()) {

		case Gdk::MODE_SCREEN: mode = InputDevice::MODE_SCREEN;  break;

		case Gdk::MODE_WINDOW: mode = InputDevice::MODE_WINDOW;  break;

		default: break;

		}

		synfig_device->set_mode(mode);

		int n_axes = device->get_source() == Gdk::SOURCE_KEYBOARD ? 0 : device->get_axes();

		if (n_axes > 0) {

			std::vector<inputdevice::axisuse> axes(n_axes);</inputdevice::axisuse>

			for(int j = 0; j < n_axes; ++j)

				switch(device->get_axis_use(j)) {

				case Gdk::AXIS_X:        axes[j] = InputDevice::AXIS_X; break;

				case Gdk::AXIS_Y:        axes[j] = InputDevice::AXIS_Y; break;

				case Gdk::AXIS_PRESSURE: axes[j] = InputDevice::AXIS_PRESSURE; break;

				case Gdk::AXIS_XTILT:    axes[j] = InputDevice::AXIS_XTILT; break;

				case Gdk::AXIS_YTILT:    axes[j] = InputDevice::AXIS_YTILT; break;

				case Gdk::AXIS_WHEEL:    axes[j] = InputDevice::AXIS_WHEEL; break;

				case Gdk::AXIS_LAST:     axes[j] = InputDevice::AXIS_LAST; break;

				default:                 axes[j] = InputDevice::AXIS_IGNORE; break;

				}

			synfig_device->set_axes(axes);

		}

		int n_keys = device->get_n_keys();

		if (n_keys > 0) {

			std::vector<inputdevice::devicekey> keys(n_keys);</inputdevice::devicekey>

			for(int j = 0; j < n_keys; ++j) {

				guint gdk_keyval = 0;

				Gdk::ModifierType gdk_modifiers = Gdk::ModifierType();

				device->get_key(j, gdk_keyval, gdk_modifiers);

				keys[j].keyval = gdk_keyval;

				keys[j].modifiers = gdk_modifiers;

			}

			synfig_device->set_keys(keys);

		}

	}

}

void

DeviceTracker::load_preferences()

{

	DeviceList devices;

	list_devices(devices);

	for(DeviceList::const_iterator i = devices.begin(); i != devices.end(); ++i) {

		const Glib::RefPtr<gdk::device> &device = *i;</gdk::device>

		InputDevice::Handle synfig_device = synfigapp::Main::find_input_device(device->get_name());

		if (!synfig_device)

			continue;

		Gdk::InputMode gdk_mode = Gdk::MODE_DISABLED;

		switch(synfig_device->get_mode()) {

		case InputDevice::MODE_SCREEN: gdk_mode = Gdk::MODE_SCREEN;  break;

		case InputDevice::MODE_WINDOW: gdk_mode = Gdk::MODE_WINDOW;  break;

		default: break;

		}

		device->set_mode(gdk_mode);

		const std::vector<inputdevice::axisuse> axes = synfig_device->get_axes();</inputdevice::axisuse>

		for(int axis = 0; axis < (int)axes.size(); ++axis)

			switch(axes[axis]) {

			case InputDevice::AXIS_X:        device->set_axis_use(axis, Gdk::AXIS_X);        break;

			case InputDevice::AXIS_Y:        device->set_axis_use(axis, Gdk::AXIS_Y);        break;

			case InputDevice::AXIS_PRESSURE: device->set_axis_use(axis, Gdk::AXIS_PRESSURE); break;

			case InputDevice::AXIS_XTILT:    device->set_axis_use(axis, Gdk::AXIS_XTILT);    break;

			case InputDevice::AXIS_YTILT:    device->set_axis_use(axis, Gdk::AXIS_YTILT);    break;

			case InputDevice::AXIS_WHEEL:    device->set_axis_use(axis, Gdk::AXIS_WHEEL);    break;

			case InputDevice::AXIS_LAST:     device->set_axis_use(axis, Gdk::AXIS_LAST);     break;

			default:                         device->set_axis_use(axis, Gdk::AXIS_IGNORE);   break;

			}

		const std::vector<inputdevice::devicekey> keys = synfig_device->get_keys();</inputdevice::devicekey>

		for (int key = 0; key < (int) keys.size(); key++)

			device->set_key(key, keys[key].keyval, Gdk::ModifierType(keys[key].modifiers));

	}

}