/* * gfig_read_gimp_style() reads the style settings from the Gimp core, * and applies them to the specified style, giving that style the * specified name. This is mainly useful as a way of initializing * a style. The function does not cause a repaint. */ void gfig_read_gimp_style (Style *style, const gchar *name) { gint dummy; if (!name) g_message ("Error: name is NULL in gfig_read_gimp_style."); if (gfig_context->debug_styles) g_printerr ("Reading Gimp settings as style %s\n", name); style->name = g_strdup (name); gimp_context_get_foreground (&style->foreground); gimp_context_get_background (&style->background); style->brush_name = gimp_context_get_brush (); gimp_brush_get_info (style->brush_name, &style->brush_width, &style->brush_height, &dummy, &dummy); gimp_brush_get_spacing (style->brush_name, &style->brush_spacing); style->gradient = gimp_context_get_gradient (); style->pattern = gimp_context_get_pattern (); style->fill_opacity = 100.; gfig_context->bdesc.name = style->brush_name; gfig_context->bdesc.width = style->brush_width; gfig_context->bdesc.height = style->brush_height; }
gboolean gimp_paint_options_get_gradient_color (GimpPaintOptions *paint_options, GimpImage *image, gdouble grad_point, gdouble pixel_dist, GimpRGB *color) { GimpDynamics *dynamics; g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE); g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (color != NULL, FALSE); dynamics = gimp_context_get_dynamics (GIMP_CONTEXT (paint_options)); if (gimp_dynamics_is_output_enabled (dynamics, GIMP_DYNAMICS_OUTPUT_COLOR)) { GimpGradientOptions *gradient_options = paint_options->gradient_options; GimpGradient *gradient; gradient = gimp_context_get_gradient (GIMP_CONTEXT (paint_options)); gimp_gradient_get_color_at (gradient, GIMP_CONTEXT (paint_options), NULL, grad_point, gradient_options->gradient_reverse, color); return TRUE; } return FALSE; }
static GValueArray * gradients_sample_uniform_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; gint32 num_samples; gboolean reverse; gint32 array_length = 0; gdouble *color_samples = NULL; num_samples = g_value_get_int (&args->values[0]); reverse = g_value_get_boolean (&args->values[1]); if (success) { GimpGradient *gradient; GimpGradientSegment *seg = NULL; gdouble pos, delta; GimpRGB color; gdouble *pv; pos = 0.0; delta = 1.0 / (num_samples - 1); array_length = num_samples * 4; pv = color_samples = g_new (gdouble, array_length); gradient = gimp_context_get_gradient (context); while (num_samples--) { seg = gimp_gradient_get_color_at (gradient, context, seg, pos, reverse, &color); *pv++ = color.r; *pv++ = color.g; *pv++ = color.b; *pv++ = color.a; pos += delta; } } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) { g_value_set_int (&return_vals->values[1], array_length); gimp_value_take_floatarray (&return_vals->values[2], color_samples, array_length); } return return_vals; }
/* Returns NGRADSAMPLES samples of active gradient. Each sample has (gimp_drawable_bpp (drawable_id)) bytes. "ripped" from gradmap.c. */ static guchar * get_gradient_samples (gint32 drawable_id, gboolean reverse) { gchar *gradient_name; gint n_f_samples; gdouble *f_samples, *f_samp; /* float samples */ guchar *b_samples, *b_samp; /* byte samples */ gint bpp, color, has_alpha, alpha; gint i, j; gradient_name = gimp_context_get_gradient (); gimp_gradient_get_uniform_samples (gradient_name, NGRADSAMPLES, reverse, &n_f_samples, &f_samples); g_free (gradient_name); bpp = gimp_drawable_bpp (drawable_id); color = gimp_drawable_is_rgb (drawable_id); has_alpha = gimp_drawable_has_alpha (drawable_id); alpha = (has_alpha ? bpp - 1 : bpp); b_samples = g_new (guchar, NGRADSAMPLES * bpp); for (i = 0; i < NGRADSAMPLES; i++) { b_samp = &b_samples[i * bpp]; f_samp = &f_samples[i * 4]; if (color) for (j = 0; j < 3; j++) b_samp[j] = f_samp[j] * 255; else b_samp[0] = GIMP_RGB_LUMINANCE (f_samp[0], f_samp[1], f_samp[2]) * 255; if (has_alpha) b_samp[alpha] = f_samp[3] * 255; } g_free (f_samples); return b_samples; }
static gboolean gimp_blend_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (! gimp_context_get_gradient (GIMP_CONTEXT (options))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("No gradient available for use with this tool.")); return FALSE; } return TRUE; }
static void gimp_blend_tool_commit (GimpBlendTool *blend_tool) { GimpTool *tool = GIMP_TOOL (blend_tool); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (options); GimpContext *context = GIMP_CONTEXT (options); GimpImage *image = gimp_display_get_image (tool->display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpProgress *progress; gint off_x; gint off_y; progress = gimp_progress_start (GIMP_PROGRESS (tool), FALSE, _("Blending")); gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); gimp_drawable_blend (drawable, context, gimp_context_get_gradient (context), gimp_context_get_paint_mode (context), options->gradient_type, gimp_context_get_opacity (context), options->offset, paint_options->gradient_options->gradient_repeat, paint_options->gradient_options->gradient_reverse, options->supersample, options->supersample_depth, options->supersample_threshold, options->dither, blend_tool->start_x - off_x, blend_tool->start_y - off_y, blend_tool->end_x - off_x, blend_tool->end_y - off_y, progress); if (progress) gimp_progress_end (progress); gimp_image_flush (image); }
static void palette_import_grad_callback (GtkWidget *widget, ImportDialog *dialog) { GimpGradient *gradient; if (! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) return; dialog->import_type = GRADIENT_IMPORT; gradient = gimp_context_get_gradient (dialog->context); gtk_entry_set_text (GTK_ENTRY (dialog->entry), gimp_object_get_name (gradient)); palette_import_set_sensitive (dialog); palette_import_make_palette (dialog); }
/* Returns 2048 samples of the gradient. Each sample is (R'G'B'A float) or (Y'A float), depending on the drawable */ static gdouble * get_samples_gradient (gint32 drawable_id) { gchar *gradient_name; gint n_d_samples; gdouble *d_samples = NULL; gradient_name = gimp_context_get_gradient (); /* FIXME: "reverse" hardcoded to FALSE. */ gimp_gradient_get_uniform_samples (gradient_name, NSAMPLES, FALSE, &n_d_samples, &d_samples); g_free (gradient_name); if (!gimp_drawable_is_rgb (drawable_id)) { const Babl *format_src = babl_format ("R'G'B'A double"); const Babl *format_dst = babl_format ("Y'A double"); const Babl *fish = babl_fish (format_src, format_dst); babl_process (fish, d_samples, d_samples, NSAMPLES); } return d_samples; }
static void palette_import_make_palette (ImportDialog *dialog) { GimpPalette *palette = NULL; const gchar *palette_name; gint n_colors; gint n_columns; gint threshold; palette_name = gtk_entry_get_text (GTK_ENTRY (dialog->entry)); if (! palette_name || ! strlen (palette_name)) palette_name = _("Untitled"); n_colors = ROUND (gtk_adjustment_get_value (dialog->num_colors)); n_columns = ROUND (gtk_adjustment_get_value (dialog->columns)); threshold = ROUND (gtk_adjustment_get_value (dialog->threshold)); switch (dialog->import_type) { case GRADIENT_IMPORT: { GimpGradient *gradient; gradient = gimp_context_get_gradient (dialog->context); palette = gimp_palette_import_from_gradient (gradient, dialog->context, FALSE, palette_name, n_colors); } break; case IMAGE_IMPORT: { GimpImage *image = gimp_context_get_image (dialog->context); gboolean sample_merged; gboolean selection_only; sample_merged = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle)); selection_only = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle)); if (gimp_image_get_base_type (image) == GIMP_INDEXED) { palette = gimp_palette_import_from_indexed_image (image, dialog->context, palette_name); } else if (sample_merged) { palette = gimp_palette_import_from_image (image, dialog->context, palette_name, n_colors, threshold, selection_only); } else { GimpDrawable *drawable; drawable = GIMP_DRAWABLE (gimp_image_get_active_layer (image)); palette = gimp_palette_import_from_drawable (drawable, dialog->context, palette_name, n_colors, threshold, selection_only); } } break; case FILE_IMPORT: { GFile *file; GError *error = NULL; file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog->file_chooser)); palette = gimp_palette_import_from_file (dialog->context, file, palette_name, &error); g_object_unref (file); if (! palette) { gimp_message_literal (dialog->context->gimp, G_OBJECT (dialog->dialog), GIMP_MESSAGE_ERROR, error->message); g_error_free (error); } } break; } if (palette) { if (dialog->palette) g_object_unref (dialog->palette); gimp_palette_set_columns (palette, n_columns); gimp_view_set_viewable (GIMP_VIEW (dialog->preview), GIMP_VIEWABLE (palette)); dialog->palette = palette; } gtk_widget_set_visible (dialog->no_colors_label, dialog->palette && gimp_palette_get_n_colors (dialog->palette) > 0); }
GtkWidget * palette_import_dialog_new (GimpContext *context) { ImportDialog *dialog; GimpGradient *gradient; GtkWidget *button; GtkWidget *main_hbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *abox; GtkSizeGroup *size_group; GSList *group = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); gradient = gimp_context_get_gradient (context); dialog = g_slice_new0 (ImportDialog); dialog->import_type = GRADIENT_IMPORT; dialog->context = gimp_context_new (context->gimp, "Palette Import", context); dialog->dialog = gimp_dialog_new (_("Import a New Palette"), "gimp-palette-import", NULL, 0, gimp_standard_help_func, GIMP_HELP_PALETTE_IMPORT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("_Import"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-convert", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data_full (G_OBJECT (dialog->dialog), "palette-import-dialog", dialog, (GDestroyNotify) palette_import_free); g_signal_connect (dialog->dialog, "response", G_CALLBACK (palette_import_response), dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_GRADIENT, import_dialog_drop_callback, dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_IMAGE, import_dialog_drop_callback, dialog); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* The "Source" frame */ frame = gimp_frame_new (_("Select Source")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (5, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); dialog->gradient_radio = gtk_radio_button_new_with_mnemonic (group, _("_Gradient")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio)); gtk_table_attach (GTK_TABLE (table), dialog->gradient_radio, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->gradient_radio); g_signal_connect (dialog->gradient_radio, "toggled", G_CALLBACK (palette_import_grad_callback), dialog); dialog->image_radio = gtk_radio_button_new_with_mnemonic (group, _("I_mage")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->image_radio, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->image_radio); g_signal_connect (dialog->image_radio, "toggled", G_CALLBACK (palette_import_image_callback), dialog); gtk_widget_set_sensitive (dialog->image_radio, ! gimp_container_is_empty (context->gimp->images)); dialog->sample_merged_toggle = gtk_check_button_new_with_mnemonic (_("Sample _Merged")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle), TRUE); gtk_table_attach (GTK_TABLE (table), dialog->sample_merged_toggle, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->sample_merged_toggle); g_signal_connect_swapped (dialog->sample_merged_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->selection_only_toggle = gtk_check_button_new_with_mnemonic (_("_Selected Pixels only")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle), FALSE); gtk_table_attach (GTK_TABLE (table), dialog->selection_only_toggle, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->selection_only_toggle); g_signal_connect_swapped (dialog->selection_only_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->file_radio = gtk_radio_button_new_with_mnemonic (group, _("Palette _file")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->file_radio, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->file_radio); g_signal_connect (dialog->file_radio, "toggled", G_CALLBACK (palette_import_file_callback), dialog); size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); /* The gradient menu */ dialog->gradient_combo = gimp_container_combo_box_new (gimp_data_factory_get_container (context->gimp->gradient_factory), dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, NULL, 0.0, 0.5, dialog->gradient_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->gradient_combo); /* The image menu */ dialog->image_combo = gimp_container_combo_box_new (context->gimp->images, dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, NULL, 0.0, 0.5, dialog->image_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->image_combo); /* Palette file name entry */ dialog->file_chooser = gtk_file_chooser_button_new (_("Select Palette File"), GTK_FILE_CHOOSER_ACTION_OPEN); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->file_chooser); g_object_unref (size_group); /* The "Import" frame */ frame = gimp_frame_new (_("Import Options")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* The source's name */ dialog->entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (dialog->entry), gradient ? gimp_object_get_name (gradient) : _("New import")); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Palette _name:"), 0.0, 0.5, dialog->entry, 2, FALSE); /* The # of colors */ dialog->num_colors = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("N_umber of colors:"), -1, 5, 256, 2, 10000, 1, 10, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->num_colors, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The columns */ dialog->columns = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("C_olumns:"), -1, 5, 16, 0, 64, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (dialog->columns, "value-changed", G_CALLBACK (palette_import_columns_changed), dialog); /* The interval */ dialog->threshold = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("I_nterval:"), -1, 5, 1, 1, 128, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->threshold, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The "Preview" frame */ frame = gimp_frame_new (_("Preview")); gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); dialog->preview = gimp_view_new_full_by_types (dialog->context, GIMP_TYPE_VIEW, GIMP_TYPE_PALETTE, 192, 192, 1, TRUE, FALSE, FALSE); gtk_container_add (GTK_CONTAINER (abox), dialog->preview); gtk_widget_show (dialog->preview); dialog->no_colors_label = gtk_label_new (_("The selected source contains no colors.")); gtk_widget_set_size_request (dialog->no_colors_label, 194, -1); gtk_label_set_line_wrap (GTK_LABEL (dialog->no_colors_label), TRUE); gimp_label_set_attributes (GTK_LABEL (dialog->no_colors_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), dialog->no_colors_label, FALSE, FALSE, 0); gtk_widget_show (dialog->no_colors_label); /* keep the dialog up-to-date */ g_signal_connect (context->gimp->images, "add", G_CALLBACK (palette_import_image_add), dialog); g_signal_connect (context->gimp->images, "remove", G_CALLBACK (palette_import_image_remove), dialog); g_signal_connect (dialog->context, "gradient-changed", G_CALLBACK (palette_import_gradient_changed), dialog); g_signal_connect (dialog->context, "image-changed", G_CALLBACK (palette_import_image_changed), dialog); g_signal_connect (dialog->file_chooser, "selection-changed", G_CALLBACK (palette_import_filename_changed), dialog); palette_import_grad_callback (dialog->gradient_radio, dialog); return dialog->dialog; }
/** * gimp_gradients_get_gradient: * * This procedure is deprecated! Use gimp_context_get_gradient() instead. * * Returns: The name of the active gradient. */ gchar * gimp_gradients_get_gradient (void) { return gimp_context_get_gradient (); }
void gradients_save_as_pov_ray_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context; GimpGradient *gradient; GtkWidget *dialog; context = gimp_container_view_get_context (editor->view); gradient = gimp_context_get_gradient (context); if (! gradient) return; #define SAVE_AS_POV_DIALOG_KEY "gimp-save-as-pov-ray-dialog" dialog = dialogs_get_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY); if (! dialog) { gchar *title = g_strdup_printf (_("Save '%s' as POV-Ray"), gimp_object_get_name (gradient)); dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_OK, NULL); g_free (title); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data (G_OBJECT (dialog), "gimp", context->gimp); gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (GTK_WIDGET (editor))); gtk_window_set_role (GTK_WINDOW (dialog), "gimp-gradient-save-pov"); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); g_signal_connect (dialog, "response", G_CALLBACK (gradients_save_as_pov_ray_response), gradient); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect_object (dialog, "destroy", G_CALLBACK (g_object_unref), g_object_ref (gradient), G_CONNECT_SWAPPED); gimp_help_connect (dialog, gimp_standard_help_func, GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL); dialogs_attach_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); }
gboolean gimp_paint_options_get_gradient_color (GimpPaintOptions *paint_options, GimpImage *image, gdouble grad_point, gdouble pixel_dist, GimpRGB *color) { GimpGradientOptions *gradient_options; GimpGradient *gradient; g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE); g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (color != NULL, FALSE); gradient_options = paint_options->gradient_options; gradient = gimp_context_get_gradient (GIMP_CONTEXT (paint_options)); if (paint_options->pressure_options->color || paint_options->velocity_options->color || paint_options->random_options->color) { gimp_gradient_get_color_at (gradient, GIMP_CONTEXT (paint_options), NULL, grad_point, gradient_options->gradient_reverse, color); return TRUE; } else if (gradient_options->use_gradient) { gdouble gradient_length = 0.0; gdouble unit_factor; gdouble pos; switch (gradient_options->gradient_unit) { case GIMP_UNIT_PIXEL: gradient_length = gradient_options->gradient_length; break; case GIMP_UNIT_PERCENT: gradient_length = (MAX (gimp_image_get_width (image), gimp_image_get_height (image)) * gradient_options->gradient_length / 100); break; default: { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); unit_factor = gimp_unit_get_factor (gradient_options->gradient_unit); gradient_length = (gradient_options->gradient_length * MAX (xres, yres) / unit_factor); } break; } if (gradient_length > 0.0) pos = pixel_dist / gradient_length; else pos = 1.0; /* for no repeat, set pos close to 1.0 after the first chunk */ if (gradient_options->gradient_repeat == GIMP_REPEAT_NONE && pos >= 1.0) pos = 0.9999999; if (((gint) pos & 1) && gradient_options->gradient_repeat != GIMP_REPEAT_SAWTOOTH) pos = 1.0 - (pos - (gint) pos); else pos = pos - (gint) pos; gimp_gradient_get_color_at (gradient, GIMP_CONTEXT (paint_options), NULL, pos, gradient_options->gradient_reverse, color); return TRUE; } return FALSE; }
GtkWidget * gimp_toolbox_indicator_area_create (GimpToolbox *toolbox) { GimpContext *context; GtkWidget *indicator_table; GtkWidget *brush_view; GtkWidget *pattern_view; GtkWidget *gradient_view; g_return_val_if_fail (GIMP_IS_TOOLBOX (toolbox), NULL); context = GIMP_DOCK (toolbox)->context; indicator_table = gtk_table_new (2, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (indicator_table), CELL_SPACING); gtk_table_set_col_spacings (GTK_TABLE (indicator_table), CELL_SPACING); /* brush view */ brush_view = gimp_view_new_full_by_types (context, GIMP_TYPE_VIEW, GIMP_TYPE_BRUSH, CELL_SIZE, CELL_SIZE, 1, FALSE, TRUE, TRUE); gimp_view_set_viewable (GIMP_VIEW (brush_view), GIMP_VIEWABLE (gimp_context_get_brush (context))); gtk_table_attach_defaults (GTK_TABLE (indicator_table), brush_view, 0, 1, 0, 1); gtk_widget_show (brush_view); gimp_help_set_help_data (brush_view, _("The active brush.\n" "Click to open the Brush Dialog."), NULL); g_signal_connect_object (context, "brush-changed", G_CALLBACK (gimp_view_set_viewable), brush_view, G_CONNECT_SWAPPED); g_signal_connect (brush_view, "clicked", G_CALLBACK (brush_preview_clicked), toolbox); gimp_dnd_viewable_dest_add (brush_view, GIMP_TYPE_BRUSH, brush_preview_drop_brush, context); /* pattern view */ pattern_view = gimp_view_new_full_by_types (context, GIMP_TYPE_VIEW, GIMP_TYPE_PATTERN, CELL_SIZE, CELL_SIZE, 1, FALSE, TRUE, TRUE); gimp_view_set_viewable (GIMP_VIEW (pattern_view), GIMP_VIEWABLE (gimp_context_get_pattern (context))); gtk_table_attach_defaults (GTK_TABLE (indicator_table), pattern_view, 1, 2, 0, 1); gtk_widget_show (pattern_view); gimp_help_set_help_data (pattern_view, _("The active pattern.\n" "Click to open the Pattern Dialog."), NULL); g_signal_connect_object (context, "pattern-changed", G_CALLBACK (gimp_view_set_viewable), pattern_view, G_CONNECT_SWAPPED); g_signal_connect (pattern_view, "clicked", G_CALLBACK (pattern_preview_clicked), toolbox); gimp_dnd_viewable_dest_add (pattern_view, GIMP_TYPE_PATTERN, pattern_preview_drop_pattern, context); /* gradient view */ gradient_view = gimp_view_new_full_by_types (context, GIMP_TYPE_VIEW, GIMP_TYPE_GRADIENT, GRAD_CELL_WIDTH, GRAD_CELL_HEIGHT, 1, FALSE, TRUE, TRUE); gimp_view_set_viewable (GIMP_VIEW (gradient_view), GIMP_VIEWABLE (gimp_context_get_gradient (context))); gtk_table_attach_defaults (GTK_TABLE (indicator_table), gradient_view, 0, 2, 1, 2); gtk_widget_show (gradient_view); gimp_help_set_help_data (gradient_view, _("The active gradient.\n" "Click to open the Gradient Dialog."), NULL); g_signal_connect_object (context, "gradient-changed", G_CALLBACK (gimp_view_set_viewable), gradient_view, G_CONNECT_SWAPPED); g_signal_connect (gradient_view, "clicked", G_CALLBACK (gradient_preview_clicked), toolbox); gimp_dnd_viewable_dest_add (gradient_view, GIMP_TYPE_GRADIENT, gradient_preview_drop_gradient, context); gtk_widget_show (indicator_table); return indicator_table; }
static GValueArray * gradients_get_gradient_data_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; const gchar *name; gint32 sample_size; gboolean reverse; gchar *actual_name = NULL; gint32 width = 0; gdouble *grad_data = NULL; name = g_value_get_string (&args->values[0]); sample_size = g_value_get_int (&args->values[1]); reverse = g_value_get_boolean (&args->values[2]); if (success) { GimpGradient *gradient; if (sample_size < 1 || sample_size > 10000) sample_size = GIMP_GRADIENT_DEFAULT_SAMPLE_SIZE; if (name && strlen (name)) gradient = gimp_pdb_get_gradient (gimp, name, FALSE, error); else gradient = gimp_context_get_gradient (context); if (gradient) { GimpGradientSegment *seg = NULL; gdouble *pv; gdouble pos, delta; GimpRGB color; pos = 0.0; delta = 1.0 / (sample_size - 1); actual_name = g_strdup (gimp_object_get_name (GIMP_OBJECT (gradient))); grad_data = g_new (gdouble, sample_size * 4); width = sample_size * 4; pv = grad_data; while (sample_size) { seg = gimp_gradient_get_color_at (gradient, context, seg, pos, reverse, &color); *pv++ = color.r; *pv++ = color.g; *pv++ = color.b; *pv++ = color.a; pos += delta; } } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) { g_value_take_string (&return_vals->values[1], actual_name); g_value_set_int (&return_vals->values[2], width); gimp_value_take_floatarray (&return_vals->values[3], grad_data, width); } return return_vals; }