graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-20 09:21:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

changed gimp_channel_get_color() to not return the color but take a second

Browse source 
2002-03-08  Michael Natterer  <mitch@gimp.org>

	* app/core/gimpchannel.[ch]: changed gimp_channel_get_color() to
	not return the color but take a second GimpRGB* parameter like all
	other _get_color() functions. Reordered some functions to make
	more sense, added some g_return_if_fail().

	* app/core/gimppalette.[ch]: added gimp_palette_[set|get]_n_columns()

	* app/gui/menus.c: added a "<PaletteEditor>" item factory.

	* app/gui/Makefile.am
	* app/gui/palette-editor-commands.[ch]: callbacks for the factory.

	* app/widgets/gimppaletteeditor.[ch]: removed the menu stuff here,
	added a spinbutton to adjust the number of columns.

	* app/gui/gradient-editor-commands.c: removed usage of "the_gimp".

	* app/widgets/gimpgradienteditor.c: minor cleanup.

	* app/widgets/gimpbrusheditor.h
	* app/widgets/gimpgradienteditor.h
	* app/widgets/gimppaletteeditor.h: forgot to declare the _get_type()
	functions publically.
This commit is contained in:
Michael Natterer 2002-03-08 16:34:42 +00:00 committed by Michael Natterer
parent 7453a6604d
commit 5437f54a81
23 changed files with 928 additions and 359 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
ChangeLog
View file

@ -1,3 +1,29 @@
2002-03-08 Michael Natterer <mitch@gimp.org>
* app/core/gimpchannel.[ch]: changed gimp_channel_get_color() to
not return the color but take a second GimpRGB* parameter like all
other _get_color() functions. Reordered some functions to make
more sense, added some g_return_if_fail().
* app/core/gimppalette.[ch]: added gimp_palette_[set|get]_n_columns()
* app/gui/menus.c: added a "<PaletteEditor>" item factory.
* app/gui/Makefile.am
* app/gui/palette-editor-commands.[ch]: callbacks for the factory.
* app/widgets/gimppaletteeditor.[ch]: removed the menu stuff here,
added a spinbutton to adjust the number of columns.
* app/gui/gradient-editor-commands.c: removed usage of "the_gimp".
* app/widgets/gimpgradienteditor.c: minor cleanup.
* app/widgets/gimpbrusheditor.h
* app/widgets/gimpgradienteditor.h
* app/widgets/gimppaletteeditor.h: forgot to declare the _get_type()
functions publically.
2002-03-08 Sven Neumann <sven@gimp.org>
Handle gtk-doc just like GTK+ does it now:

10
app/actions/gradient-editor-commands.c
View file

@ -35,8 +35,6 @@
#include "color-notebook.h"
#include "gradient-editor-commands.h"
#include "app_procs.h"
#include "libgimp/gimpintl.h"
@ -113,7 +111,7 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
i = (gint) action;
@ -236,7 +234,7 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
i = (gint) action;
@ -947,9 +945,9 @@ gradient_editor_menu_update (GtkItemFactory *factory,
gboolean selection;
gboolean delete;
editor = (GimpGradientEditor *) data;
editor = GIMP_GRADIENT_EDITOR (data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
if (editor->control_sel_l->prev)
left_seg = editor->control_sel_l->prev;

210
app/actions/palette-editor-commands.c Normal file
View file

@ -0,0 +1,210 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "gui-types.h"
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimppalette.h"
#include "widgets/gimppaletteeditor.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "color-area.h"
#include "color-notebook.h"
#include "palette-editor-commands.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data);
/* public functions */
void
palette_editor_new_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
GimpContext *user_context;
GimpRGB color;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! palette)
return;
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
if (active_color == FOREGROUND)
gimp_context_get_foreground (user_context, &color);
else if (active_color == BACKGROUND)
gimp_context_get_background (user_context, &color);
editor->color = gimp_palette_add_entry (palette, NULL, &color);
}
void
palette_editor_edit_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
if (! editor->color_notebook)
{
editor->color_notebook =
color_notebook_new (_("Edit Palette Color"),
(const GimpRGB *) &editor->color->color,
palette_editor_color_notebook_callback,
editor,
FALSE,
FALSE);
editor->color_notebook_active = TRUE;
}
else
{
if (! editor->color_notebook_active)
{
color_notebook_show (editor->color_notebook);
editor->color_notebook_active = TRUE;
}
color_notebook_set_color (editor->color_notebook,
&editor->color->color);
}
}
void
palette_editor_delete_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
gimp_palette_delete_entry (palette, editor->color);
}
void
palette_editor_menu_update (GtkItemFactory *factory,
gpointer data)
{
GimpPaletteEditor *editor;
editor = GIMP_PALETTE_EDITOR (data);
#define SET_SENSITIVE(menu,condition) \
gimp_item_factory_set_sensitive (factory, menu, (condition) != 0)
SET_SENSITIVE ("/New Color", TRUE);
SET_SENSITIVE ("/Edit Color...", editor->color);
SET_SENSITIVE ("/Delete Color", editor->color);
#undef SET_SENSITIVE
}
/* private functions */
static void
palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
GimpContext *user_context;
editor = GIMP_PALETTE_EDITOR (data);
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
switch (state)
{
case COLOR_NOTEBOOK_UPDATE:
break;
case COLOR_NOTEBOOK_OK:
if (editor->color)
{
editor->color->color = *color;
/* Update either foreground or background colors */
if (active_color == FOREGROUND)
gimp_context_set_foreground (user_context, color);
else if (active_color == BACKGROUND)
gimp_context_set_background (user_context, color);
gimp_data_dirty (GIMP_DATA (palette));
}
/* Fallthrough */
case COLOR_NOTEBOOK_CANCEL:
if (editor->color_notebook_active)
{
color_notebook_hide (editor->color_notebook);
editor->color_notebook_active = FALSE;
}
}
}

37
app/actions/palette-editor-commands.h Normal file
View file

@ -0,0 +1,37 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __PALETTE_EDITOR_COMMANDS_H__
#define __PALETTE_EDITOR_COMMANDS_H__
void palette_editor_new_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_edit_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_delete_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_menu_update (GtkItemFactory *factory,
gpointer data);
#endif /* __PALETTE_EDITOR_COMMANDS_H__ */

104
app/core/gimpchannel-combine.c
View file

@ -250,12 +250,14 @@ gimp_channel_set_color (GimpChannel *channel,
}
}
const GimpRGB *
gimp_channel_get_color (const GimpChannel *channel)
void
gimp_channel_get_color (const GimpChannel *channel,
GimpRGB *color)
{
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);
g_return_if_fail (GIMP_IS_CHANNEL (channel));
g_return_if_fail (color != NULL);
return &channel->color;
*color = channel->color;
}
gdouble
@ -1195,6 +1197,28 @@ gimp_channel_feather (GimpChannel *mask,
mask->bounds_known = FALSE;
}
void
gimp_channel_sharpen (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = threshold_lut_new (0.5, 1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
}
void
gimp_channel_push_undo (GimpChannel *mask)
{
@ -1261,52 +1285,6 @@ gimp_channel_clear (GimpChannel *mask)
mask->y2 = GIMP_DRAWABLE (mask)->height;
}
void
gimp_channel_invert (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = invert_lut_new (1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
mask->bounds_known = FALSE;
}
void
gimp_channel_sharpen (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = threshold_lut_new (0.5, 1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
}
void
gimp_channel_all (GimpChannel *mask)
{
@ -1334,6 +1312,30 @@ gimp_channel_all (GimpChannel *mask)
mask->y2 = GIMP_DRAWABLE (mask)->height;
}
void
gimp_channel_invert (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = invert_lut_new (1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
mask->bounds_known = FALSE;
}
void
gimp_channel_border (GimpChannel *mask,
gint radius_x,
@ -1601,6 +1603,7 @@ gimp_channel_layer_alpha (GimpChannel *mask,
g_return_if_fail (GIMP_IS_CHANNEL (mask));
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)));
/* push the current mask onto the undo stack */
gimp_channel_push_undo (mask);
@ -1640,6 +1643,7 @@ gimp_channel_layer_mask (GimpChannel *mask,
g_return_if_fail (GIMP_IS_CHANNEL (mask));
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_get_mask (layer));
/* push the current mask onto the undo stack */
gimp_channel_push_undo (mask);

11
app/core/gimpchannel-combine.h
View file

@ -80,7 +80,8 @@ gdouble gimp_channel_get_opacity (const GimpChannel *channel);
void gimp_channel_set_opacity (GimpChannel *channel,
gdouble opacity);
const GimpRGB * gimp_channel_get_color (const GimpChannel *channel);
void gimp_channel_get_color (const GimpChannel *channel,
GimpRGB *color);
void gimp_channel_set_color (GimpChannel *channel,
const GimpRGB *color);
@ -100,6 +101,7 @@ void gimp_channel_resize (GimpChannel *channel,
GimpChannel * gimp_channel_new_mask (GimpImage *gimage,
gint width,
gint height);
gboolean gimp_channel_boundary (GimpChannel *mask,
BoundSeg **segs_in,
BoundSeg **segs_out,
@ -118,6 +120,7 @@ gint gimp_channel_value (GimpChannel *mask,
gint x,
gint y);
gboolean gimp_channel_is_empty (GimpChannel *mask);
void gimp_channel_add_segment (GimpChannel *mask,
gint x,
gint y,
@ -146,16 +149,18 @@ void gimp_channel_combine_mask (GimpChannel *mask,
ChannelOps op,
gint off_x,
gint off_y);
void gimp_channel_feather (GimpChannel *mask,
gdouble radius_x,
gdouble radius_y,
gboolean push_undo);
void gimp_channel_sharpen (GimpChannel *mask);
void gimp_channel_push_undo (GimpChannel *mask);
void gimp_channel_clear (GimpChannel *mask);
void gimp_channel_invert (GimpChannel *mask);
void gimp_channel_sharpen (GimpChannel *mask);
void gimp_channel_all (GimpChannel *mask);
void gimp_channel_invert (GimpChannel *mask);
void gimp_channel_border (GimpChannel *mask,
gint radius_x,

104
app/core/gimpchannel.c
View file

@ -250,12 +250,14 @@ gimp_channel_set_color (GimpChannel *channel,
}
}
const GimpRGB *
gimp_channel_get_color (const GimpChannel *channel)
void
gimp_channel_get_color (const GimpChannel *channel,
GimpRGB *color)
{
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);
g_return_if_fail (GIMP_IS_CHANNEL (channel));
g_return_if_fail (color != NULL);
return &channel->color;
*color = channel->color;
}
gdouble
@ -1195,6 +1197,28 @@ gimp_channel_feather (GimpChannel *mask,
mask->bounds_known = FALSE;
}
void
gimp_channel_sharpen (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = threshold_lut_new (0.5, 1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
}
void
gimp_channel_push_undo (GimpChannel *mask)
{
@ -1261,52 +1285,6 @@ gimp_channel_clear (GimpChannel *mask)
mask->y2 = GIMP_DRAWABLE (mask)->height;
}
void
gimp_channel_invert (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = invert_lut_new (1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
mask->bounds_known = FALSE;
}
void
gimp_channel_sharpen (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = threshold_lut_new (0.5, 1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
}
void
gimp_channel_all (GimpChannel *mask)
{
@ -1334,6 +1312,30 @@ gimp_channel_all (GimpChannel *mask)
mask->y2 = GIMP_DRAWABLE (mask)->height;
}
void
gimp_channel_invert (GimpChannel *mask)
{
PixelRegion maskPR;
GimpLut *lut;
g_return_if_fail (GIMP_IS_CHANNEL (mask));
/* push the current channel onto the undo stack */
gimp_channel_push_undo (mask);
pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (mask)->width,
GIMP_DRAWABLE (mask)->height, TRUE);
lut = invert_lut_new (1);
pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
lut, 1, &maskPR);
gimp_lut_free (lut);
mask->bounds_known = FALSE;
}
void
gimp_channel_border (GimpChannel *mask,
gint radius_x,
@ -1601,6 +1603,7 @@ gimp_channel_layer_alpha (GimpChannel *mask,
g_return_if_fail (GIMP_IS_CHANNEL (mask));
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)));
/* push the current mask onto the undo stack */
gimp_channel_push_undo (mask);
@ -1640,6 +1643,7 @@ gimp_channel_layer_mask (GimpChannel *mask,
g_return_if_fail (GIMP_IS_CHANNEL (mask));
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_get_mask (layer));
/* push the current mask onto the undo stack */
gimp_channel_push_undo (mask);

11
app/core/gimpchannel.h
View file

@ -80,7 +80,8 @@ gdouble gimp_channel_get_opacity (const GimpChannel *channel);
void gimp_channel_set_opacity (GimpChannel *channel,
gdouble opacity);
const GimpRGB * gimp_channel_get_color (const GimpChannel *channel);
void gimp_channel_get_color (const GimpChannel *channel,
GimpRGB *color);
void gimp_channel_set_color (GimpChannel *channel,
const GimpRGB *color);
@ -100,6 +101,7 @@ void gimp_channel_resize (GimpChannel *channel,
GimpChannel * gimp_channel_new_mask (GimpImage *gimage,
gint width,
gint height);
gboolean gimp_channel_boundary (GimpChannel *mask,
BoundSeg **segs_in,
BoundSeg **segs_out,
@ -118,6 +120,7 @@ gint gimp_channel_value (GimpChannel *mask,
gint x,
gint y);
gboolean gimp_channel_is_empty (GimpChannel *mask);
void gimp_channel_add_segment (GimpChannel *mask,
gint x,
gint y,
@ -146,16 +149,18 @@ void gimp_channel_combine_mask (GimpChannel *mask,
ChannelOps op,
gint off_x,
gint off_y);
void gimp_channel_feather (GimpChannel *mask,
gdouble radius_x,
gdouble radius_y,
gboolean push_undo);
void gimp_channel_sharpen (GimpChannel *mask);
void gimp_channel_push_undo (GimpChannel *mask);
void gimp_channel_clear (GimpChannel *mask);
void gimp_channel_invert (GimpChannel *mask);
void gimp_channel_sharpen (GimpChannel *mask);
void gimp_channel_all (GimpChannel *mask);
void gimp_channel_invert (GimpChannel *mask);
void gimp_channel_border (GimpChannel *mask,
gint radius_x,

29
app/core/gimppalette-load.c
View file

@ -525,7 +525,6 @@ gimp_palette_add_entry (GimpPalette *palette,
GimpPaletteEntry *entry;
g_return_val_if_fail (GIMP_IS_PALETTE (palette), NULL);
g_return_val_if_fail (color != NULL, NULL);
entry = g_new0 (GimpPaletteEntry, 1);
@ -551,7 +550,6 @@ gimp_palette_delete_entry (GimpPalette *palette,
gint pos = 0;
g_return_if_fail (GIMP_IS_PALETTE (palette));
g_return_if_fail (entry != NULL);
if (g_list_find (palette->colors, entry))
@ -587,6 +585,33 @@ gimp_palette_delete_entry (GimpPalette *palette,
}
}
void
gimp_palette_set_n_columns (GimpPalette *palette,
gint n_columns)
{
g_return_if_fail (GIMP_IS_PALETTE (palette));
n_columns = CLAMP (n_columns, 0, 64);
if (palette->n_columns != n_columns)
{
palette->n_columns = n_columns;
gimp_data_dirty (GIMP_DATA (palette));
}
}
gint
gimp_palette_get_n_columns (GimpPalette *palette)
{
g_return_val_if_fail (GIMP_IS_PALETTE (palette), 0);
return palette->n_columns;
}
/* private functions */
static void
gimp_palette_entry_free (GimpPaletteEntry *entry)
{

29
app/core/gimppalette-save.c
View file

@ -525,7 +525,6 @@ gimp_palette_add_entry (GimpPalette *palette,
GimpPaletteEntry *entry;
g_return_val_if_fail (GIMP_IS_PALETTE (palette), NULL);
g_return_val_if_fail (color != NULL, NULL);
entry = g_new0 (GimpPaletteEntry, 1);
@ -551,7 +550,6 @@ gimp_palette_delete_entry (GimpPalette *palette,
gint pos = 0;
g_return_if_fail (GIMP_IS_PALETTE (palette));
g_return_if_fail (entry != NULL);
if (g_list_find (palette->colors, entry))
@ -587,6 +585,33 @@ gimp_palette_delete_entry (GimpPalette *palette,
}
}
void
gimp_palette_set_n_columns (GimpPalette *palette,
gint n_columns)
{
g_return_if_fail (GIMP_IS_PALETTE (palette));
n_columns = CLAMP (n_columns, 0, 64);
if (palette->n_columns != n_columns)
{
palette->n_columns = n_columns;
gimp_data_dirty (GIMP_DATA (palette));
}
}
gint
gimp_palette_get_n_columns (GimpPalette *palette)
{
g_return_val_if_fail (GIMP_IS_PALETTE (palette), 0);
return palette->n_columns;
}
/* private functions */
static void
gimp_palette_entry_free (GimpPaletteEntry *entry)
{

29
app/core/gimppalette.c
View file

@ -525,7 +525,6 @@ gimp_palette_add_entry (GimpPalette *palette,
GimpPaletteEntry *entry;
g_return_val_if_fail (GIMP_IS_PALETTE (palette), NULL);
g_return_val_if_fail (color != NULL, NULL);
entry = g_new0 (GimpPaletteEntry, 1);
@ -551,7 +550,6 @@ gimp_palette_delete_entry (GimpPalette *palette,
gint pos = 0;
g_return_if_fail (GIMP_IS_PALETTE (palette));
g_return_if_fail (entry != NULL);
if (g_list_find (palette->colors, entry))
@ -587,6 +585,33 @@ gimp_palette_delete_entry (GimpPalette *palette,
}
}
void
gimp_palette_set_n_columns (GimpPalette *palette,
gint n_columns)
{
g_return_if_fail (GIMP_IS_PALETTE (palette));
n_columns = CLAMP (n_columns, 0, 64);
if (palette->n_columns != n_columns)
{
palette->n_columns = n_columns;
gimp_data_dirty (GIMP_DATA (palette));
}
}
gint
gimp_palette_get_n_columns (GimpPalette *palette)
{
g_return_val_if_fail (GIMP_IS_PALETTE (palette), 0);
return palette->n_columns;
}
/* private functions */
static void
gimp_palette_entry_free (GimpPaletteEntry *entry)
{

4
app/core/gimppalette.h
View file

@ -74,5 +74,9 @@ GimpPaletteEntry * gimp_palette_add_entry (GimpPalette *palette,
void gimp_palette_delete_entry (GimpPalette *palette,
GimpPaletteEntry *entry);
void gimp_palette_set_n_columns (GimpPalette *palette,
gint n_columns);
gint gimp_palette_get_n_columns (GimpPalette *palette);
#endif /* __GIMP_PALETTE_H__ */

2
app/gui/Makefile.am
View file

@ -79,6 +79,8 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
module-browser.h \
offset-dialog.c \
offset-dialog.h \
palette-editor-commands.c \
palette-editor-commands.h \
palette-import-dialog.c \
palette-import-dialog.h \
palette-select.c \

10
app/gui/gradient-editor-commands.c
View file

@ -35,8 +35,6 @@
#include "color-notebook.h"
#include "gradient-editor-commands.h"
#include "app_procs.h"
#include "libgimp/gimpintl.h"
@ -113,7 +111,7 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
i = (gint) action;
@ -236,7 +234,7 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
i = (gint) action;
@ -947,9 +945,9 @@ gradient_editor_menu_update (GtkItemFactory *factory,
gboolean selection;
gboolean delete;
editor = (GimpGradientEditor *) data;
editor = GIMP_GRADIENT_EDITOR (data);
user_context = gimp_get_user_context (the_gimp);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
if (editor->control_sel_l->prev)
left_seg = editor->control_sel_l->prev;

38
app/gui/menus.c
View file

@ -62,6 +62,7 @@
#include "image-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "palette-editor-commands.h"
#include "palettes-commands.h"
#include "paths-dialog.h"
#include "patterns-commands.h"
@ -1743,6 +1744,28 @@ static GimpItemFactoryEntry gradients_entries[] =
};
/***** <PaletteEditor> *****/
static GimpItemFactoryEntry palette_editor_entries[] =
{
{ { N_("/New Color"), NULL,
palette_editor_new_color_cmd_callback, 0,
"<StockItem>", GTK_STOCK_NEW },
NULL,
NULL, NULL },
{ { N_("/Edit Color..."), NULL,
palette_editor_edit_color_cmd_callback, 0,
"<StockItem>", GIMP_STOCK_EDIT },
NULL,
NULL, NULL },
{ { N_("/Delete Color"), NULL,
palette_editor_delete_color_cmd_callback, 0,
"<StockItem>", GTK_STOCK_DELETE },
NULL,
NULL, NULL }
};
/***** <Palettes> *****/
static GimpItemFactoryEntry palettes_entries[] =
@ -1893,6 +1916,7 @@ static GimpItemFactory *brushes_factory = NULL;
static GimpItemFactory *patterns_factory = NULL;
static GimpItemFactory *gradient_editor_factory = NULL;
static GimpItemFactory *gradients_factory = NULL;
static GimpItemFactory *palette_editor_factory = NULL;
static GimpItemFactory *palettes_factory = NULL;
static GimpItemFactory *buffers_factory = NULL;
static GimpItemFactory *documents_factory = NULL;
@ -2070,6 +2094,14 @@ menus_init (Gimp *gimp)
gimp,
FALSE);
palette_editor_factory = gimp_item_factory_new (GTK_TYPE_MENU,
"<PaletteEditor>", "palette_editor",
palette_editor_menu_update,
G_N_ELEMENTS (palette_editor_entries),
palette_editor_entries,
gimp,
FALSE);
palettes_factory = gimp_item_factory_new (GTK_TYPE_MENU,
"<Palettes>", "palettes",
palettes_menu_update,
@ -2268,6 +2300,12 @@ menus_exit (Gimp *gimp)
gradients_factory = NULL;
}
if (palette_editor_factory)
{
g_object_unref (G_OBJECT (palette_editor_factory));
palette_editor_factory = NULL;
}
if (palettes_factory)
{
g_object_unref (G_OBJECT (palettes_factory));

210
app/gui/palette-editor-commands.c Normal file
View file

@ -0,0 +1,210 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "gui-types.h"
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimppalette.h"
#include "widgets/gimppaletteeditor.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "color-area.h"
#include "color-notebook.h"
#include "palette-editor-commands.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data);
/* public functions */
void
palette_editor_new_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
GimpContext *user_context;
GimpRGB color;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! palette)
return;
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
if (active_color == FOREGROUND)
gimp_context_get_foreground (user_context, &color);
else if (active_color == BACKGROUND)
gimp_context_get_background (user_context, &color);
editor->color = gimp_palette_add_entry (palette, NULL, &color);
}
void
palette_editor_edit_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
if (! editor->color_notebook)
{
editor->color_notebook =
color_notebook_new (_("Edit Palette Color"),
(const GimpRGB *) &editor->color->color,
palette_editor_color_notebook_callback,
editor,
FALSE,
FALSE);
editor->color_notebook_active = TRUE;
}
else
{
if (! editor->color_notebook_active)
{
color_notebook_show (editor->color_notebook);
editor->color_notebook_active = TRUE;
}
color_notebook_set_color (editor->color_notebook,
&editor->color->color);
}
}
void
palette_editor_delete_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
editor = (GimpPaletteEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
gimp_palette_delete_entry (palette, editor->color);
}
void
palette_editor_menu_update (GtkItemFactory *factory,
gpointer data)
{
GimpPaletteEditor *editor;
editor = GIMP_PALETTE_EDITOR (data);
#define SET_SENSITIVE(menu,condition) \
gimp_item_factory_set_sensitive (factory, menu, (condition) != 0)
SET_SENSITIVE ("/New Color", TRUE);
SET_SENSITIVE ("/Edit Color...", editor->color);
SET_SENSITIVE ("/Delete Color", editor->color);
#undef SET_SENSITIVE
}
/* private functions */
static void
palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
GimpContext *user_context;
editor = GIMP_PALETTE_EDITOR (data);
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
switch (state)
{
case COLOR_NOTEBOOK_UPDATE:
break;
case COLOR_NOTEBOOK_OK:
if (editor->color)
{
editor->color->color = *color;
/* Update either foreground or background colors */
if (active_color == FOREGROUND)
gimp_context_set_foreground (user_context, color);
else if (active_color == BACKGROUND)
gimp_context_set_background (user_context, color);
gimp_data_dirty (GIMP_DATA (palette));
}
/* Fallthrough */
case COLOR_NOTEBOOK_CANCEL:
if (editor->color_notebook_active)
{
color_notebook_hide (editor->color_notebook);
editor->color_notebook_active = FALSE;
}
}
}

37
app/gui/palette-editor-commands.h Normal file
View file

@ -0,0 +1,37 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __PALETTE_EDITOR_COMMANDS_H__
#define __PALETTE_EDITOR_COMMANDS_H__
void palette_editor_new_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_edit_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_delete_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action);
void palette_editor_menu_update (GtkItemFactory *factory,
gpointer data);
#endif /* __PALETTE_EDITOR_COMMANDS_H__ */

38
app/menus/menus.c
View file

@ -62,6 +62,7 @@
#include "image-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "palette-editor-commands.h"
#include "palettes-commands.h"
#include "paths-dialog.h"
#include "patterns-commands.h"
@ -1743,6 +1744,28 @@ static GimpItemFactoryEntry gradients_entries[] =
};
/***** <PaletteEditor> *****/
static GimpItemFactoryEntry palette_editor_entries[] =
{
{ { N_("/New Color"), NULL,
palette_editor_new_color_cmd_callback, 0,
"<StockItem>", GTK_STOCK_NEW },
NULL,
NULL, NULL },
{ { N_("/Edit Color..."), NULL,
palette_editor_edit_color_cmd_callback, 0,
"<StockItem>", GIMP_STOCK_EDIT },
NULL,
NULL, NULL },
{ { N_("/Delete Color"), NULL,
palette_editor_delete_color_cmd_callback, 0,
"<StockItem>", GTK_STOCK_DELETE },
NULL,
NULL, NULL }
};
/***** <Palettes> *****/
static GimpItemFactoryEntry palettes_entries[] =
@ -1893,6 +1916,7 @@ static GimpItemFactory *brushes_factory = NULL;
static GimpItemFactory *patterns_factory = NULL;
static GimpItemFactory *gradient_editor_factory = NULL;
static GimpItemFactory *gradients_factory = NULL;
static GimpItemFactory *palette_editor_factory = NULL;
static GimpItemFactory *palettes_factory = NULL;
static GimpItemFactory *buffers_factory = NULL;
static GimpItemFactory *documents_factory = NULL;
@ -2070,6 +2094,14 @@ menus_init (Gimp *gimp)
gimp,
FALSE);
palette_editor_factory = gimp_item_factory_new (GTK_TYPE_MENU,
"<PaletteEditor>", "palette_editor",
palette_editor_menu_update,
G_N_ELEMENTS (palette_editor_entries),
palette_editor_entries,
gimp,
FALSE);
palettes_factory = gimp_item_factory_new (GTK_TYPE_MENU,
"<Palettes>", "palettes",
palettes_menu_update,
@ -2268,6 +2300,12 @@ menus_exit (Gimp *gimp)
gradients_factory = NULL;
}
if (palette_editor_factory)
{
g_object_unref (G_OBJECT (palette_editor_factory));
palette_editor_factory = NULL;
}
if (palettes_factory)
{
g_object_unref (G_OBJECT (palettes_factory));

4
app/widgets/gimpbrusheditor.h
View file

@ -62,7 +62,9 @@ struct _GimpBrushEditorClass
};
GimpDataEditor * gimp_brush_editor_new (Gimp *gimp);
GType gimp_brush_editor_get_type (void) G_GNUC_CONST;
GimpDataEditor * gimp_brush_editor_new (Gimp *gimp);
#endif /* __GIMP_BRUSH_EDITOR_H__ */

6
app/widgets/gimpgradienteditor.c
View file

@ -706,12 +706,10 @@ preview_events (GtkWidget *widget,
{
case GDK_EXPOSE:
preview_update (editor, FALSE);
return FALSE;
case GDK_LEAVE_NOTIFY:
gradient_editor_set_hint (editor, "", "", "");
break;
case GDK_MOTION_NOTIFY:
@ -735,7 +733,6 @@ preview_events (GtkWidget *widget,
preview_set_hint (editor, x);
}
}
break;
case GDK_BUTTON_PRESS:
@ -767,7 +764,6 @@ preview_events (GtkWidget *widget,
default:
break;
}
break;
case GDK_SCROLL:
@ -792,7 +788,6 @@ preview_events (GtkWidget *widget,
gtk_adjustment_set_value (adj, new_value);
}
break;
case GDK_BUTTON_RELEASE:
@ -810,7 +805,6 @@ preview_events (GtkWidget *widget,
preview_set_foreground (editor, x);
break;
}
break;
default:

8
app/widgets/gimpgradienteditor.h
View file

@ -114,10 +114,12 @@ struct _GimpGradientEditorClass
};
GimpDataEditor * gimp_gradient_editor_new (Gimp *gimp);
GType gimp_gradient_editor_get_type (void) G_GNUC_CONST;
void gimp_gradient_editor_update (GimpGradientEditor *editor,
GradientEditorUpdateMask flags);
GimpDataEditor * gimp_gradient_editor_new (Gimp *gimp);
void gimp_gradient_editor_update (GimpGradientEditor *editor,
GradientEditorUpdateMask flags);
#endif /* __GIMP_GRADIENT_EDITOR_H__ */

322
app/widgets/gimppaletteeditor.c
View file

@ -38,6 +38,7 @@
#include "core/gimppalette.h"
#include "gimpdnd.h"
#include "gimpitemfactory.h"
#include "gimppaletteeditor.h"
#include "gimppreview.h"
@ -72,18 +73,6 @@ static void gimp_palette_editor_unmap (GtkWidget *widget);
static void gimp_palette_editor_set_data (GimpDataEditor *editor,
GimpData *data);
static void palette_editor_create_popup_menu (GimpPaletteEditor *editor);
static void palette_editor_new_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor);
static void palette_editor_edit_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor);
static void palette_editor_delete_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor);
static void palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data);
static gint palette_editor_eventbox_button_press (GtkWidget *widget,
GdkEventButton *bevent,
GimpPaletteEditor *editor);
@ -98,6 +87,8 @@ static void palette_editor_scroll_top_left (GimpPaletteEditor *editor);
static void palette_editor_color_name_changed (GtkWidget *widget,
GimpPaletteEditor *editor);
static void palette_editor_columns_changed (GtkAdjustment *adj,
GimpPaletteEditor *editor);
static void palette_editor_zoom_in_callback (GtkWidget *widget,
GimpPaletteEditor *editor);
static void palette_editor_zoom_out_callback (GtkWidget *widget,
@ -183,9 +174,11 @@ gimp_palette_editor_init (GimpPaletteEditor *editor)
{
GtkWidget *scrolledwindow;
GtkWidget *palette_region;
GtkWidget *entry;
GtkWidget *eventbox;
GtkWidget *alignment;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *spinbutton;
editor->zoom_factor = 1.0;
editor->columns = COLUMNS;
@ -248,18 +241,36 @@ gimp_palette_editor_init (GimpPaletteEditor *editor)
palette_editor_drop_palette,
editor);
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* The color name entry */
entry = editor->color_name = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (editor), entry, FALSE, FALSE, 0);
gtk_entry_set_text (GTK_ENTRY (entry), _("Undefined"));
gtk_widget_set_sensitive (entry, FALSE);
gtk_widget_show (entry);
editor->color_name = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), editor->color_name, TRUE, TRUE, 0);
gtk_entry_set_text (GTK_ENTRY (editor->color_name), _("Undefined"));
gtk_widget_set_sensitive (editor->color_name, FALSE);
gtk_widget_show (editor->color_name);
editor->entry_sig_id =
g_signal_connect (G_OBJECT (entry), "changed",
g_signal_connect (G_OBJECT (editor->color_name), "changed",
G_CALLBACK (palette_editor_color_name_changed),
editor);
label = gtk_label_new (_("Columns:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new ((GtkObject **) &editor->columns_data,
0, 0, 64, 1, 4, 4, 1, 0);
gtk_widget_set_size_request (spinbutton, 50, -1);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
g_signal_connect (G_OBJECT (editor->columns_data), "value_changed",
G_CALLBACK (palette_editor_columns_changed),
editor);
/* + and - buttons */
gimp_editor_add_button (GIMP_EDITOR (editor),
GTK_STOCK_ZOOM_FIT,
@ -281,8 +292,6 @@ gimp_palette_editor_init (GimpPaletteEditor *editor)
G_CALLBACK (palette_editor_zoom_out_callback),
NULL,
editor);
palette_editor_create_popup_menu (editor);
}
static void
@ -326,6 +335,12 @@ gimp_palette_editor_set_data (GimpDataEditor *editor,
palette_editor = GIMP_PALETTE_EDITOR (editor);
g_signal_handler_block (G_OBJECT (palette_editor->color_name),
palette_editor->entry_sig_id);
g_signal_handlers_block_by_func (G_OBJECT (palette_editor->columns_data),
palette_editor_columns_changed,
editor);
if (editor->data)
{
if (palette_editor->color_notebook)
@ -342,31 +357,41 @@ gimp_palette_editor_set_data (GimpDataEditor *editor,
palette_editor->columns_valid = FALSE;
palette_editor->color = NULL;
g_signal_handler_block (G_OBJECT (palette_editor->color_name),
palette_editor->entry_sig_id);
gtk_entry_set_text (GTK_ENTRY (palette_editor->color_name),
_("Undefined"));
g_signal_handler_unblock (G_OBJECT (palette_editor->color_name),
palette_editor->entry_sig_id);
gtk_widget_set_sensitive (palette_editor->color_name, FALSE);
gtk_adjustment_set_value (palette_editor->columns_data, 0);
}
GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);
if (editor->data)
{
GimpPalette *palette;
palette = GIMP_PALETTE (editor->data);
g_signal_connect (G_OBJECT (editor->data), "invalidate_preview",
G_CALLBACK (palette_editor_invalidate_preview),
editor);
gtk_adjustment_set_value (palette_editor->columns_data,
palette->n_columns);
palette_editor_invalidate_preview (GIMP_PALETTE (editor->data),
palette_editor);
palette_editor_scroll_top_left (palette_editor);
}
g_signal_handlers_unblock_by_func (G_OBJECT (palette_editor->columns_data),
palette_editor_columns_changed,
editor);
g_signal_handler_unblock (G_OBJECT (palette_editor->color_name),
palette_editor->entry_sig_id);
}
/* public functions */
@ -427,162 +452,6 @@ gimp_palette_editor_update_color (GimpContext *context,
/* private functions */
/* the palette dialog popup menu & callbacks *******************************/
static void
palette_editor_create_popup_menu (GimpPaletteEditor *palette_editor)
{
GtkWidget *menu;
GtkWidget *menu_item;
palette_editor->popup_menu = menu = gtk_menu_new ();
menu_item = gtk_menu_item_new_with_label (_("New"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (palette_editor_new_entry_callback),
palette_editor);
menu_item = gtk_menu_item_new_with_label (_("Edit"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (palette_editor_edit_entry_callback),
palette_editor);
palette_editor->edit_menu_item = menu_item;
menu_item = gtk_menu_item_new_with_label (_("Delete"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (palette_editor_delete_entry_callback),
palette_editor);
palette_editor->delete_menu_item = menu_item;
}
static void
palette_editor_new_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor)
{
GimpPalette *palette;
GimpContext *user_context;
GimpRGB color;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! palette)
return;
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
if (active_color == FOREGROUND)
gimp_context_get_foreground (user_context, &color);
else if (active_color == BACKGROUND)
gimp_context_get_background (user_context, &color);
editor->color = gimp_palette_add_entry (palette, NULL, &color);
}
static void
palette_editor_edit_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor)
{
GimpPalette *palette;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
if (! editor->color_notebook)
{
editor->color_notebook =
color_notebook_new (_("Edit Palette Color"),
(const GimpRGB *) &editor->color->color,
palette_editor_color_notebook_callback,
editor,
FALSE,
FALSE);
editor->color_notebook_active = TRUE;
}
else
{
if (! editor->color_notebook_active)
{
color_notebook_show (editor->color_notebook);
editor->color_notebook_active = TRUE;
}
color_notebook_set_color (editor->color_notebook,
&editor->color->color);
}
}
static void
palette_editor_delete_entry_callback (GtkWidget *widget,
GimpPaletteEditor *editor)
{
GimpPalette *palette;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! (palette && editor->color))
return;
gimp_palette_delete_entry (palette, editor->color);
}
static void
palette_editor_color_notebook_callback (ColorNotebook *color_notebook,
const GimpRGB *color,
ColorNotebookState state,
gpointer data)
{
GimpPaletteEditor *editor;
GimpPalette *palette;
GimpContext *user_context;
editor = GIMP_PALETTE_EDITOR (data);
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (GIMP_DATA_EDITOR (editor)->gimp);
switch (state)
{
case COLOR_NOTEBOOK_UPDATE:
break;
case COLOR_NOTEBOOK_OK:
if (editor->color)
{
editor->color->color = *color;
/* Update either foreground or background colors */
if (active_color == FOREGROUND)
gimp_context_set_foreground (user_context, color);
else if (active_color == BACKGROUND)
gimp_context_set_background (user_context, color);
gimp_data_dirty (GIMP_DATA (palette));
}
/* Fallthrough */
case COLOR_NOTEBOOK_CANCEL:
if (editor->color_notebook_active)
{
color_notebook_hide (editor->color_notebook);
editor->color_notebook_active = FALSE;
}
}
}
/* the color area event callbacks ******************************************/
static gint
@ -595,15 +464,11 @@ palette_editor_eventbox_button_press (GtkWidget *widget,
if (bevent->button == 3)
{
if (GTK_WIDGET_SENSITIVE (editor->edit_menu_item))
{
gtk_widget_set_sensitive (editor->edit_menu_item, FALSE);
gtk_widget_set_sensitive (editor->delete_menu_item, FALSE);
}
GimpItemFactory *factory;
gtk_menu_popup (GTK_MENU (editor->popup_menu), NULL, NULL,
NULL, NULL, 3,
bevent->time);
factory = gimp_item_factory_from_path ("<PaletteEditor>");
gimp_item_factory_popup_with_data (factory, editor, NULL);
}
return TRUE;
@ -631,7 +496,7 @@ palette_editor_color_area_events (GtkWidget *widget,
{
case GDK_EXPOSE:
palette_editor_redraw (editor);
break;
return FALSE;
case GDK_BUTTON_PRESS:
bevent = (GdkEventButton *) event;
@ -685,9 +550,6 @@ palette_editor_color_area_events (GtkWidget *widget,
palette_editor_draw_entries (editor, row, col);
/* Update the active color name */
g_print ("former color name: '%s'\n",
editor->color->name);
g_signal_handler_block (G_OBJECT (editor->color_name),
editor->entry_sig_id);
@ -697,40 +559,27 @@ palette_editor_color_area_events (GtkWidget *widget,
g_signal_handler_unblock (G_OBJECT (editor->color_name),
editor->entry_sig_id);
g_print ("new color name: '%s'\n",
editor->color->name);
gtk_widget_set_sensitive (editor->color_name, TRUE);
/* palette_update_current_entry (editor); */
if (bevent->button == 3)
{
if (! GTK_WIDGET_SENSITIVE (editor->edit_menu_item))
{
gtk_widget_set_sensitive (editor->edit_menu_item, TRUE);
gtk_widget_set_sensitive (editor->delete_menu_item, TRUE);
}
GimpItemFactory *factory;
gtk_menu_popup (GTK_MENU (editor->popup_menu),
NULL, NULL,
NULL, NULL, 3,
bevent->time);
factory = gimp_item_factory_from_path ("<PaletteEditor>");
gimp_item_factory_popup_with_data (factory, editor, NULL);
}
}
else
{
if (bevent->button == 3)
{
if (GTK_WIDGET_SENSITIVE (editor->edit_menu_item))
{
gtk_widget_set_sensitive (editor->edit_menu_item, FALSE);
gtk_widget_set_sensitive (editor->delete_menu_item, FALSE);
}
GimpItemFactory *factory;
gtk_menu_popup (GTK_MENU (editor->popup_menu),
NULL, NULL,
NULL, NULL, 3,
bevent->time);
factory = gimp_item_factory_from_path ("<PaletteEditor>");
gimp_item_factory_popup_with_data (factory, editor, NULL);
}
}
}
@ -740,7 +589,7 @@ palette_editor_color_area_events (GtkWidget *widget,
break;
}
return FALSE;
return TRUE;
}
/* functions for drawing & updating the palette dialog color area **********/
@ -1092,6 +941,22 @@ palette_editor_color_name_changed (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (palette));
}
/* the columns spinbutton callback *****************************************/
static void
palette_editor_columns_changed (GtkAdjustment *adj,
GimpPaletteEditor *editor)
{
GimpPalette *palette;
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
if (! palette)
return;
gimp_palette_set_n_columns (palette, ROUND (adj->value));
}
/* palette zoom functions & callbacks **************************************/
static void
@ -1154,12 +1019,22 @@ palette_editor_redraw_zoom (GimpPaletteEditor *editor)
editor->zoom_factor = 0.1;
}
editor->columns = COLUMNS;
if (GIMP_DATA_EDITOR (editor)->data)
{
GimpPalette *palette;
editor->columns_valid = FALSE;
palette_editor_redraw (editor);
palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
palette_editor_scroll_top_left (editor);
if (palette->n_columns)
editor->columns = palette->n_columns;
else
editor->columns = COLUMNS;
editor->columns_valid = FALSE;
palette_editor_redraw (editor);
palette_editor_scroll_top_left (editor);
}
}
@ -1214,6 +1089,11 @@ static void
palette_editor_invalidate_preview (GimpPalette *palette,
GimpPaletteEditor *editor)
{
if (palette->n_columns)
editor->columns = palette->n_columns;
else
editor->columns = COLUMNS;
editor->columns_valid = FALSE;
palette_editor_redraw (editor);

8
app/widgets/gimppaletteeditor.h
View file

@ -49,11 +49,9 @@ struct _GimpPaletteEditor
GtkWidget *color_area;
GtkWidget *scrolled_window;
GtkWidget *color_name;
GtkWidget *popup_menu;
GtkWidget *delete_menu_item;
GtkWidget *edit_menu_item;
GtkWidget *color_name;
GtkAdjustment *columns_data;
ColorNotebook *color_notebook;
gboolean color_notebook_active;
@ -76,6 +74,8 @@ struct _GimpPaletteEditorClass
};
GType gimp_palette_editor_get_type (void) G_GNUC_CONST;
GimpDataEditor * gimp_palette_editor_new (Gimp *gimp);
void gimp_palette_editor_update_color (GimpContext *context,