void
gimp_displays_delete (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* this removes the GimpDisplay from the list, so do a while loop
* "around" the first element to get them all
*/
while (GIMP_LIST (gimp->displays)->list)
{
GimpDisplay *display = GIMP_LIST (gimp->displays)->list->data;
gimp_display_delete (display);
}
}
static GtkWidget *
gimp_operation_tool_get_settings_ui (GimpImageMapTool *im_tool,
GimpContainer *settings,
GFile *settings_file,
const gchar *import_dialog_title,
const gchar *export_dialog_title,
const gchar *file_dialog_help_id,
GFile *default_folder,
GtkWidget **settings_box)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);
GType type = G_TYPE_FROM_INSTANCE (im_tool->config);
GtkWidget *widget;
gchar *basename;
GFile *file;
gchar *import_title;
gchar *export_title;
settings = gimp_gegl_get_config_container (type);
if (! gimp_list_get_sort_func (GIMP_LIST (settings)))
gimp_list_set_sort_func (GIMP_LIST (settings),
(GCompareFunc) gimp_settings_compare);
basename = g_strconcat (G_OBJECT_TYPE_NAME (im_tool->config),
".settings", NULL);
file = gimp_directory_file ("filters", basename, NULL);
g_free (basename);
import_title = g_strdup_printf (_("Import '%s' Settings"), tool->undo_desc);
export_title = g_strdup_printf (_("Export '%s' Settings"), tool->undo_desc);
widget =
GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->get_settings_ui (im_tool,
settings,
file,
import_title,
export_title,
"help-foo",
NULL, /* sic */
settings_box);
g_free (import_title);
g_free (export_title);
g_object_unref (file);
return widget;
}
void
dialogs_load_recent_docks (Gimp *gimp)
{
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = dialogs_get_dockrc_filename ();
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (global_recent_docks),
filename,
NULL, &error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_clear_error (&error);
}
/* In GIMP 2.6 dockrc did not contain the factory entries for the
* session infos, so set that up manually if needed
*/
gimp_container_foreach (global_recent_docks,
(GFunc) dialogs_ensure_factory_entry_on_recent_dock,
NULL);
gimp_list_reverse (GIMP_LIST (global_recent_docks));
g_free (filename);
}
GList *
gimp_get_tool_info_iter (Gimp *gimp)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
return GIMP_LIST (gimp->tool_info_list)->list;
}
GList *
gimp_get_display_iter (Gimp *gimp)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
return GIMP_LIST (gimp->displays)->list;
}
GList *
gimp_get_image_iter (Gimp *gimp)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
return GIMP_LIST (gimp->images)->list;
}
void
dialogs_load_recent_docks (Gimp *gimp)
{
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = gimp_personal_rc_file ("dockrc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (global_recent_docks),
filename,
NULL, &error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message);
g_clear_error (&error);
}
gimp_list_reverse (GIMP_LIST (global_recent_docks));
g_free (filename);
}
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);
}
void
gimp_font_list_restore (GimpFontList *list)
{
PangoFontMap *fontmap;
PangoContext *context;
g_return_if_fail (GIMP_IS_FONT_LIST (list));
fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
if (! fontmap)
g_error ("You are using a Pango that has been built against a cairo "
"that lacks the Freetype font backend");
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (fontmap),
list->yresolution);
context = pango_font_map_create_context (fontmap);
g_object_unref (fontmap);
gimp_container_freeze (GIMP_CONTAINER (list));
gimp_font_list_load_names (list, PANGO_FONT_MAP (fontmap), context);
g_object_unref (context);
gimp_list_sort_by_name (GIMP_LIST (list));
gimp_container_thaw (GIMP_CONTAINER (list));
}
static GimpLayer *
select_layer_by_coords (GimpImage *image,
gint x,
gint y)
{
GList *list;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
for (list = GIMP_LIST (image->layers)->list;
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
gint off_x, off_y;
gint width, height;
if (! gimp_item_get_visible (GIMP_ITEM (layer)))
continue;
gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
width = gimp_item_width (GIMP_ITEM (layer));
height = gimp_item_height (GIMP_ITEM (layer));
if (off_x <= x &&
off_y <= y &&
x < off_x + width &&
y < off_y + height)
{
return layer;
}
}
return NULL;
}
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);
}
static void
gimp_tagged_container_clear (GimpContainer *container)
{
GimpFilteredContainer *filtered_container = GIMP_FILTERED_CONTAINER (container);
GimpTaggedContainer *tagged_container = GIMP_TAGGED_CONTAINER (container);
GList *list;
for (list = GIMP_LIST (filtered_container->src_container)->queue->head;
list;
list = g_list_next (list))
{
g_signal_handlers_disconnect_by_func (list->data,
gimp_tagged_container_tag_added,
tagged_container);
g_signal_handlers_disconnect_by_func (list->data,
gimp_tagged_container_tag_removed,
tagged_container);
}
if (tagged_container->tag_ref_counts)
{
g_hash_table_remove_all (tagged_container->tag_ref_counts);
tagged_container->tag_count = 0;
}
GIMP_CONTAINER_CLASS (parent_class)->clear (container);
}
static void
tool_options_actions_update_presets (GimpActionGroup *group,
const gchar *action_prefix,
GCallback callback,
const gchar *help_id,
GimpContainer *presets)
{
GList *list;
gint n_children = 0;
gint i;
for (i = 0; ; i++)
{
gchar *action_name;
GtkAction *action;
action_name = g_strdup_printf ("%s-%03d", action_prefix, i);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
g_free (action_name);
if (! action)
break;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
}
if (presets)
n_children = gimp_container_get_n_children (presets);
if (n_children > 0)
{
GimpEnumActionEntry entry;
entry.name = NULL;
entry.label = NULL;
entry.accelerator = "";
entry.tooltip = NULL;
entry.value = 0;
entry.value_variable = FALSE;
entry.help_id = help_id;
for (list = GIMP_LIST (presets)->list, i = 0;
list;
list = g_list_next (list), i++)
{
GimpObject *options = list->data;
entry.name = g_strdup_printf ("%s-%03d", action_prefix, i);
entry.label = gimp_object_get_name (options);
entry.stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (options));
entry.value = i;
gimp_action_group_add_enum_actions (group, NULL, &entry, 1, callback);
g_free ((gchar *) entry.name);
}
}
}
static gint
gimp_list_get_child_index (const GimpContainer *container,
const GimpObject *object)
{
GimpList *list = GIMP_LIST (container);
return g_list_index (list->list, (gpointer) object);
}
static gboolean
gimp_list_have (const GimpContainer *container,
const GimpObject *object)
{
GimpList *list = GIMP_LIST (container);
return g_list_find (list->list, object) ? TRUE : FALSE;
}
static void
gimp_list_clear (GimpContainer *container)
{
GimpList *list = GIMP_LIST (container);
while (list->list)
gimp_container_remove (container, list->list->data);
}
static void
gimp_list_foreach (const GimpContainer *container,
GFunc func,
gpointer user_data)
{
GimpList *list = GIMP_LIST (container);
g_list_foreach (list->list, func, user_data);
}
void
gimp_devices_restore (Gimp *gimp)
{
GimpDeviceManager *manager;
GimpContext *user_context;
GimpDeviceInfo *current_device;
GList *list;
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
manager = gimp_devices_get_manager (gimp);
g_return_if_fail (GIMP_IS_DEVICE_MANAGER (manager));
user_context = gimp_get_user_context (gimp);
for (list = GIMP_LIST (manager)->list;
list;
list = g_list_next (list))
{
GimpDeviceInfo *device_info = list->data;
gimp_context_copy_properties (user_context, GIMP_CONTEXT (device_info),
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_device_info_set_default_tool (device_info);
}
filename = gimp_personal_rc_file ("devicerc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager),
filename,
gimp,
&error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_error_free (error);
/* don't bail out here */
}
g_free (filename);
current_device = gimp_device_manager_get_current_device (manager);
gimp_context_copy_properties (GIMP_CONTEXT (current_device), user_context,
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_context_set_parent (GIMP_CONTEXT (current_device), user_context);
}
static void
gimp_undo_stack_free (GimpUndo *undo,
GimpUndoMode undo_mode)
{
GimpUndoStack *stack = GIMP_UNDO_STACK (undo);
GList *list;
for (list = GIMP_LIST (stack->undos)->list;
list;
list = g_list_next (list))
{
GimpUndo *child = list->data;
gimp_undo_free (child, undo_mode);
g_object_unref (child);
}
while (GIMP_LIST (stack->undos)->list)
gimp_container_remove (GIMP_CONTAINER (stack->undos),
GIMP_LIST (stack->undos)->list->data);
}
GeglNode *
gimp_filter_stack_get_graph (GimpFilterStack *stack)
{
GList *list;
GeglNode *first = NULL;
GeglNode *previous = NULL;
GeglNode *input;
GeglNode *output;
g_return_val_if_fail (GIMP_IS_FILTER_STACK (stack), NULL);
if (stack->graph)
return stack->graph;
stack->graph = gegl_node_new ();
for (list = GIMP_LIST (stack)->queue->tail;
list;
list = g_list_previous (list))
{
GimpFilter *filter = list->data;
GeglNode *node = gimp_filter_get_node (filter);
if (! first)
first = node;
gegl_node_add_child (stack->graph, node);
if (previous)
gegl_node_connect_to (previous, "output",
node, "input");
previous = node;
}
input = gegl_node_get_input_proxy (stack->graph, "input");
output = gegl_node_get_output_proxy (stack->graph, "output");
if (first && previous)
{
gegl_node_connect_to (input, "output",
first, "input");
gegl_node_connect_to (previous, "output",
output, "input");
}
else
{
gegl_node_connect_to (input, "output",
output, "input");
}
return stack->graph;
}
void
gimp_controllers_restore (Gimp *gimp,
GimpUIManager *ui_manager)
{
GimpControllerManager *manager;
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_UI_MANAGER (ui_manager));
manager = gimp_controller_manager_get (gimp);
g_return_if_fail (manager != NULL);
g_return_if_fail (manager->ui_manager == NULL);
manager->ui_manager = g_object_ref (ui_manager);
filename = gimp_personal_rc_file ("controllerrc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager->controllers),
filename, NULL, &error))
{
if (error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT)
{
g_clear_error (&error);
g_free (filename);
filename = g_build_filename (gimp_sysconf_directory (),
"controllerrc", NULL);
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager->controllers),
filename, NULL, &error))
{
gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR,
"%s", error->message);
}
}
else
{
gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message);
}
g_clear_error (&error);
}
gimp_list_reverse (GIMP_LIST (manager->controllers));
g_free (filename);
}
static void
gimp_tagged_container_src_thaw (GimpFilteredContainer *filtered_container)
{
GList *list;
for (list = GIMP_LIST (filtered_container->src_container)->queue->head;
list;
list = g_list_next (list))
{
gimp_tagged_container_src_add (filtered_container, list->data);
}
}
static void
gimp_list_remove (GimpContainer *container,
GimpObject *object)
{
GimpList *list = GIMP_LIST (container);
if (list->unique_names || list->sort_func)
g_signal_handlers_disconnect_by_func (object,
gimp_list_object_renamed,
list);
list->list = g_list_remove (list->list, object);
}
GimpContainer *
gimp_displays_get_dirty_images (Gimp *gimp)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
if (gimp_displays_dirty (gimp))
{
GimpContainer *container = gimp_list_new_weak (GIMP_TYPE_IMAGE, FALSE);
GList *list;
GQuark handler;
handler =
gimp_container_add_handler (gimp->images, "clean",
G_CALLBACK (gimp_displays_image_dirty_callback),
container);
g_object_set_data (G_OBJECT (container), "clean-handler",
GINT_TO_POINTER (handler));
handler =
gimp_container_add_handler (gimp->images, "dirty",
G_CALLBACK (gimp_displays_image_dirty_callback),
container);
g_object_set_data (G_OBJECT (container), "dirty-handler",
GINT_TO_POINTER (handler));
g_signal_connect_object (container, "disconnect",
G_CALLBACK (gimp_displays_dirty_images_disconnect),
G_OBJECT (gimp->images), 0);
gimp_container_add_handler (container, "clean",
G_CALLBACK (gimp_displays_image_clean_callback),
container);
gimp_container_add_handler (container, "dirty",
G_CALLBACK (gimp_displays_image_clean_callback),
container);
for (list = GIMP_LIST (gimp->images)->list;
list;
list = g_list_next (list))
{
GimpImage *image = list->data;
if (image->dirty && image->disp_count > 0)
gimp_container_add (container, GIMP_OBJECT (image));
}
return container;
}
return NULL;
}
GimpContext *
gimp_pdb_context_new (Gimp *gimp,
GimpContext *parent,
gboolean set_parent)
{
GimpPDBContext *context;
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (parent), NULL);
context = g_object_new (GIMP_TYPE_PDB_CONTEXT,
"gimp", gimp,
"name", "PDB Context",
NULL);
gimp_config_sync (G_OBJECT (parent), G_OBJECT (context), 0);
if (set_parent)
{
gimp_context_define_properties (GIMP_CONTEXT (context),
GIMP_CONTEXT_ALL_PROPS_MASK, FALSE);
gimp_context_set_parent (GIMP_CONTEXT (context), parent);
for (list = gimp_get_paint_info_iter (gimp);
list;
list = g_list_next (list))
{
GimpPaintInfo *info = list->data;
gimp_container_add (context->paint_options_list,
GIMP_OBJECT (info->paint_options));
}
}
else
{
for (list = GIMP_LIST (GIMP_PDB_CONTEXT (parent)->paint_options_list)->list;
list;
list = g_list_next (list))
{
GimpPaintOptions *options = gimp_config_duplicate (list->data);
gimp_container_add (context->paint_options_list,
GIMP_OBJECT (options));
g_object_unref (options);
}
}
return GIMP_CONTEXT (context);
}
static GimpObject *
gimp_list_get_child_by_index (const GimpContainer *container,
gint index)
{
GimpList *list = GIMP_LIST (container);
GList *glist;
glist = g_list_nth (list->list, index);
if (glist)
return (GimpObject *) glist->data;
return NULL;
}
static void
gimp_list_reorder (GimpContainer *container,
GimpObject *object,
gint new_index)
{
GimpList *list = GIMP_LIST (container);
list->list = g_list_remove (list->list, object);
if (new_index == -1 || new_index == container->num_children - 1)
list->list = g_list_append (list->list, object);
else
list->list = g_list_insert (list->list, object, new_index);
}
static GimpObject *
gimp_list_get_child_by_name (const GimpContainer *container,
const gchar *name)
{
GimpList *list = GIMP_LIST (container);
GList *glist;
for (glist = list->list; glist; glist = g_list_next (glist))
{
GimpObject *object = glist->data;
if (! strcmp (object->name, name))
return object;
}
return NULL;
}
static void
gimp_undo_stack_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpUndoStack *stack = GIMP_UNDO_STACK (undo);
GList *list;
for (list = GIMP_LIST (stack->undos)->list;
list;
list = g_list_next (list))
{
GimpUndo *child = list->data;
gimp_undo_pop (child, undo_mode, accum);
}
}
GimpLayer *
gimp_image_merge_down (GimpImage *image,
GimpLayer *current_layer,
GimpContext *context,
GimpMergeType merge_type)
{
GimpLayer *layer;
GList *list;
GList *layer_list;
GSList *merge_list;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
for (list = GIMP_LIST (image->layers)->list, layer_list = NULL;
list && !layer_list;
list = g_list_next (list))
{
layer = list->data;
if (layer == current_layer)
break;
}
for (layer_list = g_list_next (list), merge_list = NULL;
layer_list && !merge_list;
layer_list = g_list_next (layer_list))
{
layer = layer_list->data;
if (gimp_item_get_visible (GIMP_ITEM (layer)))
merge_list = g_slist_append (NULL, layer);
}
merge_list = g_slist_prepend (merge_list, current_layer);
gimp_set_busy (image->gimp);
layer = gimp_image_merge_layers (image, merge_list, context, merge_type,
_("Merge Down"));
g_slist_free (merge_list);
gimp_unset_busy (image->gimp);
return layer;
}
