mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-21 03:52:33 +00:00
f6858e21d1
* app/*.[ch]: Actually use the enum types GimpImageType, GimpImageBaseType, LayerModeEffects, PaintApplicationMode, BrushApplicationMode, GimpFillType and ConvertPaletteType, instead of just int or gint. Hopefully I catched most of the places where these should be used. Add an enum ConvolutionType, suffix the too general constants NORMAL, ABSOLUTE and NEGATIVE with _CONVOL. Use NORMAL_MODE instead of NORMAL in some places (this was what was intended). Fix some minor gccisms. * app/apptypes.h: New file. This file contains the above enumeration types, and some opaque struct typedefs. It was necessary to collect these in one header that doesn't include other headers, because when we started using the above mentioned types in the headers, all hell broke loose because of the spaghetti-like cross-inclusion mess between headers. (An example: Header A includes header B, which includes header C which includes A. B uses a type defined in A. This is not defined, because A hasn't defined it yet at the point where it includes B, and A included from B of course is skipped as we already are reading A.)
1409 lines
36 KiB
C
1409 lines
36 KiB
C
/* The GIMP -- an 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 2 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, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#include "appenv.h"
|
|
#include "actionarea.h"
|
|
#include "brush_scale.h"
|
|
#include "gimpbrushlist.h"
|
|
#include "devices.h"
|
|
#include "interface.h"
|
|
#include "gimprc.h"
|
|
#include "patterns.h"
|
|
#include "palette.h"
|
|
#include "session.h"
|
|
#include "tools.h"
|
|
#include "dialog_handler.h"
|
|
#include "indicator_area.h"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
#include "libgimp/gimpenv.h"
|
|
|
|
#define CELL_SIZE 20 /* The size of the preview cells */
|
|
#define PREVIEW_EVENT_MASK GDK_EXPOSURE_MASK | \
|
|
GDK_BUTTON_PRESS_MASK | \
|
|
GDK_BUTTON_RELEASE_MASK | \
|
|
GDK_BUTTON1_MOTION_MASK | \
|
|
GDK_ENTER_NOTIFY_MASK | \
|
|
GDK_LEAVE_NOTIFY_MASK
|
|
|
|
#define BRUSH_PREVIEW 1
|
|
#define PATTERN_PREVIEW 2
|
|
|
|
typedef struct _DeviceInfo DeviceInfo;
|
|
|
|
struct _DeviceInfo {
|
|
guint32 device; /* device ID */
|
|
gchar *name;
|
|
|
|
short is_init; /* has the user used it? */
|
|
short is_present; /* is the device currently present */
|
|
|
|
/* gdk_input options - for not present devices */
|
|
|
|
GdkInputMode mode;
|
|
gint num_axes;
|
|
GdkAxisUse *axes;
|
|
gint num_keys;
|
|
GdkDeviceKey *keys;
|
|
|
|
GimpBrushP brush;
|
|
GPatternP pattern;
|
|
ToolType tool;
|
|
unsigned char foreground[3];
|
|
};
|
|
|
|
typedef struct _DeviceInfoDialog DeviceInfoDialog;
|
|
|
|
struct _DeviceInfoDialog {
|
|
int num_devices;
|
|
guint32 current;
|
|
guint32 *ids;
|
|
|
|
GtkWidget *shell;
|
|
GtkWidget *table;
|
|
|
|
GtkWidget **frames;
|
|
GtkWidget **tools;
|
|
GtkWidget **colors;
|
|
GtkWidget **brushes;
|
|
GtkWidget **patterns;
|
|
GtkWidget **eventboxes;
|
|
};
|
|
|
|
/* Local Data */
|
|
|
|
GList *devices_info = NULL;
|
|
DeviceInfoDialog *deviceD = NULL;
|
|
GtkWidget *device_bpopup = NULL; /* Can't share since differnt depths */
|
|
GtkWidget *device_bpreview = NULL;
|
|
GtkWidget *device_patpopup = NULL;
|
|
GtkWidget *device_patpreview = NULL;
|
|
/* If true, don't update device information dialog */
|
|
int suppress_update = FALSE;
|
|
|
|
/* Local functions */
|
|
static void input_dialog_destroy_callback (GtkWidget *, gpointer);
|
|
void input_dialog_able_callback (GtkWidget *w, guint32 deviceid,
|
|
gpointer data);
|
|
static void devices_save_current_info (void);
|
|
static void devices_write_rc_device (DeviceInfo *device_info, FILE *fp);
|
|
static void devices_write_rc (void);
|
|
static void device_status_destroy_callback (void);
|
|
static void devices_close_callback (GtkWidget *, gpointer);
|
|
static void device_status_update_current ();
|
|
static gint brush_preview_events (GtkWidget *, GdkEvent *, int);
|
|
static gint pattern_preview_events (GtkWidget *, GdkEvent *, int);
|
|
|
|
/* Global data */
|
|
int current_device = GDK_CORE_POINTER;
|
|
|
|
/* the action area structure */
|
|
static ActionAreaItem action_items[] =
|
|
{
|
|
{ N_("Save"), (ActionCallback)devices_write_rc, NULL, NULL },
|
|
{ N_("Close"), devices_close_callback, NULL, NULL }
|
|
};
|
|
|
|
void
|
|
create_input_dialog (void)
|
|
{
|
|
static GtkWidget *inputd = NULL;
|
|
GtkWidget *hbbox;
|
|
|
|
if (!inputd)
|
|
{
|
|
inputd = gtk_input_dialog_new();
|
|
|
|
/* register this one only */
|
|
dialog_register(inputd);
|
|
|
|
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(inputd)->action_area), 2);
|
|
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (inputd)->action_area),
|
|
FALSE);
|
|
|
|
hbbox = gtk_hbutton_box_new();
|
|
gtk_button_box_set_spacing(GTK_BUTTON_BOX (hbbox), 4);
|
|
|
|
gtk_widget_reparent (GTK_INPUT_DIALOG (inputd)->save_button, hbbox);
|
|
GTK_WIDGET_SET_FLAGS (GTK_INPUT_DIALOG (inputd)->save_button,
|
|
GTK_CAN_DEFAULT);
|
|
gtk_widget_reparent (GTK_INPUT_DIALOG (inputd)->close_button, hbbox);
|
|
GTK_WIDGET_SET_FLAGS (GTK_INPUT_DIALOG (inputd)->close_button,
|
|
GTK_CAN_DEFAULT);
|
|
|
|
gtk_box_pack_end(GTK_BOX (GTK_DIALOG (inputd)->action_area), hbbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_grab_default (GTK_INPUT_DIALOG (inputd)->close_button);
|
|
gtk_widget_show(hbbox);
|
|
|
|
gtk_signal_connect (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->save_button),
|
|
"clicked",
|
|
GTK_SIGNAL_FUNC(devices_write_rc), NULL);
|
|
gtk_signal_connect (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
|
|
"clicked",
|
|
GTK_SIGNAL_FUNC(devices_close_callback), inputd);
|
|
|
|
gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
|
|
(GtkSignalFunc)input_dialog_destroy_callback,
|
|
&inputd);
|
|
gtk_signal_connect (GTK_OBJECT(inputd), "enable_device",
|
|
GTK_SIGNAL_FUNC(input_dialog_able_callback), NULL);
|
|
gtk_signal_connect (GTK_OBJECT(inputd), "disable_device",
|
|
GTK_SIGNAL_FUNC(input_dialog_able_callback), NULL);
|
|
gtk_widget_show (inputd);
|
|
}
|
|
else
|
|
{
|
|
if (!GTK_WIDGET_MAPPED(inputd))
|
|
gtk_widget_show(inputd);
|
|
else
|
|
gdk_window_raise(inputd->window);
|
|
}
|
|
}
|
|
|
|
void
|
|
input_dialog_able_callback (GtkWidget *w,
|
|
guint32 deviceid,
|
|
gpointer data)
|
|
{
|
|
device_status_update (deviceid);
|
|
}
|
|
|
|
static void
|
|
input_dialog_destroy_callback (GtkWidget *w,
|
|
gpointer call_data)
|
|
{
|
|
*((GtkWidget **)call_data) = NULL;
|
|
}
|
|
|
|
void
|
|
devices_init (void)
|
|
{
|
|
GList *tmp_list;
|
|
|
|
/* Create device info structures for present devices */
|
|
|
|
tmp_list = gdk_input_list_devices ();
|
|
|
|
while (tmp_list)
|
|
{
|
|
GdkDeviceInfo *gdk_info = (GdkDeviceInfo *)tmp_list->data;
|
|
DeviceInfo *device_info = g_new (DeviceInfo, 1);
|
|
|
|
device_info->device = gdk_info->deviceid;
|
|
device_info->name = g_strdup (gdk_info->name);
|
|
|
|
device_info->is_init = FALSE;
|
|
device_info->is_present = TRUE;
|
|
|
|
device_info->mode = gdk_info->mode;
|
|
device_info->num_axes = gdk_info->num_axes;
|
|
device_info->axes = NULL;
|
|
|
|
device_info->brush = NULL;
|
|
device_info->pattern = NULL;
|
|
device_info->tool = RECT_SELECT;
|
|
device_info->foreground[0] = 0;
|
|
device_info->foreground[1] = 0;
|
|
device_info->foreground[2] = 0;
|
|
|
|
devices_info = g_list_append (devices_info, device_info);
|
|
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
devices_restore (void)
|
|
{
|
|
char *filename;
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
|
|
/* Augment with information from rc file */
|
|
filename = gimp_personal_rc_file ("devicerc");
|
|
parse_gimprc_file (filename);
|
|
g_free (filename);
|
|
|
|
tmp_list = devices_info;
|
|
device_info = NULL;
|
|
while (tmp_list)
|
|
{
|
|
if (((DeviceInfo *)tmp_list->data)->device == current_device)
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
g_return_if_fail (device_info != NULL);
|
|
|
|
suppress_update = TRUE;
|
|
|
|
if (device_info->is_init)
|
|
{
|
|
if (device_info->brush)
|
|
select_brush (device_info->brush);
|
|
gtk_widget_activate (tool_info[(int) device_info->tool].tool_widget);
|
|
|
|
palette_set_foreground (device_info->foreground[0],
|
|
device_info->foreground[1],
|
|
device_info->foreground[2]);
|
|
|
|
if (device_info->pattern)
|
|
select_pattern(device_info->pattern);
|
|
}
|
|
|
|
suppress_update = FALSE;
|
|
}
|
|
|
|
void
|
|
devices_rc_update (gchar *name, DeviceValues values,
|
|
GdkInputMode mode, gint num_axes,
|
|
GdkAxisUse *axes, gint num_keys, GdkDeviceKey *keys,
|
|
gchar *brush_name, ToolType tool,
|
|
guchar foreground[], gchar *pattern_name)
|
|
{
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
|
|
/* Find device if we have it */
|
|
|
|
tmp_list = devices_info;
|
|
device_info = NULL;
|
|
while (tmp_list)
|
|
{
|
|
if (!strcmp (((DeviceInfo *)tmp_list->data)->name, name))
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
if (!device_info)
|
|
{
|
|
device_info = g_new (DeviceInfo, 1);
|
|
device_info->name = g_strdup (name);
|
|
device_info->is_present = FALSE;
|
|
|
|
if (values & DEVICE_AXES)
|
|
{
|
|
device_info->num_axes = num_axes;
|
|
device_info->axes = g_new (GdkAxisUse, num_axes);
|
|
memcpy (device_info->axes, axes, num_axes * sizeof (GdkAxisUse));
|
|
}
|
|
else
|
|
{
|
|
device_info->num_axes = 0;
|
|
device_info->axes = NULL;
|
|
}
|
|
|
|
if (values & DEVICE_KEYS)
|
|
{
|
|
device_info->num_keys = num_keys;
|
|
device_info->keys = g_new (GdkDeviceKey, num_keys);
|
|
memcpy (device_info->keys, axes, num_keys * sizeof (GdkDeviceKey));
|
|
}
|
|
|
|
if (values & DEVICE_MODE)
|
|
device_info->mode = mode;
|
|
else
|
|
device_info->mode = GDK_MODE_DISABLED;
|
|
|
|
device_info->brush = NULL;
|
|
device_info->pattern = NULL;
|
|
device_info->tool = RECT_SELECT;
|
|
device_info->foreground[0] = 0;
|
|
device_info->foreground[1] = 0;
|
|
device_info->foreground[2] = 0;
|
|
|
|
devices_info = g_list_append (devices_info, device_info);
|
|
}
|
|
else
|
|
{
|
|
GdkDeviceInfo *gdk_info = NULL; /* Quiet gcc */
|
|
|
|
tmp_list = gdk_input_list_devices();
|
|
while (tmp_list)
|
|
{
|
|
GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;
|
|
|
|
if (info->deviceid == device_info->device)
|
|
{
|
|
gdk_info = info;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
if (gdk_info != NULL)
|
|
{
|
|
if (values & DEVICE_MODE)
|
|
gdk_input_set_mode (gdk_info->deviceid, mode);
|
|
|
|
if ((values & DEVICE_AXES) && num_axes >= gdk_info->num_axes)
|
|
gdk_input_set_axes (gdk_info->deviceid, axes);
|
|
|
|
if ((values & DEVICE_KEYS) && num_keys >= gdk_info->num_keys)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<MAX (num_keys, gdk_info->num_keys); i++)
|
|
gdk_input_set_key (gdk_info->deviceid, i,
|
|
keys[i].keyval, keys[i].modifiers);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_warning (_("devices_rc_update called multiple times for not present device\n"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (values & (DEVICE_PATTERN | DEVICE_BRUSH | DEVICE_TOOL | DEVICE_FOREGROUND))
|
|
device_info->is_init = TRUE;
|
|
|
|
|
|
if (values & DEVICE_BRUSH)
|
|
{
|
|
device_info->brush = gimp_brush_list_get_brush (brush_list, brush_name);
|
|
}
|
|
|
|
if (values & DEVICE_PATTERN)
|
|
{
|
|
device_info->pattern = pattern_list_get_pattern (pattern_list,pattern_name);
|
|
}
|
|
|
|
if (values & DEVICE_TOOL)
|
|
device_info->tool = tool;
|
|
|
|
if (values & DEVICE_FOREGROUND)
|
|
{
|
|
device_info->foreground[0] = foreground[0];
|
|
device_info->foreground[1] = foreground[1];
|
|
device_info->foreground[2] = foreground[2];
|
|
}
|
|
}
|
|
|
|
void
|
|
select_device (guint32 new_device)
|
|
{
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
|
|
suppress_update = TRUE;
|
|
|
|
/* store old information */
|
|
|
|
devices_save_current_info();
|
|
|
|
/* Now see if there is already information about the new device */
|
|
|
|
tmp_list = devices_info;
|
|
device_info = NULL;
|
|
while (tmp_list)
|
|
{
|
|
if (((DeviceInfo *)tmp_list->data)->device == new_device)
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
current_device = new_device;
|
|
|
|
if (device_info->is_init)
|
|
{
|
|
if (device_info->brush)
|
|
select_brush (device_info->brush);
|
|
gtk_widget_activate (tool_info[(int) device_info->tool].tool_widget);
|
|
palette_set_foreground (device_info->foreground[0],
|
|
device_info->foreground[1],
|
|
device_info->foreground[2]);
|
|
if (device_info->pattern)
|
|
select_pattern(device_info->pattern);
|
|
}
|
|
|
|
suppress_update = FALSE;
|
|
|
|
device_status_update_current ();
|
|
}
|
|
|
|
gint
|
|
devices_check_change (GdkEvent *event)
|
|
{
|
|
guint32 device;
|
|
|
|
switch (event->type)
|
|
{
|
|
case GDK_MOTION_NOTIFY:
|
|
device = ((GdkEventMotion *)event)->deviceid;
|
|
break;
|
|
case GDK_BUTTON_PRESS:
|
|
case GDK_BUTTON_RELEASE:
|
|
device = ((GdkEventButton *)event)->deviceid;
|
|
break;
|
|
case GDK_PROXIMITY_OUT:
|
|
device = ((GdkEventProximity *)event)->deviceid;
|
|
break;
|
|
default:
|
|
device = current_device;
|
|
}
|
|
|
|
if (device != current_device)
|
|
{
|
|
select_device (device);
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
devices_save_current_info (void)
|
|
{
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
|
|
tmp_list = devices_info;
|
|
device_info = NULL;
|
|
while (tmp_list)
|
|
{
|
|
if (((DeviceInfo *)tmp_list->data)->device == current_device)
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
device_info->is_init = TRUE;
|
|
device_info->device = current_device;
|
|
device_info->brush = get_active_brush ();
|
|
device_info->pattern = get_active_pattern();
|
|
if (active_tool)
|
|
device_info->tool = active_tool->type;
|
|
else
|
|
device_info->tool = RECT_SELECT;
|
|
palette_get_foreground (&device_info->foreground[0],
|
|
&device_info->foreground[1],
|
|
&device_info->foreground[2]);
|
|
}
|
|
|
|
static void
|
|
devices_write_rc_device (DeviceInfo *device_info,
|
|
FILE *fp)
|
|
{
|
|
GdkDeviceInfo *gdk_info;
|
|
GList *tmp_list;
|
|
gchar *mode = NULL; /* Quiet gcc */
|
|
int i;
|
|
|
|
gdk_info = NULL;
|
|
if (device_info->is_present)
|
|
{
|
|
/* gdk_input_list_devices returns an internal list, so we shouldn't
|
|
free it afterwards */
|
|
tmp_list = gdk_input_list_devices();
|
|
while (tmp_list)
|
|
{
|
|
GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;
|
|
|
|
if (info->deviceid == device_info->device)
|
|
{
|
|
gdk_info = info;
|
|
break;
|
|
}
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
}
|
|
|
|
fprintf(fp, "(device \"%s\"",device_info->name);
|
|
|
|
switch (gdk_info ? gdk_info->mode : device_info->mode)
|
|
{
|
|
case GDK_MODE_DISABLED:
|
|
mode = "disabled";
|
|
break;
|
|
case GDK_MODE_SCREEN:
|
|
mode = "screen";
|
|
break;
|
|
case GDK_MODE_WINDOW:
|
|
mode = "window";
|
|
break;
|
|
}
|
|
|
|
fprintf(fp, "\n (mode %s)",mode);
|
|
|
|
fprintf(fp, "\n (axes %d",gdk_info ? gdk_info->num_axes : device_info->num_axes);
|
|
|
|
for (i=0; i<(gdk_info ? gdk_info->num_axes : device_info->num_axes); i++)
|
|
{
|
|
gchar *axis_type = NULL; /* Quiet gcc */
|
|
|
|
switch (gdk_info ? gdk_info->axes[i] : device_info->axes[i])
|
|
{
|
|
case GDK_AXIS_IGNORE:
|
|
axis_type = "ignore";
|
|
break;
|
|
case GDK_AXIS_X:
|
|
axis_type = "x";
|
|
break;
|
|
case GDK_AXIS_Y:
|
|
axis_type = "y";
|
|
break;
|
|
case GDK_AXIS_PRESSURE:
|
|
axis_type = "pressure";
|
|
break;
|
|
case GDK_AXIS_XTILT:
|
|
axis_type = "xtilt";
|
|
break;
|
|
case GDK_AXIS_YTILT:
|
|
axis_type = "ytilt";
|
|
break;
|
|
}
|
|
fprintf(fp, " %s",axis_type);
|
|
}
|
|
fprintf(fp,")");
|
|
|
|
fprintf(fp, "\n (keys %d", gdk_info ? gdk_info->num_keys : device_info->num_keys);
|
|
|
|
for (i=0; i<(gdk_info ? gdk_info->num_keys : device_info->num_keys); i++)
|
|
{
|
|
GdkModifierType modifiers = gdk_info ? gdk_info->keys[i].modifiers :
|
|
device_info->keys[i].modifiers;
|
|
guint keyval = gdk_info ? gdk_info->keys[i].keyval :
|
|
device_info->keys[i].keyval;
|
|
|
|
if (keyval)
|
|
{
|
|
/* FIXME: integrate this back with menus_install_accelerator */
|
|
char accel[64];
|
|
char t2[2];
|
|
|
|
accel[0] = '\0';
|
|
if (modifiers & GDK_CONTROL_MASK)
|
|
strcat (accel, "<control>");
|
|
if (modifiers & GDK_SHIFT_MASK)
|
|
strcat (accel, "<shift>");
|
|
if (modifiers & GDK_MOD1_MASK)
|
|
strcat (accel, "<alt>");
|
|
|
|
t2[0] = keyval;
|
|
t2[1] = '\0';
|
|
strcat (accel, t2);
|
|
fprintf (fp, " \"%s\"",accel);
|
|
}
|
|
else
|
|
fprintf (fp, " \"\"");
|
|
}
|
|
fprintf(fp,")");
|
|
|
|
if (device_info->is_init)
|
|
{
|
|
if (device_info->brush)
|
|
fprintf(fp, "\n (brush \"%s\")",device_info->brush->name);
|
|
if (device_info->pattern)
|
|
fprintf(fp, "\n (pattern \"%s\")",device_info->pattern->name);
|
|
/* Fixme: hard coded last tool.... see gimprc */
|
|
if (device_info->tool && device_info->tool <= LAST_TOOLBOX_TOOL)
|
|
fprintf(fp, "\n (tool \"%s\")",
|
|
tool_info[device_info->tool].tool_name);
|
|
fprintf(fp, "\n (foreground %d %d %d)",
|
|
device_info->foreground[0],
|
|
device_info->foreground[1],
|
|
device_info->foreground[2]);
|
|
}
|
|
fprintf(fp,")\n");
|
|
|
|
}
|
|
|
|
static void
|
|
devices_write_rc (void)
|
|
{
|
|
char *filename;
|
|
FILE *fp;
|
|
|
|
devices_save_current_info ();
|
|
|
|
filename = gimp_personal_rc_file ("devicerc");
|
|
fp = fopen (filename, "wb");
|
|
g_free (filename);
|
|
|
|
if (!fp)
|
|
return;
|
|
|
|
g_list_foreach (devices_info, (GFunc)devices_write_rc_device, fp);
|
|
|
|
fclose (fp);
|
|
}
|
|
|
|
void
|
|
create_device_status (void)
|
|
{
|
|
GtkWidget *label;
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
int i;
|
|
|
|
if (deviceD == NULL)
|
|
{
|
|
deviceD = g_new (DeviceInfoDialog, 1);
|
|
deviceD->shell = gtk_dialog_new ();
|
|
|
|
/* register this one only */
|
|
dialog_register(deviceD->shell);
|
|
|
|
gtk_window_set_title (GTK_WINDOW(deviceD->shell), _("Device Status"));
|
|
gtk_window_set_policy (GTK_WINDOW (deviceD->shell), FALSE, FALSE, TRUE);
|
|
/* don't set the dialog's size, as the number of devices may have
|
|
* changed since the last session
|
|
*/
|
|
session_set_window_geometry (deviceD->shell,
|
|
&device_status_session_info, FALSE);
|
|
|
|
deviceD->num_devices = 0;
|
|
tmp_list = devices_info;
|
|
while (tmp_list)
|
|
{
|
|
if (((DeviceInfo *)tmp_list->data)->is_present)
|
|
deviceD->num_devices++;
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
/* devices table */
|
|
deviceD->table = gtk_table_new (deviceD->num_devices, 5, FALSE);
|
|
gtk_container_set_border_width (GTK_CONTAINER(deviceD->table), 3);
|
|
gtk_container_add (GTK_CONTAINER(GTK_DIALOG(deviceD->shell)->vbox),
|
|
deviceD->table);
|
|
gtk_widget_realize (deviceD->table);
|
|
gtk_widget_show (deviceD->table);
|
|
|
|
deviceD->ids = g_new (guint32, deviceD->num_devices);
|
|
deviceD->frames = g_new (GtkWidget *, deviceD->num_devices);
|
|
deviceD->tools = g_new (GtkWidget *, deviceD->num_devices);
|
|
deviceD->colors = g_new (GtkWidget *, deviceD->num_devices);
|
|
deviceD->brushes = g_new (GtkWidget *, deviceD->num_devices);
|
|
deviceD->patterns = g_new (GtkWidget *, deviceD->num_devices);
|
|
deviceD->eventboxes = g_new (GtkWidget *, deviceD->num_devices);
|
|
|
|
tmp_list = devices_info;
|
|
i=0;
|
|
while (tmp_list)
|
|
{
|
|
if (!((DeviceInfo *)tmp_list->data)->is_present)
|
|
{
|
|
tmp_list = tmp_list->next;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
|
|
deviceD->ids[i] = device_info->device;
|
|
|
|
deviceD->frames[i] = gtk_frame_new (NULL);
|
|
|
|
gtk_frame_set_shadow_type (GTK_FRAME(deviceD->frames[i]), GTK_SHADOW_OUT);
|
|
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->frames[i],
|
|
0, 1, i, i+1,
|
|
GTK_FILL, GTK_FILL, 2, 0);
|
|
|
|
label = gtk_label_new (device_info->name);
|
|
gtk_misc_set_padding (GTK_MISC(label), 2, 0);
|
|
gtk_container_add (GTK_CONTAINER(deviceD->frames[i]), label);
|
|
gtk_widget_show(label);
|
|
|
|
deviceD->eventboxes[i] = gtk_event_box_new();
|
|
|
|
deviceD->tools[i] = gtk_pixmap_new (create_tool_pixmap(deviceD->table,
|
|
RECT_SELECT),
|
|
NULL);
|
|
|
|
gtk_container_add (GTK_CONTAINER (deviceD->eventboxes[i]),deviceD->tools[i]);
|
|
|
|
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->eventboxes[i],
|
|
1, 2, i, i+1,
|
|
0, 0, 2, 2);
|
|
|
|
deviceD->colors[i] = gtk_preview_new (GTK_PREVIEW_COLOR);
|
|
gtk_widget_set_events (deviceD->colors[i], PREVIEW_EVENT_MASK);
|
|
gtk_preview_size (GTK_PREVIEW (deviceD->colors[i]), CELL_SIZE, CELL_SIZE);
|
|
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->colors[i],
|
|
2, 3, i, i+1,
|
|
0, 0, 2, 2);
|
|
|
|
deviceD->brushes[i] = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
|
|
gtk_preview_size (GTK_PREVIEW (deviceD->brushes[i]), CELL_SIZE, CELL_SIZE);
|
|
gtk_widget_set_events (deviceD->brushes[i], PREVIEW_EVENT_MASK);
|
|
gtk_signal_connect (GTK_OBJECT (deviceD->brushes[i]), "event",
|
|
(GtkSignalFunc) brush_preview_events,
|
|
(gpointer)i);
|
|
|
|
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->brushes[i],
|
|
3, 4, i, i+1,
|
|
0, 0, 2, 2);
|
|
|
|
|
|
deviceD->patterns[i] = gtk_preview_new (GTK_PREVIEW_COLOR);
|
|
gtk_preview_size (GTK_PREVIEW (deviceD->patterns[i]), CELL_SIZE, CELL_SIZE);
|
|
gtk_widget_set_events (deviceD->patterns[i], PREVIEW_EVENT_MASK);
|
|
gtk_signal_connect (GTK_OBJECT (deviceD->patterns[i]), "event",
|
|
(GtkSignalFunc) pattern_preview_events,
|
|
(gpointer)i);
|
|
|
|
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->patterns[i],
|
|
4, 5, i, i+1,
|
|
0, 0, 2, 2);
|
|
|
|
|
|
if (device_info->is_present)
|
|
device_status_update (device_info->device);
|
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
i++;
|
|
}
|
|
|
|
action_items[1].user_data = deviceD->shell;
|
|
build_action_area (GTK_DIALOG (deviceD->shell), action_items, 2, 1);
|
|
|
|
deviceD->current = 0xffffffff; /* random, but doesn't matter */
|
|
device_status_update_current ();
|
|
|
|
gtk_widget_show (deviceD->shell);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (deviceD->shell), "destroy",
|
|
GTK_SIGNAL_FUNC(device_status_destroy_callback),
|
|
NULL);
|
|
}
|
|
else
|
|
{
|
|
if (!GTK_WIDGET_MAPPED(deviceD->shell))
|
|
gtk_widget_show(deviceD->shell);
|
|
else
|
|
gdk_window_raise(deviceD->shell->window);
|
|
}
|
|
}
|
|
|
|
static void
|
|
device_status_destroy_callback (void)
|
|
{
|
|
g_free(deviceD->ids);
|
|
g_free(deviceD->frames);
|
|
g_free(deviceD->tools);
|
|
g_free(deviceD->eventboxes);
|
|
g_free(deviceD->colors);
|
|
g_free(deviceD->brushes);
|
|
g_free(deviceD->patterns);
|
|
|
|
g_free(deviceD);
|
|
deviceD = NULL;
|
|
}
|
|
|
|
static void
|
|
devices_close_callback (GtkWidget *w,
|
|
gpointer data)
|
|
{
|
|
gtk_widget_hide (GTK_WIDGET(data));
|
|
}
|
|
|
|
void
|
|
device_status_free (void)
|
|
{
|
|
/* Save device status on exit */
|
|
if(save_device_status)
|
|
devices_write_rc();
|
|
|
|
if (deviceD)
|
|
{
|
|
session_get_window_info (deviceD->shell, &device_status_session_info);
|
|
device_status_destroy_callback ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
device_status_update_current ()
|
|
{
|
|
int i;
|
|
|
|
if (deviceD)
|
|
{
|
|
for (i=0; i<deviceD->num_devices; i++)
|
|
{
|
|
if (deviceD->ids[i] == deviceD->current)
|
|
gtk_frame_set_shadow_type (GTK_FRAME(deviceD->frames[i]),
|
|
GTK_SHADOW_OUT);
|
|
else if (deviceD->ids[i] == current_device)
|
|
gtk_frame_set_shadow_type (GTK_FRAME(deviceD->frames[i]),
|
|
GTK_SHADOW_IN);
|
|
}
|
|
deviceD->current = current_device;
|
|
}
|
|
}
|
|
|
|
static void
|
|
brush_popup_open (int preview_id,
|
|
int x,
|
|
int y,
|
|
GimpBrushP brush)
|
|
{
|
|
gint x_org, y_org;
|
|
gint scr_w, scr_h;
|
|
gchar *src, *buf;
|
|
|
|
/* make sure the popup exists and is not visible */
|
|
if (device_bpopup == NULL)
|
|
{
|
|
GtkWidget *frame;
|
|
|
|
device_bpopup = gtk_window_new (GTK_WINDOW_POPUP);
|
|
gtk_window_set_policy (GTK_WINDOW (device_bpopup), FALSE, FALSE, TRUE);
|
|
|
|
frame = gtk_frame_new (NULL);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
|
|
gtk_container_add (GTK_CONTAINER (device_bpopup), frame);
|
|
gtk_widget_show (frame);
|
|
device_bpreview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
|
|
gtk_container_add (GTK_CONTAINER (frame), device_bpreview);
|
|
gtk_widget_show (device_bpreview);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (device_bpopup);
|
|
}
|
|
|
|
/* decide where to put the popup */
|
|
gdk_window_get_origin (deviceD->brushes[preview_id]->window, &x_org, &y_org);
|
|
scr_w = gdk_screen_width ();
|
|
scr_h = gdk_screen_height ();
|
|
x = x_org + x - (brush->mask->width >> 1);
|
|
y = y_org + y - (brush->mask->height >> 1);
|
|
x = (x < 0) ? 0 : x;
|
|
y = (y < 0) ? 0 : y;
|
|
x = (x + brush->mask->width > scr_w) ? scr_w - brush->mask->width : x;
|
|
y = (y + brush->mask->height > scr_h) ? scr_h - brush->mask->height : y;
|
|
gtk_preview_size (GTK_PREVIEW (device_bpreview), brush->mask->width, brush->mask->height);
|
|
|
|
gtk_widget_popup (device_bpopup, x, y);
|
|
|
|
/* Draw the brush */
|
|
buf = g_new (gchar, brush->mask->width);
|
|
src = (gchar *)temp_buf_data (brush->mask);
|
|
for (y = 0; y < brush->mask->height; y++)
|
|
{
|
|
/* Invert the mask for display. We're doing this because
|
|
* a value of 255 in the mask means it is full intensity.
|
|
* However, it makes more sense for full intensity to show
|
|
* up as black in this brush preview window...
|
|
*/
|
|
for (x = 0; x < brush->mask->width; x++)
|
|
buf[x] = 255 - src[x];
|
|
gtk_preview_draw_row (GTK_PREVIEW (device_bpreview), (guchar *)buf, 0, y, brush->mask->width);
|
|
src += brush->mask->width;
|
|
}
|
|
g_free(buf);
|
|
|
|
/* Draw the brush preview */
|
|
gtk_widget_draw (device_bpreview, NULL);
|
|
}
|
|
|
|
static void
|
|
pattern_popup_open (int preview_id,
|
|
int x,
|
|
int y,
|
|
GPatternP pattern)
|
|
{
|
|
gint x_org, y_org;
|
|
gint scr_w, scr_h;
|
|
gchar *src, *buf;
|
|
|
|
/* make sure the popup exists and is not visible */
|
|
if (device_patpopup == NULL)
|
|
{
|
|
GtkWidget *frame;
|
|
|
|
device_patpopup = gtk_window_new (GTK_WINDOW_POPUP);
|
|
gtk_window_set_policy (GTK_WINDOW (device_patpopup), FALSE, FALSE, TRUE);
|
|
|
|
frame = gtk_frame_new (NULL);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
|
|
gtk_container_add (GTK_CONTAINER (device_patpopup), frame);
|
|
gtk_widget_show (frame);
|
|
device_patpreview = gtk_preview_new (GTK_PREVIEW_COLOR);
|
|
gtk_container_add (GTK_CONTAINER (frame), device_patpreview);
|
|
gtk_widget_show (device_patpreview);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (device_patpopup);
|
|
}
|
|
|
|
/* decide where to put the popup */
|
|
gdk_window_get_origin (deviceD->patterns[preview_id]->window, &x_org, &y_org);
|
|
scr_w = gdk_screen_width ();
|
|
scr_h = gdk_screen_height ();
|
|
x = x_org + x - (pattern->mask->width >> 1);
|
|
y = y_org + y - (pattern->mask->height >> 1);
|
|
x = (x < 0) ? 0 : x;
|
|
y = (y < 0) ? 0 : y;
|
|
x = (x + pattern->mask->width > scr_w) ? scr_w - pattern->mask->width : x;
|
|
y = (y + pattern->mask->height > scr_h) ? scr_h - pattern->mask->height : y;
|
|
gtk_preview_size (GTK_PREVIEW (device_patpreview), pattern->mask->width, pattern->mask->height);
|
|
|
|
gtk_widget_popup (device_patpopup, x, y);
|
|
|
|
/* Draw the pattern */
|
|
buf = g_new (gchar, pattern->mask->width * 3);
|
|
src = (gchar *)temp_buf_data (pattern->mask);
|
|
for (y = 0; y < pattern->mask->height; y++)
|
|
{
|
|
if (pattern->mask->bytes == 1)
|
|
for (x = 0; x < pattern->mask->width; x++)
|
|
{
|
|
buf[x*3+0] = src[x];
|
|
buf[x*3+1] = src[x];
|
|
buf[x*3+2] = src[x];
|
|
}
|
|
else
|
|
for (x = 0; x < pattern->mask->width; x++)
|
|
{
|
|
buf[x*3+0] = src[x*3+0];
|
|
buf[x*3+1] = src[x*3+1];
|
|
buf[x*3+2] = src[x*3+2];
|
|
}
|
|
gtk_preview_draw_row (GTK_PREVIEW (device_patpreview), (guchar *)buf, 0, y, pattern->mask->width);
|
|
src += pattern->mask->width * pattern->mask->bytes;
|
|
}
|
|
g_free(buf);
|
|
|
|
/* Draw the brush preview */
|
|
gtk_widget_draw (device_patpreview, NULL);
|
|
}
|
|
|
|
static void
|
|
device_popup_close (int type)
|
|
{
|
|
if(type == BRUSH_PREVIEW)
|
|
{
|
|
if (device_bpopup != NULL)
|
|
gtk_widget_hide (device_bpopup);
|
|
}
|
|
else if (type == PATTERN_PREVIEW)
|
|
{
|
|
if (device_patpopup != NULL)
|
|
gtk_widget_hide (device_patpopup);
|
|
}
|
|
}
|
|
|
|
static gint
|
|
device_preview_events (GtkWidget *widget,
|
|
GdkEvent *event,
|
|
int deviceid,
|
|
int type)
|
|
{
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
GdkEventButton *bevent;
|
|
GimpBrushP brush;
|
|
GPatternP pattern;
|
|
|
|
switch (event->type)
|
|
{
|
|
case GDK_EXPOSE:
|
|
break;
|
|
|
|
case GDK_BUTTON_PRESS:
|
|
bevent = (GdkEventButton *) event;
|
|
|
|
if (bevent->button == 1)
|
|
{
|
|
tmp_list = devices_info;
|
|
while (tmp_list)
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
|
|
if (device_info->device == deviceD->ids[deviceid])
|
|
break;
|
|
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
if(tmp_list == NULL)
|
|
{
|
|
g_message(_("Failed to find device_info\n"));
|
|
break; /* Error no device info */
|
|
}
|
|
|
|
/* Grab the pointer */
|
|
gdk_pointer_grab (widget->window, FALSE,
|
|
(GDK_POINTER_MOTION_HINT_MASK |
|
|
GDK_BUTTON1_MOTION_MASK |
|
|
GDK_BUTTON_RELEASE_MASK),
|
|
NULL, NULL, bevent->time);
|
|
|
|
if (type == BRUSH_PREVIEW)
|
|
{
|
|
brush = device_info->brush;
|
|
|
|
/* Show the brush popup window if the brush is too large */
|
|
if (brush->mask->width > CELL_SIZE ||
|
|
brush->mask->height > CELL_SIZE)
|
|
brush_popup_open (deviceid, bevent->x, bevent->y, brush);
|
|
}
|
|
else if (type == PATTERN_PREVIEW)
|
|
{
|
|
pattern = device_info->pattern;
|
|
|
|
/* Show the pattern popup window if the pattern is too large */
|
|
if (pattern->mask->width > CELL_SIZE ||
|
|
pattern->mask->height > CELL_SIZE)
|
|
pattern_popup_open (deviceid, bevent->x, bevent->y, pattern);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GDK_BUTTON_RELEASE:
|
|
bevent = (GdkEventButton *) event;
|
|
|
|
if (bevent->button == 1)
|
|
{
|
|
/* Ungrab the pointer */
|
|
gdk_pointer_ungrab (bevent->time);
|
|
|
|
/* Close the device preview popup window */
|
|
device_popup_close (type);
|
|
}
|
|
break;
|
|
case GDK_DELETE:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
brush_preview_events (GtkWidget *widget,
|
|
GdkEvent *event,
|
|
int deviceid)
|
|
{
|
|
return (device_preview_events (widget, event, deviceid, BRUSH_PREVIEW));
|
|
}
|
|
|
|
static gint
|
|
pattern_preview_events (GtkWidget *widget,
|
|
GdkEvent *event,
|
|
int deviceid)
|
|
{
|
|
return (device_preview_events (widget, event, deviceid, PATTERN_PREVIEW));
|
|
}
|
|
|
|
static void
|
|
device_update_brush (GimpBrushP brush,
|
|
int preview_id)
|
|
{
|
|
guchar buffer[CELL_SIZE];
|
|
MaskBuf * brush_buf;
|
|
unsigned char * src, *s = NULL;
|
|
unsigned char *b;
|
|
gboolean scale = FALSE;
|
|
int width,height;
|
|
int offset_x, offset_y;
|
|
int yend;
|
|
int ystart;
|
|
int i, j;
|
|
|
|
if (no_data || no_interface) return;
|
|
/* Set the tip to be the name of the brush */
|
|
gtk_tooltips_set_tip (tool_tips, deviceD->brushes[preview_id], brush->name, NULL);
|
|
|
|
brush_buf = brush->mask;
|
|
|
|
if (brush_buf->width > CELL_SIZE || brush_buf->height > CELL_SIZE)
|
|
{
|
|
double ratio_x = (double)brush_buf->width / CELL_SIZE;
|
|
double ratio_y = (double)brush_buf->height / CELL_SIZE;
|
|
|
|
if (ratio_x >= ratio_y)
|
|
brush_buf = brush_scale_mask (brush_buf,
|
|
(double)(brush_buf->width) / ratio_x,
|
|
(double)(brush_buf->height) / ratio_x);
|
|
else
|
|
brush_buf = brush_scale_mask (brush_buf,
|
|
(double)(brush_buf->width) / ratio_y,
|
|
(double)(brush_buf->height) / ratio_y);
|
|
scale = TRUE;
|
|
}
|
|
|
|
/* Get the pointer into the brush mask data */
|
|
src = mask_buf_data (brush_buf);
|
|
|
|
/* Limit to cell size */
|
|
width = (brush_buf->width > CELL_SIZE) ? CELL_SIZE: brush_buf->width;
|
|
height = (brush_buf->height > CELL_SIZE) ? CELL_SIZE: brush_buf->height;
|
|
|
|
/* Set buffer to white */
|
|
memset(buffer, 255, sizeof(buffer));
|
|
for (i = 0; i < CELL_SIZE; i++)
|
|
gtk_preview_draw_row (GTK_PREVIEW (deviceD->brushes[preview_id]),
|
|
buffer, 0, i, CELL_SIZE);
|
|
|
|
offset_x = ((CELL_SIZE - width) >> 1);
|
|
offset_y = ((CELL_SIZE - height) >> 1);
|
|
|
|
ystart = BOUNDS (offset_y, 0, CELL_SIZE);
|
|
yend = BOUNDS (offset_y + height, 0, CELL_SIZE);
|
|
|
|
for (i = ystart; i < yend; i++)
|
|
{
|
|
/* Invert the mask for display. We're doing this because
|
|
* a value of 255 in the mask means it is full intensity.
|
|
* However, it makes more sense for full intensity to show
|
|
* up as black in this brush preview window...
|
|
*/
|
|
s = src;
|
|
b = buffer;
|
|
for (j = 0; j < width ; j++)
|
|
*b++ = 255 - *s++;
|
|
|
|
gtk_preview_draw_row (GTK_PREVIEW (deviceD->brushes[preview_id]),
|
|
buffer,
|
|
offset_x, i, width);
|
|
|
|
src += brush_buf->width;
|
|
}
|
|
|
|
if (scale)
|
|
{
|
|
offset_y = CELL_SIZE - brush_scale_indicator_height - 1;
|
|
for (i = 0; i < brush_scale_indicator_height; i++)
|
|
{
|
|
offset_x = CELL_SIZE - brush_scale_indicator_width - 1;
|
|
gtk_preview_draw_row (GTK_PREVIEW (deviceD->brushes[preview_id]),
|
|
brush_scale_indicator_bits[i][0],
|
|
offset_x, offset_y + i,
|
|
brush_scale_indicator_width);
|
|
}
|
|
mask_buf_free (brush_buf);
|
|
}
|
|
}
|
|
|
|
static void
|
|
device_update_pattern (GPatternP pattern,
|
|
int preview_id)
|
|
{
|
|
guchar *buffer = NULL;
|
|
TempBuf * pattern_buf;
|
|
unsigned char * src, *s = NULL;
|
|
unsigned char *b;
|
|
int rowstride;
|
|
int width,height;
|
|
int offset_x, offset_y;
|
|
int yend;
|
|
int ystart;
|
|
int i, j;
|
|
if (no_interface || no_data) return;
|
|
/* Set the tip to be the name of the brush */
|
|
gtk_tooltips_set_tip(tool_tips,deviceD->patterns[preview_id],pattern->name,NULL);
|
|
|
|
buffer = g_new (guchar, pattern->mask->width * 3);
|
|
pattern_buf = pattern->mask;
|
|
|
|
/* Limit to cell size */
|
|
width = (pattern_buf->width > CELL_SIZE) ? CELL_SIZE: pattern_buf->width;
|
|
height = (pattern_buf->height > CELL_SIZE) ? CELL_SIZE: pattern_buf->height;
|
|
|
|
/* Set buffer to white */
|
|
memset(buffer, 255, sizeof(buffer));
|
|
for (i = 0; i < CELL_SIZE; i++)
|
|
gtk_preview_draw_row (GTK_PREVIEW(deviceD->patterns[preview_id]), buffer, 0, i, CELL_SIZE);
|
|
|
|
offset_x = ((CELL_SIZE - width) >> 1);
|
|
offset_y = ((CELL_SIZE - height) >> 1);
|
|
|
|
ystart = BOUNDS (offset_y, 0, CELL_SIZE);
|
|
yend = BOUNDS (offset_y + height, 0, CELL_SIZE);
|
|
|
|
/* Get the pointer into the brush mask data */
|
|
rowstride = pattern_buf->width * pattern_buf->bytes;
|
|
src = mask_buf_data (pattern_buf) + (ystart - offset_y) * rowstride;
|
|
|
|
for (i = ystart; i < yend; i++)
|
|
{
|
|
/* Invert the mask for display. We're doing this because
|
|
* a value of 255 in the mask means it is full intensity.
|
|
* However, it makes more sense for full intensity to show
|
|
* up as black in this brush preview window...
|
|
*/
|
|
s = src;
|
|
b = buffer;
|
|
|
|
if (pattern_buf->bytes == 1)
|
|
for (j = 0; j < width; j++)
|
|
{
|
|
*b++ = *s;
|
|
*b++ = *s;
|
|
*b++ = *s++;
|
|
}
|
|
else
|
|
for (j = 0; j < width; j++)
|
|
{
|
|
*b++ = *s++;
|
|
*b++ = *s++;
|
|
*b++ = *s++;
|
|
}
|
|
|
|
gtk_preview_draw_row (GTK_PREVIEW(deviceD->patterns[preview_id]),
|
|
buffer,
|
|
offset_x, i, width);
|
|
|
|
src += rowstride;
|
|
}
|
|
g_free(buffer);
|
|
}
|
|
|
|
void
|
|
device_status_update (guint32 deviceid)
|
|
{
|
|
int i, j;
|
|
guchar buffer[CELL_SIZE*3];
|
|
gchar ttbuf[20]; /* [xxx,xxx,xxx] + null */
|
|
GList *tmp_list;
|
|
DeviceInfo *device_info;
|
|
GdkDeviceInfo *gdk_info;
|
|
|
|
if (deviceD && !suppress_update)
|
|
{
|
|
if (deviceid == current_device)
|
|
{
|
|
devices_save_current_info();
|
|
}
|
|
|
|
tmp_list = devices_info;
|
|
while (tmp_list)
|
|
{
|
|
device_info = (DeviceInfo *)tmp_list->data;
|
|
|
|
if (device_info->device == deviceid)
|
|
break;
|
|
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
g_return_if_fail (tmp_list != NULL);
|
|
|
|
tmp_list = gdk_input_list_devices();
|
|
while (tmp_list)
|
|
{
|
|
gdk_info = (GdkDeviceInfo *)tmp_list->data;
|
|
|
|
if (gdk_info->deviceid == deviceid)
|
|
break;
|
|
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
g_return_if_fail (tmp_list != NULL);
|
|
|
|
for (i=0; i<deviceD->num_devices; i++)
|
|
{
|
|
if (deviceD->ids[i] == deviceid)
|
|
break;
|
|
}
|
|
|
|
g_return_if_fail (i<deviceD->num_devices);
|
|
|
|
if (gdk_info->mode == GDK_MODE_DISABLED)
|
|
{
|
|
gtk_widget_hide (deviceD->frames[i]);
|
|
gtk_widget_hide (deviceD->tools[i]);
|
|
gtk_widget_hide (deviceD->eventboxes[i]);
|
|
gtk_widget_hide (deviceD->colors[i]);
|
|
gtk_widget_hide (deviceD->brushes[i]);
|
|
gtk_widget_hide (deviceD->patterns[i]);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_show (deviceD->frames[i]);
|
|
|
|
gtk_pixmap_set (GTK_PIXMAP (deviceD->tools[i]),
|
|
create_tool_pixmap (deviceD->table,
|
|
device_info->tool),
|
|
NULL);
|
|
|
|
gtk_widget_draw (deviceD->tools[i], NULL);
|
|
gtk_widget_show (deviceD->tools[i]);
|
|
gtk_widget_show (deviceD->eventboxes[i]);
|
|
|
|
gtk_tooltips_set_tip(tool_tips,deviceD->eventboxes[i],
|
|
tool_info[(int) device_info->tool].tool_desc,
|
|
NULL);
|
|
|
|
if(!device_info->is_init)
|
|
return; /* None of the entries have been set */
|
|
|
|
for (j=0;j<CELL_SIZE*3;j+=3)
|
|
{
|
|
buffer[j] = device_info->foreground[0];
|
|
buffer[j+1] = device_info->foreground[1];
|
|
buffer[j+2] = device_info->foreground[2];
|
|
}
|
|
|
|
for (j=0;j<CELL_SIZE;j++)
|
|
gtk_preview_draw_row (GTK_PREVIEW(deviceD->colors[i]), buffer,
|
|
0, j, CELL_SIZE);
|
|
gtk_widget_draw (deviceD->colors[i], NULL);
|
|
gtk_widget_show (deviceD->colors[i]);
|
|
|
|
/* Set the tip to be the RGB value */
|
|
sprintf(ttbuf,"[%3d,%3d,%3d]",
|
|
device_info->foreground[0],
|
|
device_info->foreground[1],
|
|
device_info->foreground[2]);
|
|
|
|
gtk_tooltips_set_tip(tool_tips,deviceD->colors[i],ttbuf,NULL);
|
|
|
|
|
|
device_update_brush(device_info->brush,i);
|
|
gtk_widget_draw (deviceD->brushes[i],NULL);
|
|
gtk_widget_show (deviceD->brushes[i]);
|
|
|
|
device_update_pattern(device_info->pattern,i);
|
|
gtk_widget_draw (deviceD->patterns[i],NULL);
|
|
gtk_widget_show (deviceD->patterns[i]);
|
|
|
|
}
|
|
}
|
|
|
|
if (show_indicators)
|
|
{
|
|
brush_area_update();
|
|
pattern_area_update();
|
|
}
|
|
}
|