static GimpValueArray *
palettes_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *filter;
gint32 num_palettes = 0;
gchar **palette_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
palette_list = gimp_container_get_filtered_name_array (gimp_data_factory_get_container (gimp->palette_factory),
filter, &num_palettes);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_palettes);
gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), palette_list, num_palettes);
}
return return_vals;
}
static GValueArray *
palettes_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *palette_callback;
const gchar *palette_name;
palette_callback = g_value_get_string (&args->values[0]);
palette_name = g_value_get_string (&args->values[1]);
if (success)
{
if (gimp->no_interface ||
! gimp_pdb_lookup_procedure (gimp->pdb, palette_callback) ||
! gimp_pdb_dialog_set (gimp, gimp_data_factory_get_container (gimp->palette_factory),
palette_callback, palette_name,
NULL))
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static void
palette_import_response (GtkWidget *widget,
gint response_id,
ImportDialog *dialog)
{
Gimp *gimp = dialog->context->gimp;
palette_import_image_changed (dialog->context, NULL, dialog);
if (dialog->palette)
{
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);
gimp_container_add (gimp_data_factory_get_container (gimp->palette_factory),
GIMP_OBJECT (dialog->palette));
}
}
gtk_widget_destroy (dialog->dialog);
}
void
context_gradient_select_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
return_if_no_context (context, data);
context_select_object ((GimpActionSelectType) value,
context, gimp_data_factory_get_container (context->gimp->gradient_factory));
}
static GimpObject *
gimp_pdb_get_data_factory_item (GimpDataFactory *data_factory,
const gchar *name)
{
GimpObject *gimp_object;
gimp_object = gimp_container_get_child_by_name (gimp_data_factory_get_container (data_factory), name);
if (! gimp_object)
gimp_object = gimp_container_get_child_by_name (gimp_data_factory_get_container_obsolete (data_factory), name);
return gimp_object;
}
static GtkWidget *
mybrush_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size)
{
if (! container)
container = gimp_data_factory_get_container (context->gimp->mybrush_factory);
return gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_LARGE, view_size,
"gimp-mypaint-brush-grid|gimp-mypaint-brush-list",
GIMP_STOCK_BRUSH,
_("Open the MyPaint brush selection dialog"),
NULL, NULL);
}
static GtkWidget *
pattern_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size)
{
if (! container)
container = gimp_data_factory_get_container (context->gimp->pattern_factory);
return gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_SMALL, view_size,
"gimp-pattern-grid|gimp-pattern-list",
GIMP_STOCK_PATTERN,
_("Open the pattern selection dialog"),
NULL, NULL);
}
static void
data_delete_dialog_response (GtkWidget *dialog,
gint response_id,
DataDeleteDialog *delete_data)
{
gtk_widget_destroy (dialog);
if (response_id == GTK_RESPONSE_OK)
{
GimpDataFactory *factory = delete_data->factory;
GimpData *data = delete_data->data;
GimpContainer *container;
GimpObject *new_active = NULL;
GError *error = NULL;
container = gimp_data_factory_get_container (factory);
if (delete_data->context &&
GIMP_OBJECT (data) ==
gimp_context_get_by_type (delete_data->context,
gimp_container_get_children_type (container)))
{
new_active = gimp_container_get_neighbor_of (container,
GIMP_OBJECT (data));
}
if (! gimp_data_factory_data_delete (factory, data, TRUE, &error))
{
gimp_message (gimp_data_factory_get_gimp (factory),
G_OBJECT (delete_data->parent), GIMP_MESSAGE_ERROR,
"%s", error->message);
g_clear_error (&error);
}
if (new_active)
gimp_context_set_by_type (delete_data->context,
gimp_container_get_children_type (container),
new_active);
}
g_slice_free (DataDeleteDialog, delete_data);
}
static GimpGradient *
gimp_gradients_add_gradient (Gimp *gimp,
const gchar *name,
const gchar *id)
{
GimpGradient *gradient;
gradient = GIMP_GRADIENT (gimp_gradient_new (gimp_get_user_context (gimp),
name));
gimp_data_make_internal (GIMP_DATA (gradient), id);
gimp_container_add (gimp_data_factory_get_container (gimp->gradient_factory),
GIMP_OBJECT (gradient));
g_object_unref (gradient);
g_object_set_data (G_OBJECT (gimp), id, gradient);
return gradient;
}
static GtkWidget *
palette_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size,
const gchar *editor_id,
const gchar *editor_tooltip)
{
if (! container)
container = gimp_data_factory_get_container (context->gimp->palette_factory);
return gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_MEDIUM, view_size,
"gimp-palette-list|gimp-palette-grid",
GIMP_STOCK_PALETTE,
_("Open the palette selection dialog"),
editor_id, editor_tooltip);
}
static GtkWidget *
brush_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size,
const gchar *editor_id,
const gchar *editor_tooltip)
{
if (! container)
container = gimp_data_factory_get_container (context->gimp->brush_factory);
return gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_SMALL, view_size,
"gimp-brush-grid|gimp-brush-list",
GIMP_STOCK_BRUSH,
_("Open the brush selection dialog"),
editor_id, editor_tooltip);
}
static GtkWidget *
dynamics_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size,
const gchar *editor_id,
const gchar *editor_tooltip)
{
if (! container)
container = gimp_data_factory_get_container (context->gimp->dynamics_factory);
return gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_SMALL, view_size,
"gimp-dynamics-list|gimp-dynamics-grid",
GIMP_STOCK_DYNAMICS,
_("Open the dynamics selection dialog"),
editor_id, editor_tooltip);
}
static void
gimp_data_editor_set_context (GimpDocked *docked,
GimpContext *context)
{
GimpDataEditor *editor = GIMP_DATA_EDITOR (docked);
if (context == editor->context)
return;
if (parent_docked_iface->set_context)
parent_docked_iface->set_context (docked, context);
if (editor->context)
{
g_signal_handlers_disconnect_by_func (editor->context,
gimp_data_editor_data_changed,
editor);
g_object_unref (editor->context);
}
editor->context = context;
if (editor->context)
{
GType data_type;
GimpData *data;
g_object_ref (editor->context);
data_type = gimp_container_get_children_type (gimp_data_factory_get_container (editor->data_factory));
data = GIMP_DATA (gimp_context_get_by_type (editor->context, data_type));
g_signal_connect (editor->context,
gimp_context_type_to_signal_name (data_type),
G_CALLBACK (gimp_data_editor_data_changed),
editor);
gimp_data_editor_data_changed (editor->context, data, editor);
}
}
void
gimp_data_editor_set_data (GimpDataEditor *editor,
GimpData *data)
{
g_return_if_fail (GIMP_IS_DATA_EDITOR (editor));
g_return_if_fail (data == NULL || GIMP_IS_DATA (data));
g_return_if_fail (data == NULL ||
g_type_is_a (G_TYPE_FROM_INSTANCE (data),
gimp_container_get_children_type (gimp_data_factory_get_container (editor->data_factory))));
if (editor->data != data)
{
GIMP_DATA_EDITOR_GET_CLASS (editor)->set_data (editor, data);
g_object_notify (G_OBJECT (editor), "data");
if (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)))
gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
}
}
void
gimp_data_editor_set_edit_active (GimpDataEditor *editor,
gboolean edit_active)
{
g_return_if_fail (GIMP_IS_DATA_EDITOR (editor));
if (editor->edit_active != edit_active)
{
editor->edit_active = edit_active;
if (editor->edit_active && editor->context)
{
GType data_type;
GimpData *data;
data_type = gimp_container_get_children_type (gimp_data_factory_get_container (editor->data_factory));
data = GIMP_DATA (gimp_context_get_by_type (editor->context,
data_type));
gimp_data_editor_set_data (editor, data);
}
}
}
static void
gimp_data_editor_set_aux_info (GimpDocked *docked,
GList *aux_info)
{
GimpDataEditor *editor = GIMP_DATA_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_EDIT_ACTIVE))
{
gboolean edit_active;
edit_active = ! g_ascii_strcasecmp (aux->value, "true");
gimp_data_editor_set_edit_active (editor, edit_active);
}
else if (! strcmp (aux->name, AUX_INFO_CURRENT_DATA))
{
if (! editor->edit_active)
{
GimpData *data;
data = (GimpData *)
gimp_container_get_child_by_name (gimp_data_factory_get_container (editor->data_factory),
aux->value);
if (data)
gimp_data_editor_set_data (editor, data);
}
}
}
}
GimpToolInfo *
gimp_tool_info_new (Gimp *gimp,
GType tool_type,
GType tool_options_type,
GimpContextPropMask context_props,
const gchar *identifier,
const gchar *blurb,
const gchar *help,
const gchar *menu_label,
const gchar *menu_accel,
const gchar *help_domain,
const gchar *help_id,
const gchar *paint_core_name,
const gchar *icon_name)
{
GimpPaintInfo *paint_info;
GimpToolInfo *tool_info;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (identifier != NULL, NULL);
g_return_val_if_fail (blurb != NULL, NULL);
g_return_val_if_fail (help != NULL, NULL);
g_return_val_if_fail (menu_label != NULL, NULL);
g_return_val_if_fail (help_id != NULL, NULL);
g_return_val_if_fail (paint_core_name != NULL, NULL);
g_return_val_if_fail (icon_name != NULL, NULL);
paint_info = (GimpPaintInfo *)
gimp_container_get_child_by_name (gimp->paint_info_list, paint_core_name);
g_return_val_if_fail (GIMP_IS_PAINT_INFO (paint_info), NULL);
tool_info = g_object_new (GIMP_TYPE_TOOL_INFO,
"name", identifier,
"icon-name", icon_name,
NULL);
tool_info->gimp = gimp;
tool_info->tool_type = tool_type;
tool_info->tool_options_type = tool_options_type;
tool_info->context_props = context_props;
tool_info->blurb = g_strdup (blurb);
tool_info->help = g_strdup (help);
tool_info->menu_label = g_strdup (menu_label);
tool_info->menu_accel = g_strdup (menu_accel);
tool_info->help_domain = g_strdup (help_domain);
tool_info->help_id = g_strdup (help_id);
tool_info->paint_info = paint_info;
if (tool_info->tool_options_type == paint_info->paint_options_type)
{
tool_info->tool_options = g_object_ref (paint_info->paint_options);
}
else
{
tool_info->tool_options = g_object_new (tool_info->tool_options_type,
"gimp", gimp,
"name", identifier,
NULL);
}
g_object_set (tool_info->tool_options,
"tool", tool_info,
"tool-info", tool_info, NULL);
if (tool_info->tool_options_type != GIMP_TYPE_TOOL_OPTIONS)
{
GimpContainer *presets;
presets = gimp_data_factory_get_container (gimp->tool_preset_factory);
tool_info->presets =
gimp_filtered_container_new (presets,
gimp_tool_info_filter_preset,
tool_info);
}
return tool_info;
}
void
gimp_restore (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (status_callback != NULL);
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
/* initialize the global parasite table */
status_callback (_("Looking for data files"), _("Parasites"), 0.0);
gimp_parasiterc_load (gimp);
/* initialize the list of gimp brushes */
status_callback (NULL, _("Brushes"), 0.1);
gimp_data_factory_data_init (gimp->brush_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of gimp dynamics */
status_callback (NULL, _("Dynamics"), 0.2);
gimp_data_factory_data_init (gimp->dynamics_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of mypaint brushes */
status_callback (NULL, _("MyPaint Brushes"), 0.25);
gimp_data_factory_data_init (gimp->mybrush_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of gimp patterns */
status_callback (NULL, _("Patterns"), 0.3);
gimp_data_factory_data_init (gimp->pattern_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of gimp palettes */
status_callback (NULL, _("Palettes"), 0.4);
gimp_data_factory_data_init (gimp->palette_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of gimp gradients */
status_callback (NULL, _("Gradients"), 0.5);
gimp_data_factory_data_init (gimp->gradient_factory, gimp->user_context,
gimp->no_data);
/* initialize the list of fonts */
status_callback (NULL, _("Fonts (this may take a while)"), 0.6);
if (! gimp->no_fonts)
gimp_fonts_load (gimp);
/* initialize the color history */
gimp_palettes_load (gimp);
/* initialize the list of gimp tool presets if we have a GUI */
if (! gimp->no_interface)
{
status_callback (NULL, _("Tool Presets"), 0.65);
gimp_data_factory_data_init (gimp->tool_preset_factory, gimp->user_context,
gimp->no_data);
}
/* initialize the template list */
status_callback (NULL, _("Templates"), 0.7);
gimp_templates_load (gimp);
/* initialize the module list */
status_callback (NULL, _("Modules"), 0.8);
gimp_modules_load (gimp);
/* update tag cache */
status_callback (NULL, _("Updating tag cache"), 0.9);
gimp_tag_cache_load (gimp->tag_cache);
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->brush_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->dynamics_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->mybrush_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->pattern_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->gradient_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->palette_factory));
gimp_tag_cache_add_container (gimp->tag_cache,
gimp_data_factory_get_container (gimp->tool_preset_factory));
g_signal_emit (gimp, gimp_signals[RESTORE], 0, status_callback);
/* when done, make sure everything is clean, to clean out dirty
* states from data object which reference each other and got
* dirtied by loading the referenced object
*/
gimp_data_factory_data_clean (gimp->brush_factory);
gimp_data_factory_data_clean (gimp->dynamics_factory);
gimp_data_factory_data_clean (gimp->mybrush_factory);
gimp_data_factory_data_clean (gimp->pattern_factory);
gimp_data_factory_data_clean (gimp->palette_factory);
gimp_data_factory_data_clean (gimp->gradient_factory);
gimp_data_factory_data_clean (gimp->tool_preset_factory);
}
static void
gimp_real_initialize (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
static const GimpDataFactoryLoaderEntry brush_loader_entries[] =
{
{ gimp_brush_load, GIMP_BRUSH_FILE_EXTENSION, FALSE },
{ gimp_brush_load, GIMP_BRUSH_PIXMAP_FILE_EXTENSION, FALSE },
{ gimp_brush_load_abr, GIMP_BRUSH_PS_FILE_EXTENSION, FALSE },
{ gimp_brush_load_abr, GIMP_BRUSH_PSP_FILE_EXTENSION, FALSE },
{ gimp_brush_generated_load, GIMP_BRUSH_GENERATED_FILE_EXTENSION, TRUE },
{ gimp_brush_pipe_load, GIMP_BRUSH_PIPE_FILE_EXTENSION, FALSE }
};
static const GimpDataFactoryLoaderEntry dynamics_loader_entries[] =
{
{ gimp_dynamics_load, GIMP_DYNAMICS_FILE_EXTENSION, TRUE }
};
static const GimpDataFactoryLoaderEntry mybrush_loader_entries[] =
{
{ gimp_mybrush_load, GIMP_MYBRUSH_FILE_EXTENSION, FALSE }
};
static const GimpDataFactoryLoaderEntry pattern_loader_entries[] =
{
{ gimp_pattern_load, GIMP_PATTERN_FILE_EXTENSION, FALSE },
{ gimp_pattern_load_pixbuf, NULL /* fallback loader */, FALSE }
};
static const GimpDataFactoryLoaderEntry gradient_loader_entries[] =
{
{ gimp_gradient_load, GIMP_GRADIENT_FILE_EXTENSION, TRUE },
{ gimp_gradient_load_svg, GIMP_GRADIENT_SVG_FILE_EXTENSION, FALSE }
};
static const GimpDataFactoryLoaderEntry palette_loader_entries[] =
{
{ gimp_palette_load, GIMP_PALETTE_FILE_EXTENSION, TRUE }
};
static const GimpDataFactoryLoaderEntry tool_preset_loader_entries[] =
{
{ gimp_tool_preset_load, GIMP_TOOL_PRESET_FILE_EXTENSION, TRUE }
};
GimpData *clipboard_brush;
GimpData *clipboard_pattern;
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
status_callback (_("Initialization"), NULL, 0.0);
gimp_fonts_init (gimp);
gimp->brush_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_BRUSH,
"brush-path", "brush-path-writable",
brush_loader_entries,
G_N_ELEMENTS (brush_loader_entries),
gimp_brush_new,
gimp_brush_get_standard);
gimp_object_set_static_name (GIMP_OBJECT (gimp->brush_factory),
"brush factory");
gimp->dynamics_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_DYNAMICS,
"dynamics-path", "dynamics-path-writable",
dynamics_loader_entries,
G_N_ELEMENTS (dynamics_loader_entries),
gimp_dynamics_new,
gimp_dynamics_get_standard);
gimp_object_set_static_name (GIMP_OBJECT (gimp->dynamics_factory),
"dynamics factory");
gimp->mybrush_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_MYBRUSH,
"mypaint-brush-path", "mypaint-brush-path-writable",
mybrush_loader_entries,
G_N_ELEMENTS (mybrush_loader_entries),
NULL,
NULL);
gimp_object_set_static_name (GIMP_OBJECT (gimp->mybrush_factory),
"mypaint brush factory");
gimp->pattern_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_PATTERN,
"pattern-path", "pattern-path-writable",
pattern_loader_entries,
G_N_ELEMENTS (pattern_loader_entries),
NULL,
gimp_pattern_get_standard);
gimp_object_set_static_name (GIMP_OBJECT (gimp->pattern_factory),
"pattern factory");
gimp->gradient_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_GRADIENT,
"gradient-path", "gradient-path-writable",
gradient_loader_entries,
G_N_ELEMENTS (gradient_loader_entries),
gimp_gradient_new,
gimp_gradient_get_standard);
gimp_object_set_static_name (GIMP_OBJECT (gimp->gradient_factory),
"gradient factory");
gimp->palette_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_PALETTE,
"palette-path", "palette-path-writable",
palette_loader_entries,
G_N_ELEMENTS (palette_loader_entries),
gimp_palette_new,
gimp_palette_get_standard);
gimp_object_set_static_name (GIMP_OBJECT (gimp->palette_factory),
"palette factory");
gimp->tool_preset_factory =
gimp_data_factory_new (gimp,
GIMP_TYPE_TOOL_PRESET,
"tool-preset-path", "tool-preset-path-writable",
tool_preset_loader_entries,
G_N_ELEMENTS (tool_preset_loader_entries),
gimp_tool_preset_new,
NULL);
gimp_object_set_static_name (GIMP_OBJECT (gimp->tool_preset_factory),
"tool preset factory");
gimp->tag_cache = gimp_tag_cache_new ();
gimp_paint_init (gimp);
/* Set the last values used to default values. */
gimp->image_new_last_template =
gimp_config_duplicate (GIMP_CONFIG (gimp->config->default_image));
/* create user and default context */
gimp_contexts_init (gimp);
/* add the builtin FG -> BG etc. gradients */
gimp_gradients_init (gimp);
/* add the color history palette */
gimp_palettes_init (gimp);
/* add the clipboard brush */
clipboard_brush = gimp_brush_clipboard_new (gimp);
gimp_data_make_internal (GIMP_DATA (clipboard_brush),
"gimp-brush-clipboard");
gimp_container_add (gimp_data_factory_get_container (gimp->brush_factory),
GIMP_OBJECT (clipboard_brush));
g_object_unref (clipboard_brush);
/* add the clipboard pattern */
clipboard_pattern = gimp_pattern_clipboard_new (gimp);
gimp_data_make_internal (GIMP_DATA (clipboard_pattern),
"gimp-pattern-clipboard");
gimp_container_add (gimp_data_factory_get_container (gimp->pattern_factory),
GIMP_OBJECT (clipboard_pattern));
g_object_unref (clipboard_pattern);
/* register all internal procedures */
status_callback (NULL, _("Internal Procedures"), 0.2);
internal_procs_init (gimp->pdb);
gimp_pdb_compat_procs_register (gimp->pdb, gimp->pdb_compat_mode);
gimp_plug_in_manager_initialize (gimp->plug_in_manager, status_callback);
status_callback (NULL, "", 1.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;
}
GtkWidget *
gimp_text_editor_new (const gchar *title,
GtkWindow *parent,
Gimp *gimp,
GimpMenuFactory *menu_factory,
GimpText *text,
GimpTextBuffer *text_buffer,
gdouble xres,
gdouble yres)
{
GimpTextEditor *editor;
GtkWidget *content_area;
GtkWidget *toolbar;
GtkWidget *style_editor;
GtkWidget *scrolled_window;
gboolean use_header_bar;
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), NULL);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (text_buffer), NULL);
g_object_get (gtk_settings_get_default (),
"gtk-dialogs-use-header", &use_header_bar,
NULL);
editor = g_object_new (GIMP_TYPE_TEXT_EDITOR,
"title", title,
"role", "gimp-text-editor",
"transient-for", parent,
"help-func", gimp_standard_help_func,
"help-id", GIMP_HELP_TEXT_EDITOR_DIALOG,
"use-header-bar", use_header_bar,
NULL);
gtk_dialog_add_button (GTK_DIALOG (editor),
_("_Close"), GTK_RESPONSE_CLOSE);
g_signal_connect (editor, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
g_signal_connect_object (text_buffer, "changed",
G_CALLBACK (gimp_text_editor_text_changed),
editor, 0);
editor->ui_manager = gimp_menu_factory_manager_new (menu_factory,
"<TextEditor>",
editor);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (editor));
toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (editor->ui_manager),
"/text-editor-toolbar");
if (toolbar)
{
gtk_box_pack_start (GTK_BOX (content_area), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
}
style_editor = gimp_text_style_editor_new (gimp, text, text_buffer,
gimp_data_factory_get_container (gimp->font_factory),
xres, yres);
gtk_box_pack_start (GTK_BOX (content_area), style_editor, FALSE, FALSE, 0);
gtk_widget_show (style_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 2);
gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
editor->view = gtk_text_view_new_with_buffer (GTK_TEXT_BUFFER (text_buffer));
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (editor->view),
GTK_WRAP_WORD_CHAR);
gtk_container_add (GTK_CONTAINER (scrolled_window), editor->view);
gtk_widget_show (editor->view);
switch (editor->base_dir)
{
case GIMP_TEXT_DIRECTION_LTR:
case GIMP_TEXT_DIRECTION_TTB_RTL:
case GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT:
case GIMP_TEXT_DIRECTION_TTB_LTR:
case GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT:
gtk_widget_set_direction (editor->view, GTK_TEXT_DIR_LTR);
break;
case GIMP_TEXT_DIRECTION_RTL:
gtk_widget_set_direction (editor->view, GTK_TEXT_DIR_RTL);
break;
}
gtk_widget_set_size_request (editor->view, 200, 64);
editor->font_toggle =
gtk_check_button_new_with_mnemonic (_("_Use selected font"));
gtk_box_pack_start (GTK_BOX (content_area), editor->font_toggle,
FALSE, FALSE, 0);
gtk_widget_show (editor->font_toggle);
g_signal_connect (editor->font_toggle, "toggled",
G_CALLBACK (gimp_text_editor_font_toggled),
editor);
gtk_widget_grab_focus (editor->view);
gimp_ui_manager_update (editor->ui_manager, editor);
return GTK_WIDGET (editor);
}
static GtkWidget *
gradient_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size,
const gchar *reverse_prop,
const gchar *editor_id,
const gchar *editor_tooltip)
{
GtkWidget *hbox;
GtkWidget *button;
GList *children;
if (! container)
container = gimp_data_factory_get_container (context->gimp->gradient_factory);
hbox = gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_SMALL, view_size,
"gimp-gradient-list|gimp-gradient-grid",
GIMP_STOCK_GRADIENT,
_("Open the gradient selection dialog"),
editor_id, editor_tooltip);
children = gtk_container_get_children (GTK_CONTAINER (hbox));
button = children->data;
g_list_free (children);
GIMP_VIEWABLE_BUTTON (button)->button_view_size = GIMP_VIEW_SIZE_SMALL;
if (reverse_prop)
{
GtkWidget *toggle;
GtkWidget *view;
GtkWidget *image;
gchar *signal_name;
toggle = gimp_prop_check_button_new (G_OBJECT (context), reverse_prop,
NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (hbox), toggle, 1);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle, _("Reverse"), NULL);
image = gtk_image_new_from_icon_name (GIMP_STOCK_FLIP_HORIZONTAL,
GTK_ICON_SIZE_MENU);
/* gimp_prop_check_button_new() adds the property nick as label of
* the button by default. */
gtk_container_remove (GTK_CONTAINER (toggle),
gtk_bin_get_child (GTK_BIN (toggle)));
gtk_container_add (GTK_CONTAINER (toggle), image);
gtk_widget_show (image);
view = gtk_bin_get_child (GTK_BIN (button));
signal_name = g_strconcat ("notify::", reverse_prop, NULL);
g_signal_connect_object (context, signal_name,
G_CALLBACK (gimp_gradient_box_reverse_notify),
G_OBJECT (view), 0);
g_free (signal_name);
gimp_gradient_box_reverse_notify (G_OBJECT (context),
NULL,
GIMP_VIEW (view));
}
return hbox;
}
static GtkWidget *
convert_dialog_palette_box (IndexedDialog *dialog)
{
Gimp *gimp = dialog->image->gimp;
GList *list;
GimpPalette *palette;
GimpPalette *web_palette = NULL;
gboolean default_found = FALSE;
/* We can't dither to > 256 colors */
dialog->container = gimp_container_filter (gimp_data_factory_get_container (gimp->palette_factory),
convert_dialog_palette_filter,
NULL);
if (gimp_container_is_empty (dialog->container))
{
g_object_unref (dialog->container);
dialog->container = NULL;
return NULL;
}
dialog->context = gimp_context_new (gimp, "convert-dialog", NULL);
g_object_weak_ref (G_OBJECT (dialog->dialog),
(GWeakNotify) g_object_unref, dialog->context);
g_object_weak_ref (G_OBJECT (dialog->dialog),
(GWeakNotify) g_object_unref, dialog->container);
for (list = GIMP_LIST (dialog->container)->list;
list;
list = g_list_next (list))
{
palette = list->data;
/* Preferentially, the initial default is 'Web' if available */
if (web_palette == NULL &&
g_ascii_strcasecmp (gimp_object_get_name (palette), "Web") == 0)
{
web_palette = palette;
}
if (saved_palette == palette)
{
dialog->custom_palette = saved_palette;
default_found = TRUE;
}
}
if (! default_found)
{
if (web_palette)
dialog->custom_palette = web_palette;
else
dialog->custom_palette = GIMP_LIST (dialog->container)->list->data;
}
gimp_context_set_palette (dialog->context, dialog->custom_palette);
g_signal_connect (dialog->context, "palette-changed",
G_CALLBACK (convert_dialog_palette_changed),
dialog);
return gimp_palette_box_new (dialog->container, dialog->context, NULL, 4);
}
