static void
gimp_palette_editor_constructed (GObject *object)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-edit-color", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-new-color-fg",
"palette-editor-new-color-bg",
gimp_get_toggle_behavior_mask (),
NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-delete-color", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-out", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-in", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-all", NULL);
}
void
palette_editor_edit_color_cmd_callback (GtkAction *action,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
gimp_palette_editor_edit_color (editor);
}
void
palette_editor_zoom_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
gimp_palette_editor_zoom (editor, (GimpZoomType) value);
}
static void
gimp_palette_editor_unmap (GtkWidget *widget)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (widget);
if (editor->color_dialog)
gtk_widget_hide (editor->color_dialog);
GTK_WIDGET_CLASS (parent_class)->unmap (widget);
}
void
palette_editor_actions_update (GimpActionGroup *group,
gpointer user_data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (user_data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (user_data);
GimpData *data;
gboolean editable = FALSE;
GimpRGB fg;
GimpRGB bg;
gboolean edit_active = FALSE;
data = data_editor->data;
if (data)
{
if (data_editor->data_editable)
editable = TRUE;
}
if (data_editor->context)
{
gimp_context_get_foreground (data_editor->context, &fg);
gimp_context_get_background (data_editor->context, &bg);
}
edit_active = gimp_data_editor_get_edit_active (data_editor);
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE);
SET_SENSITIVE ("palette-editor-edit-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-delete-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-new-color-fg", editable);
SET_SENSITIVE ("palette-editor-new-color-bg", editable);
SET_COLOR ("palette-editor-new-color-fg", data_editor->context ? &fg : NULL);
SET_COLOR ("palette-editor-new-color-bg", data_editor->context ? &bg : NULL);
SET_SENSITIVE ("palette-editor-zoom-out", data);
SET_SENSITIVE ("palette-editor-zoom-in", data);
SET_SENSITIVE ("palette-editor-zoom-all", data);
SET_ACTIVE ("palette-editor-edit-active", edit_active);
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_COLOR
}
static void
gimp_palette_editor_set_context (GimpDocked *docked,
GimpContext *context)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (docked);
parent_docked_iface->set_context (docked, context);
gimp_view_renderer_set_context (GIMP_VIEW (editor->view)->renderer,
context);
}
static void
gimp_palette_editor_dispose (GObject *object)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (object);
if (editor->color_dialog)
{
gtk_widget_destroy (editor->color_dialog);
editor->color_dialog = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_palette_editor_set_data (GimpDataEditor *editor,
GimpData *data)
{
GimpPaletteEditor *palette_editor = GIMP_PALETTE_EDITOR (editor);
g_signal_handlers_block_by_func (palette_editor->columns_adj,
palette_editor_columns_changed,
editor);
if (editor->data)
{
if (palette_editor->color_dialog)
{
gtk_widget_destroy (palette_editor->color_dialog);
palette_editor->color_dialog = NULL;
}
g_signal_handlers_disconnect_by_func (editor->data,
palette_editor_invalidate_preview,
editor);
gtk_adjustment_set_value (palette_editor->columns_adj, 0);
}
GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);
gimp_view_set_viewable (GIMP_VIEW (palette_editor->view),
GIMP_VIEWABLE (data));
if (editor->data)
{
GimpPalette *palette = GIMP_PALETTE (editor->data);
g_signal_connect (editor->data, "invalidate-preview",
G_CALLBACK (palette_editor_invalidate_preview),
editor);
gtk_adjustment_set_value (palette_editor->columns_adj,
gimp_palette_get_columns (palette));
palette_editor_scroll_top_left (palette_editor);
palette_editor_invalidate_preview (GIMP_PALETTE (editor->data),
palette_editor);
}
g_signal_handlers_unblock_by_func (palette_editor->columns_adj,
palette_editor_columns_changed,
editor);
}
void
palette_editor_delete_color_cmd_callback (GtkAction *action,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
if (data_editor->data_editable && editor->color)
{
GimpPalette *palette = GIMP_PALETTE (data_editor->data);
gimp_palette_delete_entry (palette, editor->color);
}
}
static GimpPaletteEditor *
context_get_palette_editor (void)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (widget)
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
return NULL;
}
static GimpPaletteEditor *
context_get_palette_editor (void)
{
GimpSessionInfo *info = NULL;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL);
info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (info && gimp_session_info_get_widget (info))
return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info))));
return NULL;
}
void
palette_editor_edit_color_cmd_callback (GtkAction *action,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
GimpPalette *palette;
if (! (data_editor->data_editable && editor->color))
return;
palette = GIMP_PALETTE (data_editor->data);
if (! editor->color_dialog)
{
editor->color_dialog =
gimp_color_dialog_new (GIMP_VIEWABLE (palette),
data_editor->context,
_("Edit Palette Color"),
GIMP_STOCK_PALETTE,
_("Edit Color Palette Entry"),
GTK_WIDGET (editor),
gimp_dialog_factory_get_singleton (),
"gimp-palette-editor-color-dialog",
&editor->color->color,
FALSE, FALSE);
g_signal_connect (editor->color_dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&editor->color_dialog);
g_signal_connect (editor->color_dialog, "update",
G_CALLBACK (palette_editor_edit_color_update),
editor);
}
else
{
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (editor->color_dialog),
GIMP_VIEWABLE (palette),
data_editor->context);
gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (editor->color_dialog),
&editor->color->color);
}
gtk_window_present (GTK_WINDOW (editor->color_dialog));
}
static GList *
gimp_palette_editor_get_aux_info (GimpDocked *docked)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (docked);
GList *aux_info;
aux_info = parent_docked_iface->get_aux_info (docked);
if (editor->zoom_factor != 1.0)
{
GimpSessionInfoAux *aux;
gchar value[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_formatd (value, sizeof (value), "%.2f", editor->zoom_factor);
aux = gimp_session_info_aux_new (AUX_INFO_ZOOM_FACTOR, value);
aux_info = g_list_append (aux_info, aux);
}
return aux_info;
}
void
palette_editor_new_color_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
if (data_editor->data_editable)
{
GimpPalette *palette = GIMP_PALETTE (data_editor->data);
GimpRGB color;
if (value)
gimp_context_get_background (data_editor->context, &color);
else
gimp_context_get_foreground (data_editor->context, &color);
editor->color = gimp_palette_add_entry (palette, -1, NULL, &color);
}
}
static void
gimp_palette_editor_set_aux_info (GimpDocked *docked,
GList *aux_info)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (docked);
GList *list;
parent_docked_iface->set_aux_info (docked, aux_info);
for (list = aux_info; list; list = g_list_next (list))
{
GimpSessionInfoAux *aux = list->data;
if (! strcmp (aux->name, AUX_INFO_ZOOM_FACTOR))
{
gdouble zoom_factor;
zoom_factor = g_ascii_strtod (aux->value, NULL);
editor->zoom_factor = CLAMP (zoom_factor, 0.1, 4.0);
}
}
}
static void
gimp_color_tool_real_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
gdouble x,
gdouble y,
const Babl *sample_format,
const GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpContext *context;
/* use this tool's own options here (NOT color_tool->options) */
context = GIMP_CONTEXT (gimp_tool_get_options (tool));
if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND ||
color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND)
{
GtkWidget *widget;
if (babl_format_is_palette (sample_format))
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-indexed-palette");
if (widget)
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
}
if (TRUE)
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (widget)
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
index = gimp_palette_editor_get_index (editor, color);
if (index != -1)
gimp_palette_editor_set_index (editor, index, NULL);
}
}
}
switch (color_tool->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
gimp_context_set_foreground (context, color);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
gimp_context_set_background (context, color);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
{
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell));
GtkWidget *dockable;
dockable =
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)),
tool->display->gimp,
gimp_dialog_factory_get_singleton (),
screen,
"gimp-palette-editor");
if (dockable)
{
GtkWidget *palette_editor;
GimpData *data;
/* don't blink like mad when updating */
if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE)
gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable));
palette_editor = gtk_bin_get_child (GTK_BIN (dockable));
data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor));
if (! data)
{
data = GIMP_DATA (gimp_context_get_palette (context));
gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor),
data);
}
gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor),
color, pick_state);
}
}
break;
}
}
static void
gimp_color_tool_real_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
GimpImageType sample_type,
GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpContext *context;
GimpDialogFactory *dialog_factory;
/* use this tool's own options here (NOT color_tool->options) */
context = GIMP_CONTEXT (gimp_tool_get_options (tool));
dialog_factory = gimp_dialog_factory_from_name ("dock");
if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND ||
color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND)
{
GimpSessionInfo *info;
if (GIMP_IMAGE_TYPE_IS_INDEXED (sample_type))
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-indexed-palette");
if (info && info->widget)
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
}
if (TRUE)
{
info = gimp_dialog_factory_find_session_info (dialog_factory,
"gimp-palette-editor");
if (info && info->widget)
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget)));
index = gimp_palette_editor_get_index (editor, color);
if (index != -1)
gimp_palette_editor_set_index (editor, index, NULL);
}
}
}
switch (color_tool->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
gimp_context_set_foreground (context, color);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
gimp_context_set_background (context, color);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
{
GdkScreen *screen;
GtkWidget *dockable;
screen = gtk_widget_get_screen (tool->display->shell);
dockable = gimp_dialog_factory_dialog_raise (dialog_factory, screen,
"gimp-palette-editor",
-1);
if (dockable)
{
GtkWidget *palette_editor;
GimpData *data;
/* don't blink like mad when updating */
if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE)
gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable));
palette_editor = gtk_bin_get_child (GTK_BIN (dockable));
data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor));
if (! data)
{
data = GIMP_DATA (gimp_context_get_palette (context));
gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor),
data);
}
gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor),
color, pick_state);
}
}
break;
}
}
