/** * gimp_object_name_changed: * @object: a #GimpObject * * Causes the ::name-changed signal to be emitted. **/ void gimp_object_name_changed (GimpObject *object) { g_return_if_fail (GIMP_IS_OBJECT (object)); g_signal_emit (object, object_signals[NAME_CHANGED], 0); }
void gimp_procedure_execute_async (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GimpObject *display, GError **error) { g_return_if_fail (GIMP_IS_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (args != NULL); g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display)); g_return_if_fail (error == NULL || *error == NULL); if (gimp_procedure_validate_args (procedure, procedure->args, procedure->num_args, args, FALSE, error)) { if (GIMP_IS_PDB_CONTEXT (context)) context = g_object_ref (context); else context = gimp_pdb_context_new (gimp, context, TRUE); GIMP_PROCEDURE_GET_CLASS (procedure)->execute_async (procedure, gimp, context, progress, args, display); g_object_unref (context); } }
void gimp_gegl_config_proxy_sync (GimpObject *proxy, GeglNode *node) { GParamSpec **pspecs; gchar *operation; guint n_pspecs; gint i; g_return_if_fail (GIMP_IS_OBJECT (proxy)); g_return_if_fail (GEGL_IS_NODE (node)); gegl_node_get (node, "operation", &operation, NULL); g_return_if_fail (operation != NULL); pspecs = gegl_operation_list_properties (operation, &n_pspecs); g_free (operation); for (i = 0; i < n_pspecs; i++) { GParamSpec *gegl_pspec = pspecs[i]; GParamSpec *gimp_pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (proxy), gegl_pspec->name); if (gimp_pspec) { GValue value = { 0, }; g_value_init (&value, gimp_pspec->value_type); g_object_get_property (G_OBJECT (proxy), gimp_pspec->name, &value); if (GEGL_IS_PARAM_SPEC_COLOR (gegl_pspec)) { GimpRGB gimp_color; GeglColor *gegl_color; gimp_value_get_rgb (&value, &gimp_color); g_value_unset (&value); gegl_color = gimp_gegl_color_new (&gimp_color); g_value_init (&value, gegl_pspec->value_type); g_value_take_object (&value, gegl_color); } gegl_node_set_property (node, gegl_pspec->name, &value); g_value_unset (&value); } } g_free (pspecs); }
/** * gimp_object_get_name: * @object: a #GimpObject * * This function gives access to the name of a GimpObject. The * returned name belongs to the object and must not be freed. * * Return value: a pointer to the @object's name **/ const gchar * gimp_object_get_name (gconstpointer object) { const GimpObject *object_typed = object; g_return_val_if_fail (GIMP_IS_OBJECT (object_typed), NULL); return object_typed->p->name; }
GimpObject * action_select_object (GimpActionSelectType select_type, GimpContainer *container, GimpObject *current) { gint select_index; gint n_children; g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL); g_return_val_if_fail (current == NULL || GIMP_IS_OBJECT (current), NULL); if (! current) return NULL; n_children = gimp_container_get_n_children (container); if (n_children == 0) return NULL; switch (select_type) { case GIMP_ACTION_SELECT_FIRST: select_index = 0; break; case GIMP_ACTION_SELECT_LAST: select_index = n_children - 1; break; case GIMP_ACTION_SELECT_PREVIOUS: select_index = gimp_container_get_child_index (container, current) - 1; break; case GIMP_ACTION_SELECT_NEXT: select_index = gimp_container_get_child_index (container, current) + 1; break; case GIMP_ACTION_SELECT_SKIP_PREVIOUS: select_index = gimp_container_get_child_index (container, current) - 10; break; case GIMP_ACTION_SELECT_SKIP_NEXT: select_index = gimp_container_get_child_index (container, current) + 10; break; default: if ((gint) select_type >= 0) select_index = (gint) select_type; else g_return_val_if_reached (current); break; } select_index = CLAMP (select_index, 0, n_children - 1); return gimp_container_get_child_by_index (container, select_index); }
gboolean gimp_procedure_get_sensitive (GimpProcedure *procedure, GimpObject *object) { g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), FALSE); g_return_val_if_fail (object == NULL || GIMP_IS_OBJECT (object), FALSE); return GIMP_PROCEDURE_GET_CLASS (procedure)->get_sensitive (procedure, object); }
void gimp_delete_display (Gimp *gimp, GimpObject *display) { g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_OBJECT (display)); if (gimp->gui.display_delete) gimp->gui.display_delete (display); }
GimpProgress * gimp_new_progress (Gimp *gimp, GimpObject *display) { g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (display == NULL || GIMP_IS_OBJECT (display), NULL); if (gimp->gui.progress_new) return gimp->gui.progress_new (gimp, display); return NULL; }
guint32 gimp_get_display_window_id (Gimp *gimp, GimpObject *display) { g_return_val_if_fail (GIMP_IS_GIMP (gimp), -1); g_return_val_if_fail (GIMP_IS_OBJECT (display), -1); if (gimp->gui.display_get_window_id) return gimp->gui.display_get_window_id (display); return -1; }
void gimp_plug_in_progress_start (GimpPlugIn *plug_in, const gchar *message, GimpObject *display) { GimpPlugInProcFrame *proc_frame; g_return_if_fail (GIMP_IS_PLUG_IN (plug_in)); g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display)); proc_frame = gimp_plug_in_get_proc_frame (plug_in); if (! proc_frame->progress) { proc_frame->progress = gimp_new_progress (plug_in->manager->gimp, display); if (proc_frame->progress) { proc_frame->progress_created = TRUE; g_object_ref (proc_frame->progress); gimp_plug_in_progress_attach (proc_frame->progress); } } if (proc_frame->progress) { if (! proc_frame->progress_cancel_id) proc_frame->progress_cancel_id = g_signal_connect (proc_frame->progress, "cancel", G_CALLBACK (gimp_plug_in_progress_cancel_callback), plug_in); if (gimp_progress_is_active (proc_frame->progress)) { if (message) gimp_progress_set_text (proc_frame->progress, message); if (gimp_progress_get_value (proc_frame->progress) > 0.0) gimp_progress_set_value (proc_frame->progress, 0.0); } else { gimp_progress_start (proc_frame->progress, message ? message : "", TRUE); } } }
void gimp_object_set_static_name (GimpObject *object, const gchar *name) { g_return_if_fail (GIMP_IS_OBJECT (object)); if (! g_strcmp0 (object->p->name, name)) return; gimp_object_name_free (object); object->p->name = (gchar *) name; object->p->static_name = TRUE; gimp_object_name_changed (object); g_object_notify (G_OBJECT (object), "name"); }
/** * gimp_object_set_name_safe: * @object: a #GimpObject * @name: the @object's new name * * A safe version of gimp_object_set_name() that takes care of * handling newlines and overly long names. The actual name set * may be different to the @name you pass. **/ void gimp_object_set_name_safe (GimpObject *object, const gchar *name) { g_return_if_fail (GIMP_IS_OBJECT (object)); if (! g_strcmp0 (object->p->name, name)) return; gimp_object_name_free (object); object->p->name = gimp_utf8_strtrim (name, 30); object->p->static_name = FALSE; gimp_object_name_changed (object); g_object_notify (G_OBJECT (object), "name"); }
void gimp_object_take_name (GimpObject *object, gchar *name) { g_return_if_fail (GIMP_IS_OBJECT (object)); if (! g_strcmp0 (object->p->name, name)) { g_free (name); return; } gimp_object_name_free (object); object->p->name = name; object->p->static_name = FALSE; gimp_object_name_changed (object); g_object_notify (G_OBJECT (object), "name"); }
gint64 gimp_object_get_memsize (GimpObject *object, gint64 *gui_size) { gint64 my_size = 0; gint64 my_gui_size = 0; g_return_val_if_fail (object == NULL || GIMP_IS_OBJECT (object), 0); if (! object) { if (gui_size) *gui_size = 0; return 0; } #ifdef DEBUG_MEMSIZE if (gimp_debug_memsize) { static gint indent_level = 0; static GList *aggregation_tree = NULL; static gchar indent_buf[256]; gint64 memsize; gint64 gui_memsize = 0; gint i; gint my_indent_level; gchar *object_size; indent_level++; my_indent_level = indent_level; memsize = GIMP_OBJECT_GET_CLASS (object)->get_memsize (object, &gui_memsize); indent_level--; for (i = 0; i < MIN (my_indent_level * 2, sizeof (indent_buf) - 1); i++) indent_buf[i] = ' '; indent_buf[i] = '\0'; object_size = g_strdup_printf ("%s%s \"%s\": " "%" G_GINT64_FORMAT "(%" G_GINT64_FORMAT ")\n", indent_buf, g_type_name (G_TYPE_FROM_INSTANCE (object)), object->p->name ? object->p->name : "anonymous", memsize, gui_memsize); aggregation_tree = g_list_prepend (aggregation_tree, object_size); if (indent_level == 0) { GList *list; for (list = aggregation_tree; list; list = g_list_next (list)) { g_print ("%s", (gchar *) list->data); g_free (list->data); } g_list_free (aggregation_tree); aggregation_tree = NULL; } return memsize; } #endif /* DEBUG_MEMSIZE */ my_size = GIMP_OBJECT_GET_CLASS (object)->get_memsize (object, &my_gui_size); if (gui_size) *gui_size = my_gui_size; return my_size; }
GimpValueArray * gimp_plug_in_manager_call_run (GimpPlugInManager *manager, GimpContext *context, GimpProgress *progress, GimpPlugInProcedure *procedure, GimpValueArray *args, gboolean synchronous, GimpObject *display) { GimpValueArray *return_vals = NULL; GimpPlugIn *plug_in; g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), NULL); g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (procedure), NULL); g_return_val_if_fail (args != NULL, NULL); g_return_val_if_fail (display == NULL || GIMP_IS_OBJECT (display), NULL); plug_in = gimp_plug_in_new (manager, context, progress, procedure, NULL); if (plug_in) { GimpCoreConfig *core_config = manager->gimp->config; GimpGeglConfig *gegl_config = GIMP_GEGL_CONFIG (core_config); GimpDisplayConfig *display_config = GIMP_DISPLAY_CONFIG (core_config); GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (core_config); GPConfig config; GPProcRun proc_run; gint display_ID; GObject *screen; gint monitor; if (! gimp_plug_in_open (plug_in, GIMP_PLUG_IN_CALL_RUN, FALSE)) { const gchar *name = gimp_object_get_name (plug_in); GError *error = g_error_new (GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED, _("Failed to run plug-in \"%s\""), name); g_object_unref (plug_in); return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure), FALSE, error); g_error_free (error); return return_vals; } display_ID = display ? gimp_get_display_ID (manager->gimp, display) : -1; config.version = GIMP_PROTOCOL_VERSION; config.tile_width = GIMP_PLUG_IN_TILE_WIDTH; config.tile_height = GIMP_PLUG_IN_TILE_HEIGHT; config.shm_ID = (manager->shm ? gimp_plug_in_shm_get_ID (manager->shm) : -1); config.check_size = display_config->transparency_size; config.check_type = display_config->transparency_type; config.show_help_button = (gui_config->use_help && gui_config->show_help_button); config.use_cpu_accel = manager->gimp->use_cpu_accel; config.use_opencl = gegl_config->use_opencl; config.gimp_reserved_6 = 0; config.gimp_reserved_7 = 0; config.gimp_reserved_8 = 0; config.install_cmap = FALSE; config.show_tooltips = gui_config->show_tooltips; config.min_colors = 144; config.gdisp_ID = display_ID; config.app_name = (gchar *) g_get_application_name (); config.wm_class = (gchar *) gimp_get_program_class (manager->gimp); config.display_name = gimp_get_display_name (manager->gimp, display_ID, &screen, &monitor); config.monitor_number = monitor; config.timestamp = gimp_get_user_time (manager->gimp); proc_run.name = GIMP_PROCEDURE (procedure)->original_name; proc_run.nparams = gimp_value_array_length (args); proc_run.params = plug_in_args_to_params (args, FALSE); if (! gp_config_write (plug_in->my_write, &config, plug_in) || ! gp_proc_run_write (plug_in->my_write, &proc_run, plug_in) || ! gimp_wire_flush (plug_in->my_write, plug_in)) { const gchar *name = gimp_object_get_name (plug_in); GError *error = g_error_new (GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED, _("Failed to run plug-in \"%s\""), name); g_free (config.display_name); g_free (proc_run.params); g_object_unref (plug_in); return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure), FALSE, error); g_error_free (error); return return_vals; } g_free (config.display_name); g_free (proc_run.params); /* If this is an extension, * wait for an installation-confirmation message */ if (GIMP_PROCEDURE (procedure)->proc_type == GIMP_EXTENSION) { plug_in->ext_main_loop = g_main_loop_new (NULL, FALSE); gimp_threads_leave (manager->gimp); g_main_loop_run (plug_in->ext_main_loop); gimp_threads_enter (manager->gimp); /* main_loop is quit in gimp_plug_in_handle_extension_ack() */ g_main_loop_unref (plug_in->ext_main_loop); plug_in->ext_main_loop = NULL; } /* If this plug-in is requested to run synchronously, * wait for its return values */ if (synchronous) { GimpPlugInProcFrame *proc_frame = &plug_in->main_proc_frame; proc_frame->main_loop = g_main_loop_new (NULL, FALSE); gimp_threads_leave (manager->gimp); g_main_loop_run (proc_frame->main_loop); gimp_threads_enter (manager->gimp); /* main_loop is quit in gimp_plug_in_handle_proc_return() */ g_main_loop_unref (proc_frame->main_loop); proc_frame->main_loop = NULL; return_vals = gimp_plug_in_proc_frame_get_return_values (proc_frame); } g_object_unref (plug_in); } return return_vals; }
static void gimp_list_uniquefy_name (GimpList *gimp_list, GimpObject *object) { GList *list; GList *list2; gint unique_ext = 0; gchar *new_name = NULL; gchar *ext; g_return_if_fail (GIMP_IS_LIST (gimp_list)); g_return_if_fail (GIMP_IS_OBJECT (object)); for (list = gimp_list->list; list; list = g_list_next (list)) { GimpObject *object2 = GIMP_OBJECT (list->data); if (object != object2 && strcmp (gimp_object_get_name (GIMP_OBJECT (object)), gimp_object_get_name (GIMP_OBJECT (object2))) == 0) { ext = strrchr (object->name, '#'); if (ext) { gchar *ext_str; unique_ext = atoi (ext + 1); ext_str = g_strdup_printf ("%d", unique_ext); /* check if the extension really is of the form "#<n>" */ if (! strcmp (ext_str, ext + 1)) { *ext = '\0'; } else { unique_ext = 0; } g_free (ext_str); } else { unique_ext = 0; } do { unique_ext++; g_free (new_name); new_name = g_strdup_printf ("%s#%d", object->name, unique_ext); for (list2 = gimp_list->list; list2; list2 = g_list_next (list2)) { object2 = GIMP_OBJECT (list2->data); if (object == object2) continue; if (! strcmp (object2->name, new_name)) break; } } while (list2); gimp_object_take_name (object, new_name); break; } } }