static void
gimp_image_map_tool_base_init (GimpImageMapToolClass *klass)
{
klass->recent_settings = gimp_list_new (GIMP_TYPE_IMAGE_MAP_CONFIG, TRUE);
gimp_list_set_sort_func (GIMP_LIST (klass->recent_settings),
(GCompareFunc) gimp_image_map_config_compare);
}
/**
* gimp_templates_migrate:
* @olddir: the old user directory
*
* Migrating the templaterc from GIMP 2.0 to GIMP 2.2 needs this special
* hack since we changed the way that units are handled. This function
* merges the user's templaterc with the systemwide templaterc. The goal
* is to replace the unit for a couple of default templates with "pixels".
**/
void
gimp_templates_migrate (const gchar *olddir)
{
GimpContainer *templates = gimp_list_new (GIMP_TYPE_TEMPLATE, TRUE);
GFile *file = gimp_directory_file ("templaterc", NULL);
if (gimp_config_deserialize_gfile (GIMP_CONFIG (templates), file,
NULL, NULL))
{
GFile *sysconf_file;
sysconf_file = gimp_sysconf_directory_file ("templaterc", NULL);
if (olddir && (strstr (olddir, "2.0") || strstr (olddir, "2.2")))
{
/* We changed the spelling of a couple of template names:
*
* - from upper to lower case between 2.0 and 2.2
* - from "dpi" to "ppi" between 2.2 and 2.4
*/
GimpContainerClass *class = GIMP_CONTAINER_GET_CLASS (templates);
gpointer func = class->get_child_by_name;
class->get_child_by_name = gimp_templates_migrate_get_child_by_name;
gimp_config_deserialize_gfile (GIMP_CONFIG (templates),
sysconf_file, NULL, NULL);
class->get_child_by_name = func;
}
else
{
GimpContainer *
gimp_gegl_get_config_container (GType config_type)
{
GimpContainer *container;
g_return_val_if_fail (g_type_is_a (config_type, GIMP_TYPE_OBJECT), NULL);
if (! config_containers)
config_containers = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify) g_object_unref);
container = g_hash_table_lookup (config_containers, (gpointer) config_type);
if (! container)
{
container = gimp_list_new (config_type, TRUE);
g_hash_table_insert (config_containers,
(gpointer) config_type, container);
}
return container;
}
void
gimp_controllers_init (Gimp *gimp)
{
GimpControllerManager *manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (gimp_controller_manager_get (gimp) == NULL);
manager = g_slice_new0 (GimpControllerManager);
g_object_set_data_full (G_OBJECT (gimp),
GIMP_CONTROLLER_MANAGER_DATA_KEY, manager,
(GDestroyNotify) gimp_controller_manager_free);
manager->controllers = gimp_list_new (GIMP_TYPE_CONTROLLER_INFO, TRUE);
g_signal_connect (manager->controllers, "add",
G_CALLBACK (gimp_controllers_add),
manager);
g_signal_connect (manager->controllers, "remove",
G_CALLBACK (gimp_controllers_remove),
manager);
manager->event_mapped_id =
gimp_container_add_handler (manager->controllers, "event-mapped",
G_CALLBACK (gimp_controllers_event_mapped),
manager);
g_type_class_ref (GIMP_TYPE_CONTROLLER_WHEEL);
g_type_class_ref (GIMP_TYPE_CONTROLLER_KEYBOARD);
}
void
dialogs_init (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
GimpDialogFactory *factory = NULL;
gint i = 0;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
factory = gimp_dialog_factory_new ("toplevel",
gimp_get_user_context (gimp),
menu_factory);
gimp_dialog_factory_set_singleton (factory);
for (i = 0; i < G_N_ELEMENTS (entries); i++)
gimp_dialog_factory_register_entry (gimp_dialog_factory_get_singleton (),
entries[i].identifier,
gettext (entries[i].name),
gettext (entries[i].blurb),
entries[i].icon_name,
entries[i].help_id,
entries[i].new_func,
entries[i].restore_func,
entries[i].view_size,
entries[i].singleton,
entries[i].session_managed,
entries[i].remember_size,
entries[i].remember_if_open,
entries[i].hideable,
entries[i].image_window,
entries[i].dockable);
global_recent_docks = gimp_list_new (GIMP_TYPE_SESSION_INFO, FALSE);
}
void
gimp_paint_init (Gimp *gimp)
{
GimpPaintRegisterFunc register_funcs[] =
{
gimp_dodge_burn_register,
gimp_smudge_register,
gimp_convolve_register,
gimp_perspective_clone_register,
gimp_heal_register,
gimp_clone_register,
gimp_ink_register,
gimp_airbrush_register,
gimp_eraser_register,
gimp_paintbrush_register,
gimp_pencil_register
};
gint i;
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp->paint_info_list = gimp_list_new (GIMP_TYPE_PAINT_INFO, FALSE);
gimp_object_set_static_name (GIMP_OBJECT (gimp->paint_info_list),
"paint infos");
gimp_container_freeze (gimp->paint_info_list);
for (i = 0; i < G_N_ELEMENTS (register_funcs); i++)
{
register_funcs[i] (gimp, gimp_paint_register);
}
gimp_container_thaw (gimp->paint_info_list);
}
static void
gimp_image_map_tool_base_init (GimpImageMapToolClass *klass)
{
klass->recent_settings = gimp_list_new (GIMP_TYPE_SETTINGS, TRUE);
gimp_list_set_sort_func (GIMP_LIST (klass->recent_settings),
(GCompareFunc) gimp_settings_compare);
}
static void
gimp_init (Gimp *gimp)
{
gimp->be_verbose = FALSE;
gimp->no_data = FALSE;
gimp->no_interface = FALSE;
gimp->show_gui = TRUE;
gimp->use_shm = FALSE;
gimp->use_cpu_accel = TRUE;
gimp->message_handler = GIMP_CONSOLE;
gimp->show_playground = FALSE;
gimp->stack_trace_mode = GIMP_STACK_TRACE_NEVER;
gimp->pdb_compat_mode = GIMP_PDB_COMPAT_OFF;
gimp_gui_init (gimp);
gimp->parasites = gimp_parasite_list_new ();
gimp->images = gimp_list_new_weak (GIMP_TYPE_IMAGE, FALSE);
gimp_object_set_static_name (GIMP_OBJECT (gimp->images), "images");
gimp->next_guide_ID = 1;
gimp->next_sample_point_ID = 1;
gimp->image_table = gimp_id_table_new ();
gimp->item_table = gimp_id_table_new ();
gimp->displays = g_object_new (GIMP_TYPE_LIST,
"children-type", GIMP_TYPE_OBJECT,
"policy", GIMP_CONTAINER_POLICY_WEAK,
"append", TRUE,
NULL);
gimp_object_set_static_name (GIMP_OBJECT (gimp->displays), "displays");
gimp->next_display_ID = 1;
gimp->named_buffers = gimp_list_new (GIMP_TYPE_BUFFER, TRUE);
gimp_object_set_static_name (GIMP_OBJECT (gimp->named_buffers),
"named buffers");
gimp->tool_info_list = gimp_list_new (GIMP_TYPE_TOOL_INFO, FALSE);
gimp_object_set_static_name (GIMP_OBJECT (gimp->tool_info_list),
"tool infos");
gimp->templates = gimp_list_new (GIMP_TYPE_TEMPLATE, TRUE);
gimp_object_set_static_name (GIMP_OBJECT (gimp->templates), "templates");
}
void
dialogs_init (Gimp *gimp,
GimpMenuFactory *menu_factory)
{
gint i;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
global_dialog_factory = gimp_dialog_factory_new ("toplevel",
gimp_get_user_context (gimp),
menu_factory,
NULL,
TRUE);
global_toolbox_factory = gimp_dialog_factory_new ("toolbox",
gimp_get_user_context (gimp),
menu_factory,
dialogs_toolbox_get,
TRUE);
gimp_dialog_factory_set_constructor (global_toolbox_factory,
dialogs_dockable_constructor);
global_dock_factory = gimp_dialog_factory_new ("dock",
gimp_get_user_context (gimp),
menu_factory,
dialogs_dock_new,
TRUE);
gimp_dialog_factory_set_constructor (global_dock_factory,
dialogs_dockable_constructor);
global_display_factory = gimp_dialog_factory_new ("display",
gimp_get_user_context (gimp),
menu_factory,
NULL,
FALSE);
for (i = 0; i < G_N_ELEMENTS (toplevel_entries); i++)
gimp_dialog_factory_register_entry (global_dialog_factory,
toplevel_entries[i].identifier,
gettext (toplevel_entries[i].name),
gettext (toplevel_entries[i].blurb),
toplevel_entries[i].stock_id,
toplevel_entries[i].help_id,
toplevel_entries[i].new_func,
toplevel_entries[i].view_size,
toplevel_entries[i].singleton,
toplevel_entries[i].session_managed,
toplevel_entries[i].remember_size,
toplevel_entries[i].remember_if_open);
for (i = 0; i < G_N_ELEMENTS (dock_entries); i++)
gimp_dialog_factory_register_entry (global_dock_factory,
dock_entries[i].identifier,
gettext (dock_entries[i].name),
gettext (dock_entries[i].blurb),
dock_entries[i].stock_id,
dock_entries[i].help_id,
dock_entries[i].new_func,
dock_entries[i].view_size,
dock_entries[i].singleton,
dock_entries[i].session_managed,
dock_entries[i].remember_size,
dock_entries[i].remember_if_open);
gimp_dialog_factory_register_entry (global_display_factory,
"gimp-empty-image-window",
NULL, NULL,
NULL, NULL,
NULL,
-1,
TRUE,
TRUE,
TRUE,
FALSE);
global_recent_docks = gimp_list_new (GIMP_TYPE_SESSION_INFO, FALSE);
}
static void
gimp_pdb_context_init (GimpPDBContext *context)
{
context->paint_options_list = gimp_list_new (GIMP_TYPE_PAINT_OPTIONS,
FALSE);
}
void
gimp_tools_restore (Gimp *gimp)
{
GimpContainer *gimp_list;
GimpObject *object;
GFile *file;
GList *list;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp_list = gimp_list_new (GIMP_TYPE_TOOL_INFO, FALSE);
file = gimp_directory_file ("toolrc", NULL);
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file));
if (gimp_config_deserialize_gfile (GIMP_CONFIG (gimp_list), file,
NULL, NULL))
{
gint n = gimp_container_get_n_children (gimp->tool_info_list);
gint i;
gimp_list_reverse (GIMP_LIST (gimp_list));
for (list = GIMP_LIST (gimp_list)->list, i = 0;
list;
list = g_list_next (list), i++)
{
const gchar *name;
name = gimp_object_get_name (list->data);
object = gimp_container_get_child_by_name (gimp->tool_info_list,
name);
if (object)
{
g_object_set (object,
"visible", GIMP_TOOL_INFO (list->data)->visible,
NULL);
gimp_container_reorder (gimp->tool_info_list,
object, MIN (i, n - 1));
}
}
}
g_object_unref (file);
g_object_unref (gimp_list);
/* make the generic operation tool invisible by default */
object = gimp_container_get_child_by_name (gimp->tool_info_list,
"gimp-operation-tool");
if (object)
g_object_set (object, "visible", FALSE, NULL);
for (list = gimp_get_tool_info_iter (gimp);
list;
list = g_list_next (list))
{
GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data);
/* get default values from prefs (see bug #120832) */
gimp_config_reset (GIMP_CONFIG (tool_info->tool_options));
}
if (! gimp_contexts_load (gimp, &error))
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING, error->message);
g_clear_error (&error);
}
/* make sure there is always a tool active, so broken config files
* can't leave us with no initial tool
*/
if (! gimp_context_get_tool (gimp_get_user_context (gimp)))
{
gimp_context_set_tool (gimp_get_user_context (gimp),
gimp_get_tool_info_iter (gimp)->data);
}
for (list = gimp_get_tool_info_iter (gimp);
list;
list = g_list_next (list))
{
GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data);
GimpToolOptionsGUIFunc options_gui_func;
GtkWidget *options_gui;
/* copy all context properties except those the tool actually
* uses, because the subsequent deserialize() on the tool
* options will only set the properties that were set to
* non-default values at the time of saving, and we want to
* keep these default values as if they have been saved.
* (see bug #541586).
*/
gimp_context_copy_properties (gimp_get_user_context (gimp),
GIMP_CONTEXT (tool_info->tool_options),
GIMP_CONTEXT_PROP_MASK_ALL &~
(tool_info->context_props |
GIMP_CONTEXT_PROP_MASK_TOOL |
GIMP_CONTEXT_PROP_MASK_PAINT_INFO));
gimp_tool_options_deserialize (tool_info->tool_options, NULL);
options_gui_func = g_object_get_data (G_OBJECT (tool_info),
"gimp-tool-options-gui-func");
if (options_gui_func)
{
options_gui = (* options_gui_func) (tool_info->tool_options);
}
else
{
GtkWidget *label;
options_gui = gimp_tool_options_gui (tool_info->tool_options);
label = gtk_label_new (_("This tool has\nno options."));
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (options_gui), label, FALSE, FALSE, 6);
gtk_widget_show (label);
}
gimp_tools_set_tool_options_gui (tool_info->tool_options,
g_object_ref_sink (options_gui));
}
}
static void
gimp_undo_stack_init (GimpUndoStack *stack)
{
stack->undos = gimp_list_new (GIMP_TYPE_UNDO, FALSE);
}