procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 17:59:37 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

app: get rid of GtkInputDialog, also brings us closer to XI2

Browse source 
Added two new widgets, GimpDeviceInfoEditor, which is an editor/view
widget for GimpDeviceInfo, and GimpDeviceEditor, which is an editor
widget for all devices. Both are pretty much ugly right now and look a
lot like the old GtkInputDialog, but are at least internally cleaned
up and easily changable code and ui wise. Consider this a completely
intermediate state.

Also cleaned up GimpDeviceInfo so it's possible to have a proper
view on it, and did the needed changes to the preferences dialog
to use the new stuff.
This commit is contained in:
Michael Natterer 2010-02-12 15:46:07 +01:00
parent 77498d1587
commit c6bbeda444
9 changed files with 943 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

69
app/dialogs/preferences-dialog.c
View file

@ -19,9 +19,6 @@
#include <string.h> #include <string.h>
#undef GTK_DISABLE_DEPRECATED /* GtkInputDialog */
#undef GSEAL_ENABLE
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h" #include "libgimpmath/gimpmath.h"
@ -41,7 +38,7 @@
#include "widgets/gimpcontainercombobox.h" #include "widgets/gimpcontainercombobox.h"
#include "widgets/gimpcontainerview.h" #include "widgets/gimpcontainerview.h"
#include "widgets/gimpcontrollerlist.h" #include "widgets/gimpcontrollerlist.h"
#include "widgets/gimpdeviceinfo.h" #include "widgets/gimpdeviceeditor.h"
#include "widgets/gimpdevices.h" #include "widgets/gimpdevices.h"
#include "widgets/gimpdialogfactory.h" #include "widgets/gimpdialogfactory.h"
#include "widgets/gimpgrideditor.h" #include "widgets/gimpgrideditor.h"
@ -103,9 +100,9 @@ static void prefs_resolution_calibrate_callback (GtkWidget *widget,
GtkWidget *entry); GtkWidget *entry);
static void prefs_input_devices_dialog (GtkWidget *widget, static void prefs_input_devices_dialog (GtkWidget *widget,
Gimp *gimp); Gimp *gimp);
static void prefs_input_dialog_able_callback (GtkWidget *widget, static void prefs_input_devices_dialog_response (GtkWidget *dialog,
GdkDevice *device, gint response_id,
gpointer data); Gimp *gimp);
static void prefs_menus_save_callback (GtkWidget *widget, static void prefs_menus_save_callback (GtkWidget *widget,
Gimp *gimp); Gimp *gimp);
static void prefs_menus_clear_callback (GtkWidget *widget, static void prefs_menus_clear_callback (GtkWidget *widget,
@ -498,15 +495,28 @@ prefs_input_devices_dialog (GtkWidget *widget,
{ {
static GtkWidget *input_dialog = NULL; static GtkWidget *input_dialog = NULL;
GtkWidget *content_area;
GtkWidget *editor;
if (input_dialog) if (input_dialog)
{ {
gtk_window_present (GTK_WINDOW (input_dialog)); gtk_window_present (GTK_WINDOW (input_dialog));
return; return;
} }
input_dialog = g_object_new (GTK_TYPE_INPUT_DIALOG, input_dialog = gimp_dialog_new (_("Configure Input Devices"), "preferences",
"title", _("Configure Input Devices"), NULL, 0,
NULL); NULL, NULL,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (input_dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CLOSE,
-1);
g_object_add_weak_pointer (G_OBJECT (input_dialog), g_object_add_weak_pointer (G_OBJECT (input_dialog),
(gpointer) &input_dialog); (gpointer) &input_dialog);
@ -515,32 +525,35 @@ prefs_input_devices_dialog (GtkWidget *widget,
GTK_WINDOW (prefs_dialog)); GTK_WINDOW (prefs_dialog));
gtk_window_set_destroy_with_parent (GTK_WINDOW (input_dialog), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (input_dialog), TRUE);
g_signal_connect_swapped (GTK_INPUT_DIALOG (input_dialog)->save_button, g_signal_connect (input_dialog, "response",
"clicked", G_CALLBACK (prefs_input_devices_dialog_response),
G_CALLBACK (gimp_devices_save), gimp);
gimp);
g_signal_connect_swapped (GTK_INPUT_DIALOG (input_dialog)->close_button, content_area = gtk_dialog_get_content_area (GTK_DIALOG (input_dialog));
"clicked",
G_CALLBACK (gtk_widget_destroy),
input_dialog);
g_signal_connect (input_dialog, "enable-device", editor = gimp_device_editor_new ();
G_CALLBACK (prefs_input_dialog_able_callback), gtk_container_set_border_width (GTK_CONTAINER (editor), 12);
NULL); gtk_container_add (GTK_CONTAINER (content_area), editor);
g_signal_connect (input_dialog, "disable-device", gtk_widget_show (editor);
G_CALLBACK (prefs_input_dialog_able_callback),
NULL);
gtk_widget_show (input_dialog); gtk_widget_show (input_dialog);
} }
static void static void
prefs_input_dialog_able_callback (GtkWidget *widget, prefs_input_devices_dialog_response (GtkWidget *dialog,
GdkDevice *device, gint response_id,
gpointer data) Gimp *gimp)
{ {
gimp_device_info_changed_by_device (device); switch (response_id)
{
case GTK_RESPONSE_OK:
gimp_devices_save (gimp, TRUE);
break;
default:
gtk_widget_destroy (dialog);
break;
}
} }
static void static void

4
app/widgets/Makefile.am
View file

@ -112,8 +112,12 @@ libappwidgets_a_sources = \
gimpdataeditor.h \ gimpdataeditor.h \
gimpdatafactoryview.c \ gimpdatafactoryview.c \
gimpdatafactoryview.h \ gimpdatafactoryview.h \
gimpdeviceeditor.c \
gimpdeviceeditor.h \
gimpdeviceinfo.c \ gimpdeviceinfo.c \
gimpdeviceinfo.h \ gimpdeviceinfo.h \
gimpdeviceinfoeditor.c \
gimpdeviceinfoeditor.h \
gimpdevices.c \ gimpdevices.c \
gimpdevices.h \ gimpdevices.h \
gimpdevicestatus.c \ gimpdevicestatus.c \

129
app/widgets/gimpdeviceeditor.c Normal file
View file

@ -0,0 +1,129 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimpmarshal.h"
#include "gimpdeviceeditor.h"
#include "gimpdeviceinfo.h"
#include "gimpdeviceinfoeditor.h"
#include "gimp-intl.h"
typedef struct _GimpDeviceEditorPrivate GimpDeviceEditorPrivate;
struct _GimpDeviceEditorPrivate
{
GtkWidget *notebook;
};
#define GIMP_DEVICE_EDITOR_GET_PRIVATE(editor) \
G_TYPE_INSTANCE_GET_PRIVATE (editor, \
GIMP_TYPE_DEVICE_EDITOR, \
GimpDeviceEditorPrivate)
static void gimp_device_editor_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen);
G_DEFINE_TYPE (GimpDeviceEditor, gimp_device_editor, GTK_TYPE_HBOX)
static void
gimp_device_editor_class_init (GimpDeviceEditorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
widget_class->screen_changed = gimp_device_editor_screen_changed;
g_type_class_add_private (object_class, sizeof (GimpDeviceEditorPrivate));
}
static void
gimp_device_editor_init (GimpDeviceEditor *editor)
{
GimpDeviceEditorPrivate *private = GIMP_DEVICE_EDITOR_GET_PRIVATE (editor);
gtk_box_set_spacing (GTK_BOX (editor), 12);
private->notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (private->notebook), GTK_POS_LEFT);
gtk_box_pack_start (GTK_BOX (editor), private->notebook, TRUE, TRUE, 0);
gtk_widget_show (private->notebook);
}
static void
gimp_device_editor_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GimpDeviceEditor *editor = GIMP_DEVICE_EDITOR (widget);
GimpDeviceEditorPrivate *private = GIMP_DEVICE_EDITOR_GET_PRIVATE (editor);
GdkDevice *core_pointer = NULL;
GList *devices = NULL;
GList *list;
if (gtk_widget_has_screen (widget))
{
GdkDisplay *display = gtk_widget_get_display (widget);
devices = gdk_display_list_devices (display);
core_pointer = gdk_display_get_core_pointer (display);
}
gtk_container_foreach (GTK_CONTAINER (private->notebook),
(GtkCallback) gtk_widget_destroy,
NULL);
if (g_list_length (devices) <= 1)
return;
for (list = devices; list; list = g_list_next (list))
{
GdkDevice *device = list->data;
if (device != core_pointer)
{
GimpDeviceInfo *info = gimp_device_info_get_by_device (device);
GtkWidget *widget;
widget = gimp_device_info_editor_new (info);
gtk_container_set_border_width (GTK_CONTAINER (widget), 12);
gtk_notebook_append_page (GTK_NOTEBOOK (private->notebook),
widget,
gtk_label_new (gimp_object_get_name (info)));
gtk_widget_show (widget);
}
}
}
GtkWidget *
gimp_device_editor_new (void)
{
return g_object_new (GIMP_TYPE_DEVICE_EDITOR, NULL);
}

48
app/widgets/gimpdeviceeditor.h Normal file
View file

@ -0,0 +1,48 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <http://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_DEVICE_EDITOR_H__
#define __GIMP_DEVICE_EDITOR_H__
#define GIMP_TYPE_DEVICE_EDITOR (gimp_device_editor_get_type ())
#define GIMP_DEVICE_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DEVICE_EDITOR, GimpDeviceEditor))
#define GIMP_DEVICE_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DEVICE_EDITOR, GimpDeviceEditorClass))
#define GIMP_IS_DEVICE_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DEVICE_EDITOR))
#define GIMP_IS_DEVICE_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DEVICE_EDITOR))
#define GIMP_DEVICE_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DEVICE_EDITOR, GimpDeviceEditorClass))
typedef struct _GimpDeviceEditorClass GimpDeviceEditorClass;
struct _GimpDeviceEditor
{
GtkHBox parent_instance;
};
struct _GimpDeviceEditorClass
{
GtkHBoxClass parent_class;
};
GType gimp_device_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_device_editor_new (void);
#endif /* __GIMP_DEVICE_EDITOR_H__ */

228
app/widgets/gimpdeviceinfo.c
View file

@ -129,9 +129,9 @@ gimp_device_info_init (GimpDeviceInfo *device_info)
device_info->device = NULL; device_info->device = NULL;
device_info->display = NULL; device_info->display = NULL;
device_info->mode = GDK_MODE_DISABLED; device_info->mode = GDK_MODE_DISABLED;
device_info->num_axes = 0; device_info->n_axes = 0;
device_info->axes = NULL; device_info->axes = NULL;
device_info->num_keys = 0; device_info->n_keys = 0;
device_info->keys = NULL; device_info->keys = NULL;
} }
@ -210,10 +210,7 @@ gimp_device_info_set_property (GObject *object,
switch (property_id) switch (property_id)
{ {
case PROP_MODE: case PROP_MODE:
if (device) gimp_device_info_set_mode (device_info, g_value_get_enum (value));
gdk_device_set_mode (device, g_value_get_enum (value));
else
device_info->mode = g_value_get_enum (value);
break; break;
case PROP_AXES: case PROP_AXES:
@ -233,8 +230,8 @@ gimp_device_info_set_property (GObject *object,
{ {
n_device_values = array->n_values; n_device_values = array->n_values;
device_info->num_axes = n_device_values; device_info->n_axes = n_device_values;
device_info->axes = g_new0 (GdkAxisUse, n_device_values); device_info->axes = g_new0 (GdkAxisUse, n_device_values);
} }
for (i = 0; i < n_device_values; i++) for (i = 0; i < n_device_values; i++)
@ -243,10 +240,7 @@ gimp_device_info_set_property (GObject *object,
axis_use = g_value_get_enum (g_value_array_get_nth (array, i)); axis_use = g_value_get_enum (g_value_array_get_nth (array, i));
if (device) gimp_device_info_set_axis_use (device_info, i, axis_use);
gdk_device_set_axis_use (device, i, axis_use);
else
device_info->axes[i] = axis_use;
} }
} }
} }
@ -269,8 +263,8 @@ gimp_device_info_set_property (GObject *object,
{ {
n_device_values = array->n_values; n_device_values = array->n_values;
device_info->num_keys = n_device_values; device_info->n_keys = n_device_values;
device_info->keys = g_new0 (GdkDeviceKey, n_device_values); device_info->keys = g_new0 (GdkDeviceKey, n_device_values);
} }
for (i = 0; i < n_device_values; i++) for (i = 0; i < n_device_values; i++)
@ -283,15 +277,7 @@ gimp_device_info_set_property (GObject *object,
gtk_accelerator_parse (accel, &keyval, &modifiers); gtk_accelerator_parse (accel, &keyval, &modifiers);
if (device) gimp_device_info_set_key (device_info, i, keyval, modifiers);
{
gdk_device_set_key (device, i, keyval, modifiers);
}
else
{
device_info->keys[i].keyval = keyval;
device_info->keys[i].modifiers = modifiers;
}
} }
} }
} }
@ -310,31 +296,30 @@ gimp_device_info_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpDeviceInfo *device_info = GIMP_DEVICE_INFO (object); GimpDeviceInfo *device_info = GIMP_DEVICE_INFO (object);
GdkDevice *device = device_info->device;
switch (property_id) switch (property_id)
{ {
case PROP_MODE: case PROP_MODE:
if (device) g_value_set_enum (value, gimp_device_info_get_mode (device_info));
g_value_set_enum (value, device->mode);
else
g_value_set_enum (value, device_info->mode);
break; break;
case PROP_AXES: case PROP_AXES:
{ {
GValueArray *array; GValueArray *array;
GValue enum_value = { 0, }; GValue enum_value = { 0, };
gint n_axes;
gint i; gint i;
array = g_value_array_new (6); array = g_value_array_new (6);
g_value_init (&enum_value, GDK_TYPE_AXIS_USE); g_value_init (&enum_value, GDK_TYPE_AXIS_USE);
for (i = 0; i < (device ? device->num_axes : device_info->num_axes); i++) n_axes = gimp_device_info_get_n_axes (device_info);
for (i = 0; i < n_axes; i++)
{ {
g_value_set_enum (&enum_value, g_value_set_enum (&enum_value,
device ? gimp_device_info_get_axis_use (device_info, i));
device->axes[i].use : device_info->axes[i]);
g_value_array_append (array, &enum_value); g_value_array_append (array, &enum_value);
} }
@ -348,17 +333,20 @@ gimp_device_info_get_property (GObject *object,
{ {
GValueArray *array; GValueArray *array;
GValue string_value = { 0, }; GValue string_value = { 0, };
gint n_keys;
gint i; gint i;
array = g_value_array_new (32); array = g_value_array_new (32);
g_value_init (&string_value, G_TYPE_STRING); g_value_init (&string_value, G_TYPE_STRING);
for (i = 0; i < (device ? device->num_keys : device_info->num_keys); i++) n_keys = gimp_device_info_get_n_keys (device_info);
for (i = 0; i < n_keys; i++)
{ {
GdkModifierType modifiers = (device ? device->keys[i].modifiers : guint keyval;
device_info->keys[i].modifiers); GdkModifierType modifiers;
guint keyval = (device ? device->keys[i].keyval :
device_info->keys[i].keyval); gimp_device_info_get_key (device_info, i, &keyval, &modifiers);
if (keyval) if (keyval)
{ {
@ -392,6 +380,9 @@ gimp_device_info_get_property (GObject *object,
} }
} }
/* public functions */
GimpDeviceInfo * GimpDeviceInfo *
gimp_device_info_new (Gimp *gimp, gimp_device_info_new (Gimp *gimp,
const gchar *name) const gchar *name)
@ -405,6 +396,144 @@ gimp_device_info_new (Gimp *gimp,
NULL); NULL);
} }
GdkInputMode
gimp_device_info_get_mode (GimpDeviceInfo *info)
{
g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), GDK_MODE_DISABLED);
if (info->device)
return info->device->mode;
else
return info->mode;
}
void
gimp_device_info_set_mode (GimpDeviceInfo *info,
GdkInputMode mode)
{
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
if (mode != gimp_device_info_get_mode (info))
{
if (info->device)
gdk_device_set_mode (info->device, mode);
else
info->mode = mode;
g_object_notify (G_OBJECT (info), "mode");
gimp_device_info_changed (info);
}
}
gint
gimp_device_info_get_n_axes (GimpDeviceInfo *info)
{
g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), 0);
if (info->device)
return info->device->num_axes;
else
return info->n_axes;
}
GdkAxisUse
gimp_device_info_get_axis_use (GimpDeviceInfo *info,
gint axis)
{
g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), GDK_AXIS_IGNORE);
g_return_val_if_fail (axis >= 0 && axis < gimp_device_info_get_n_axes (info),
GDK_AXIS_IGNORE);
if (info->device)
return info->device->axes[axis].use;
else
return info->axes[axis];
}
void
gimp_device_info_set_axis_use (GimpDeviceInfo *info,
gint axis,
GdkAxisUse use)
{
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
g_return_if_fail (axis >= 0 && axis < gimp_device_info_get_n_axes (info));
if (use != gimp_device_info_get_axis_use (info, axis))
{
if (info->device)
gdk_device_set_axis_use (info->device, axis, use);
else
info->axes[axis] = use;
g_object_notify (G_OBJECT (info), "axes");
}
}
gint
gimp_device_info_get_n_keys (GimpDeviceInfo *info)
{
g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), 0);
if (info->device)
return info->device->num_keys;
else
return info->n_keys;
}
void
gimp_device_info_get_key (GimpDeviceInfo *info,
gint key,
guint *keyval,
GdkModifierType *modifiers)
{
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
g_return_if_fail (key >= 0 && key < gimp_device_info_get_n_keys (info));
g_return_if_fail (keyval != NULL);
g_return_if_fail (modifiers != NULL);
if (info->device)
{
*keyval = info->device->keys[key].keyval;
*modifiers = info->device->keys[key].modifiers;
}
else
{
*keyval = info->keys[key].keyval;
*modifiers = info->keys[key].modifiers;
}
}
void
gimp_device_info_set_key (GimpDeviceInfo *info,
gint key,
guint keyval,
GdkModifierType modifiers)
{
guint old_keyval;
GdkModifierType old_modifiers;
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
g_return_if_fail (key >= 0 && key < gimp_device_info_get_n_keys (info));
gimp_device_info_get_key (info, key, &old_keyval, &old_modifiers);
if (keyval != old_keyval ||
modifiers != old_modifiers)
{
if (info->device)
{
gdk_device_set_key (info->device, key, keyval, modifiers);
}
else
{
info->keys[key].keyval = keyval;
info->keys[key].modifiers = modifiers;
}
g_object_notify (G_OBJECT (info), "keys");
}
}
GimpDeviceInfo * GimpDeviceInfo *
gimp_device_info_set_from_device (GimpDeviceInfo *device_info, gimp_device_info_set_from_device (GimpDeviceInfo *device_info,
GdkDevice *device, GdkDevice *device,
@ -416,16 +545,16 @@ gimp_device_info_set_from_device (GimpDeviceInfo *device_info,
g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, device_info); g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, device_info);
device_info->device = device; device_info->device = device;
device_info->display = display; device_info->display = display;
device_info->mode = device->mode; device_info->mode = device->mode;
device_info->num_axes = device->num_axes; device_info->n_axes = device->num_axes;
device_info->axes = NULL; device_info->axes = NULL;
device_info->num_keys = device->num_keys; device_info->n_keys = device->num_keys;
device_info->keys = NULL; device_info->keys = NULL;
return device_info; return device_info;
} }
@ -445,16 +574,3 @@ gimp_device_info_get_by_device (GdkDevice *device)
return g_object_get_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY); return g_object_get_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY);
} }
void
gimp_device_info_changed_by_device (GdkDevice *device)
{
GimpDeviceInfo *device_info;
g_return_if_fail (GDK_IS_DEVICE (device));
device_info = gimp_device_info_get_by_device (device);
if (device_info)
gimp_device_info_changed (device_info);
}

34
app/widgets/gimpdeviceinfo.h
View file

@ -55,9 +55,9 @@ struct _GimpDeviceInfo
/* either "device" or the options below are set */ /* either "device" or the options below are set */
GdkInputMode mode; GdkInputMode mode;
gint num_axes; gint n_axes;
GdkAxisUse *axes; GdkAxisUse *axes;
gint num_keys; gint n_keys;
GdkDeviceKey *keys; GdkDeviceKey *keys;
}; };
@ -71,16 +71,36 @@ struct _GimpDeviceInfoClass
GType gimp_device_info_get_type (void) G_GNUC_CONST; GType gimp_device_info_get_type (void) G_GNUC_CONST;
GimpDeviceInfo * gimp_device_info_new (Gimp *gimp, GimpDeviceInfo * gimp_device_info_new (Gimp *gimp,
const gchar *name); const gchar *name);
GimpDeviceInfo * gimp_device_info_set_from_device (GimpDeviceInfo *device_info, GdkInputMode gimp_device_info_get_mode (GimpDeviceInfo *info);
void gimp_device_info_set_mode (GimpDeviceInfo *info,
GdkInputMode mode);
gint gimp_device_info_get_n_axes (GimpDeviceInfo *info);
GdkAxisUse gimp_device_info_get_axis_use (GimpDeviceInfo *info,
gint axis);
void gimp_device_info_set_axis_use (GimpDeviceInfo *info,
gint axis,
GdkAxisUse use);
gint gimp_device_info_get_n_keys (GimpDeviceInfo *info);
void gimp_device_info_get_key (GimpDeviceInfo *info,
gint key,
guint *keyval,
GdkModifierType *modifiers);
void gimp_device_info_set_key (GimpDeviceInfo *info,
gint key,
guint keyval,
GdkModifierType modifiers);
GimpDeviceInfo * gimp_device_info_set_from_device (GimpDeviceInfo *info,
GdkDevice *device, GdkDevice *device,
GdkDisplay *display); GdkDisplay *display);
void gimp_device_info_changed (GimpDeviceInfo *device_info); void gimp_device_info_changed (GimpDeviceInfo *info);
GimpDeviceInfo * gimp_device_info_get_by_device (GdkDevice *device); GimpDeviceInfo * gimp_device_info_get_by_device (GdkDevice *device);
void gimp_device_info_changed_by_device (GdkDevice *device);
G_END_DECLS G_END_DECLS

469
app/widgets/gimpdeviceinfoeditor.c Normal file
View file

@ -0,0 +1,469 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis
*
* gimpdeviceinfoeditor.c
* Copyright (C) 2010 Michael Natterer <mitch@gimp.org>
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "gimpdeviceinfo.h"
#include "gimpdeviceinfoeditor.h"
#include "gimp-intl.h"
enum
{
PROP_0,
PROP_INFO
};
typedef struct _GimpInputKeyInfo GimpInputKeyInfo;
struct _GimpInputKeyInfo
{
gint index;
GtkWidget *entry;
GimpDeviceInfoEditor *editor;
};
typedef struct _GimpDeviceInfoEditorPrivate GimpDeviceInfoEditorPrivate;
struct _GimpDeviceInfoEditorPrivate
{
GimpDeviceInfo *info;
GtkWidget *axis_combos[GDK_AXIS_LAST - GDK_AXIS_X];
};
#define GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE(editor) \
G_TYPE_INSTANCE_GET_PRIVATE (editor, \
GIMP_TYPE_DEVICE_INFO_EDITOR, \
GimpDeviceInfoEditorPrivate)
static GObject * gimp_device_info_editor_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_device_info_editor_finalize (GObject *object);
static void gimp_device_info_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_device_info_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
void gimp_device_info_editor_axis_changed (GimpIntComboBox *combo,
GimpDeviceInfoEditor *editor);
static gboolean gimp_device_info_editor_key_press (GtkWidget *widget,
GdkEventKey *event,
GimpInputKeyInfo *key);
static void gimp_device_info_editor_clear_key (GtkWidget *widget,
GimpInputKeyInfo *key);
static void gimp_device_info_editor_set_key (GimpInputKeyInfo *key,
guint keyval,
GdkModifierType modifiers);
G_DEFINE_TYPE (GimpDeviceInfoEditor, gimp_device_info_editor, GTK_TYPE_VBOX)
#define parent_class gimp_device_info_editor_parent_class
static void
gimp_device_info_editor_class_init (GimpDeviceInfoEditorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructor = gimp_device_info_editor_constructor;
object_class->finalize = gimp_device_info_editor_finalize;
object_class->set_property = gimp_device_info_editor_set_property;
object_class->get_property = gimp_device_info_editor_get_property;
g_object_class_install_property (object_class, PROP_INFO,
g_param_spec_object ("info",
NULL, NULL,
GIMP_TYPE_DEVICE_INFO,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (object_class, sizeof (GimpDeviceInfoEditorPrivate));
}
static void
gimp_device_info_editor_init (GimpDeviceInfoEditor *editor)
{
gtk_box_set_spacing (GTK_BOX (editor), 6);
}
static GObject *
gimp_device_info_editor_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpDeviceInfoEditor *editor;
GimpDeviceInfoEditorPrivate *private;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *table;
gint n_keys;
gint i;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
editor = GIMP_DEVICE_INFO_EDITOR (object);
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (object);
g_assert (GIMP_IS_DEVICE_INFO (private->info));
/* the mode menu */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Mode:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_prop_enum_combo_box_new (G_OBJECT (private->info), "mode",
0, 0);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
/* the axes */
table = gtk_table_new (GDK_AXIS_LAST, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (editor), table, FALSE, FALSE, 0);
gtk_widget_show (table);
for (i = GDK_AXIS_X; i < GDK_AXIS_LAST; i++)
{
static const gchar *const axis_use_strings[] =
{
N_("_X:"),
N_("_Y:"),
N_("_Pressure:"),
N_("X _tilt:"),
N_("Y t_ilt:"),
N_("_Wheel:")
};
gint n_axes = gimp_device_info_get_n_axes (private->info);
gint j;
combo = gimp_int_combo_box_new (_("none"), -1,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), -1);
private->axis_combos[i - 1] = combo;
gimp_table_attach_aligned (GTK_TABLE (table), 0, i - 1,
axis_use_strings[i - 1], 0.0, 0.5,
combo, 1, FALSE);
for (j = 0; j < n_axes; j++)
{
gchar string[16];
g_snprintf (string, sizeof (string), "%d", j + 1);
gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (combo),
GIMP_INT_STORE_VALUE, j,
GIMP_INT_STORE_LABEL, string,
-1);
if (gimp_device_info_get_axis_use (private->info, j) == i)
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), j);
}
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_device_info_editor_axis_changed),
editor);
}
/* the keys */
n_keys = gimp_device_info_get_n_keys (private->info);
table = gtk_table_new (n_keys, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (editor), table, FALSE, FALSE, 0);
gtk_widget_show (table);
for (i = 0; i < n_keys; i++)
{
GimpInputKeyInfo *key = g_new (GimpInputKeyInfo, 1);
GtkWidget *button;
gchar string[32];
guint keyval;
GdkModifierType modifiers;
key->index = i;
key->editor = editor;
g_snprintf (string, sizeof (string), "_%d:", i + 1);
hbox = gtk_hbox_new (FALSE, 6);
key->entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label), key->entry);
gtk_box_pack_start (GTK_BOX (hbox), key->entry, TRUE, TRUE, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, i - 1,
string, 0.0, 0.5,
hbox, 1, FALSE);
g_signal_connect (key->entry, "key-press-event",
G_CALLBACK (gimp_device_info_editor_key_press),
key);
g_object_set_data_full (G_OBJECT (key->entry), "key", key,
(GDestroyNotify) g_free);
button = gtk_button_new_with_mnemonic (_("Cl_ear"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_device_info_editor_clear_key),
key);
gimp_device_info_get_key (private->info, i, &keyval, &modifiers);
gimp_device_info_editor_set_key (key, keyval, modifiers);
}
return object;
}
static void
gimp_device_info_editor_finalize (GObject *object)
{
GimpDeviceInfoEditorPrivate *private;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (object);
if (private->info)
{
g_object_unref (private->info);
private->info = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_device_info_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpDeviceInfoEditorPrivate *private;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (object);
switch (property_id)
{
case PROP_INFO:
private->info = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_device_info_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpDeviceInfoEditorPrivate *private;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (object);
switch (property_id)
{
case PROP_INFO:
g_value_set_object (value, private->info);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
gimp_device_info_editor_axis_changed (GimpIntComboBox *combo,
GimpDeviceInfoEditor *editor)
{
GimpDeviceInfoEditorPrivate *private;
GdkAxisUse new_use;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (editor);
for (new_use = GDK_AXIS_X; new_use < GDK_AXIS_LAST; new_use++)
{
if (private->axis_combos[new_use - 1] == (GtkWidget *) combo)
{
GdkAxisUse old_use = GDK_AXIS_IGNORE;
gint new_axis = -1;
gint old_axis = -1;
gint n_axes;
gint i;
gimp_int_combo_box_get_active (combo, &new_axis);
n_axes = gimp_device_info_get_n_axes (private->info);
for (i = 0; i < n_axes; i++)
if (gimp_device_info_get_axis_use (private->info, i) == new_use)
{
old_axis = i;
break;
}
if (new_axis == old_axis)
return;
if (new_axis != -1)
old_use = gimp_device_info_get_axis_use (private->info, new_axis);
/* we must always have an x and a y axis */
if ((new_axis == -1 && (new_use == GDK_AXIS_X ||
new_use == GDK_AXIS_Y)) ||
(old_axis == -1 && (old_use == GDK_AXIS_X ||
old_use == GDK_AXIS_Y)))
{
gimp_int_combo_box_set_active (combo, old_axis);
}
else
{
if (new_axis != -1)
gimp_device_info_set_axis_use (private->info, new_axis, new_use);
if (old_axis != -1)
gimp_device_info_set_axis_use (private->info, old_axis, old_use);
if (old_use != GDK_AXIS_IGNORE)
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (private->axis_combos[old_use - 1]),
old_axis);
}
break;
}
}
}
static gboolean
gimp_device_info_editor_key_press (GtkWidget *widget,
GdkEventKey *event,
GimpInputKeyInfo *key)
{
GimpDeviceInfoEditorPrivate *private;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (key->editor);
gimp_device_info_editor_set_key (key, event->keyval, event->state & 0xFF);
gimp_device_info_set_key (private->info, key->index,
event->keyval, event->state & 0xFF);
return TRUE;
}
static void
gimp_device_info_editor_clear_key (GtkWidget *widget,
GimpInputKeyInfo *key)
{
GimpDeviceInfoEditorPrivate *private;
private = GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE (key->editor);
gimp_device_info_editor_set_key (key, 0, 0);
gimp_device_info_set_key (private->info, key->index, 0, 0);
}
static void
gimp_device_info_editor_set_key (GimpInputKeyInfo *key,
guint keyval,
GdkModifierType modifiers)
{
GString *str;
gchar chars[2];
if (keyval)
{
str = g_string_new (NULL);
if (modifiers & GDK_SHIFT_MASK)
g_string_append (str, "Shift+");
if (modifiers & GDK_CONTROL_MASK)
g_string_append (str, "Ctrl+");
if (modifiers & GDK_MOD1_MASK)
g_string_append (str, "Alt+");
if ((keyval >= 0x20) && (keyval <= 0xFF))
{
chars[0] = keyval;
chars[1] = 0;
g_string_append (str, chars);
}
else
g_string_append (str, _("(unknown)"));
gtk_entry_set_text (GTK_ENTRY (key->entry),
g_string_free (str, FALSE));
}
else
{
gtk_entry_set_text (GTK_ENTRY (key->entry), _("(disabled)"));
}
}
/* public functions */
GtkWidget *
gimp_device_info_editor_new (GimpDeviceInfo *info)
{
g_return_val_if_fail (GIMP_IS_DEVICE_INFO (info), NULL);
return g_object_new (GIMP_TYPE_DEVICE_INFO_EDITOR,
"info", info,
NULL);
}

51
app/widgets/gimpdeviceinfoeditor.h Normal file
View file

@ -0,0 +1,51 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdeviceinfoeditor.h
* Copyright (C) 2010 Michael Natterer <mitch@gimp.org>
*
* 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 <http://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_DEVICE_INFO_EDITOR_H__
#define __GIMP_DEVICE_INFO_EDITOR_H__
#define GIMP_TYPE_DEVICE_INFO_EDITOR (gimp_device_info_editor_get_type ())
#define GIMP_DEVICE_INFO_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DEVICE_INFO_EDITOR, GimpDeviceInfoEditor))
#define GIMP_DEVICE_INFO_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DEVICE_INFO_EDITOR, GimpDeviceInfoEditorClass))
#define GIMP_IS_DEVICE_INFO_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DEVICE_INFO_EDITOR))
#define GIMP_IS_DEVICE_INFO_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DEVICE_INFO_EDITOR))
#define GIMP_DEVICE_INFO_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DEVICE_INFO_EDITOR, GimpDeviceInfoEditorClass))
typedef struct _GimpDeviceInfoEditorClass GimpDeviceInfoEditorClass;
struct _GimpDeviceInfoEditor
{
GtkVBox parent_instance;
};
struct _GimpDeviceInfoEditorClass
{
GtkVBoxClass parent_class;
};
GType gimp_device_info_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_device_info_editor_new (GimpDeviceInfo *info);
#endif /* __GIMP_DEVICE_INFO_EDITOR_H__ */

2
app/widgets/widgets-types.h
View file

@ -161,6 +161,8 @@ typedef struct _GimpControllerEditor GimpControllerEditor;
typedef struct _GimpControllerList GimpControllerList; typedef struct _GimpControllerList GimpControllerList;
typedef struct _GimpCurveView GimpCurveView; typedef struct _GimpCurveView GimpCurveView;
typedef struct _GimpDashEditor GimpDashEditor; typedef struct _GimpDashEditor GimpDashEditor;
typedef struct _GimpDeviceEditor GimpDeviceEditor;
typedef struct _GimpDeviceInfoEditor GimpDeviceInfoEditor;
typedef struct _GimpFgBgEditor GimpFgBgEditor; typedef struct _GimpFgBgEditor GimpFgBgEditor;
typedef struct _GimpFgBgView GimpFgBgView; typedef struct _GimpFgBgView GimpFgBgView;
typedef struct _GimpFileProcView GimpFileProcView; typedef struct _GimpFileProcView GimpFileProcView;