From 427130be25e123e2da1b4fdf6c90144f8ed92218 Mon Sep 17 00:00:00 2001 From: Alx Sa Date: Thu, 26 Oct 2023 17:16:49 +0000 Subject: [PATCH] plug-ins: port dds-write to GimpProcedureDialog. Note that "save-type" and "mipmaps" were left as ints rather than GimpChoice, as some options are conditionally disabled and I don't know if that is available in GimpChoice just yet. A DDS loading bug related to 6ad54ca3 was also resolved. The correct header value to check for the pixel size was not "depth" but "bpp". --- plug-ins/file-dds/dds.c | 197 +++++++----- plug-ins/file-dds/ddsread.c | 22 +- plug-ins/file-dds/ddswrite.c | 576 +++++++++++++++-------------------- plug-ins/file-dds/ddswrite.h | 14 +- 4 files changed, 372 insertions(+), 437 deletions(-) diff --git a/plug-ins/file-dds/dds.c b/plug-ins/file-dds/dds.c index 33de628222..61c4909b0d 100644 --- a/plug-ins/file-dds/dds.c +++ b/plug-ins/file-dds/dds.c @@ -185,10 +185,13 @@ dds_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_image_types (procedure, "INDEXED, GRAY, RGB"); gimp_procedure_set_menu_label (procedure, _("DDS image")); + gimp_file_procedure_set_format_name (GIMP_FILE_PROCEDURE (procedure), + _("DDS")); + gimp_procedure_set_documentation (procedure, - "Saves files in DDS image format", - "Saves files in DDS image format", + _("Saves files in DDS image format"), + _("Saves files in DDS image format"), name); gimp_procedure_set_attribution (procedure, "Shawn Kirst", @@ -200,14 +203,77 @@ dds_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "dds"); - GIMP_PROC_ARG_INT (procedure, "compression-format", - "Compression format", - "Compression format (0 = None, 1 = BC1/DXT1, " - "2 = BC2/DXT3, 3 = BC3/DXT5, 4 = BC3n/DXT5nm, " - "5 = BC4/ATI1N, 6 = BC5/ATI2N, 7 = RXGB (DXT5), " - "8 = Alpha Exponent (DXT5), 9 = YCoCg (DXT5), " - "10 = YCoCg scaled (DXT5))", - 0, 10, DDS_COMPRESS_NONE, + GIMP_PROC_ARG_CHOICE (procedure, "compression-format", + _("Compressio_n"), + _("Compression format"), + gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL, + "bc1", DDS_COMPRESS_BC1, _("BC1 / DXT1"), NULL, + "bc2", DDS_COMPRESS_BC2, _("BC2 / DXT3"), NULL, + "bc3, ", DDS_COMPRESS_BC3, _("BC3 / DXT5"), NULL, + "bc3n", DDS_COMPRESS_BC3N, _("BC3nm / DXT5nm"), NULL, + "bc4", DDS_COMPRESS_BC4, _("BC4 / ATI1 (3Dc+)"), NULL, + "bc5", DDS_COMPRESS_BC5, _("BC5 / ATI2 (3Dc)"), NULL, + "rxgb", DDS_COMPRESS_RXGB, _("RXGB (DXT5)"), NULL, + "aexp", DDS_COMPRESS_AEXP, _("Alpha Exponent (DXT5)"), NULL, + "ycocg", DDS_COMPRESS_YCOCG, _("YCoCg (DXT5)"), NULL, + "ycocgs", DDS_COMPRESS_YCOCGS, _("YCoCg scaled (DXT5)"), NULL, + NULL), + "none", + G_PARAM_READWRITE); + + GIMP_PROC_ARG_BOOLEAN (procedure, "perceptual-metric", + _("Use percept_ual error metric"), + _("Use a perceptual error metric during compression"), + FALSE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_CHOICE (procedure, "format", + _("_Format"), + _("Pixel format"), + gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL, + "rgb8", DDS_FORMAT_RGB8, _("RGB8"), NULL, + "rgba8", DDS_FORMAT_RGBA8, _("RGBA8"), NULL, + "bgr8", DDS_FORMAT_BGR8, _("BGR8"), NULL, + "abgr8, ", DDS_FORMAT_ABGR8, _("ABGR8"), NULL, + "r5g6b5", DDS_FORMAT_R5G6B5, _("R5G6B5"), NULL, + "rgba4", DDS_FORMAT_RGBA4, _("RGBA4"), NULL, + "rgb5a1", DDS_FORMAT_RGB5A1, _("RGB5A1"), NULL, + "rgb10a2", DDS_FORMAT_RGB10A2, _("RGB10A2"), NULL, + "r3g3b2", DDS_FORMAT_R3G3B2, _("R3G3B2"), NULL, + "a8", DDS_FORMAT_A8, _("A8"), NULL, + "l8", DDS_FORMAT_L8, _("L8"), NULL, + "l8a8", DDS_FORMAT_L8A8, _("L8A8"), NULL, + "aexp", DDS_FORMAT_AEXP, _("AEXP"), NULL, + "ycocg", DDS_FORMAT_YCOCG, _("YCOCG"), NULL, + NULL), + "default", + G_PARAM_READWRITE); + + GIMP_PROC_ARG_INT (procedure, "save-type", + "Save type", + "How to save the image (0 = selected layer, " + "1 = cube map, 2 = volume map, 3 = texture array, " + "4 = all visible layers)", + 0, 4, DDS_SAVE_SELECTED_LAYER, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image", + _("Flip image _vertically on export"), + _("Flip the image vertically on export"), + FALSE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-color", + _("Set _transparent color"), + _("Make an indexed color transparent"), + FALSE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_INT (procedure, "transparent-index", + _("Transparent inde_x"), + _("Index of transparent color or -1 to disable " + "(for indexed images only)."), + 0, 255, 0, G_PARAM_READWRITE); GIMP_PROC_ARG_INT (procedure, "mipmaps", @@ -218,97 +284,62 @@ dds_create_procedure (GimpPlugIn *plug_in, 0, 2, DDS_MIPMAP_NONE, G_PARAM_READWRITE); - GIMP_PROC_ARG_INT (procedure, "save-type", - "Save type", - "How to save the image (0 = selected layer, " - "1 = cube map, 2 = volume map, 3 = texture array, " - "4 = all visible layers)", - 0, 4, DDS_SAVE_SELECTED_LAYER, - G_PARAM_READWRITE); + GIMP_PROC_ARG_CHOICE (procedure, "mipmap-filter", + _("F_ilter"), + _("Filtering to use when generating mipmaps"), + gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL, + "nearest", DDS_MIPMAP_FILTER_NEAREST, _("Nearest"), NULL, + "box", DDS_MIPMAP_FILTER_BOX, _("Box"), NULL, + "triangle", DDS_MIPMAP_FILTER_TRIANGLE, _("Triangle"), NULL, + "quadratic", DDS_MIPMAP_FILTER_QUADRATIC, _("Quadratic"), NULL, + "bspline", DDS_MIPMAP_FILTER_BSPLINE, _("B-Spline"), NULL, + "mitchell", DDS_MIPMAP_FILTER_MITCHELL, _("Mitchell"), NULL, + "lanczos", DDS_MIPMAP_FILTER_LANCZOS, _("Lanczos"), NULL, + "kaiser", DDS_MIPMAP_FILTER_KAISER, _("Kaiser"), NULL, + NULL), + "default", + G_PARAM_READWRITE); - GIMP_PROC_ARG_INT (procedure, "format", - "Format", - "Pixel format (0 = default, 1 = DDS_FORMAT_RGB8, " - "2 = DDS_FORMAT_RGBA8, 3 = DDS_FORMAT_BGR8, " - "4 = DDS_FORMAT_ABGR8, 5 = DDS_FORMAT_R5G6B5, " - "6 = DDS_FORMAT_RGBA4, 7 = DDS_FORMAT_RGB5A1, " - "8 = DDS_FORMAT_RGB10A2, 9 = DDS_FORMAT_R3G3B2, " - "10 = DDS_FORMAT_A8, 11 = DDS_FORMAT_L8, " - "12 = DDS_FORMAT_L8A8, 13 = DDS_FORMAT_AEXP, " - "14 = DDS_FORMAT_YCOCG)", - 0, 14, DDS_FORMAT_DEFAULT, - G_PARAM_READWRITE); - - GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image", - "Flip image vertically", - "Flip the image vertically on export", - FALSE, - G_PARAM_READWRITE); - - GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-color", - "Transparent color", - "Make an indexed color transparent", - FALSE, - G_PARAM_READWRITE); - - GIMP_PROC_ARG_INT (procedure, "transparent-index", - "Transparent index", - "Index of transparent color or -1 to disable " - "(for indexed images only).", - 0, 255, 0, - G_PARAM_READWRITE); - - GIMP_PROC_ARG_INT (procedure, "mipmap-filter", - "Mipmap filter", - "Filtering to use when generating mipmaps " - "(0 = default, 1 = nearest, 2 = box, 3 = triangle, " - "4 = quadratic, 5 = bspline, 6 = mitchell, " - "7 = lanczos, 8 = kaiser)", - 0, 8, DDS_MIPMAP_FILTER_DEFAULT, - G_PARAM_READWRITE); - - GIMP_PROC_ARG_INT (procedure, "mipmap-wrap", - "Mipmap wrap", - "Wrap mode to use when generating mipmaps " - "(0 = default, 1 = mirror, 2 = repeat, 3 = clamp)", - 0, 3, DDS_MIPMAP_WRAP_DEFAULT, - G_PARAM_READWRITE); + GIMP_PROC_ARG_CHOICE (procedure, "mipmap-wrap", + _("_Wrap mode"), + _("Wrap mode to use when generating mipmaps"), + gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL, + "mirror", DDS_MIPMAP_WRAP_MIRROR, _("Mirror"), NULL, + "repeat", DDS_MIPMAP_WRAP_REPEAT, _("Repeat"), NULL, + "clamp", DDS_MIPMAP_WRAP_CLAMP, _("Clamp"), NULL, + NULL), + "default", + G_PARAM_READWRITE); GIMP_PROC_ARG_BOOLEAN (procedure, "gamma-correct", - "Gamma correct", - "Use gamma correct mipmap filtering", + _("Appl_y gamma correction"), + _("Use gamma correct mipmap filtering"), FALSE, G_PARAM_READWRITE); GIMP_PROC_ARG_BOOLEAN (procedure, "srgb", - "sRGB", - "Use sRGB colorspace for gamma correction", + _("Use sRG_B colorspace"), + _("Use sRGB colorspace for gamma correction"), FALSE, G_PARAM_READWRITE); GIMP_PROC_ARG_DOUBLE (procedure, "gamma", - "Gamma", - "Gamma value to use for gamma correction (i.e. 2.2)", + _("_Gamma"), + _("Gamma value to use for gamma correction (i.e. 2.2)"), 0.0, 10.0, 0.0, G_PARAM_READWRITE); - GIMP_PROC_ARG_BOOLEAN (procedure, "perceptual-metric", - "Perceptual metric", - "Use a perceptual error metric during compression", - FALSE, - G_PARAM_READWRITE); - GIMP_PROC_ARG_BOOLEAN (procedure, "preserve-alpha-coverage", - "Preserve alpha coverage", - "Preserve alpha test converage for alpha " - "channel maps", + _("Preserve al_pha test coverage"), + _("Preserve alpha test converage for alpha " + "channel maps"), FALSE, G_PARAM_READWRITE); GIMP_PROC_ARG_DOUBLE (procedure, "alpha-test-threshold", - "Alpha test threshold", - "Alpha test threshold value for which alpha test " - "converage should be preserved", + _("Alp_ha test threshold"), + _("Alpha test threshold value for which alpha test " + "converage should be preserved"), 0.0, 1.0, 0.5, G_PARAM_READWRITE); } @@ -478,7 +509,7 @@ dds_save (GimpProcedure *procedure, */ status = write_dds (file, image, drawables[0], run_mode == GIMP_RUN_INTERACTIVE, - procedure, G_OBJECT (config), + procedure, config, export == GIMP_EXPORT_EXPORT); if (export == GIMP_EXPORT_EXPORT) diff --git a/plug-ins/file-dds/ddsread.c b/plug-ins/file-dds/ddsread.c index 96d5af0e76..a6f26054e2 100644 --- a/plug-ins/file-dds/ddsread.c +++ b/plug-ins/file-dds/ddsread.c @@ -212,17 +212,6 @@ read_dds (GFile *file, } } - /* verify header information is accurate */ - if (hdr.depth < 1 || - (hdr.pitch_or_linsize > (file_size - sizeof (hdr))) || - (((guint64) hdr.height * hdr.width * hdr.depth) > (file_size - sizeof (hdr)))) - { - fclose (fp); - g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), - _("Invalid or corrupted DDS header")); - return GIMP_PDB_EXECUTION_ERROR; - } - if (hdr.pixelfmt.flags & DDPF_FOURCC) { /* fourcc is dXt* or rXgb */ @@ -374,6 +363,17 @@ read_dds (GFile *file, precision = GIMP_PRECISION_U8_NON_LINEAR; } + /* verify header information is accurate */ + if (d.bpp < 1 || + (hdr.pitch_or_linsize > (file_size - sizeof (hdr))) || + (((guint64) hdr.height * hdr.width * d.gimp_bps) > (file_size - sizeof (hdr)))) + { + fclose (fp); + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Invalid or corrupted DDS header")); + return GIMP_PDB_EXECUTION_ERROR; + } + image = gimp_image_new_with_precision (hdr.width, hdr.height, type, precision); if (! image) diff --git a/plug-ins/file-dds/ddswrite.c b/plug-ins/file-dds/ddswrite.c index da90a8f39e..d5d3dcb18b 100644 --- a/plug-ins/file-dds/ddswrite.c +++ b/plug-ins/file-dds/ddswrite.c @@ -44,14 +44,14 @@ #include "color.h" -static gboolean write_image (FILE *fp, - GimpImage *image, - GimpDrawable *drawable, - GObject *config); -static gboolean save_dialog (GimpImage *image, - GimpDrawable *drawable, - GimpProcedure *procedure, - GObject *config); +static gboolean write_image (FILE *fp, + GimpImage *image, + GimpDrawable *drawable, + GimpProcedureConfig *config); +static gboolean save_dialog (GimpImage *image, + GimpDrawable *drawable, + GimpProcedure *procedure, + GimpProcedureConfig *config); static const char *cubemap_face_names[4][6] = @@ -78,25 +78,14 @@ static const char *cubemap_face_names[4][6] = } }; +static GimpImage *global_image = NULL; static GimpLayer *cubemap_faces[6]; static gboolean is_cubemap = FALSE; static gboolean is_volume = FALSE; static gboolean is_array = FALSE; static gboolean is_mipmap_chain_valid = FALSE; -static GtkWidget *compress_opt; -static GtkWidget *format_opt; -static GtkWidget *mipmap_opt; -static GtkWidget *mipmap_filter_opt; -static GtkWidget *mipmap_wrap_opt; -static GtkWidget *transparent_spin; -static GtkWidget *srgb_check; -static GtkWidget *flip_check; -static GtkWidget *gamma_check; -static GtkWidget *gamma_spin; -static GtkWidget *pm_check; -static GtkWidget *alpha_coverage_check; -static GtkWidget *alpha_test_threshold_spin; +static GtkWidget *transparent_check; static struct { @@ -128,8 +117,7 @@ static struct static gboolean -check_mipmaps (GimpImage *image, - gint savetype) +check_mipmaps (gint savetype) { GList *layers; GList *list; @@ -159,11 +147,11 @@ check_mipmaps (GimpImage *image, max_surfaces = INT_MAX; } - layers = gimp_image_list_layers (image); + layers = gimp_image_list_layers (global_image); num_layers = g_list_length (layers); - w = gimp_image_get_width (image); - h = gimp_image_get_height (image); + w = gimp_image_get_width (global_image); + h = gimp_image_get_height (global_image); num_mipmaps = get_num_mipmaps (w, h); @@ -237,7 +225,7 @@ check_cubemap (GimpImage *image) if (num_layers > 6) { /* check that mipmap layers are in order for a cubemap */ - if (! check_mipmaps (image, DDS_SAVE_CUBEMAP)) + if (! check_mipmaps (DDS_SAVE_CUBEMAP)) return FALSE; /* invalidate cubemap faces */ @@ -425,7 +413,7 @@ check_array (GimpImage *image) gint w, h; GimpImageType type; - if (check_mipmaps (image, DDS_SAVE_ARRAY)) + if (check_mipmaps (DDS_SAVE_ARRAY)) return 1; layers = gimp_image_list_layers (image); @@ -506,13 +494,13 @@ get_array_size (GimpImage *image) } GimpPDBStatusType -write_dds (GFile *file, - GimpImage *image, - GimpDrawable *drawable, - gboolean interactive, - GimpProcedure *procedure, - GObject *config, - gboolean is_duplicate_image) +write_dds (GFile *file, + GimpImage *image, + GimpDrawable *drawable, + gboolean interactive, + GimpProcedure *procedure, + GimpProcedureConfig *config, + gboolean is_duplicate_image) { FILE *fp; gint rc = 0; @@ -520,13 +508,16 @@ write_dds (GFile *file, gint mipmaps; gint savetype; + compression = gimp_procedure_config_get_choice_id (config, + "compression-format"); g_object_get (config, - "compression-format", &compression, - "mipmaps", &mipmaps, - "save-type", &savetype, + "save-type", &savetype, + "mipmaps", &mipmaps, NULL); - is_mipmap_chain_valid = check_mipmaps (image, savetype); + global_image = image; + + is_mipmap_chain_valid = check_mipmaps (savetype); is_cubemap = check_cubemap (image); is_volume = check_volume (image); @@ -850,15 +841,15 @@ get_mipmap_chain (unsigned char *dst, } static void -write_layer (FILE *fp, - GimpImage *image, - GimpDrawable *drawable, - GObject *config, - int w, - int h, - int bpp, - int fmtbpp, - int num_mipmaps) +write_layer (FILE *fp, + GimpImage *image, + GimpDrawable *drawable, + GimpProcedureConfig *config, + int w, + int h, + int bpp, + int fmtbpp, + int num_mipmaps) { GeglBuffer *buffer; const Babl *format; @@ -882,11 +873,12 @@ write_layer (FILE *fp, gint flags = 0; g_object_get (config, - "compression-format", &compression, - "mipmaps", &mipmaps, - "format", &pixel_format, "perceptual-metric", &perceptual_metric, + "mipmaps", &mipmaps, NULL); + compression = gimp_procedure_config_get_choice_id (config, + "compression-format"); + pixel_format = gimp_procedure_config_get_choice_id (config, "format"); basetype = gimp_image_get_base_type (image); type = gimp_drawable_type (drawable); @@ -1037,14 +1029,16 @@ write_layer (FILE *fp, gdouble alpha_test_threshold; g_object_get (config, - "mipmap-filter", &mipmap_filter, - "mipmap-wrap", &mipmap_wrap, "gamma-correct", &gamma_correct, "srgb", &srgb, "gamma", &gamma, "preserve-alpha-coverage", &preserve_alpha_coverage, "alpha-test-threshold", &alpha_test_threshold, NULL); + mipmap_filter = gimp_procedure_config_get_choice_id (config, + "mipmap-filter"); + mipmap_wrap = gimp_procedure_config_get_choice_id (config, + "mipmap-wrap"); generate_mipmaps (dst, src, w, h, bpp, palette != NULL, num_mipmaps, @@ -1135,14 +1129,16 @@ write_layer (FILE *fp, gdouble alpha_test_threshold; g_object_get (config, - "mipmap-filter", &mipmap_filter, - "mipmap-wrap", &mipmap_wrap, "gamma-correct", &gamma_correct, "srgb", &srgb, "gamma", &gamma, "preserve-alpha-coverage", &preserve_alpha_coverage, "alpha-test-threshold", &alpha_test_threshold, NULL); + mipmap_filter = gimp_procedure_config_get_choice_id (config, + "mipmap-filter"); + mipmap_wrap = gimp_procedure_config_get_choice_id (config, + "mipmap-wrap"); generate_mipmaps (fmtdst, src, w, h, bpp, 0, num_mipmaps, mipmap_filter, @@ -1179,16 +1175,16 @@ write_layer (FILE *fp, } static void -write_volume_mipmaps (FILE *fp, - GimpImage *image, - GObject *config, - GList *layers, - int w, - int h, - int d, - int bpp, - int fmtbpp, - int num_mipmaps) +write_volume_mipmaps (FILE *fp, + GimpImage *image, + GimpProcedureConfig *config, + GList *layers, + int w, + int h, + int d, + int bpp, + int fmtbpp, + int num_mipmaps) { GList *list; gint i; @@ -1212,14 +1208,16 @@ write_volume_mipmaps (FILE *fp, gdouble gamma; g_object_get (config, - "compression-format", &compression, - "format", &pixel_format, - "mipmap-filter", &mipmap_filter, - "mipmap-wrap", &mipmap_wrap, "gamma-correct", &gamma_correct, "srgb", &srgb, "gamma", &gamma, NULL); + compression = gimp_procedure_config_get_choice_id (config, + "compression-format"); + pixel_format = gimp_procedure_config_get_choice_id (config, "format"); + mipmap_filter = gimp_procedure_config_get_choice_id (config, + "mipmap-filter"); + mipmap_wrap = gimp_procedure_config_get_choice_id (config, "mipmap-wrap"); type = gimp_image_get_base_type (image); @@ -1317,10 +1315,10 @@ write_volume_mipmaps (FILE *fp, } static gboolean -write_image (FILE *fp, - GimpImage *image, - GimpDrawable *drawable, - GObject *config) +write_image (FILE *fp, + GimpImage *image, + GimpDrawable *drawable, + GimpProcedureConfig *config) { GimpImageType drawable_type; GimpImageBaseType basetype; @@ -1351,13 +1349,14 @@ write_image (FILE *fp, gboolean flip_export; g_object_get (config, - "compression-format", &compression, - "mipmaps", &mipmaps, - "save-type", &savetype, - "format", &pixel_format, "transparent-index", &transindex, "flip-image", &flip_export, + "mipmaps", &mipmaps, + "save-type", &savetype, NULL); + compression = gimp_procedure_config_get_choice_id (config, + "compression-format"); + pixel_format = gimp_procedure_config_get_choice_id (config, "format"); if (flip_export) gimp_image_flip (image, GIMP_ORIENTATION_VERTICAL); @@ -1804,29 +1803,32 @@ combo_set_item_sensitive (GtkWidget *widget, } static void -config_notify (GObject *config, - const GParamSpec *pspec, - GimpImage *image) +config_notify (GimpProcedureConfig *config, + const GParamSpec *pspec, + GimpProcedureDialog *dialog) { if (! strcmp (pspec->name, "compression-format")) { gint compression; - g_object_get (config, - "compression-format", &compression, - NULL); + compression = gimp_procedure_config_get_choice_id (config, + "compression-format"); - if (format_opt) - gtk_widget_set_sensitive (format_opt, - compression == DDS_COMPRESS_NONE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "format", + compression == DDS_COMPRESS_NONE, + NULL, NULL, FALSE); - if (pm_check) - gtk_widget_set_sensitive (pm_check, - compression != DDS_COMPRESS_NONE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "perceptual-metric", + compression != DDS_COMPRESS_NONE, + NULL, NULL, FALSE); } else if (! strcmp (pspec->name, "save-type")) { - gint savetype; + gint savetype; + GtkWidget *widget; + GtkWidget *combo; g_object_get (config, "save-type", &savetype, @@ -1838,20 +1840,26 @@ config_notify (GObject *config, case DDS_SAVE_VISIBLE_LAYERS: case DDS_SAVE_CUBEMAP: case DDS_SAVE_ARRAY: - gtk_widget_set_sensitive (compress_opt, TRUE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "compression-format", TRUE, + NULL, NULL, FALSE); break; case DDS_SAVE_VOLUMEMAP: g_object_set (config, - "compression-format", DDS_COMPRESS_NONE, + "compression-format", "none", NULL); - gtk_widget_set_sensitive (compress_opt, FALSE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "compression-format", FALSE, + NULL, NULL, FALSE); break; } - if (mipmap_opt) - combo_set_item_sensitive (mipmap_opt, DDS_MIPMAP_EXISTING, - check_mipmaps (image, savetype)); + widget = gimp_procedure_dialog_get_widget (GIMP_PROCEDURE_DIALOG (dialog), + "mipmaps", G_TYPE_NONE); + combo = gimp_label_int_widget_get_widget (GIMP_LABEL_INT_WIDGET (widget)); + combo_set_item_sensitive (combo, DDS_MIPMAP_EXISTING, + check_mipmaps (savetype)); } else if (! strcmp (pspec->name, "mipmaps")) { @@ -1861,59 +1869,64 @@ config_notify (GObject *config, gboolean preserve_alpha_coverage; g_object_get (config, - "mipmaps", &mipmaps, "gamma-correct", &gamma_correct, "srgb", &srgb, "preserve-alpha-coverage", &preserve_alpha_coverage, + "mipmaps", &mipmaps, NULL); - if (mipmap_filter_opt) - gtk_widget_set_sensitive (mipmap_filter_opt, - mipmaps == DDS_MIPMAP_GENERATE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "mipmap-filter", + mipmaps == DDS_MIPMAP_GENERATE, + NULL, NULL, FALSE); - if (mipmap_wrap_opt) - gtk_widget_set_sensitive (mipmap_wrap_opt, - mipmaps == DDS_MIPMAP_GENERATE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "mipmap-wrap", + mipmaps == DDS_MIPMAP_GENERATE, + NULL, NULL, FALSE); - if (gamma_check) - gtk_widget_set_sensitive (gamma_check, - mipmaps == DDS_MIPMAP_GENERATE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "gamma-correct", + mipmaps == DDS_MIPMAP_GENERATE, + NULL, NULL, FALSE); - if (srgb_check) - gtk_widget_set_sensitive (srgb_check, - (mipmaps == DDS_MIPMAP_GENERATE) && - gamma_correct); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "srgb", + ((mipmaps == DDS_MIPMAP_GENERATE) && + gamma_correct), + NULL, NULL, FALSE); - if (gamma_spin) - gtk_widget_set_sensitive (gamma_spin, - (mipmaps == DDS_MIPMAP_GENERATE) && - gamma_correct && - ! srgb); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "gamma", + ((mipmaps == DDS_MIPMAP_GENERATE) && + gamma_correct && ! srgb), + NULL, NULL, FALSE); - if (alpha_coverage_check) - gtk_widget_set_sensitive (alpha_coverage_check, - mipmaps == DDS_MIPMAP_GENERATE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "preserve-alpha-coverage", + mipmaps == DDS_MIPMAP_GENERATE, + NULL, NULL, FALSE); - if (alpha_test_threshold_spin) - gtk_widget_set_sensitive (alpha_test_threshold_spin, - (mipmaps == DDS_MIPMAP_GENERATE) && - preserve_alpha_coverage); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "alpha-test-threshold", + ((mipmaps == DDS_MIPMAP_GENERATE) && + preserve_alpha_coverage), + NULL, NULL, FALSE); } else if (! strcmp (pspec->name, "transparent-color")) { - GimpImageBaseType base_type; - gboolean transparent_color; - - base_type = gimp_image_get_base_type (image); + gboolean transparent_color; g_object_get (config, "transparent-color", &transparent_color, NULL); - if (transparent_spin) - gtk_widget_set_sensitive (transparent_spin, - transparent_color && - base_type == GIMP_INDEXED); + if (transparent_check && + gtk_widget_get_sensitive (transparent_check)) + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "transparent-index", + transparent_color, + NULL, NULL, FALSE); } else if (! strcmp (pspec->name, "gamma-correct")) { @@ -1925,11 +1938,14 @@ config_notify (GObject *config, "srgb", &srgb, NULL); - if (srgb_check) - gtk_widget_set_sensitive (srgb_check, gamma_correct); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "srgb", gamma_correct, + NULL, NULL, FALSE); - if (gamma_spin) - gtk_widget_set_sensitive (gamma_spin, gamma_correct && ! srgb); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "gamma", + (gamma_correct && ! srgb), + NULL, NULL, FALSE); } else if (! strcmp (pspec->name, "srgb")) { @@ -1941,8 +1957,10 @@ config_notify (GObject *config, "srgb", &srgb, NULL); - if (gamma_spin) - gtk_widget_set_sensitive (gamma_spin, gamma_correct && ! srgb); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "gamma", + (gamma_correct && ! srgb), + NULL, NULL, FALSE); } else if (! strcmp (pspec->name, "preserve-alpha-coverage")) { @@ -1952,251 +1970,137 @@ config_notify (GObject *config, "preserve-alpha-coverage", &preserve_alpha_coverage, NULL); - if (alpha_test_threshold_spin) - gtk_widget_set_sensitive (alpha_test_threshold_spin, - preserve_alpha_coverage); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "alpha-test-threshold", + preserve_alpha_coverage, + NULL, NULL, FALSE); } } static gboolean -save_dialog (GimpImage *image, - GimpDrawable *drawable, - GimpProcedure *procedure, - GObject *config) +save_dialog (GimpImage *image, + GimpDrawable *drawable, + GimpProcedure *procedure, + GimpProcedureConfig *config) { - GtkWidget *dialog; - GtkWidget *vbox; - GtkWidget *hbox; - GtkWidget *grid; - GtkListStore *store; - GtkWidget *opt; - GtkWidget *check; - GtkWidget *frame; - gboolean run; + GtkWidget *dialog; + GtkWidget *widget; + GtkWidget *combo; + GtkListStore *store; + GimpImageBaseType base_type; + gboolean run; + + base_type = gimp_image_get_base_type (image); if (is_cubemap || is_volume || is_array) g_object_set (config, "save-type", DDS_SAVE_SELECTED_LAYER, NULL); - dialog = gimp_procedure_dialog_new (procedure, - GIMP_PROCEDURE_CONFIG (config), - _("Export Image as DDS")); + dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), + GIMP_PROCEDURE_CONFIG (config), + image); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); - vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); - gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); - gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), - vbox, TRUE, TRUE, 0); - gtk_widget_show (vbox); + transparent_check = + gimp_procedure_dialog_get_widget (GIMP_PROCEDURE_DIALOG (dialog), + "transparent-color", + G_TYPE_NONE); + gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), + "transparent-color", + base_type == GIMP_INDEXED, + NULL, NULL, FALSE); - grid = gtk_grid_new (); - gtk_grid_set_row_spacing (GTK_GRID (grid), 6); - gtk_grid_set_column_spacing (GTK_GRID (grid), 6); - gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0); - gtk_widget_show (grid); + gimp_procedure_dialog_fill_frame (GIMP_PROCEDURE_DIALOG (dialog), + "transparency-frame", + "transparent-color", FALSE, + "transparent-index"); - store = gimp_int_store_new ("None", DDS_COMPRESS_NONE, - "BC1 / DXT1", DDS_COMPRESS_BC1, - "BC2 / DXT3", DDS_COMPRESS_BC2, - "BC3 / DXT5", DDS_COMPRESS_BC3, - "BC3nm / DXT5nm", DDS_COMPRESS_BC3N, - "BC4 / ATI1 (3Dc+)", DDS_COMPRESS_BC4, - "BC5 / ATI2 (3Dc)", DDS_COMPRESS_BC5, - "RXGB (DXT5)", DDS_COMPRESS_RXGB, - "Alpha Exponent (DXT5)", DDS_COMPRESS_AEXP, - "YCoCg (DXT5)", DDS_COMPRESS_YCOCG, - "YCoCg scaled (DXT5)", DDS_COMPRESS_YCOCGS, + gimp_procedure_dialog_get_label (GIMP_PROCEDURE_DIALOG (dialog), + "mipmap-options-label", + _("Mipmap Options"), + FALSE, FALSE); + + gimp_procedure_dialog_fill_box (GIMP_PROCEDURE_DIALOG (dialog), + "mipmap-options-box", + "mipmap-filter", "mipmap-wrap", + "gamma-correct", "srgb", "gamma", + "preserve-alpha-coverage", + "alpha-test-threshold", NULL); + + gimp_procedure_dialog_fill_frame (GIMP_PROCEDURE_DIALOG (dialog), + "mipmap-options-frame", + "mipmap-options-label", FALSE, + "mipmap-options-box"); + + store = gimp_int_store_new (_("Selected layer"), DDS_SAVE_SELECTED_LAYER, + _("All visible layers"), DDS_SAVE_VISIBLE_LAYERS, + _("As cube map"), DDS_SAVE_CUBEMAP, + _("As volume map"), DDS_SAVE_VOLUMEMAP, + _("As texture array"), DDS_SAVE_ARRAY, NULL); - compress_opt = gimp_prop_int_combo_box_new (config, "compression-format", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 0, - _("_Compression:"), - 0.0, 0.5, - compress_opt, 1); - - pm_check = gimp_prop_check_button_new (config, "perceptual-metric", - _("Use _perceptual error metric")); - gtk_grid_attach (GTK_GRID (grid), pm_check, 1, 1, 1, 1); - - store = gimp_int_store_new ("Default", DDS_FORMAT_DEFAULT, - "RGB8", DDS_FORMAT_RGB8, - "RGBA8", DDS_FORMAT_RGBA8, - "BGR8", DDS_FORMAT_BGR8, - "ABGR8", DDS_FORMAT_ABGR8, - "R5G6B5", DDS_FORMAT_R5G6B5, - "RGBA4", DDS_FORMAT_RGBA4, - "RGB5A1", DDS_FORMAT_RGB5A1, - "RGB10A2", DDS_FORMAT_RGB10A2, - "R3G3B2", DDS_FORMAT_R3G3B2, - "A8", DDS_FORMAT_A8, - "L8", DDS_FORMAT_L8, - "L8A8", DDS_FORMAT_L8A8, - "AExp", DDS_FORMAT_AEXP, - "YCoCg", DDS_FORMAT_YCOCG, - NULL); - format_opt = gimp_prop_int_combo_box_new (config, "format", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 2, - _("_Format:"), - 0.0, 0.5, - format_opt, 1); - - store = gimp_int_store_new (_("Selected layer"), DDS_SAVE_SELECTED_LAYER, - _("All visible layers"), DDS_SAVE_VISIBLE_LAYERS, - _("As cube map"), DDS_SAVE_CUBEMAP, - _("As volume map"), DDS_SAVE_VOLUMEMAP, - _("As texture array"), DDS_SAVE_ARRAY, - NULL); - opt = gimp_prop_int_combo_box_new (config, "save-type", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 3, - _("_Save:"), - 0.0, 0.5, - opt, 1); - - gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (opt), - combo_sensitivity_func, - opt, NULL); - - combo_set_item_sensitive (opt, DDS_SAVE_CUBEMAP, is_cubemap); - combo_set_item_sensitive (opt, DDS_SAVE_VOLUMEMAP, is_volume); - combo_set_item_sensitive (opt, DDS_SAVE_ARRAY, is_array); - - flip_check = gimp_prop_check_button_new (config, "flip-image", - _("Flip image _vertically on export")); - gtk_grid_attach (GTK_GRID (grid), flip_check, 1, 4, 1, 1); + widget = gimp_procedure_dialog_get_int_combo (GIMP_PROCEDURE_DIALOG (dialog), + "save-type", + GIMP_INT_STORE (store)); + combo = gimp_label_int_widget_get_widget (GIMP_LABEL_INT_WIDGET (widget)); + gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (combo), + combo_sensitivity_func, combo, NULL); + combo_set_item_sensitive (combo, DDS_SAVE_CUBEMAP, is_cubemap); + combo_set_item_sensitive (combo, DDS_SAVE_VOLUMEMAP, is_volume); + combo_set_item_sensitive (combo, DDS_SAVE_ARRAY, is_array); store = gimp_int_store_new (_("No mipmaps"), DDS_MIPMAP_NONE, _("Generate mipmaps"), DDS_MIPMAP_GENERATE, _("Use existing mipmaps"), DDS_MIPMAP_EXISTING, NULL); - mipmap_opt = gimp_prop_int_combo_box_new (config, "mipmaps", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 5, - _("_Mipmaps:"), - 0.0, 0.5, - mipmap_opt, 1); - - gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (mipmap_opt), - combo_sensitivity_func, - mipmap_opt, NULL); - - combo_set_item_sensitive (mipmap_opt, DDS_MIPMAP_EXISTING, + widget = gimp_procedure_dialog_get_int_combo (GIMP_PROCEDURE_DIALOG (dialog), + "mipmaps", + GIMP_INT_STORE (store)); + combo = gimp_label_int_widget_get_widget (GIMP_LABEL_INT_WIDGET (widget)); + gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (combo), + combo_sensitivity_func, combo, NULL); + combo_set_item_sensitive (combo, DDS_MIPMAP_EXISTING, ! (is_volume || is_cubemap) && is_mipmap_chain_valid); + gimp_procedure_dialog_fill (GIMP_PROCEDURE_DIALOG (dialog), + "compression-format", "perceptual-metric", + "format", "save-type", "flip-image", + "mipmaps", "transparency-frame", + "mipmap-options-frame", NULL); - hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); - gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); - gtk_widget_show (hbox); - - check = gimp_prop_check_button_new (config, "transparent-color", - _("Transparent index:")); - gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0); - gtk_widget_show (check); - - transparent_spin = gimp_prop_spin_button_new (config, "transparent-index", - 1, 8, 0); - gtk_box_pack_start (GTK_BOX (hbox), transparent_spin, TRUE, TRUE, 0); - - frame = gimp_frame_new (_("Mipmap Options")); - gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); - gtk_widget_show (frame); - - grid = gtk_grid_new (); - gtk_grid_set_row_spacing (GTK_GRID (grid), 6); - gtk_grid_set_column_spacing (GTK_GRID (grid), 8); - gtk_container_add (GTK_CONTAINER (frame), grid); - gtk_widget_show (grid); - - store = gimp_int_store_new ("Default", DDS_MIPMAP_FILTER_DEFAULT, - "Nearest", DDS_MIPMAP_FILTER_NEAREST, - "Box", DDS_MIPMAP_FILTER_BOX, - "Triangle", DDS_MIPMAP_FILTER_TRIANGLE, - "Quadratic", DDS_MIPMAP_FILTER_QUADRATIC, - "B-Spline", DDS_MIPMAP_FILTER_BSPLINE, - "Mitchell", DDS_MIPMAP_FILTER_MITCHELL, - "Lanczos", DDS_MIPMAP_FILTER_LANCZOS, - "Kaiser", DDS_MIPMAP_FILTER_KAISER, - NULL); - mipmap_filter_opt = gimp_prop_int_combo_box_new (config, "mipmap-filter", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 0, - _("F_ilter:"), - 0.0, 0.5, - mipmap_filter_opt, 1); - - store = gimp_int_store_new ("Default", DDS_MIPMAP_WRAP_DEFAULT, - "Mirror", DDS_MIPMAP_WRAP_MIRROR, - "Repeat", DDS_MIPMAP_WRAP_REPEAT, - "Clamp", DDS_MIPMAP_WRAP_CLAMP, - NULL); - mipmap_wrap_opt = gimp_prop_int_combo_box_new (config, "mipmap-wrap", - GIMP_INT_STORE (store)); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1, - _("_Wrap mode:"), - 0.0, 0.5, - mipmap_wrap_opt, 1); - - gamma_check = gimp_prop_check_button_new (config, "gamma-correct", - _("Appl_y gamma correction")); - gtk_grid_attach (GTK_GRID (grid), gamma_check, 1, 2, 1, 1); - - srgb_check = gimp_prop_check_button_new (config, "srgb", - _("Use s_RGB colorspace")); - gtk_grid_attach (GTK_GRID (grid), srgb_check, 1, 3, 1, 1); - - gamma_spin = gimp_prop_spin_button_new (config, "gamma", - 0.1, 0.5, 1); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 4, - _("_Gamma:"), 0.0, 0.5, - gamma_spin, 1); - - alpha_coverage_check = - gimp_prop_check_button_new (config, "preserve-alpha-coverage", - _("Preserve alpha _test coverage")); - gtk_grid_attach (GTK_GRID (grid), alpha_coverage_check, 1, 5, 1, 1); - - alpha_test_threshold_spin = - gimp_prop_spin_button_new (config, "alpha-test-threshold", - 0.01, 0.1, 2); - gimp_grid_attach_aligned (GTK_GRID (grid), 0, 6, - _("_Alpha test threshold:"), 0.0, 0.5, - alpha_test_threshold_spin, 1); - - config_notify (config, + config_notify (GIMP_PROCEDURE_CONFIG (config), g_object_class_find_property (G_OBJECT_GET_CLASS (config), "compression-format"), - image); + GIMP_PROCEDURE_DIALOG (dialog)); - config_notify (config, + config_notify (GIMP_PROCEDURE_CONFIG (config), g_object_class_find_property (G_OBJECT_GET_CLASS (config), "mipmaps"), - image); + GIMP_PROCEDURE_DIALOG (dialog)); - config_notify (config, + config_notify (GIMP_PROCEDURE_CONFIG (config), g_object_class_find_property (G_OBJECT_GET_CLASS (config), "save-type"), - image); + GIMP_PROCEDURE_DIALOG (dialog)); - config_notify (config, + config_notify (GIMP_PROCEDURE_CONFIG (config), g_object_class_find_property (G_OBJECT_GET_CLASS (config), "transparent-color"), - image); + GIMP_PROCEDURE_DIALOG (dialog)); - g_signal_connect (config, "notify", + g_signal_connect (GIMP_PROCEDURE_CONFIG (config), "notify", G_CALLBACK (config_notify), - image); + GIMP_PROCEDURE_DIALOG (dialog)); gtk_widget_show (dialog); run = gimp_procedure_dialog_run (GIMP_PROCEDURE_DIALOG (dialog)); - g_signal_handlers_disconnect_by_func (config, + g_signal_handlers_disconnect_by_func (GIMP_PROCEDURE_CONFIG (config), config_notify, - image); + GIMP_PROCEDURE_DIALOG (dialog)); gtk_widget_destroy (dialog); diff --git a/plug-ins/file-dds/ddswrite.h b/plug-ins/file-dds/ddswrite.h index 06b2084e7e..f5abff7c83 100644 --- a/plug-ins/file-dds/ddswrite.h +++ b/plug-ins/file-dds/ddswrite.h @@ -22,13 +22,13 @@ #define __DDSWRITE_H__ -extern GimpPDBStatusType write_dds (GFile *file, - GimpImage *image, - GimpDrawable *drawable, - gboolean interactive, - GimpProcedure *procedure, - GObject *config, - gboolean is_duplicate_image); +extern GimpPDBStatusType write_dds (GFile *file, + GimpImage *image, + GimpDrawable *drawable, + gboolean interactive, + GimpProcedure *procedure, + GimpProcedureConfig *config, + gboolean is_duplicate_image); #endif /* __DDSWRITE_H__ */