callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added support for extracting colors from the selected pixels only.

Browse Source 
2006-05-28  Michael Natterer  <mitch@gimp.org>

	* app/core/gimppalette-import.[ch]: added support for extracting
	colors from the selected pixels only.

	* app/dialogs/palette-import-dialog.c: added "Sample merged" and
	"Selected Pixels only" toggles. Fixes bug #316212. Cleaned up the
	code quite a bit.
This commit is contained in:
Michael Natterer
2006-05-28 14:51:06 +00:00
committed by Michael Natterer
parent 5af5606aac
commit 70adfc5c7e
4 changed files with 325 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
2006-05-28 Michael Natterer <mitch@gimp.org>
* app/core/gimppalette-import.[ch]: added support for extracting
colors from the selected pixels only.
* app/dialogs/palette-import-dialog.c: added "Sample merged" and
"Selected Pixels only" toggles. Fixes bug #316212. Cleaned up the
code quite a bit.
2006-05-28 Michael Natterer <mitch@gimp.org>
* app/tools/gimpcolorpickertool.c (gimp_color_picker_tool_picked):

143
app/core/gimppalette-import.c
View File

@ -43,8 +43,8 @@
#include "base/pixel-region.h"
#include "gimpchannel.h"
#include "gimpcontainer.h"
#include "gimpdrawable.h"
#include "gimpgradient.h"
#include "gimpimage.h"
#include "gimppalette.h"
@ -266,8 +266,10 @@ gimp_palette_import_make_palette (GHashTable *table,
static GHashTable *
gimp_palette_import_extract (GimpImage *image,
TileManager *tiles,
GimpImageType type,
GimpPickable *pickable,
gint pickable_off_x,
gint pickable_off_y,
gboolean selection_only,
gint x,
gint y,
gint width,
@ -275,49 +277,82 @@ gimp_palette_import_extract (GimpImage *image,
gint n_colors,
gint threshold)
{
PixelRegion region;
gpointer pr;
GHashTable *colors = NULL;
TileManager *tiles;
GimpImageType type;
PixelRegion region;
PixelRegion mask_region;
PixelRegion *maskPR = NULL;
gpointer pr;
GHashTable *colors = NULL;
tiles = gimp_pickable_get_tiles (pickable);
type = gimp_pickable_get_image_type (pickable);
pixel_region_init (&region, tiles, x, y, width, height, FALSE);
for (pr = pixel_regions_register (1, &region);
if (selection_only &&
! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
pixel_region_init (&mask_region,
GIMP_DRAWABLE (gimp_image_get_mask (image))->tiles,
x + pickable_off_x, y + pickable_off_y,
width, height,
FALSE);
maskPR = &mask_region;
}
for (pr = pixel_regions_register (maskPR ? 2 : 1, &region, maskPR);
pr != NULL;
pr = pixel_regions_process (pr))
{
const guchar *data = region.data;
const guchar *data = region.data;
const guchar *mask_data = NULL;
gint i, j;
if (maskPR)
mask_data = maskPR->data;
for (i = 0; i < region.h; i++)
{
const guchar *idata = data;
const guchar *mdata = mask_data;
for (j = 0; j < region.w; j++)
{
guchar rgba[MAX_CHANNELS];
gimp_image_get_color (image, type, idata, rgba);
/* ignore completely transparent pixels */
if (rgba[ALPHA_PIX])
if (! mdata || *mdata)
{
guchar rgb_real[MAX_CHANNELS];
guchar rgba[MAX_CHANNELS];
memcpy (rgb_real, rgba, MAX_CHANNELS);
gimp_image_get_color (image, type, idata, rgba);
rgba[0] = (rgba[0] / threshold) * threshold;
rgba[1] = (rgba[1] / threshold) * threshold;
rgba[2] = (rgba[2] / threshold) * threshold;
/* ignore completely transparent pixels */
if (rgba[ALPHA_PIX])
{
guchar rgb_real[MAX_CHANNELS];
colors = gimp_palette_import_store_colors (colors,
rgba, rgb_real,
n_colors);
memcpy (rgb_real, rgba, MAX_CHANNELS);
rgba[0] = (rgba[0] / threshold) * threshold;
rgba[1] = (rgba[1] / threshold) * threshold;
rgba[2] = (rgba[2] / threshold) * threshold;
colors = gimp_palette_import_store_colors (colors,
rgba, rgb_real,
n_colors);
}
}
idata += region.bytes;
if (mdata)
mdata += maskPR->bytes;
}
data += region.rowstride;
if (mask_data)
mask_data += maskPR->rowstride;
}
}
@ -328,24 +363,41 @@ GimpPalette *
gimp_palette_import_from_image (GimpImage *image,
const gchar *palette_name,
gint n_colors,
gint threshold)
gint threshold,
gboolean selection_only)
{
GimpPickable *pickable;
GHashTable *colors;
GHashTable *colors;
gint x, y;
gint width, height;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (palette_name != NULL, NULL);
g_return_val_if_fail (n_colors > 1, NULL);
g_return_val_if_fail (threshold > 0, NULL);
pickable = GIMP_PICKABLE (image->projection);
gimp_pickable_flush (GIMP_PICKABLE (image->projection));
gimp_pickable_flush (pickable);
if (selection_only)
{
gimp_channel_bounds (gimp_image_get_mask (image),
&x, &y, &width, &height);
width -= x;
height -= y;
}
else
{
x = 0;
y = 0;
width = image->width;
height = image->height;
}
colors = gimp_palette_import_extract (image,
gimp_pickable_get_tiles (pickable),
gimp_pickable_get_image_type (pickable),
0, 0, image->width, image->height,
GIMP_PICKABLE (image->projection),
0, 0,
selection_only,
x, y, width, height,
n_colors, threshold);
return gimp_palette_import_make_palette (colors, palette_name, n_colors);
@ -391,11 +443,13 @@ GimpPalette *
gimp_palette_import_from_drawable (GimpDrawable *drawable,
const gchar *palette_name,
gint n_colors,
gint threshold)
gint threshold,
gboolean selection_only)
{
GHashTable *colors = NULL;
gint x, y;
gint width, height;
gint off_x, off_y;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
@ -403,15 +457,28 @@ gimp_palette_import_from_drawable (GimpDrawable *drawable,
g_return_val_if_fail (n_colors > 1, NULL);
g_return_val_if_fail (threshold > 0, NULL);
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
if (selection_only)
{
colors =
gimp_palette_import_extract (gimp_item_get_image (GIMP_ITEM (drawable)),
gimp_drawable_get_tiles (drawable),
gimp_drawable_type (drawable),
0, 0, width, height,
n_colors, threshold);
if (! gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
return NULL;
}
else
{
x = 0;
y = 0;
width = gimp_item_width (GIMP_ITEM (drawable));
height = gimp_item_height (GIMP_ITEM (drawable));
}
gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y);
colors =
gimp_palette_import_extract (gimp_item_get_image (GIMP_ITEM (drawable)),
GIMP_PICKABLE (drawable),
off_x, off_y,
selection_only,
x, y, width, height,
n_colors, threshold);
return gimp_palette_import_make_palette (colors, palette_name, n_colors);
}

6
app/core/gimppalette-import.h
View File

@ -27,13 +27,15 @@ GimpPalette * gimp_palette_import_from_gradient (GimpGradient *gradient,
GimpPalette * gimp_palette_import_from_image (GimpImage *image,
const gchar *palette_name,
gint n_colors,
gint treshold);
gint treshold,
gboolean selection_only);
GimpPalette * gimp_palette_import_from_indexed_image (GimpImage *image,
const gchar *palette_name);
GimpPalette * gimp_palette_import_from_drawable (GimpDrawable *drawable,
const gchar *palette_name,
gint n_colors,
gint threshold);
gint threshold,
gboolean selection_only);
GimpPalette * gimp_palette_import_from_file (const gchar *filename,
const gchar *palette_name,
GError **error);

309
app/dialogs/palette-import-dialog.c
View File

@ -30,6 +30,7 @@
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpdatafactory.h"
#include "core/gimpdrawable.h"
#include "core/gimpgradient.h"
#include "core/gimpimage.h"
#include "core/gimppalette.h"
@ -62,27 +63,32 @@ typedef struct _ImportDialog ImportDialog;
struct _ImportDialog
{
GtkWidget *dialog;
GtkWidget *dialog;
ImportType import_type;
GimpContext *context;
GimpPalette *palette;
ImportType import_type;
GimpContext *context;
GimpImage *image;
GtkWidget *gradient_combo;
GtkWidget *image_combo;
GtkWidget *file_chooser;
GimpPalette *palette;
GtkWidget *entry;
GtkWidget *gradient_radio;
GtkWidget *image_radio;
GtkWidget *file_radio;
GtkWidget *image_radio;
GtkWidget *gradient_radio;
GtkWidget *palettefile_radio;
GtkWidget *gradient_combo;
GtkWidget *image_combo;
GtkWidget *file_chooser;
GtkAdjustment *threshold;
GtkAdjustment *num_colors;
GtkAdjustment *columns;
GtkWidget *sample_merged_toggle;
GtkWidget *selection_only_toggle;
GtkWidget *preview;
GtkWidget *entry;
GtkAdjustment *num_colors;
GtkAdjustment *columns;
GtkAdjustment *threshold;
GtkWidget *preview;
GtkWidget *no_colors_label;
};
@ -96,6 +102,10 @@ static void palette_import_gradient_changed (GimpContext *context,
static void palette_import_image_changed (GimpContext *context,
GimpImage *image,
ImportDialog *dialog);
static void palette_import_layer_changed (GimpImage *image,
ImportDialog *dialog);
static void palette_import_mask_changed (GimpImage *image,
ImportDialog *dialog);
static void palette_import_filename_changed (GtkFileChooser *button,
ImportDialog *dialog);
static void import_dialog_drop_callback (GtkWidget *widget,
@ -159,7 +169,8 @@ palette_import_dialog_new (Gimp *gimp)
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *abox;
GSList *group;
GtkSizeGroup *size_group;
GSList *group = NULL;
gradient = gimp_context_get_gradient (gimp_get_user_context (gimp));
@ -212,19 +223,22 @@ palette_import_dialog_new (Gimp *gimp)
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 (3, 2, FALSE);
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 (NULL, _("_Gradient"));
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);
@ -233,11 +247,9 @@ palette_import_dialog_new (Gimp *gimp)
G_CALLBACK (palette_import_grad_callback),
dialog);
group =
gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio));
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);
@ -249,62 +261,70 @@ palette_import_dialog_new (Gimp *gimp)
gtk_widget_set_sensitive (dialog->image_radio,
! gimp_container_is_empty (gimp->images));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio));
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);
dialog->palettefile_radio =
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"));
gtk_table_attach (GTK_TABLE (table), dialog->palettefile_radio,
0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->palettefile_radio);
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->palettefile_radio, "toggled",
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->gradient_factory->container,
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 (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, 2,
gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE);
gtk_widget_show (dialog->file_chooser);
gtk_size_group_add_widget (size_group, dialog->file_chooser);
{
gint focus_line_width;
gint focus_padding;
gint ythickness;
gint ysize;
gtk_widget_style_get (dialog->gradient_combo,
"focus-line-width", &focus_line_width,
"focus-padding", &focus_padding,
NULL);
ythickness = dialog->gradient_combo->style->ythickness;
ysize = 24 + (2 * (1 /* CHILD_SPACING */ +
ythickness +
focus_padding +
focus_line_width));
gtk_widget_set_size_request (dialog->gradient_combo, -1, ysize);
gtk_widget_set_size_request (dialog->image_combo, -1, ysize);
}
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);
@ -356,7 +376,6 @@ palette_import_dialog_new (Gimp *gimp)
1, 1, 128, 1, 8, 0,
TRUE, 0.0, 0.0,
NULL, NULL));
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold), FALSE);
g_signal_connect_swapped (dialog->threshold, "value-changed",
G_CALLBACK (palette_import_make_palette),
@ -368,8 +387,12 @@ palette_import_dialog_new (Gimp *gimp)
gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 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_container_add (GTK_CONTAINER (frame), abox);
gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0);
gtk_widget_show (abox);
dialog->preview = gimp_view_new_full_by_types (GIMP_TYPE_VIEW,
@ -379,6 +402,17 @@ palette_import_dialog_new (Gimp *gimp)
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 (gimp->images, "add",
@ -398,8 +432,6 @@ palette_import_dialog_new (Gimp *gimp)
G_CALLBACK (palette_import_filename_changed),
dialog);
palette_import_make_palette (dialog);
palette_import_grad_callback (dialog->gradient_radio, dialog);
return dialog;
@ -415,6 +447,8 @@ palette_import_response (GtkWidget *widget,
{
Gimp *gimp = dialog->context->gimp;
palette_import_image_changed (dialog->context, NULL, dialog);
g_signal_handlers_disconnect_by_func (gimp->images,
palette_import_image_add,
dialog);
@ -422,22 +456,23 @@ palette_import_response (GtkWidget *widget,
palette_import_image_remove,
dialog);
if (response_id == GTK_RESPONSE_OK && dialog->palette)
if (dialog->palette)
{
const gchar *name = gtk_entry_get_text (GTK_ENTRY (dialog->entry));
if (response_id == GTK_RESPONSE_OK)
{
const gchar *name = gtk_entry_get_text (GTK_ENTRY (dialog->entry));
if (name && *name)
gimp_object_set_name (GIMP_OBJECT (dialog->palette), name);
if (name && *name)
gimp_object_set_name (GIMP_OBJECT (dialog->palette), name);
gimp_container_add (gimp->palette_factory->container,
GIMP_OBJECT (dialog->palette));
gimp_container_add (gimp->palette_factory->container,
GIMP_OBJECT (dialog->palette));
}
g_object_unref (dialog->palette);
}
g_object_unref (dialog->context);
if (dialog->palette)
g_object_unref (dialog->palette);
gtk_widget_destroy (dialog->dialog);
g_free (dialog);
@ -466,38 +501,81 @@ palette_import_image_changed (GimpContext *context,
GimpImage *image,
ImportDialog *dialog)
{
if (dialog->image)
{
g_signal_handlers_disconnect_by_func (dialog->image,
palette_import_layer_changed,
dialog);
g_signal_handlers_disconnect_by_func (dialog->image,
palette_import_mask_changed,
dialog);
}
dialog->image = image;
if (dialog->import_type == IMAGE_IMPORT)
{
gboolean sensitive;
gboolean sensitive = FALSE;
if (image)
{
gchar *basename;
gchar *name;
gchar *label;
basename =
file_utils_uri_display_basename (gimp_image_get_uri (image));
label = g_strdup_printf ("%s-%d", basename, gimp_image_get_ID (image));
g_free (basename);
name = file_utils_uri_display_basename (gimp_image_get_uri (image));
label = g_strdup_printf ("%s-%d", name, gimp_image_get_ID (image));
g_free (name);
gtk_entry_set_text (GTK_ENTRY (dialog->entry), label);
g_free (label);
palette_import_make_palette (dialog);
sensitive = (gimp_image_base_type (image) != GIMP_INDEXED);
}
else
{
sensitive = FALSE;
if (gimp_image_base_type (image) != GIMP_INDEXED)
sensitive = TRUE;
}
gtk_widget_set_sensitive (dialog->sample_merged_toggle, sensitive);
gtk_widget_set_sensitive (dialog->selection_only_toggle, sensitive);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold),
sensitive);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->num_colors),
sensitive);
}
if (dialog->image)
{
g_signal_connect (dialog->image, "active-layer-changed",
G_CALLBACK (palette_import_layer_changed),
dialog);
g_signal_connect (dialog->image, "mask-changed",
G_CALLBACK (palette_import_mask_changed),
dialog);
}
}
static void
palette_import_layer_changed (GimpImage *image,
ImportDialog *dialog)
{
if (dialog->import_type == IMAGE_IMPORT &&
! gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle)))
{
palette_import_make_palette (dialog);
}
}
static void
palette_import_mask_changed (GimpImage *image,
ImportDialog *dialog)
{
if (dialog->import_type == IMAGE_IMPORT &&
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dialog->selection_only_toggle)))
{
palette_import_make_palette (dialog);
}
}
static void
@ -557,9 +635,26 @@ import_dialog_drop_callback (GtkWidget *widget,
}
/* the import source menu item callbacks ***********************************/
static void
palette_import_set_sensitive (ImportDialog *dialog)
{
gboolean gradient = (dialog->import_type == GRADIENT_IMPORT);
gboolean image = (dialog->import_type == IMAGE_IMPORT);
gboolean file = (dialog->import_type == FILE_IMPORT);
gtk_widget_set_sensitive (dialog->gradient_combo, gradient);
gtk_widget_set_sensitive (dialog->image_combo, image);
gtk_widget_set_sensitive (dialog->sample_merged_toggle, image);
gtk_widget_set_sensitive (dialog->selection_only_toggle, image);
gtk_widget_set_sensitive (dialog->file_chooser, file);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->num_colors), ! file);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->columns), ! file);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold), image);
}
static void
palette_import_grad_callback (GtkWidget *widget,
ImportDialog *dialog)
@ -573,16 +668,10 @@ palette_import_grad_callback (GtkWidget *widget,
gradient = gimp_context_get_gradient (dialog->context);
gtk_widget_set_sensitive (dialog->gradient_combo, TRUE);
gtk_widget_set_sensitive (dialog->image_combo, FALSE);
gtk_widget_set_sensitive (dialog->file_chooser, FALSE);
gtk_entry_set_text (GTK_ENTRY (dialog->entry),
GIMP_OBJECT (gradient)->name);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold), FALSE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->num_colors), TRUE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->columns), TRUE);
palette_import_set_sensitive (dialog);
palette_import_make_palette (dialog);
}
@ -604,13 +693,7 @@ palette_import_image_callback (GtkWidget *widget,
image = (GimpImage *)
gimp_container_get_child_by_index (dialog->context->gimp->images, 0);
gtk_widget_set_sensitive (dialog->gradient_combo, FALSE);
gtk_widget_set_sensitive (dialog->image_combo, TRUE);
gtk_widget_set_sensitive (dialog->file_chooser, FALSE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold), TRUE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->num_colors), TRUE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->columns), TRUE);
palette_import_set_sensitive (dialog);
palette_import_image_changed (dialog->context, image, dialog);
}
@ -626,10 +709,6 @@ palette_import_file_callback (GtkWidget *widget,
dialog->import_type = FILE_IMPORT;
gtk_widget_set_sensitive (dialog->gradient_combo, FALSE);
gtk_widget_set_sensitive (dialog->image_combo, FALSE);
gtk_widget_set_sensitive (dialog->file_chooser, TRUE);
filename =
gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog->file_chooser));
@ -640,17 +719,15 @@ palette_import_file_callback (GtkWidget *widget,
/* TODO: strip filename extension */
gtk_entry_set_text (GTK_ENTRY (dialog->entry), basename);
g_free (basename);
g_free (filename);
}
else
{
gtk_entry_set_text (GTK_ENTRY (dialog->entry), "");
}
g_free (filename);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->threshold), FALSE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->num_colors), FALSE);
gimp_scale_entry_set_sensitive (GTK_OBJECT (dialog->columns), FALSE);
palette_import_set_sensitive (dialog);
}
static void
@ -726,18 +803,41 @@ palette_import_make_palette (ImportDialog *dialog)
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_base_type (image) == GIMP_INDEXED)
{
palette = gimp_palette_import_from_indexed_image (image,
palette_name);
}
else
else if (sample_merged)
{
palette = gimp_palette_import_from_image (image,
palette_name,
n_colors,
threshold);
threshold,
selection_only);
}
else
{
GimpDrawable *drawable;
drawable = GIMP_DRAWABLE (gimp_image_get_active_layer (image));
palette = gimp_palette_import_from_drawable (drawable,
palette_name,
n_colors,
threshold,
selection_only);
}
}
break;
@ -775,4 +875,9 @@ palette_import_make_palette (ImportDialog *dialog)
dialog->palette = palette;
}
if (dialog->palette && dialog->palette->n_colors > 0)
gtk_widget_hide (dialog->no_colors_label);
else
gtk_widget_show (dialog->no_colors_label);
}