static void
gimp_aspect_preview_set_drawable (GimpAspectPreview *preview,
GimpDrawable *drawable)
{
gint width;
gint height;
preview->drawable = drawable;
if (drawable->width > drawable->height)
{
width = MIN (drawable->width, 512);
height = (drawable->height * width) / drawable->width;
}
else
{
height = MIN (drawable->height, 512);
width = (drawable->width * height) / drawable->height;
}
gimp_preview_set_bounds (GIMP_PREVIEW (preview), 0, 0, width, height);
if (height > 0)
g_object_set (GIMP_PREVIEW (preview)->frame,
"ratio",
(gdouble) drawable->width / (gdouble) drawable->height,
NULL);
}
// Combine wavelets with latest FFT result and show output in the preview widget
void wavelet_preview(PluginData *pd)
{
int x, y, w, h;
gimp_preview_get_position (GIMP_PREVIEW(pd->preview), &x, &y);
gimp_preview_get_size (GIMP_PREVIEW(pd->preview), &w, &h);
gimp_pixel_rgn_init (&pd->region, pd->drawable, 0, 0, pd->image_width, pd->image_height, FALSE, TRUE);
wavelet_apply(pd, x, y, w, h);
gimp_pixel_rgn_set_rect(&pd->region, pd->img_pixels, x, y, w, h);
gimp_drawable_preview_draw_region(GIMP_DRAWABLE_PREVIEW(pd->preview), &pd->region);
}
static void
gimp_scrolled_preview_hscr_update (GimpScrolledPreview *preview)
{
GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
gint width;
width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin;
gtk_adjustment_configure (adj,
gtk_adjustment_get_value (adj),
0, width,
1.0,
MAX (GIMP_PREVIEW (preview)->width / 2.0, 1.0),
GIMP_PREVIEW (preview)->width);
}
static void
gimp_scrolled_preview_vscr_update (GimpScrolledPreview *preview)
{
GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gint height;
height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin;
gtk_adjustment_configure (adj,
gtk_adjustment_get_value (adj),
0, height,
1.0,
MAX (GIMP_PREVIEW (preview)->height / 2.0, 1.0),
GIMP_PREVIEW (preview)->height);
}
static void
gimp_scrolled_preview_area_size_allocate (GtkWidget *widget,
GtkAllocation *allocation,
GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
gint width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin;
gint height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin;
gimp_scrolled_preview_freeze (preview);
GIMP_PREVIEW (preview)->width = MIN (width, allocation->width);
GIMP_PREVIEW (preview)->height = MIN (height, allocation->height);
gimp_scrolled_preview_hscr_update (preview);
switch (priv->hscr_policy)
{
case GTK_POLICY_AUTOMATIC:
gtk_widget_set_visible (preview->hscr,
width > GIMP_PREVIEW (preview)->width);
break;
case GTK_POLICY_ALWAYS:
gtk_widget_show (preview->hscr);
break;
case GTK_POLICY_NEVER:
gtk_widget_hide (preview->hscr);
break;
}
gimp_scrolled_preview_vscr_update (preview);
switch (priv->vscr_policy)
{
case GTK_POLICY_AUTOMATIC:
gtk_widget_set_visible (preview->vscr,
height > GIMP_PREVIEW (preview)->height);
break;
case GTK_POLICY_ALWAYS:
gtk_widget_show (preview->vscr);
break;
case GTK_POLICY_NEVER:
gtk_widget_hide (preview->vscr);
break;
}
gtk_widget_set_visible (preview->nav_icon,
gtk_widget_get_visible (preview->vscr) &&
gtk_widget_get_visible (preview->hscr) &&
GIMP_PREVIEW_GET_CLASS (preview)->draw_thumb);
gimp_scrolled_preview_thaw (preview);
}
static void
gimp_aspect_preview_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
GimpDrawable *drawable = GIMP_ASPECT_PREVIEW (preview)->drawable;
gint size;
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget,
"size", &size,
NULL);
if (drawable->width > drawable->height)
{
preview->width = MIN (drawable->width, size);
preview->height = (drawable->height * preview->width) / drawable->width;
}
else
{
preview->height = MIN (drawable->height, size);
preview->width = (drawable->width * preview->height) / drawable->height;
}
gtk_widget_set_size_request (preview->area,
preview->width, preview->height);
}
static void
cm_blue_scale_callback (GtkAdjustment *adjustment,
CmParamsType *mix)
{
if (mix->monochrome)
{
mix->black.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
}
else
{
switch (mix->output_channel)
{
case CM_RED_CHANNEL:
mix->red.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
case CM_GREEN_CHANNEL:
mix->green.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
case CM_BLUE_CHANNEL:
mix->blue.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
}
}
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
preview_update (GtkWidget *widget)
{
GimpPixelRgn src_rgn; /* Source image region */
guchar *dst; /* Output image */
GimpPreview *preview; /* The preview widget */
guchar *src; /* Source pixel rows */
gint img_bpp;
gint x1,y1;
gint width, height;
preview = GIMP_PREVIEW (widget);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
width = preview->width;
height = preview->height;
gimp_preview_get_position (preview, &x1, &y1);
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE);
dst = g_new (guchar, width * height * img_bpp);
src = g_new (guchar, width * height * img_bpp);
gimp_pixel_rgn_get_rect (&src_rgn, src, x1, y1, width, height);
despeckle_median (src, dst, width, height, img_bpp, despeckle_radius, TRUE);
gimp_preview_draw_buffer (preview, dst, width * img_bpp);
g_free (src);
g_free (dst);
}
static void
gimp_aspect_preview_init (GimpAspectPreview *preview)
{
g_object_set (GIMP_PREVIEW (preview)->area,
"check-size", gimp_check_size (),
"check-type", gimp_check_type (),
NULL);
}
static void
dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value)
{
gimp_double_adjustment_update (adjustment, value);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
mblur_radio_button_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
mblur_set_sensitivity ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
alienmap2_toggle_update (GtkWidget *widget,
gpointer data)
{
gimp_toggle_button_update (widget, data);
alienmap2_set_sensitive ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
shift_amount_callback (GtkWidget *widget,
gpointer data)
{
GimpPreview *preview = GIMP_PREVIEW (data);
shvals.shift_amount = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget),
0);
gimp_preview_invalidate (preview);
}
static void
alienmap2_radio_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
alienmap2_set_labels ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
/**
* gimp_scrolled_preview_thaw:
* @preview: a #GimpScrolledPreview
*
* While the @preview is frozen, it is not going to redraw itself in
* response to scroll events.
*
* This function should only be used to implement widgets derived from
* #GimpScrolledPreview. There is no point in calling this from a plug-in.
*
* Since: GIMP 2.4
**/
void
gimp_scrolled_preview_thaw (GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview));
priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
g_return_if_fail (priv->frozen > 0);
priv->frozen--;
if (! priv->frozen)
{
gimp_preview_draw (GIMP_PREVIEW (preview));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
}
static void
cm_preserve_luminosity_callback (GtkWidget *widget,
CmParamsType *mix)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
mix->preserve_luminosity = TRUE;
else
mix->preserve_luminosity = FALSE;
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
dialog_recursive_callback (GtkWidget *widget,
gpointer data)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
filter_type |= FILTER_RECURSIVE;
else
filter_type &= ~FILTER_RECURSIVE;
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
change_radius_callback (GtkWidget *coord,
gpointer data)
{
GimpPreview *preview = GIMP_PREVIEW (data);
dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0);
dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1);
gimp_preview_invalidate (preview);
}
/**
* gimp_scrolled_preview_set_position:
* @preview: a #GimpScrolledPreview
* @x: horizontal scroll offset
* @y: vertical scroll offset
*
* Since: GIMP 2.4
**/
void
gimp_scrolled_preview_set_position (GimpScrolledPreview *preview,
gint x,
gint y)
{
GtkAdjustment *adj;
g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview));
gimp_scrolled_preview_freeze (preview);
gimp_scrolled_preview_hscr_update (preview);
gimp_scrolled_preview_vscr_update (preview);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
gtk_adjustment_set_value (adj, x - GIMP_PREVIEW (preview)->xmin);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gtk_adjustment_set_value (adj, y - GIMP_PREVIEW (preview)->ymin);
gimp_scrolled_preview_thaw (preview);
}
static void
vpropagate_toggle_button_update (GtkWidget *widget,
gpointer data)
{
gint i, result;
gimp_toggle_button_update (widget, data);
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
cm_update_ui (CmParamsType *mix)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
mix->monochrome);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->preserve_luminosity_toggle),
mix->preserve_luminosity);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
mix->output_channel);
cm_set_adjusters (mix);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
/**
* gimp_scrolled_preview_set_policy
* @preview: a #GimpScrolledPreview
* @hscrollbar_policy: policy for horizontal scrollbar
* @vscrollbar_policy: policy for vertical scrollbar
*
* Since: GIMP 2.4
**/
void
gimp_scrolled_preview_set_policy (GimpScrolledPreview *preview,
GtkPolicyType hscrollbar_policy,
GtkPolicyType vscrollbar_policy)
{
GimpScrolledPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview));
priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
priv->hscr_policy = hscrollbar_policy;
priv->vscr_policy = vscrollbar_policy;
gtk_widget_queue_resize (GIMP_PREVIEW (preview)->area);
}
static void
gimp_aspect_preview_dispose (GObject *object)
{
const gchar *data_name = g_object_get_data (G_OBJECT (object),
"gimp-aspect-preview-data-name");
if (data_name)
{
GimpPreview *preview = GIMP_PREVIEW (object);
PreviewSettings settings;
settings.update = gimp_preview_get_update (preview);
gimp_set_data (data_name, &settings, sizeof (PreviewSettings));
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_aspect_preview_constructed (GObject *object)
{
gchar *data_name;
PreviewSettings settings;
G_OBJECT_CLASS (parent_class)->constructed (object);
data_name = g_strdup_printf ("%s-aspect-preview-%d",
g_get_prgname (),
gimp_aspect_preview_counter++);
if (gimp_get_data (data_name, &settings))
{
gimp_preview_set_update (GIMP_PREVIEW (object), settings.update);
}
g_object_set_data_full (object, "gimp-aspect-preview-data-name",
data_name, (GDestroyNotify) g_free);
}
static void
cm_preview (CmParamsType *mix,
GimpPreview *preview)
{
guchar *src, *s;
guchar *dst, *d;
gint x, y;
gdouble red_norm, green_norm, blue_norm, black_norm;
gint width, height, bpp;
GimpDrawable *drawable;
red_norm = cm_calculate_norm (mix, &mix->red);
green_norm = cm_calculate_norm (mix, &mix->green);
blue_norm = cm_calculate_norm (mix, &mix->blue);
black_norm = cm_calculate_norm (mix, &mix->black);
drawable = gimp_zoom_preview_get_drawable (GIMP_ZOOM_PREVIEW (preview));
src = s = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
dst = d = g_new (guchar, width * height * bpp);
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++, s += bpp, d += bpp)
{
cm_process_pixel (mix, s, d,
red_norm, green_norm, blue_norm,
black_norm);
if (bpp == 4)
d[3] = s[3];
}
}
gimp_preview_draw_buffer (GIMP_PREVIEW (preview), dst, bpp * width);
g_free (src);
g_free (dst);
}
static void
cm_monochrome_callback (GtkWidget *widget,
CmParamsType *mix)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
{
mix->old_output_channel = mix->output_channel;
mix->monochrome = TRUE;
gtk_widget_set_sensitive (mix->combo, FALSE);
}
else
{
mix->output_channel = mix->old_output_channel;
mix->monochrome = FALSE;
gtk_widget_set_sensitive (mix->combo, TRUE);
}
cm_set_adjusters (mix);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
// GTK event handler for the graph widget
static gint graph_events (GtkWidget *widget, GdkEvent *event, PluginData *pd)
{
static GdkCursorType cursor_type = GDK_TOP_LEFT_ARROW;
int tx, ty, index, dist;
gdk_window_get_pointer (pd->graph->window, &tx, &ty, NULL);
if (event->type == GDK_EXPOSE)
{
if (pd->graph_pixmap == NULL)
pd->graph_pixmap = gdk_pixmap_new (pd->graph->window, GRAPH_WIDTH, GRAPH_HEIGHT, -1);
graph_redraw (pd);
}
else if (event->type == GDK_BUTTON_PRESS)
{
// Button press: add or grab a point
index = gdkpoint_bisect(tx, pd->curve_user.user_points, pd->curve_user.count);
if (index < pd->curve_user.count)
{
dist = pd->curve_user.user_points[index].x - tx;
}
if (index > 0 && tx - pd->curve_user.user_points[index-1].x < dist)
{
index -= 1;
dist = tx - pd->curve_user.user_points[index].x;
}
if (dist <= GRAPH_HOTSPOT || pd->curve_user.count == USER_POINT_COUNT)
pd->point_grabbed = curve_move_point(index, tx, ty, &pd->curve_user);
else
pd->point_grabbed = curve_add_point(tx, ty, &pd->curve_user);
pd->curve_user_changed = TRUE;
graph_redraw (pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
else if (event->type == GDK_BUTTON_RELEASE)
{
// Button release: move a point and remove it if requested
if (pd->point_grabbed >= 0) {
if (tx < 0 && pd->point_grabbed > 0) // if point is not first, remove it
curve_remove_point(pd->point_grabbed, &pd->curve_user);
else if (tx >= GRAPH_WIDTH && pd->point_grabbed+1 < pd->curve_user.count) // if point is not last, remove it
curve_remove_point(pd->point_grabbed, &pd->curve_user);
else
curve_move_point(pd->point_grabbed, CLAMPED(tx, 0,GRAPH_WIDTH-1), CLAMPED(ty, 0,GRAPH_HEIGHT-1), &pd->curve_user);
pd->point_grabbed = -1;
pd->curve_user_changed = TRUE;
graph_redraw (pd);
if (pd->do_preview_hd)
preview_hd(NULL, pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
}
else if (event->type == GDK_MOTION_NOTIFY)
{
// Mouse move: move a previously grabbed point
if (pd->point_grabbed >= 0){
pd->point_grabbed = curve_move_point(pd->point_grabbed, CLAMPED(tx, 0,GRAPH_WIDTH-1), CLAMPED(ty, 0,GRAPH_HEIGHT-1), &pd->curve_user);
pd->curve_user_changed = TRUE;
graph_redraw (pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
}
return FALSE;
}
static gboolean koi_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *main_hbox;
GtkWidget *preview;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *thread_count_spinbutton;
GtkObject *thread_count_spinbutton_value;
GtkWidget *notebook;
int ii;
// gui_options.threads = 4;
// gui_options.texture_threshold = 140;
// gui_options.clone_block_size = 16;
// gui_options.histogram_block_size = 8;
// gui_options.radius = 20;
// gui_options.jpeg_threshold = 64;
// gui_options.compress = .85;
gboolean run;
printf("######################################\n");
printf("############## GUI init ##############\n");
gimp_ui_init ("Koi", FALSE);
dialog = gimp_dialog_new ("Koi", "Koi", NULL, 0, gimp_standard_help_func, "Koi", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
//create plugins and link them into the list
create_clone_plugin();
plugin[0] = &clone_plugin;
create_grain_plugin();
plugin[1] = &grain_plugin;
create_texture_plugin();
plugin[2] = &texture_plugin;
create_speckle_plugin();
plugin[3] = &speckle_plugin;
create_mosaic_plugin();
plugin[4] = &mosaic_plugin;
create_jpeg_plugin();
plugin[5] = &jpeg_plugin;
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new (drawable, (gboolean *)TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 6, 6, 6);
main_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (main_hbox);
gtk_container_add (GTK_CONTAINER (alignment), main_hbox);
//######################################3
//this is where im make my notebook tabs
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_widget_show (notebook);
printf("creating tabs\n");
for(ii = 0; ii< NUM_PLUGINS; ii++)
{
// should make a checkbox with its name will do that later
//add the page to the notbook
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), plugin[ii]->create_gui(), plugin[ii]->label);
}
printf("all tabs created\n");
gtk_box_pack_start (GTK_BOX (main_hbox), notebook, FALSE, FALSE, 6);
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
label = gtk_label_new ("Thread count");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
thread_count_spinbutton = gimp_spin_button_new (&thread_count_spinbutton_value, NUM_THREADS, 0, 16, 1, 1, 0, 1, 0);
gtk_widget_show (thread_count_spinbutton);
gtk_box_pack_start (GTK_BOX (vbox), thread_count_spinbutton, FALSE, FALSE, 0);
// thread_count_spinbutton = gimp_spin_button_new (&thread_count_spinbutton_value, gui_options.threads, 1, 8, 1, 1, 1, 1, 0);
// gtk_box_pack_start (GTK_BOX (vbox), thread_count_spinbutton, FALSE, FALSE, 0);
// gtk_widget_show (thread_count_spinbutton);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
g_signal_connect_swapped (preview, "invalidated",G_CALLBACK (koi), drawable);
koi (drawable, GIMP_PREVIEW (preview));
// g_signal_connect (clone_check_button, "clicked", G_CALLBACK (cb_clone_check_button), &gui_options);
g_signal_connect (thread_count_spinbutton_value, "value_changed", G_CALLBACK (gimp_int_adjustment_update), &NUM_THREADS);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
static gboolean
spread_dialog (gint32 image_ID,
GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *frame;
GtkWidget *size;
GimpUnit unit;
gdouble xres;
gdouble yres;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Spread"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
frame = gimp_frame_new (_("Spread Amount"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* Get the image resolution and unit */
gimp_image_get_resolution (image_ID, &xres, &yres);
unit = gimp_image_get_unit (image_ID);
/* sizeentries */
size = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1,
GIMP_SIZE_ENTRY_UPDATE_SIZE,
spvals.spread_amount_x == spvals.spread_amount_y,
FALSE,
_("_Horizontal:"), spvals.spread_amount_x, xres,
0, MAX (drawable->width, drawable->height),
0, 0,
_("_Vertical:"), spvals.spread_amount_y, yres,
0, MAX (drawable->width, drawable->height),
0, 0);
gtk_container_add (GTK_CONTAINER (frame), size);
gtk_widget_show (size);
g_signal_connect (preview, "invalidated",
G_CALLBACK (spread_preview_update),
size);
g_signal_connect_swapped (size, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_widget_show (dialog);
spread_preview_update (GIMP_PREVIEW (preview), size);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
spvals.spread_amount_x =
gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 0);
spvals.spread_amount_y =
gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 1);
}
gtk_widget_destroy (dialog);
return run;
}
/* show our dialog */
static gboolean
exchange_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *preview;
GtkWidget *table;
GtkWidget *threshold;
GtkWidget *colorbutton;
GtkObject *adj;
GtkSizeGroup *group;
gint framenumber;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, TRUE);
dialog = gimp_dialog_new (_("Color Exchange"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
/* do some boxes here */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
frame = gimp_frame_new (_("Middle-Click Inside Preview to "
"Pick \"From Color\""));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_container_add (GTK_CONTAINER (frame), preview);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (exchange),
drawable);
g_signal_connect (GIMP_PREVIEW (preview)->area, "event",
G_CALLBACK (preview_event_handler),
preview);
/* a hidden color_button to handle the threshold more easily */
threshold = gimp_color_button_new (NULL, 1, 1,
&xargs.threshold,
GIMP_COLOR_AREA_FLAT);
g_signal_connect (threshold, "color-changed",
G_CALLBACK (gimp_color_button_get_color),
&xargs.threshold);
g_signal_connect (threshold, "color-changed",
G_CALLBACK (color_button_callback),
&xargs.threshold);
g_signal_connect_swapped (threshold, "color-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/* and our scales */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
for (framenumber = 0; framenumber < 2; framenumber++)
{
GtkWidget *vbox;
GtkWidget *image;
gint row = 0;
frame = gimp_frame_new (framenumber ? _("To Color") : _("From Color"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
table = gtk_table_new (framenumber ? 4 : 8, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
if (! framenumber)
{
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 3, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 5, 2);
}
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
colorbutton = gimp_color_button_new (framenumber ?
_("Color Exchange: To Color") :
_("Color Exchange: From Color"),
SCALE_WIDTH / 2, 16,
(framenumber ?
&xargs.to : &xargs.from),
GIMP_COLOR_AREA_FLAT);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
NULL, 0.0, 0.0,
colorbutton, 1, FALSE);
g_signal_connect (colorbutton, "color-changed",
G_CALLBACK (gimp_color_button_get_color),
framenumber ? &xargs.to : &xargs.from);
g_signal_connect (colorbutton, "color-changed",
G_CALLBACK (color_button_callback),
framenumber ? &xargs.to : &xargs.from);
g_signal_connect_swapped (colorbutton, "color-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
if (! framenumber)
from_colorbutton = colorbutton;
/* Red */
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED,
GTK_ICON_SIZE_BUTTON);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, row, row + 1 + (framenumber ? 0 : 1),
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("_Red:"), SCALE_WIDTH, 0,
framenumber ? xargs.to.r : xargs.from.r,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton);
g_object_set_data (G_OBJECT (colorbutton), "red", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
framenumber ? &xargs.to.r : &xargs.from.r);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
framenumber ? &xargs.to : &xargs.from);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
if (! framenumber)
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("R_ed threshold:"), SCALE_WIDTH, 0,
xargs.threshold.r,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", threshold);
g_object_set_data (G_OBJECT (threshold), "red", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&xargs.threshold.r);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
&xargs.threshold);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
}
/* Green */
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN,
GTK_ICON_SIZE_BUTTON);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, row, row + 1 + (framenumber ? 0 : 1),
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("_Green:"), SCALE_WIDTH, 0,
framenumber ? xargs.to.g : xargs.from.g,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton);
g_object_set_data (G_OBJECT (colorbutton), "green", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
framenumber ? &xargs.to.g : &xargs.from.g);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
framenumber ? &xargs.to : &xargs.from);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
if (! framenumber)
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("G_reen threshold:"), SCALE_WIDTH, 0,
xargs.threshold.g,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", threshold);
g_object_set_data (G_OBJECT (threshold), "green", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&xargs.threshold.g);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
&xargs.threshold);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
}
/* Blue */
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE,
GTK_ICON_SIZE_BUTTON);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, row, row + 1 + (framenumber ? 0 : 1),
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("_Blue:"), SCALE_WIDTH, 0,
framenumber ? xargs.to.b : xargs.from.b,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton);
g_object_set_data (G_OBJECT (colorbutton), "blue", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
framenumber ? &xargs.to.b : &xargs.from.b);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
framenumber ? &xargs.to : &xargs.from);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
if (! framenumber)
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++,
_("B_lue threshold:"), SCALE_WIDTH, 0,
xargs.threshold.b,
0.0, 1.0, 0.01, 0.1, 3,
TRUE, 0, 0,
NULL, NULL);
g_object_set_data (G_OBJECT (adj), "colorbutton", threshold);
g_object_set_data (G_OBJECT (threshold), "blue", adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&xargs.threshold.b);
g_signal_connect (adj, "value-changed",
G_CALLBACK (scale_callback),
&xargs.threshold);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
}
if (! framenumber)
{
GtkWidget *button;
button = gtk_check_button_new_with_mnemonic (_("Lock _thresholds"));
gtk_table_attach (GTK_TABLE (table), button, 2, 4, row, row + 1,
GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
lock_threshold);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_toggle_button_update),
&lock_threshold);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gimp_preview_invalidate),
preview);
}
}
g_object_unref (group);
/* show everything */
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
