static void gimp_init_i18n (void) { /* We may change the locale later if the user specifies a language * in the gimprc file. Here we are just initializing the locale * according to the environment variables and set up the paths to * the message catalogs. */ setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE"-libgimp", gimp_locale_directory ()); #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE"-libgimp", "UTF-8"); #endif bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory ()); #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); }
static void iso_codes_parser_init (void) { static gboolean initialized = FALSE; if (initialized) return; #ifdef G_OS_WIN32 /* on Win32, assume iso-codes is installed in the same location as GIMP */ bindtextdomain ("iso_639", gimp_locale_directory ()); #else bindtextdomain ("iso_639", ISO_CODES_LOCALEDIR); #endif bind_textdomain_codeset ("iso_639", "UTF-8"); initialized = TRUE; }
/* * Initialize and run the language listing parser. This call must be * made only once, at program initialization, but after language_init(). */ void gimp_language_store_parser_init (void) { GHashTable *base_lang_list; gchar *current_env; GDir *locales_dir; GHashTableIter lang_iter; gpointer key; if (l10n_lang_list != NULL) { g_warning ("gimp_language_store_parser_init() must be run only once."); return; } current_env = g_strdup (g_getenv ("LANGUAGE")); l10n_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) g_free); all_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) g_free); base_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) g_free); /* Check all locales we have translations for. */ locales_dir = g_dir_open (gimp_locale_directory (), 0, NULL); if (locales_dir) { const gchar *locale; while ((locale = g_dir_read_name (locales_dir)) != NULL) { gchar *filename = g_build_filename (gimp_locale_directory (), locale, "LC_MESSAGES", GETTEXT_PACKAGE ".mo", NULL); if (g_file_test (filename, G_FILE_TEST_EXISTS)) { gchar *delimiter = NULL; gchar *base_code = NULL; delimiter = strchr (locale, '_'); if (delimiter) base_code = g_strndup (locale, delimiter - locale); else base_code = g_strdup (locale); delimiter = strchr (base_code, '@'); if (delimiter) { gchar *temp = base_code; base_code = g_strndup (base_code, delimiter - base_code); g_free (temp); } /* Save the full language code. */ g_hash_table_insert (l10n_lang_list, g_strdup (locale), NULL); /* Save the base language code. */ g_hash_table_insert (base_lang_list, base_code, NULL); } g_free (filename); } g_dir_close (locales_dir); } /* Parse ISO-639 file to get full list of language and their names. */ parse_iso_codes (base_lang_list, NULL); /* Generate the localized language names. */ g_hash_table_iter_init (&lang_iter, l10n_lang_list); while (g_hash_table_iter_next (&lang_iter, &key, NULL)) { gchar *code = (gchar*) key; gchar *localized_name = NULL; gchar *english_name = NULL; gchar *delimiter = NULL; gchar *base_code = NULL; delimiter = strchr (code, '_'); if (delimiter) base_code = g_strndup (code, delimiter - code); else base_code = g_strdup (code); delimiter = strchr (base_code, '@'); if (delimiter) { gchar *temp = base_code; base_code = g_strndup (base_code, delimiter - base_code); g_free (temp); } english_name = (gchar*) (g_hash_table_lookup (base_lang_list, base_code)); if (english_name) { gchar *semicolon; /* If possible, we want to localize a language in itself. * If it fails, gettext fallbacks to C (en_US) itself. */ g_setenv ("LANGUAGE", code, TRUE); setlocale (LC_ALL, ""); localized_name = g_strdup (dgettext ("iso_639", english_name)); /* If original and localized names are the same for other than English, * maybe localization failed. Try now in the main dialect. */ if (g_strcmp0 (english_name, localized_name) == 0 && g_strcmp0 (base_code, "en") != 0 && g_strcmp0 (code, base_code) != 0) { g_free (localized_name); g_setenv ("LANGUAGE", base_code, TRUE); setlocale (LC_ALL, ""); localized_name = g_strdup (dgettext ("iso_639", english_name)); } /* there might be several language names; use the first one */ semicolon = strchr (localized_name, ';'); if (semicolon) { gchar *temp = localized_name; localized_name = g_strndup (localized_name, semicolon - localized_name); g_free (temp); } } g_hash_table_replace (l10n_lang_list, g_strdup(code), g_strdup_printf ("%s [%s]", localized_name ? localized_name : "???", code)); g_free (localized_name); g_free (base_code); } /* Add special entries for system locale. * We want the system locale to be localized in itself. */ g_setenv ("LANGUAGE", setlocale (LC_ALL, NULL), TRUE); setlocale (LC_ALL, ""); /* g_str_hash() does not accept NULL. I give an empty code instead. * Other solution would to create a custom hash. */ g_hash_table_insert (l10n_lang_list, g_strdup(""), g_strdup (_("System Language"))); /* Go back to original localization. */ if (current_env) { g_setenv ("LANGUAGE", current_env, TRUE); g_free (current_env); } else g_unsetenv ("LANGUAGE"); setlocale (LC_ALL, ""); /* Add special entry for C (en_US). */ g_hash_table_insert (l10n_lang_list, g_strdup ("en_US"), g_strdup ("English [en_US]")); g_hash_table_destroy (base_lang_list); }
static void run( const gchar * name, gint nparams, const GimpParam * param, gint * nreturn_vals, GimpParam ** return_vals) { static GimpParam values[2]; /* Gimp return values. !!! Allow 2: status and error message. */ TGimpAdapterParameters pluginParameters; TImageSynthParameters engineParameters; GimpDrawable *drawable = NULL; GimpDrawable *corpus_drawable = NULL; GimpDrawable *map_in_drawable= NULL; GimpDrawable *map_out_drawable= NULL; gboolean ok, with_map; /* Local copies of pixmaps (not using gimp regions.) 2-D arrays of Pixel, addressable by Coordinates (Point). c++: static Bitmap<Pixelel> */ Map targetMap; Map corpusMap; Map targetMaskMap; Map corpusMaskMap; int cancelFlag = 0; #ifdef SYNTH_THREADED // This is as early as it can be called. Not sure it needs to be called. See later call to it. // Call it early since calls to gdk, gtk might require this? g_thread_init(NULL); #endif #ifdef DEBUG gimp_message_set_handler(1); // To console instead of GUI start_time = clock(); #endif // internationalization i18n // Note these constants are defined in the build environment. /* Initialize i18n support */ #if defined(G_OS_WIN32) bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory()); #else bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); #endif #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; /* Unless everything succeeds. */ drawable = gimp_drawable_get(param[2].data.d_drawable); /* Check image type (could be called non-interactive) */ if (!gimp_drawable_is_rgb(drawable->drawable_id) && !gimp_drawable_is_gray(drawable->drawable_id)) { ERROR_RETURN(_("Incompatible image mode.")); } /* Deal with run mode */ ok = FALSE; switch(param[0].data.d_int32) { case GIMP_RUN_INTERACTIVE : ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME); gimp_message("Resynthesizer engine should not be called interactively"); /* But keep going with last (or default) parameters, really no harm. */ break; case GIMP_RUN_NONINTERACTIVE : ok = get_parameters_from_list(&pluginParameters, nparams, param); break; case GIMP_RUN_WITH_LAST_VALS : ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME); break; } if (!ok) { ERROR_RETURN(_("Resynthesizer failed to get parameters.")); } /* Limit neighbours parameter to size allocated. */ if (pluginParameters.neighbours > IMAGE_SYNTH_MAX_NEIGHBORS ) pluginParameters.neighbours = IMAGE_SYNTH_MAX_NEIGHBORS; corpus_drawable = gimp_drawable_get(pluginParameters.corpus_id); /* The target and corpus must have the same base type. In earlier version, they must have the same bpp. But now we don't compare the alphas, so they can differ in presence of alpha. */ if (! equal_basetypes(drawable, corpus_drawable) ) { ERROR_RETURN(_("The input texture and output image must have the same number of color channels.")); } with_map = (pluginParameters.input_map_id != -1 && pluginParameters.output_map_id != -1); /* If only one map is passed, it is ignored quietly. */ map_in_drawable=0; map_out_drawable=0; if (with_map) { map_in_drawable = gimp_drawable_get(pluginParameters.input_map_id); map_out_drawable = gimp_drawable_get(pluginParameters.output_map_id); /* All these can be wrong at the same time. Forego userfriendliness for ease of programming: abort on first error */ if ( ! equal_basetypes(map_in_drawable, map_out_drawable) ) { /* Maps need the same base type. Formerly needed the same bpp. */ ERROR_RETURN(_("The input and output maps must have the same mode")); } if (map_in_drawable->width != corpus_drawable->width || map_in_drawable->height != corpus_drawable->height) { ERROR_RETURN(_("The input map should be the same size as the input texture image")); } if (map_out_drawable->width != drawable->width || map_out_drawable->height != drawable->height) { ERROR_RETURN(_("The output map should be the same size as the output image")); } } /* The engine should not be run interactively so no need to store last values. I.E. the meaning of "last" is "last values set by user interaction". */ #ifdef ANIMATE // Copy local pointer vars to globals targetDrawableCopy = drawable; targetMapCopy = &targetMap; #endif /* Error checks done, initialization work begins. So start progress callbacks. */ progressStart("Initializing..."); /* Set flags for presence of alpha channels. The flag is an optimization. Alternatives: - a function - OR standardize the internal pixmap to ALWAYS have an alpha pixelel initialized to VISIBLE and set from any alpha pixelel. */ gboolean is_alpha_image = gimp_drawable_has_alpha(drawable->drawable_id); gboolean is_alpha_corpus = gimp_drawable_has_alpha(corpus_drawable->drawable_id); // Image adaption requires format indices // WAS prepareImageFormatIndices(drawable, corpus_drawable, with_map, map_in_drawable); TFormatIndices formatIndices; guint map_count = (with_map? count_color_channels(map_in_drawable) : 0 ); prepareImageFormatIndices( &formatIndices, count_color_channels(drawable), map_count, is_alpha_image, is_alpha_corpus, with_map ); #ifdef ADAPT_SIMPLE /* Adapt Gimp to an engine with a simpler interface. */ setDefaultParams(¶meters); ImageBuffer imageBuffer; ImageBuffer maskBuffer; // TODO change to new signature adaptGimpToSimple(drawable, &imageBuffer, &maskBuffer); // From Gimp to simple g_printf("Here3\n"); adaptSimpleAPI(&imageBuffer, &maskBuffer); // From simple to existing engine API #else g_printf("Gimp adaption\n"); /* target/context adaption */ fetch_image_mask_map(drawable, &targetMap, formatIndices.total_bpp, &targetMaskMap, MASK_TOTALLY_SELECTED, map_out_drawable, formatIndices.map_start_bip); #ifdef ANIMATE clear_target_pixels(formatIndices.colorEndBip); // For debugging, blacken so new colors sparkle #endif /* corpus adaption */ fetch_image_mask_map(corpus_drawable, &corpusMap, formatIndices.total_bpp, &corpusMaskMap, MASK_TOTALLY_SELECTED, map_in_drawable, formatIndices.map_start_bip); // TODO These are artifacts of earlier design, not used. free_map(&corpusMaskMap); free_map(&targetMaskMap); adaptParameters(&pluginParameters, &engineParameters); #endif // After possible adaption, check size again g_assert(targetMap.width * targetMap.height); // Image is not empty g_assert(corpusMap.width * corpusMap.height); // Corpus is not empty // Done with adaption: now main image data in canonical pixmaps, etc. // Begin real work progressStart("synthesizing..."); int result = engine( engineParameters, &formatIndices, &targetMap, &corpusMap, progressUpdate, (void *) 0, &cancelFlag ); if (result == IMAGE_SYNTH_ERROR_EMPTY_CORPUS) { ERROR_RETURN(_("The texture source is empty. Does any selection include non-transparent pixels?")); } else if (result == IMAGE_SYNTH_ERROR_EMPTY_TARGET ) { ERROR_RETURN(_("The output layer is empty. Does any selection have visible pixels in the active layer?")); } // Normal post-process adaption follows /* dump_target_points(); */ /* detailed debugging. */ // print_post_stats(); // Update Gimp image from local pixmap // Note this works even for test harness where ADAPT_SIMPLE // but then it does NOT test returning results in buffer. /* We could test antiAdaptImage() here. But antiAdaptImage() has already been tested once on the incoming side. So no compelling need to test it again here. */ post_results_to_gimp(drawable, targetMap); /* Clean up */ // Adapted free_map(&targetMap); free_map(&corpusMap); // GIMP detach_drawables(drawable, corpus_drawable, map_in_drawable, map_out_drawable); gimp_progress_end(); values[0].data.d_status = GIMP_PDB_SUCCESS; }
static void run( const gchar * name, gint nparams, // !!! Always 3 for INTERACTIVE, not lengthof(param)? const GimpParam * param, gint * nreturn_vals, GimpParam ** return_vals) { static GimpParam values[1]; // return values persist after run() returns Parameters parameters; gboolean ok; /* Unless anything goes wrong, result is success */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_SUCCESS; /* Initialize i18n support */ #if defined(G_OS_WIN32) bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory()); #else bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); #endif #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); /* Don't really need the drawable or its tiles until we get to the engine. */ gint32 drawable_id; drawable_id = param[2].data.d_drawable; /* Assert the image type is OK because Gimp checked it. */ /* Deal with run mode */ ok = FALSE; switch(param[0].data.d_int32) { case GIMP_RUN_INTERACTIVE : get_last_parameters(¶meters, drawable_id, RESYNTH_CONTROLS_PDB_NAME ); init_gtk(); /* GUI dialog. */ ok = get_parameters_by_asking(¶meters,drawable_id); if (ok) /* Not canceled and not an exception. */ set_last_parameters(¶meters, drawable_id); break; case GIMP_RUN_NONINTERACTIVE : /* GUI CAN be called noninteractively, in batch mode or otherwise. */ ok = get_parameters_from_list(¶meters, nparams, param); break; case GIMP_RUN_WITH_LAST_VALS : ok = get_last_parameters(¶meters,drawable_id, RESYNTH_CONTROLS_PDB_NAME); break; } if (!ok) { /* No message displayed here because it is usually Cancel button, else the resynthesizer control panel GUI already displayed an error message? */ values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; } /* Prepare params for engine: augment passed params with user's choices. */ static GimpParam temp[RESYNTH_PARAMETER_COUNT]; set_parameters_to_list(¶meters, param, nparams, GIMP_RUN_NONINTERACTIVE, temp); /* Call resynthesizer engine. */ GimpParam * engine_result; gint engine_n_return_vals; engine_result = gimp_run_procedure2( RESYNTH_ENGINE_PDB_NAME, &engine_n_return_vals, RESYNTH_PARAMETER_COUNT, /* !!! Not nparams */ temp ); /* Always a status. */ if (engine_result[0].data.d_status != GIMP_PDB_SUCCESS) { /* Reraise engine error. */ *nreturn_vals = engine_n_return_vals; *return_vals = engine_result; } else { /* Free engine result, return our own. */ gimp_destroy_params(engine_result, engine_n_return_vals); } }