openkylin
/
gimp
mirror of https://gitee.com/openkylin/gimp.git
9
0
Fork 1
Code Issues Projects Releases Wiki Activity
gimp/modules/controller-dx-dinput.c

1123 lines
38 KiB
C
Raw Normal View History

Import Upstream version 2.10.32
2022-11-23 10:54:48 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* controller_dx_dinput.c
* Copyright (C) 2004-2007 Sven Neumann <sven@gimp.org>
* Michael Natterer <mitch@gimp.org>
* Tor Lillqvist <tml@iki.fi>
*
* This program 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 3 of the License, or
* (at your option) any later version.
*
* This program 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/* When using gcc with the February 2007 version of the DirectX SDK,
* at least, you need to fix a couple of duplicate typedefs in the
* DirectX <dinput.h>. Unfortunately I can't include the diff here,
* both for copyright reasons, and because that would confuse the C
* lexer even if inside #if 0.
*/
#include "config.h"
#include <errno.h>
#include <string.h>
#include <math.h>
#define _WIN32_WINNT 0x0501
#include <windows.h>
#define DIRECTINPUT_VERSION 0x0800
#include <dinput.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include "libgimpconfig/gimpconfig.h"
#include "libgimpmodule/gimpmodule.h"
#include "libgimpwidgets/gimpwidgets.h"
#define GIMP_ENABLE_CONTROLLER_UNDER_CONSTRUCTION
#include "libgimpwidgets/gimpcontroller.h"
#include "gimpinputdevicestore.h"
#include "libgimp/libgimp-intl.h"
enum
{
PROP_0,
PROP_DEVICE,
PROP_DEVICE_STORE
};
#define NUM_EVENTS_PER_BUTTON 3 /* Button click, press and release */
#define NUM_EVENTS_PER_AXIS 2 /* Axis decrease and increase */
#define NUM_EVENTS_PER_SLIDER 2 /* Slider decrease and increase */
#define NUM_EVENTS_PER_POV 3 /* POV view vector X and Y view and return */
#define CONTROLLER_TYPE_DX_DINPUT (controller_dx_dinput_get_type ())
#define CONTROLLER_DX_DINPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CONTROLLER_TYPE_DX_DINPUT, ControllerDXDInput))
#define CONTROLLER_DX_DINPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CONTROLLER_TYPE_DX_DINPUT, ControllerDXDInputClass))
#define CONTROLLER_IS_DX_DINPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CONTROLLER_TYPE_DX_DINPUT))
#define CONTROLLER_IS_DX_DINPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CONTROLLER_TYPE_DX_DINPUT))
typedef struct _DXDInputSource DXDInputSource;
typedef struct _ControllerDXDInput ControllerDXDInput;
typedef struct _ControllerDXDInputClass ControllerDXDInputClass;
struct _DXDInputSource
{
GSource source;
ControllerDXDInput *controller;
};
struct _ControllerDXDInput
{
GimpController parent_instance;
GimpInputDeviceStore *store;
LPDIRECTINPUTDEVICE8W didevice8;
HANDLE event;
GPollFD *pollfd;
gint num_buttons;
gint num_button_events;
gint num_axes;
gint num_axis_events;
gint num_sliders;
gint num_slider_events;
gint num_povs;
gint num_pov_events;
gint num_events;
gchar **event_names;
gchar **event_blurbs;
DIDATAFORMAT *format;
guchar *prevdata;
gchar *guid;
GSource *source;
/* Variables used by enumeration callbacks only*/
gint bei, bi, aei, ai, sei, si, pei, pi;
};
struct _ControllerDXDInputClass
{
GimpControllerClass parent_class;
};
static GType controller_dx_dinput_get_type (void);
static void dx_dinput_dispose (GObject *object);
static void dx_dinput_finalize (GObject *object);
static void dx_dinput_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void dx_dinput_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gint dx_dinput_get_n_events (GimpController *controller);
static const gchar * dx_dinput_get_event_name (GimpController *controller,
gint event_id);
static const gchar * dx_dinput_get_event_blurb (GimpController *controller,
gint event_id);
static void dx_dinput_device_changed (ControllerDXDInput *controller,
const gchar *guid);
static gboolean dx_dinput_set_device (ControllerDXDInput *controller,
const gchar *guid);
static const GimpModuleInfo dx_dinput_info =
{
GIMP_MODULE_ABI_VERSION,
N_("DirectX DirectInput event controller"),
"Tor Lillqvist <tml@iki.fi>",
"v0.1",
"(c) 2004-2007, released under the GPL",
"2004-2007"
};
G_DEFINE_DYNAMIC_TYPE (ControllerDXDInput, controller_dx_dinput,
GIMP_TYPE_CONTROLLER)
G_MODULE_EXPORT const GimpModuleInfo *
gimp_module_query (GTypeModule *module)
{
return &dx_dinput_info;
}
G_MODULE_EXPORT gboolean
gimp_module_register (GTypeModule *module)
{
gimp_input_device_store_register_types (module);
controller_dx_dinput_register_type (module);
return TRUE;
}
static void
controller_dx_dinput_class_init (ControllerDXDInputClass *klass)
{
GimpControllerClass *controller_class = GIMP_CONTROLLER_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = dx_dinput_dispose;
object_class->finalize = dx_dinput_finalize;
object_class->get_property = dx_dinput_get_property;
object_class->set_property = dx_dinput_set_property;
g_object_class_install_property (object_class, PROP_DEVICE,
g_param_spec_string ("device",
_("Device:"),
_("The device to read DirectInput events from."),
NULL,
GIMP_CONFIG_PARAM_FLAGS));
g_object_class_install_property (object_class, PROP_DEVICE_STORE,
g_param_spec_object ("device-values",
NULL, NULL,
GIMP_TYPE_INPUT_DEVICE_STORE,
G_PARAM_READABLE));
controller_class->name = _("DirectX DirectInput");
controller_class->help_id = "gimp-controller-directx-directinput";
controller_class->icon_name = GIMP_ICON_CONTROLLER_LINUX_INPUT;
controller_class->get_n_events = dx_dinput_get_n_events;
controller_class->get_event_name = dx_dinput_get_event_name;
controller_class->get_event_blurb = dx_dinput_get_event_blurb;
}
static void
controller_dx_dinput_class_finalize (ControllerDXDInputClass *klass)
{
}
static void
controller_dx_dinput_init (ControllerDXDInput *controller)
{
controller->store = gimp_input_device_store_new ();
if (controller->store)
{
g_signal_connect_swapped (controller->store, "device-added",
G_CALLBACK (dx_dinput_device_changed),
controller);
g_signal_connect_swapped (controller->store, "device-removed",
G_CALLBACK (dx_dinput_device_changed),
controller);
}
}
static void
dx_dinput_dispose (GObject *object)
{
ControllerDXDInput *controller = CONTROLLER_DX_DINPUT (object);
dx_dinput_set_device (controller, NULL);
G_OBJECT_CLASS (controller_dx_dinput_parent_class)->dispose (object);
}
static void
dx_dinput_finalize (GObject *object)
{
ControllerDXDInput *controller = CONTROLLER_DX_DINPUT (object);
if (controller->source != NULL)
{
g_source_remove_poll (controller->source, controller->pollfd);
g_source_remove (g_source_get_id (controller->source));
g_source_unref (controller->source);
}
if (controller->didevice8)
IDirectInputDevice8_SetEventNotification (controller->didevice8, NULL);
if (controller->format != NULL)
{
g_free (controller->format->rgodf);
g_free (controller->format);
controller->format = NULL;
}
g_free (controller->prevdata);
controller->prevdata = NULL;
if (controller->event != NULL)
{
CloseHandle (controller->event);
controller->event = 0;
}
if (controller->store)
{
g_object_unref (controller->store);
controller->store = NULL;
}
G_OBJECT_CLASS (controller_dx_dinput_parent_class)->finalize (object);
}
static void
dx_dinput_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
ControllerDXDInput *controller = CONTROLLER_DX_DINPUT (object);
switch (property_id)
{
case PROP_DEVICE:
dx_dinput_set_device (controller, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
dx_dinput_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
ControllerDXDInput *controller = CONTROLLER_DX_DINPUT (object);
switch (property_id)
{
case PROP_DEVICE:
g_value_set_string (value, controller->guid);
break;
case PROP_DEVICE_STORE:
g_value_set_object (value, controller->store);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gint
dx_dinput_get_n_events (GimpController *controller)
{
ControllerDXDInput *cdxdi = (ControllerDXDInput *) controller;
return cdxdi->num_events;
}
static const gchar *
dx_dinput_get_event_name (GimpController *controller,
gint event_id)
{
ControllerDXDInput *cdxdi = (ControllerDXDInput *) controller;
if (event_id < 0 || event_id >= cdxdi->num_events)
return NULL;
return cdxdi->event_names[event_id];
}
static const gchar *
dx_dinput_get_event_blurb (GimpController *controller,
gint event_id)
{
ControllerDXDInput *cdxdi = (ControllerDXDInput *) controller;
if (event_id < 0 || event_id >= cdxdi->num_events)
return NULL;
return cdxdi->event_blurbs[event_id];
}
static BOOL CALLBACK
count_objects (const DIDEVICEOBJECTINSTANCEW *doi,
void *user_data)
{
ControllerDXDInput *controller = (ControllerDXDInput *) user_data;
HRESULT hresult;
DIPROPRANGE range;
if (doi->dwType & DIDFT_AXIS)
{
/* Set reported range to physical range, not to give upper
* level software any false impression of higher accuracy.
*/
range.diph.dwSize = sizeof (DIPROPRANGE);
range.diph.dwHeaderSize = sizeof (DIPROPHEADER);
range.diph.dwObj = doi->dwType;
range.diph.dwHow = DIPH_BYID;
if (FAILED ((hresult = IDirectInputDevice8_GetProperty (controller->didevice8,
DIPROP_PHYSICALRANGE,
&range.diph))))
g_warning ("IDirectInputDevice8::GetProperty failed: %s",
g_win32_error_message (hresult));
else
{
if (FAILED ((hresult = IDirectInputDevice8_SetProperty (controller->didevice8,
DIPROP_RANGE,
&range.diph))))
g_warning ("IDirectInputDevice8::SetProperty failed: %s",
g_win32_error_message (hresult));
}
}
if (IsEqualGUID (&doi->guidType, &GUID_Button))
controller->num_buttons++;
else if (IsEqualGUID (&doi->guidType, &GUID_XAxis) ||
IsEqualGUID (&doi->guidType, &GUID_YAxis) ||
IsEqualGUID (&doi->guidType, &GUID_ZAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RxAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RyAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RzAxis))
controller->num_axes++;
else if (IsEqualGUID (&doi->guidType, &GUID_Slider))
controller->num_sliders++;
else if (IsEqualGUID (&doi->guidType, &GUID_POV))
controller->num_povs++;
return DIENUM_CONTINUE;
}
static BOOL CALLBACK
name_objects (const DIDEVICEOBJECTINSTANCEW *doi,
void *user_data)
{
ControllerDXDInput *controller = (ControllerDXDInput *) user_data;
if (IsEqualGUID (&doi->guidType, &GUID_Button))
{
controller->event_names[controller->bei] = g_strdup_printf ("button-%d", controller->bi);
controller->event_blurbs[controller->bei] = g_strdup_printf (_("Button %d"), controller->bi);
controller->bei++;
controller->event_names[controller->bei] = g_strdup_printf ("button-%d-press", controller->bi);
controller->event_blurbs[controller->bei] = g_strdup_printf (_("Button %d Press"), controller->bi);
controller->bei++;
controller->event_names[controller->bei] = g_strdup_printf ("button-%d-release", controller->bi);
controller->event_blurbs[controller->bei] = g_strdup_printf (_("Button %d Release"), controller->bi);
controller->bei++;
g_assert (controller->bi < controller->num_buttons);
controller->bi++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_XAxis) ||
IsEqualGUID (&doi->guidType, &GUID_YAxis) ||
IsEqualGUID (&doi->guidType, &GUID_ZAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RxAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RyAxis) ||
IsEqualGUID (&doi->guidType, &GUID_RzAxis))
{
if (IsEqualGUID (&doi->guidType, &GUID_XAxis))
{
controller->event_names[controller->aei] = g_strdup ("x-move-left");
controller->event_blurbs[controller->aei] = g_strdup (_("X Move Left"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("x-move-right");
controller->event_blurbs[controller->aei] = g_strdup (_("X Move Right"));
controller->aei++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_YAxis))
{
controller->event_names[controller->aei] = g_strdup ("y-move-away");
controller->event_blurbs[controller->aei] = g_strdup (_("Y Move Away"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("y-move-near");
controller->event_blurbs[controller->aei] = g_strdup (_("Y Move Near"));
controller->aei++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_ZAxis))
{
controller->event_names[controller->aei] = g_strdup ("z-move-up");
controller->event_blurbs[controller->aei] = g_strdup (_("Z Move Up"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("z-move-down");
controller->event_blurbs[controller->aei] = g_strdup (_("Z Move Down"));
controller->aei++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_RxAxis))
{
controller->event_names[controller->aei] = g_strdup ("x-axis-tilt-away");
controller->event_blurbs[controller->aei] = g_strdup (_("X Axis Tilt Away"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("x-axis-tilt-near");
controller->event_blurbs[controller->aei] = g_strdup (_("X Axis Tilt Near"));
controller->aei++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_RyAxis))
{
controller->event_names[controller->aei] = g_strdup ("y-axis-tilt-right");
controller->event_blurbs[controller->aei] = g_strdup (_("Y Axis Tilt Right"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("y-axis-tilt-left");
controller->event_blurbs[controller->aei] = g_strdup (_("Y Axis Tilt Left"));
controller->aei++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_RzAxis))
{
controller->event_names[controller->aei] = g_strdup ("z-axis-turn-left");
controller->event_blurbs[controller->aei] = g_strdup (_("Z Axis Turn Left"));
controller->aei++;
controller->event_names[controller->aei] = g_strdup ("z-axis-turn-right");
controller->event_blurbs[controller->aei] = g_strdup (_("Z Axis Turn Right"));
controller->aei++;
}
g_assert (controller->ai < controller->num_axes);
controller->ai++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_Slider))
{
controller->event_names[controller->sei] = g_strdup_printf ("slider-%d-increase", controller->si);
controller->event_blurbs[controller->sei] = g_strdup_printf (_("Slider %d Increase"), controller->si);
controller->sei++;
controller->event_names[controller->sei] = g_strdup_printf ("slider-%d-decrease", controller->si);
controller->event_blurbs[controller->sei] = g_strdup_printf (_("Slider %d Decrease"), controller->si);
controller->sei++;
g_assert (controller->si < controller->num_sliders);
controller->si++;
}
else if (IsEqualGUID (&doi->guidType, &GUID_POV))
{
controller->event_names[controller->pei] = g_strdup_printf ("pov-%d-x-view", controller->pi);
controller->event_blurbs[controller->pei] = g_strdup_printf (_("POV %d X View"), controller->pi);
controller->pei++;
controller->event_names[controller->pei] = g_strdup_printf ("pov-%d-y-view", controller->pi);
controller->event_blurbs[controller->pei] = g_strdup_printf (_("POV %d Y View"), controller->pi);
controller->pei++;
controller->event_names[controller->pei] = g_strdup_printf ("pov-%d-x-return", controller->pi);
controller->event_blurbs[controller->pei] = g_strdup_printf (_("POV %d Return"), controller->pi);
controller->pei++;
g_assert (controller->pi < controller->num_povs);
controller->pi++;
}
return DIENUM_CONTINUE;
}
static gboolean
dx_dinput_get_device_info (ControllerDXDInput *controller,
GError **error)
{
HRESULT hresult;
controller->num_buttons =
controller->num_axes =
controller->num_sliders =
controller->num_povs = 0;
if (FAILED ((hresult = IDirectInputDevice8_EnumObjects (controller->didevice8,
count_objects,
controller,
DIDFT_AXIS|
DIDFT_BUTTON|
DIDFT_POV|
DIDFT_PSHBUTTON|
DIDFT_RELAXIS|
DIDFT_TGLBUTTON))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::EnumObjects failed: %s",
g_win32_error_message (hresult));
return FALSE;
}
controller->num_button_events = controller->num_buttons*NUM_EVENTS_PER_BUTTON;
controller->num_axis_events = controller->num_axes*NUM_EVENTS_PER_AXIS;
controller->num_slider_events = controller->num_sliders*NUM_EVENTS_PER_SLIDER;
controller->num_pov_events = controller->num_povs*NUM_EVENTS_PER_POV;
controller->num_events =
controller->num_button_events +
controller->num_axis_events +
controller->num_slider_events +
controller->num_pov_events;
controller->event_names = g_new (gchar *, controller->num_events);
controller->event_blurbs = g_new (gchar *, controller->num_events);
controller->bi = controller->ai = controller->si = controller->pi = 0;
controller->bei = 0;
controller->aei = controller->bei + controller->num_button_events;
controller->sei = controller->aei + controller->num_axis_events;
controller->pei = controller->sei + controller->num_slider_events;
if (FAILED ((hresult = IDirectInputDevice8_EnumObjects (controller->didevice8,
name_objects,
controller,
DIDFT_AXIS|
DIDFT_BUTTON|
DIDFT_POV|
DIDFT_PSHBUTTON|
DIDFT_RELAXIS|
DIDFT_TGLBUTTON))))
{
g_free (controller->event_names);
g_free (controller->event_blurbs);
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::EnumObjects failed: %s",
g_win32_error_message (hresult));
return FALSE;
}
g_assert (controller->bei == controller->num_button_events);
g_assert (controller->aei == controller->bei + controller->num_axis_events);
g_assert (controller->sei == controller->aei + controller->num_slider_events);
g_assert (controller->pei == controller->sei + controller->num_pov_events);
return TRUE;
}
static void
dx_dinput_device_changed (ControllerDXDInput *controller,
const gchar *guid)
{
if (controller->guid && strcmp (guid, controller->guid) == 0)
{
dx_dinput_set_device (controller, guid);
g_object_notify (G_OBJECT (controller), "device");
}
}
static gboolean
dx_dinput_event_prepare (GSource *source,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
dx_dinput_event_check (GSource *source)
{
DXDInputSource *input = (DXDInputSource *) source;
if (WaitForSingleObject (input->controller->event, 0) == WAIT_OBJECT_0)
{
ResetEvent (input->controller->event);
return TRUE;
}
return FALSE;
}
static gboolean
dx_dinput_event_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
ControllerDXDInput * const input = ((DXDInputSource *) source)->controller;
GimpController *controller = &input->parent_instance;
const DIDATAFORMAT * const format = input->format;
const DIOBJECTDATAFORMAT *rgodf = format->rgodf;
guchar *data;
gint i;
GimpControllerEvent cevent = { 0, };
data = g_alloca (format->dwDataSize);
if (FAILED (IDirectInputDevice8_GetDeviceState (input->didevice8,
format->dwDataSize,
data)))
{
return TRUE;
}
g_object_ref (controller);
for (i = 0; i < input->num_buttons; i++)
{
if (input->prevdata[rgodf->dwOfs] != data[rgodf->dwOfs])
{
if (data[rgodf->dwOfs] & 0x80)
{
/* Click event, compatibility with Linux Input */
cevent.any.type = GIMP_CONTROLLER_EVENT_TRIGGER;
cevent.any.source = controller;
cevent.any.event_id = i*NUM_EVENTS_PER_BUTTON;
gimp_controller_event (controller, &cevent);
/* Press event */
cevent.any.event_id = i*NUM_EVENTS_PER_BUTTON + 1;
gimp_controller_event (controller, &cevent);
}
else
{
/* Release event */
cevent.any.type = GIMP_CONTROLLER_EVENT_TRIGGER;
cevent.any.source = controller;
cevent.any.event_id = i*NUM_EVENTS_PER_BUTTON + 2;
gimp_controller_event (controller, &cevent);
}
}
rgodf++;
}
for (i = 0; i < input->num_axes; i++)
{
LONG *prev = (LONG *)(input->prevdata+rgodf->dwOfs);
LONG *curr = (LONG *)(data+rgodf->dwOfs);
if (ABS (*prev - *curr) > 1)
{
cevent.any.type = GIMP_CONTROLLER_EVENT_VALUE;
cevent.any.source = controller;
cevent.any.event_id =
input->num_button_events +
i*NUM_EVENTS_PER_AXIS;
g_value_init (&cevent.value.value, G_TYPE_DOUBLE);
if (*curr - *prev < 0)
{
g_value_set_double (&cevent.value.value, *prev - *curr);
}
else
{
cevent.any.event_id++;
g_value_set_double (&cevent.value.value, *curr - *prev);
}
gimp_controller_event (controller, &cevent);
g_value_unset (&cevent.value.value);
}
else
*curr = *prev;
rgodf++;
}
for (i = 0; i < input->num_sliders; i++)
{
LONG *prev = (LONG *)(input->prevdata+rgodf->dwOfs);
LONG *curr = (LONG *)(data+rgodf->dwOfs);
if (ABS (*prev - *curr) > 1)
{
cevent.any.type = GIMP_CONTROLLER_EVENT_VALUE;
cevent.any.source = controller;
cevent.any.event_id =
input->num_button_events +
input->num_axis_events +
i*NUM_EVENTS_PER_SLIDER;
g_value_init (&cevent.value.value, G_TYPE_DOUBLE);
if (*curr - *prev < 0)
{
g_value_set_double (&cevent.value.value, *prev - *curr);
}
else
{
cevent.any.event_id++;
g_value_set_double (&cevent.value.value, *curr - *prev);
}
gimp_controller_event (controller, &cevent);
g_value_unset (&cevent.value.value);
}
else
*curr = *prev;
rgodf++;
}
for (i = 0; i < input->num_povs; i++)
{
LONG prev = *((LONG *)(input->prevdata+rgodf->dwOfs));
LONG curr = *((LONG *)(data+rgodf->dwOfs));
double prevx, prevy;
double currx, curry;
if (prev != curr)
{
if (prev == -1)
{
prevx = 0.;
prevy = 0.;
}
else
{
prevx = sin (prev/36000.*2.*G_PI);
prevy = cos (prev/36000.*2.*G_PI);
}
if (curr == -1)
{
currx = 0.;
curry = 0.;
}
else
{
currx = sin (curr/36000.*2.*G_PI);
curry = cos (curr/36000.*2.*G_PI);
}
cevent.any.type = GIMP_CONTROLLER_EVENT_VALUE;
cevent.any.source = controller;
cevent.any.event_id =
input->num_button_events +
input->num_axis_events +
input->num_slider_events +
i*NUM_EVENTS_PER_POV;
g_value_init (&cevent.value.value, G_TYPE_DOUBLE);
g_value_set_double (&cevent.value.value, currx - prevx);
gimp_controller_event (controller, &cevent);
cevent.any.event_id++;
g_value_set_double (&cevent.value.value, curry - prevy);
gimp_controller_event (controller, &cevent);
g_value_unset (&cevent.value.value);
if (curr == -1)
{
cevent.any.type = GIMP_CONTROLLER_EVENT_TRIGGER;
cevent.any.event_id++;
gimp_controller_event (controller, &cevent);
}
}
rgodf++;
}
g_assert (rgodf == format->rgodf + format->dwNumObjs);
memmove (input->prevdata, data, format->dwDataSize);
g_object_unref (controller);
return TRUE;
}
static GSourceFuncs dx_dinput_event_funcs = {
dx_dinput_event_prepare,
dx_dinput_event_check,
dx_dinput_event_dispatch,
NULL
};
static void
dump_data_format (const DIDATAFORMAT *format)
{
#ifdef GIMP_UNSTABLE
gint i;
g_print ("dwSize: %ld\n", format->dwSize);
g_print ("dwObjSize: %ld\n", format->dwObjSize);
g_print ("dwFlags: ");
if (format->dwFlags == DIDF_ABSAXIS)
g_print ("DIDF_ABSAXIS");
else if (format->dwFlags == DIDF_RELAXIS)
g_print ("DIDF_RELAXIS");
else
g_print ("%#lx", format->dwFlags);
g_print ("\n");
g_print ("dwDataSize: %ld\n", format->dwDataSize);
g_print ("dwNumObjs: %ld\n", format->dwNumObjs);
for (i = 0; i < format->dwNumObjs; i++)
{
const DIOBJECTDATAFORMAT *oformat = (DIOBJECTDATAFORMAT *) (((char *) format->rgodf) + i*format->dwObjSize);
unsigned char *guid;
g_print ("Object %d:\n", i);
if (oformat->pguid == NULL)
g_print (" pguid: NULL\n");
else
{
UuidToString (oformat->pguid, &guid);
g_print (" pguid: %s\n", guid);
RpcStringFree (&guid);
}
g_print (" dwOfs: %ld\n", oformat->dwOfs);
g_print (" dwType: ");
switch (DIDFT_GETTYPE (oformat->dwType))
{
#define CASE(x) case DIDFT_##x: g_print ("DIDFT_"#x); break
CASE (RELAXIS);
CASE (ABSAXIS);
CASE (AXIS);
CASE (PSHBUTTON);
CASE (TGLBUTTON);
CASE (BUTTON);
CASE (POV);
CASE (COLLECTION);
CASE (NODATA);
#undef CASE
default: g_print ("%#x", DIDFT_GETTYPE (oformat->dwType));
}
g_print (" ");
if (DIDFT_GETINSTANCE (oformat->dwType) == DIDFT_GETINSTANCE (DIDFT_ANYINSTANCE))
g_print ("ANYINSTANCE");
else
g_print ("#%d", DIDFT_GETINSTANCE (oformat->dwType));
#define BIT(x) if (oformat->dwType & DIDFT_##x) g_print (" "#x)
BIT (FFACTUATOR);
BIT (FFEFFECTTRIGGER);
BIT (OUTPUT);
BIT (VENDORDEFINED);
BIT (ALIAS);
BIT (OPTIONAL);
#undef BIT
g_print ("\n");
g_print (" dwFlags:");
switch (oformat->dwFlags & DIDOI_ASPECTACCEL)
{
case DIDOI_ASPECTPOSITION: g_print (" DIDOI_ASPECTPOSITION"); break;
case DIDOI_ASPECTVELOCITY: g_print (" DIDOI_ASPECTVELOCITY"); break;
case DIDOI_ASPECTACCEL: g_print (" DIDOI_ASPECTACCEL"); break;
}
if (oformat->dwFlags & DIDOI_ASPECTFORCE)
g_print (" DIDOI_ASPECTFORCE");
g_print ("\n");
}
#endif
}
static gboolean
dx_dinput_setup_events (ControllerDXDInput *controller,
GError **error)
{
HRESULT hresult;
DIPROPDWORD dword;
gint i, k;
DXDInputSource *source;
if ((controller->event = CreateEvent (NULL, TRUE, FALSE, NULL)) == NULL)
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"CreateEvent failed: %s",
g_win32_error_message (GetLastError ()));
return FALSE;
}
controller->format = g_new (DIDATAFORMAT, 1);
controller->format->dwSize = sizeof (DIDATAFORMAT);
controller->format->dwObjSize = sizeof (DIOBJECTDATAFORMAT);
dword.diph.dwSize = sizeof (DIPROPDWORD);
dword.diph.dwHeaderSize = sizeof (DIPROPHEADER);
dword.diph.dwObj = 0;
dword.diph.dwHow = DIPH_DEVICE;
/* Get the axis mode so we can use the same in the format */
if (FAILED ((hresult = IDirectInputDevice8_GetProperty (controller->didevice8,
DIPROP_AXISMODE,
&dword.diph))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::GetParameters failed: %s",
g_win32_error_message (hresult));
goto fail0;
}
controller->format->dwFlags = dword.dwData + 1;
controller->format->dwNumObjs =
controller->num_buttons +
controller->num_axes +
controller->num_sliders +
controller->num_povs;
controller->format->rgodf = g_new (DIOBJECTDATAFORMAT, controller->format->dwNumObjs);
k = 0;
controller->format->dwDataSize = 0;
for (i = 0; i < controller->num_buttons; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_BUTTON | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = 0;
controller->format->dwDataSize += 1;
k++;
}
controller->format->dwDataSize = 4*((controller->format->dwDataSize + 3)/4);
for (i = 0; i < controller->num_axes; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_AXIS | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = DIDOI_ASPECTPOSITION;
controller->format->dwDataSize += 4;
k++;
}
for (i = 0; i < controller->num_sliders; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_AXIS | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = DIDOI_ASPECTPOSITION;
controller->format->dwDataSize += 4;
k++;
}
for (i = 0; i < controller->num_povs; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_POV | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = 0;
controller->format->dwDataSize += 4;
k++;
}
g_assert (k == controller->format->dwNumObjs);
controller->format->dwDataSize = 4*((controller->format->dwDataSize + 3)/4);
controller->prevdata = g_malloc (controller->format->dwDataSize);
dump_data_format (controller->format);
if (FAILED ((hresult = IDirectInputDevice8_SetDataFormat (controller->didevice8,
controller->format))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::SetDataFormat failed: %s",
g_win32_error_message (hresult));
goto fail1;
}
if (FAILED ((hresult = IDirectInputDevice8_SetEventNotification (controller->didevice8,
controller->event))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::SetEventNotification failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
if (FAILED ((hresult = IDirectInputDevice8_Acquire (controller->didevice8))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::Acquire failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
if (FAILED ((hresult = IDirectInputDevice8_GetDeviceState (controller->didevice8,
controller->format->dwDataSize,
controller->prevdata))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::GetDeviceState failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
source = (DXDInputSource *) g_source_new (&dx_dinput_event_funcs,
sizeof (DXDInputSource));
source->controller = controller;
controller->source = (GSource *) source;
controller->pollfd = g_new (GPollFD, 1);
controller->pollfd->fd = (int) controller->event;
controller->pollfd->events = G_IO_IN;
g_source_add_poll (&source->source, controller->pollfd);
g_source_attach (&source->source, NULL);
return TRUE;
fail2:
IDirectInputDevice8_SetEventNotification (controller->didevice8, NULL);
fail1:
g_free (controller->format->rgodf);
g_free (controller->format);
controller->format = NULL;
g_free (controller->prevdata);
controller->prevdata = NULL;
fail0:
CloseHandle (controller->event);
controller->event = 0;
return FALSE;
}
static gboolean
dx_dinput_set_device (ControllerDXDInput *controller,
const gchar *guid)
{
GError *error = NULL;
if (controller->guid)
g_free (controller->guid);
controller->guid = g_strdup (guid);
g_object_set (controller, "name", _("DirectInput Events"), NULL);
if (controller->guid && strlen (controller->guid))
{
if (controller->store)
controller->didevice8 =
(LPDIRECTINPUTDEVICE8W) gimp_input_device_store_get_device_file (controller->store,
controller->guid);
}
else
{
g_object_set (controller, "state", _("No device configured"), NULL);
return FALSE;
}
if (controller->didevice8)
{
if (!dx_dinput_get_device_info (controller, &error) ||
!dx_dinput_setup_events (controller, &error))
{
g_object_set (controller, "state", error->message, NULL);
g_error_free (error);
}
}
else if (controller->store)
{
error = gimp_input_device_store_get_error (controller->store);
if (error)
{
g_object_set (controller, "state", error->message, NULL);
g_error_free (error);
}
else
{
g_object_set (controller, "state", _("Device not available"), NULL);
}
}
return FALSE;
}