static void gimp_gegl_config_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpGeglConfig *gegl_config = GIMP_GEGL_CONFIG (object); switch (property_id) { case PROP_TEMP_PATH: g_value_set_string (value, gegl_config->temp_path); break; case PROP_SWAP_PATH: g_value_set_string (value, gegl_config->swap_path); break; case PROP_NUM_PROCESSORS: g_value_set_uint (value, gegl_config->num_processors); break; case PROP_TILE_CACHE_SIZE: g_value_set_uint64 (value, gegl_config->tile_cache_size); break; case PROP_USE_OPENCL: g_value_set_boolean (value, gegl_config->use_opencl); break; case PROP_STINGY_MEMORY_USE: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
GFile * gimp_get_temp_file (Gimp *gimp, const gchar *extension) { static gint id = 0; static gint pid; gchar *basename; gchar *path; GFile *dir; GFile *file; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); if (id == 0) pid = gimp_get_pid (); if (extension) basename = g_strdup_printf ("gimp-temp-%d%d.%s", pid, id++, extension); else basename = g_strdup_printf ("gimp-temp-%d%d", pid, id++); path = gimp_config_path_expand (GIMP_GEGL_CONFIG (gimp->config)->temp_path, TRUE, NULL); dir = g_file_new_for_path (path); g_free (path); file = g_file_get_child (dir, basename); g_free (basename); g_object_unref (dir); return file; }
static void gimp_gegl_config_finalize (GObject *object) { GimpGeglConfig *gegl_config = GIMP_GEGL_CONFIG (object); g_free (gegl_config->temp_path); g_free (gegl_config->swap_path); gimp_debug_remove_instance (object); G_OBJECT_CLASS (parent_class)->finalize (object); }
void gimp_gegl_init (Gimp *gimp) { GimpGeglConfig *config; g_return_if_fail (GIMP_IS_GIMP (gimp)); config = GIMP_GEGL_CONFIG (gimp->config); #ifdef __GNUC__ #warning not setting GeglConfig:threads #endif g_object_set (gegl_config (), "tile-cache-size", (guint64) config->tile_cache_size, #if 0 "threads", config->num_processors, #endif "use-opencl", config->use_opencl, NULL); /* turn down the precision of babl - permitting use of lookup tables for * gamma conversions, this precision is anyways high enough for both 8bit * and 16bit operation */ g_object_set (gegl_config (), "babl-tolerance", 0.00015, NULL); g_signal_connect (config, "notify::tile-cache-size", G_CALLBACK (gimp_gegl_notify_tile_cache_size), NULL); g_signal_connect (config, "notify::num-processors", G_CALLBACK (gimp_gegl_notify_num_processors), NULL); g_signal_connect (config, "notify::use-opencl", G_CALLBACK (gimp_gegl_notify_use_opencl), NULL); gimp_babl_init (); gimp_operations_init (); }
void app_run (const gchar *full_prog_name, const gchar **filenames, const gchar *alternate_system_gimprc, const gchar *alternate_gimprc, const gchar *session_name, const gchar *batch_interpreter, const gchar **batch_commands, gboolean as_new, gboolean no_interface, gboolean no_data, gboolean no_fonts, gboolean no_splash, gboolean be_verbose, gboolean use_shm, gboolean use_cpu_accel, gboolean console_messages, gboolean use_debug_handler, GimpStackTraceMode stack_trace_mode, GimpPDBCompatMode pdb_compat_mode) { GimpInitStatusFunc update_status_func = NULL; Gimp *gimp; GimpGeglConfig *config; GMainLoop *loop; gboolean swap_is_ok; /* Create an instance of the "Gimp" object which is the root of the * core object system */ gimp = gimp_new (full_prog_name, session_name, be_verbose, no_data, no_fonts, no_interface, use_shm, console_messages, stack_trace_mode, pdb_compat_mode); errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode); units_init (gimp); /* Check if the user's gimp_directory exists */ if (! g_file_test (gimp_directory (), G_FILE_TEST_IS_DIR)) { GimpUserInstall *install = gimp_user_install_new (be_verbose); #ifdef GIMP_CONSOLE_COMPILATION gimp_user_install_run (install); #else if (! (no_interface ? gimp_user_install_run (install) : user_install_dialog_run (install))) exit (EXIT_FAILURE); #endif gimp_user_install_free (install); } gimp_load_config (gimp, alternate_system_gimprc, alternate_gimprc); config = GIMP_GEGL_CONFIG (gimp->config); /* change the locale if a language if specified */ language_init (gimp->config->language); /* initialize lowlevel stuff */ swap_is_ok = base_init (config, be_verbose, use_cpu_accel); gimp_gegl_init (gimp); #ifndef GIMP_CONSOLE_COMPILATION if (! no_interface) update_status_func = gui_init (gimp, no_splash); #endif if (! update_status_func) update_status_func = app_init_update_noop; /* Create all members of the global Gimp instance which need an already * parsed gimprc, e.g. the data factories */ gimp_initialize (gimp, update_status_func); /* Load all data files */ gimp_restore (gimp, update_status_func); /* display a warning when no test swap file could be generated */ if (! swap_is_ok) { gchar *path = gimp_config_path_expand (config->swap_path, FALSE, NULL); g_message (_("Unable to open a test swap file.\n\n" "To avoid data loss, please check the location " "and permissions of the swap directory defined in " "your Preferences (currently \"%s\")."), path); g_free (path); } /* enable autosave late so we don't autosave when the * monitor resolution is set in gui_init() */ gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE); /* Load the images given on the command-line. */ if (filenames) { gint i; for (i = 0; filenames[i] != NULL; i++) file_open_from_command_line (gimp, filenames[i], as_new); } batch_run (gimp, batch_interpreter, batch_commands); loop = g_main_loop_new (NULL, FALSE); g_signal_connect_after (gimp, "exit", G_CALLBACK (app_exit_after_callback), loop); gimp_threads_leave (gimp); g_main_loop_run (loop); gimp_threads_enter (gimp); g_main_loop_unref (loop); g_object_unref (gimp); gimp_debug_instances (); errors_exit (); gegl_exit (); base_exit (); }
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; }