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; }