/* Plug-in to load and save .gih (GIMP Brush Pipe) files. * * Copyright (C) 1999 Tor Lillqvist * Copyright (C) 2000 Jens Lautenbacher, Sven Neumann * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ /* Example of how to call file_gih_save from script-fu: (let ((ranks (cons-array 1 'byte))) (aset ranks 0 12) (file-gih-save 1 img drawable "foo.gih" "foo.gih" 100 "test brush" 125 125 3 4 1 ranks 1 '("random"))) */ #include "config.h" #include #include #include #include #include #include #ifdef HAVE_UNISTD_H #include #endif #include #include #ifdef G_OS_WIN32 #include #endif #ifndef _O_BINARY #define _O_BINARY 0 #endif #include #include #include #include "app/core/gimpbrush-header.h" #include "app/core/gimppattern-header.h" #include "libgimp/stdplugins-intl.h" #define LOAD_PROC "file-gih-load" #define SAVE_PROC "file-gih-save" #define PLUG_IN_BINARY "file-gih" #define PLUG_IN_ROLE "gimp-file-gih" #define DUMMY_PATTERN_NAME "x" #define MAXDESCLEN 256 /* Parameters applicable each time we save a gih, saved in the * main gimp application between invocations of this plug-in. */ static struct { guint spacing; gchar description[MAXDESCLEN+1]; } info = /* Initialize to this, change if non-interactive later */ { 20, "GIMP Brush Pipe" }; static gint num_layers = 0; static const gchar *selection_modes[] = { "incremental", "angular", "random", "velocity", "pressure", "xtilt", "ytilt" }; static GimpPixPipeParams gihparams; typedef struct { GimpOrientationType orientation; gint32 image; gint32 toplayer; gint nguides; gint32 *guides; gint *value; GtkWidget *count_label; /* Corresponding count adjustment, */ gint *count; /* cols or rows */ gint *other_count; /* and the other one */ GtkObject *ncells; GtkObject *rank0; GtkWidget *warning_label; GtkWidget *rank_entry[GIMP_PIXPIPE_MAXDIM]; GtkWidget *mode_entry[GIMP_PIXPIPE_MAXDIM]; } SizeAdjustmentData; /* static gint32 *vguides, *hguides; */ /* static gint nvguides = 0, nhguides = 0; */ /* Declare some local functions. */ static void query (void); static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals); static gint32 gih_load_image (const gchar *filename, GError **error); static gboolean gih_load_one_brush (gint fd, gint32 image_ID); static gboolean gih_save_dialog (gint32 image_ID); static gboolean gih_save_one_brush (gint fd, GimpPixelRgn *pixel_rgn, const gchar *name); static gboolean gih_save_image (const gchar *filename, gint32 image_ID, gint32 orig_image_ID, gint32 drawable_ID, GError **error); const GimpPlugInInfo PLUG_IN_INFO = { NULL, /* init_proc */ NULL, /* quit_proc */ query, /* query_proc */ run, /* run_proc */ }; MAIN () static void query (void) { static const GimpParamDef gih_save_args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image" }, { GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" }, { GIMP_PDB_STRING, "filename", "The name of the file to save the brush pipe in" }, { GIMP_PDB_STRING, "raw-filename", "The name of the file to save the brush pipe in" }, { GIMP_PDB_INT32, "spacing", "Spacing of the brush" }, { GIMP_PDB_STRING, "description", "Short description of the brush pipe" }, { GIMP_PDB_INT32, "cell-width", "Width of the brush cells" }, { GIMP_PDB_INT32, "cell-height", "Width of the brush cells" }, { GIMP_PDB_INT8, "display-cols", "Display column number" }, { GIMP_PDB_INT8, "display-rows", "Display row number" }, { GIMP_PDB_INT32, "dimension", "Dimension of the brush pipe" }, /* The number of rank and sel args depend on the dimension */ { GIMP_PDB_INT8ARRAY, "rank", "Ranks of the dimensions" }, { GIMP_PDB_INT32, "dimension", "Dimension (again)" }, { GIMP_PDB_STRINGARRAY, "sel", "Selection modes" } }; static const GimpParamDef gih_load_args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "raw-filename", "The name of the file to load" } }; static const GimpParamDef gih_load_return_vals[] = { { GIMP_PDB_IMAGE, "image", "Output image" } }; gimp_install_procedure (LOAD_PROC, "loads images in GIMP brush pipe format", "This plug-in loads a GIMP brush pipe as an image.", "Jens Lautenbacher, Sven Neumann", "Jens Lautenbacher, Sven Neumann", "2000", N_("GIMP brush (animated)"), NULL, GIMP_PLUGIN, G_N_ELEMENTS (gih_load_args), G_N_ELEMENTS (gih_load_return_vals), gih_load_args, gih_load_return_vals); gimp_plugin_icon_register (LOAD_PROC, GIMP_ICON_TYPE_STOCK_ID, (const guint8 *) GIMP_STOCK_BRUSH); gimp_register_file_handler_mime (LOAD_PROC, "image/x-gimp-gih"); gimp_register_magic_load_handler (LOAD_PROC, "gih", "", ""); gimp_install_procedure (SAVE_PROC, "saves images in GIMP brush pipe format", "This plug-in saves an image in the GIMP brush pipe format. For a colored brush pipe, RGBA layers are used, otherwise the layers should be grayscale masks. The image can be multi-layered, and additionally the layers can be divided into a rectangular array of brushes.", "Tor Lillqvist", "Tor Lillqvist", "1999", N_("GIMP brush (animated)"), "RGB*, GRAY*", GIMP_PLUGIN, G_N_ELEMENTS (gih_save_args), 0, gih_save_args, NULL); gimp_plugin_icon_register (SAVE_PROC, GIMP_ICON_TYPE_STOCK_ID, (const guint8 *) GIMP_STOCK_BRUSH); gimp_register_file_handler_mime ("file_gih_save", "image/x-gimp-gih"); gimp_register_save_handler (SAVE_PROC, "gih", ""); } static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpParasite *pipe_parasite; gint32 image_ID; gint32 orig_image_ID; gint32 drawable_ID; gint i; GimpExportReturn export = GIMP_EXPORT_CANCEL; GError *error = NULL; run_mode = param[0].data.d_int32; *return_vals = values; *nreturn_vals = 1; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; INIT_I18N(); if (strcmp (name, LOAD_PROC) == 0) { image_ID = gih_load_image (param[1].data.d_string, &error); if (image_ID != -1) { *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; } else { status = GIMP_PDB_EXECUTION_ERROR; } } else if (strcmp (name, SAVE_PROC) == 0) { image_ID = orig_image_ID = param[1].data.d_int32; drawable_ID = param[2].data.d_int32; /* eventually export the image */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_ID, NULL, GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_ALPHA | GIMP_EXPORT_CAN_HANDLE_LAYERS); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; } g_free (gimp_image_get_layers (image_ID, &num_layers)); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (SAVE_PROC, &info); gimp_pixpipe_params_init (&gihparams); /* Setup default values */ if (gihparams.rows < 1) gihparams.rows = 1; if (gihparams.cols < 1) gihparams.cols = 1; gihparams.ncells = (num_layers * gihparams.rows * gihparams.cols); if (gihparams.cellwidth == 1 && gihparams.cellheight == 1) { gihparams.cellwidth = gimp_image_width (image_ID) / gihparams.cols; gihparams.cellheight = gimp_image_height (image_ID) / gihparams.rows; } pipe_parasite = gimp_image_get_parasite (orig_image_ID, "gimp-brush-pipe-parameters"); if (pipe_parasite) gimp_pixpipe_params_parse (gimp_parasite_data (pipe_parasite), &gihparams); if (!gih_save_dialog (image_ID)) status = GIMP_PDB_CANCEL; break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 15) { status = GIMP_PDB_CALLING_ERROR; } else { info.spacing = param[5].data.d_int32; strncpy (info.description, param[6].data.d_string, MAXDESCLEN); info.description[MAXDESCLEN] = 0; gimp_pixpipe_params_init (&gihparams); gihparams.cellwidth = param[7].data.d_int32; gihparams.cellheight = param[8].data.d_int32; gihparams.cols = param[9].data.d_int8; gihparams.rows = param[10].data.d_int8; gihparams.dim = param[11].data.d_int32; gihparams.ncells = 1; if (param[13].data.d_int32 != gihparams.dim) { status = GIMP_PDB_CALLING_ERROR; } else { for (i = 0; i < gihparams.dim; i++) { gihparams.rank[i] = param[12].data.d_int8array[i]; gihparams.selection[i] = g_strdup (param[14].data.d_stringarray[i]); gihparams.ncells *= gihparams.rank[i]; } } } break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (SAVE_PROC, &info); pipe_parasite = gimp_image_get_parasite (orig_image_ID, "gimp-brush-pipe-parameters"); gimp_pixpipe_params_init (&gihparams); if (pipe_parasite) gimp_pixpipe_params_parse (gimp_parasite_data (pipe_parasite), &gihparams); break; } if (status == GIMP_PDB_SUCCESS) { if (gih_save_image (param[3].data.d_string, image_ID, orig_image_ID, drawable_ID, &error)) { gimp_set_data (SAVE_PROC, &info, sizeof (info)); } else { status = GIMP_PDB_EXECUTION_ERROR; } } if (export == GIMP_EXPORT_EXPORT) gimp_image_delete (image_ID); } else { status = GIMP_PDB_CALLING_ERROR; } if (status != GIMP_PDB_SUCCESS && error) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = error->message; } values[0].data.d_status = status; } /* load routines */ static gboolean gih_load_one_brush (gint fd, gint32 image_ID) { gchar *name = NULL; BrushHeader bh; guchar *brush_buf = NULL; gint32 layer_ID; GimpDrawable *drawable; GimpPixelRgn pixel_rgn; gint bn_size; GimpImageType image_type; gint width, height; gint new_width, new_height; g_return_val_if_fail (fd != -1, FALSE); g_return_val_if_fail (image_ID != -1, FALSE); if (read (fd, &bh, sizeof (bh)) != sizeof (bh)) return FALSE; /* rearrange the bytes in each unsigned int */ bh.header_size = g_ntohl (bh.header_size); bh.version = g_ntohl (bh.version); bh.width = g_ntohl (bh.width); bh.height = g_ntohl (bh.height); bh.bytes = g_ntohl (bh.bytes); bh.magic_number = g_ntohl (bh.magic_number); bh.spacing = g_ntohl (bh.spacing); if (bh.version == 1) { /* Version 1 didn't know about spacing */ bh.spacing = 25; /* And we need to rewind the handle a bit too */ lseek (fd, -8, SEEK_CUR); } /* Version 1 didn't know about magic either */ if ((bh.version != 1 && (bh.magic_number != GBRUSH_MAGIC || bh.version != 2)) || bh.header_size <= sizeof (bh)) { return FALSE; } if ((bn_size = (bh.header_size - sizeof (bh))) > 0) { name = g_new (gchar, bn_size); if ((read (fd, name, bn_size)) < bn_size) { g_message (_("Error in GIMP brush pipe file.")); g_free (name); return FALSE; } } else { name = g_strdup (_("Unnamed")); } /* Now there's just raw data left. */ brush_buf = g_malloc (bh.width * bh.height * bh.bytes); if (read (fd, brush_buf, bh.width * bh.height * bh.bytes) != bh.width * bh.height * bh.bytes) { g_free (brush_buf); g_free (name); return FALSE; } if (bh.bytes == 1) { PatternHeader ph; /* For backwards-compatibility, check if a pattern follows. The obsolete .gpb format did it this way. */ if (read (fd, &ph, sizeof(ph)) == sizeof(ph)) { /* rearrange the bytes in each unsigned int */ ph.header_size = g_ntohl (ph.header_size); ph.version = g_ntohl (ph.version); ph.width = g_ntohl (ph.width); ph.height = g_ntohl (ph.height); ph.bytes = g_ntohl (ph.bytes); ph.magic_number = g_ntohl (ph.magic_number); if (ph.magic_number == GPATTERN_MAGIC && ph.version == 1 && ph.header_size > sizeof (ph) && ph.bytes == 3 && ph.width == bh.width && ph.height == bh.height && lseek (fd, ph.header_size - sizeof (ph), SEEK_CUR) > 0) { guchar *plain_brush = brush_buf; gint i; bh.bytes = 4; brush_buf = g_malloc (4 * bh.width * bh.height); for (i = 0; i < ph.width * ph.height; i++) { if (read (fd, brush_buf + i * 4, 3) != 3) { g_free (name); g_free (plain_brush); g_free (brush_buf); return FALSE; } brush_buf[i * 4 + 3] = plain_brush[i]; } g_free (plain_brush); } else if (lseek (fd, - ((off_t) sizeof (PatternHeader)), SEEK_CUR) < 0) { g_message (_("GIMP brush file appears to be corrupted.")); g_free (name); g_free (brush_buf); return FALSE; } } } /* * Create a new layer of the proper size. */ switch (bh.bytes) { case 1: image_type = GIMP_GRAY_IMAGE; break; case 4: image_type = GIMP_RGBA_IMAGE; if (gimp_image_base_type (image_ID) == GIMP_GRAY) gimp_image_convert_rgb (image_ID); break; default: g_message ("Unsupported brush depth: %d\n" "GIMP Brushes must be GRAY or RGBA\n", bh.bytes); g_free (name); return FALSE; } new_width = width = gimp_image_width (image_ID); new_height = height = gimp_image_height (image_ID); if (bh.width > width || bh.height > height) { new_width = MAX (width, bh.width); new_height = MAX (height, bh.height); gimp_image_resize (image_ID, new_width, new_height, (width - new_width) / 2, (height - new_height) / 2); } layer_ID = gimp_layer_new (image_ID, name, bh.width, bh.height, image_type, 100, GIMP_NORMAL_MODE); g_free (name); if (layer_ID != -1) { gimp_image_insert_layer (image_ID, layer_ID, -1, num_layers++); gimp_layer_set_offsets (layer_ID, (new_width - bh.width) / 2, (new_height - bh.height) / 2); drawable = gimp_drawable_get (layer_ID); gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width, drawable->height, TRUE, FALSE); gimp_pixel_rgn_set_rect (&pixel_rgn, brush_buf, 0, 0, bh.width, bh.height); if (image_type == GIMP_GRAY_IMAGE) { gimp_invert (layer_ID); } } g_free (brush_buf); return TRUE; } static gint32 gih_load_image (const gchar *filename, GError **error) { gint fd; gint i; gint32 image_ID; GString *buffer; gchar c; gchar *name = NULL; gint num_of_brushes = 0; gchar *paramstring; GimpParasite *pipe_parasite; fd = g_open (filename, O_RDONLY | _O_BINARY, 0); if (fd == -1) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), g_strerror (errno)); return -1; } gimp_progress_init_printf (_("Opening '%s'"), gimp_filename_to_utf8 (filename)); /* The file format starts with a painfully simple text header */ /* get the name */ buffer = g_string_new (NULL); while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024) g_string_append_c (buffer, c); if (buffer->len > 0 && buffer->len < 1024) name = buffer->str; g_string_free (buffer, FALSE); if (!name) { g_message ("Couldn't read name for brush pipe from '%s'", gimp_filename_to_utf8 (filename)); close (fd); return -1; } /* get the number of brushes */ buffer = g_string_new (NULL); while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024) g_string_append_c (buffer, c); if (buffer->len > 0 && buffer->len < 1024) { num_of_brushes = strtol (buffer->str, ¶mstring, 10); } if (num_of_brushes < 1) { g_message ("Brush pipes should have at least one brush."); close (fd); g_free (name); g_string_free (buffer, TRUE); return -1; } image_ID = gimp_image_new (1, 1, GIMP_GRAY); gimp_image_set_filename (image_ID, filename); for (i = 0; i < num_of_brushes; i++) { if (! gih_load_one_brush (fd, image_ID)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", _("Couldn't load one brush in the pipe, giving up.")); close (fd); g_free (name); g_string_free (buffer, TRUE); return -1; } gimp_progress_update ((gdouble) i / (gdouble) num_of_brushes); } while (*paramstring && g_ascii_isspace (*paramstring)) paramstring++; /* Since we do not (yet) load the pipe as described in the header, but use one layer per brush, we have to alter the paramstring before attaching it as a parasite. */ if (*paramstring) { gimp_pixpipe_params_parse (paramstring, &gihparams); gihparams.cellwidth = gimp_image_width (image_ID); gihparams.cellheight = gimp_image_height (image_ID); gihparams.cols = 1; gihparams.rows = 1; paramstring = gimp_pixpipe_params_build (&gihparams); if (paramstring) { pipe_parasite = gimp_parasite_new ("gimp-brush-pipe-parameters", GIMP_PARASITE_PERSISTENT, strlen (paramstring) + 1, paramstring); gimp_image_attach_parasite (image_ID, pipe_parasite); gimp_parasite_free (pipe_parasite); g_free (paramstring); } } g_string_free (buffer, TRUE); return image_ID; } /* save routines */ static void size_adjustment_callback (GtkWidget *widget, gpointer data) { gint i; gint size; gint newn; gchar buf[10]; SizeAdjustmentData *adj = (SizeAdjustmentData *) data; for (i = 0; i < adj->nguides; i++) gimp_image_delete_guide (adj->image, adj->guides[i]); g_free (adj->guides); adj->guides = NULL; gimp_displays_flush (); *(adj->value) = gtk_adjustment_get_value (GTK_ADJUSTMENT (widget)); if (adj->orientation == GIMP_ORIENTATION_VERTICAL) { size = gimp_image_width (adj->image); newn = size / *(adj->value); adj->nguides = newn - 1; adj->guides = g_new (gint32, adj->nguides); for (i = 0; i < adj->nguides; i++) adj->guides[i] = gimp_image_add_vguide (adj->image, *(adj->value) * (i+1)); } else { size = gimp_image_height (adj->image); newn = size / *(adj->value); adj->nguides = newn - 1; adj->guides = g_new (gint32, adj->nguides); for (i = 0; i < adj->nguides; i++) adj->guides[i] = gimp_image_add_hguide (adj->image, *(adj->value) * (i+1)); } gimp_displays_flush (); sprintf (buf, "%2d", newn); gtk_label_set_text (GTK_LABEL (adj->count_label), buf); *(adj->count) = newn; gtk_widget_set_visible (GTK_WIDGET (adj->warning_label), newn * *(adj->value) != size); if (adj->ncells != NULL) gtk_adjustment_set_value (GTK_ADJUSTMENT (adj->ncells), *(adj->other_count) * *(adj->count)); if (adj->rank0 != NULL) gtk_adjustment_set_value (GTK_ADJUSTMENT (adj->rank0), *(adj->other_count) * *(adj->count)); } static void entry_callback (GtkWidget *widget, gpointer data) { if (data == info.description) { strncpy (info.description, gtk_entry_get_text (GTK_ENTRY (widget)), MAXDESCLEN); info.description[MAXDESCLEN] = 0; } } static void cb_callback (GtkWidget *widget, gpointer data) { gint index; index = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)); *((const gchar **) data) = selection_modes [index]; } static void dim_callback (GtkAdjustment *adjustment, SizeAdjustmentData *data) { gint i; gihparams.dim = RINT (gtk_adjustment_get_value (adjustment)); for (i = 0; i < GIMP_PIXPIPE_MAXDIM; i++) { gtk_widget_set_sensitive (data->rank_entry[i], i < gihparams.dim); gtk_widget_set_sensitive (data->mode_entry[i], i < gihparams.dim); } } static gboolean gih_save_dialog (gint32 image_ID) { GtkWidget *dialog; GtkWidget *table; GtkWidget *dimtable; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *entry; GtkWidget *box; GtkWidget *cb; gint i; gchar buffer[100]; SizeAdjustmentData cellw_adjust; SizeAdjustmentData cellh_adjust; gint32 *layer_ID; gint32 nlayers; gboolean run; dialog = gimp_export_dialog_new (_("Brush Pipe"), PLUG_IN_BINARY, SAVE_PROC); /* The main table */ table = gtk_table_new (8, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)), table, TRUE, TRUE, 0); gtk_widget_show (table); /* * Spacing: __ */ spinbutton = gimp_spin_button_new (&adjustment, info.spacing, 1, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Spacing (percent):"), 0.0, 0.5, spinbutton, 1, TRUE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &info.spacing); /* * Description: ___________ */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_text (GTK_ENTRY (entry), info.description); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Description:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (entry_callback), info.description); /* * Cell size: __ x __ pixels */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); spinbutton = gimp_spin_button_new (&adjustment, gihparams.cellwidth, 2, gimp_image_width (image_ID), 1, 10, 0, 1, 0); gtk_box_pack_start (GTK_BOX (box), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); layer_ID = gimp_image_get_layers (image_ID, &nlayers); cellw_adjust.orientation = GIMP_ORIENTATION_VERTICAL; cellw_adjust.image = image_ID; cellw_adjust.toplayer = layer_ID[nlayers-1]; cellw_adjust.nguides = 0; cellw_adjust.guides = NULL; cellw_adjust.value = &gihparams.cellwidth; g_signal_connect (adjustment, "value-changed", G_CALLBACK (size_adjustment_callback), &cellw_adjust); label = gtk_label_new ("x"); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&adjustment, gihparams.cellheight, 2, gimp_image_height (image_ID), 1, 10, 0, 1, 0); gtk_box_pack_start (GTK_BOX (box), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); cellh_adjust.orientation = GIMP_ORIENTATION_HORIZONTAL; cellh_adjust.image = image_ID; cellh_adjust.toplayer = layer_ID[nlayers-1]; cellh_adjust.nguides = 0; cellh_adjust.guides = NULL; cellh_adjust.value = &gihparams.cellheight; g_signal_connect (adjustment, "value-changed", G_CALLBACK (size_adjustment_callback), &cellh_adjust); label = gtk_label_new ( _("Pixels")); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Cell size:"), 0.0, 0.5, box, 1, FALSE); g_free (layer_ID); /* * Number of cells: ___ */ spinbutton = gimp_spin_button_new (&adjustment, gihparams.ncells, 1, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Number of cells:"), 0.0, 0.5, spinbutton, 1, TRUE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &gihparams.ncells); if (gihparams.dim == 1) cellw_adjust.ncells = cellh_adjust.ncells = adjustment; else cellw_adjust.ncells = cellh_adjust.ncells = NULL; /* * Display as: __ rows x __ cols */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_snprintf (buffer, sizeof (buffer), "%2d", gihparams.rows); label = gtk_label_new (buffer); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); cellh_adjust.count_label = label; cellh_adjust.count = &gihparams.rows; cellh_adjust.other_count = &gihparams.cols; gtk_widget_show (label); label = gtk_label_new (_(" Rows of ")); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); g_snprintf (buffer, sizeof (buffer), "%2d", gihparams.cols); label = gtk_label_new (buffer); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); cellw_adjust.count_label = label; cellw_adjust.count = &gihparams.cols; cellw_adjust.other_count = &gihparams.rows; gtk_widget_show (label); label = gtk_label_new (_(" Columns on each layer")); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); label = gtk_label_new (_(" (Width Mismatch!) ")); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); cellw_adjust.warning_label = label; label = gtk_label_new (_(" (Height Mismatch!) ")); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); cellh_adjust.warning_label = label; gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, _("Display as:"), 0.0, 0.5, box, 1, FALSE); /* * Dimension: ___ */ spinbutton = gimp_spin_button_new (&adjustment, gihparams.dim, 1, GIMP_PIXPIPE_MAXDIM, 1, 1, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 5, _("Dimension:"), 0.0, 0.5, spinbutton, 1, TRUE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (dim_callback), &cellw_adjust); /* * Ranks / Selection: ______ ______ ______ ______ ______ */ dimtable = gtk_table_new (2, GIMP_PIXPIPE_MAXDIM, FALSE); gtk_table_set_col_spacings (GTK_TABLE (dimtable), 4); for (i = 0; i < GIMP_PIXPIPE_MAXDIM; i++) { gint j; spinbutton = gimp_spin_button_new (&adjustment, gihparams.rank[i], 1, 100, 1, 1, 0, 1, 0); gtk_table_attach (GTK_TABLE (dimtable), spinbutton, 0, 1, i, i + 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (spinbutton); if (i >= gihparams.dim) gtk_widget_set_sensitive (spinbutton, FALSE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &gihparams.rank[i]); cellw_adjust.rank_entry[i] = cellh_adjust.rank_entry[i] = spinbutton; if (i == 0) { if (gihparams.dim == 1) cellw_adjust.rank0 = cellh_adjust.rank0 = adjustment; else cellw_adjust.rank0 = cellh_adjust.rank0 = NULL; } cb = gtk_combo_box_text_new (); for (j = 0; j < G_N_ELEMENTS (selection_modes); j++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), selection_modes[j]); gtk_combo_box_set_active (GTK_COMBO_BOX (cb), 2); /* random */ if (gihparams.selection[i]) for (j = 0; j < G_N_ELEMENTS (selection_modes); j++) if (!strcmp (gihparams.selection[i], selection_modes[j])) { gtk_combo_box_set_active (GTK_COMBO_BOX (cb), j); break; } gtk_table_attach (GTK_TABLE (dimtable), cb, 1, 2, i, i + 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (cb); if (i >= gihparams.dim) gtk_widget_set_sensitive (cb, FALSE); g_signal_connect (GTK_COMBO_BOX (cb), "changed", G_CALLBACK (cb_callback), &gihparams.selection[i]); cellw_adjust.mode_entry[i] = cellh_adjust.mode_entry[i] = cb; } gimp_table_attach_aligned (GTK_TABLE (table), 0, 6, _("Ranks:"), 0.0, 0.0, dimtable, 1, FALSE); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { gint i; for (i = 0; i < GIMP_PIXPIPE_MAXDIM; i++) gihparams.selection[i] = g_strdup (gihparams.selection[i]); /* Fix up bogus values */ gihparams.ncells = MIN (gihparams.ncells, num_layers * gihparams.rows * gihparams.cols); } gtk_widget_destroy (dialog); for (i = 0; i < cellw_adjust.nguides; i++) gimp_image_delete_guide (image_ID, cellw_adjust.guides[i]); for (i = 0; i < cellh_adjust.nguides; i++) gimp_image_delete_guide (image_ID, cellh_adjust.guides[i]); return run; } static gboolean gih_save_one_brush (gint fd, GimpPixelRgn *pixel_rgn, const gchar *name) { BrushHeader header; guchar *buffer; guint y; g_return_val_if_fail (fd != -1, FALSE); g_return_val_if_fail (pixel_rgn != NULL, FALSE); if (pixel_rgn->w < 1 || pixel_rgn->h < 1) return FALSE; if (! name) name = _("Unnamed"); header.header_size = g_htonl (sizeof (header) + strlen (name) + 1); header.version = g_htonl (2); header.width = g_htonl (pixel_rgn->w); header.height = g_htonl (pixel_rgn->h); header.bytes = g_htonl (pixel_rgn->bpp > 2 ? 4 : 1); header.magic_number = g_htonl (GBRUSH_MAGIC); header.spacing = g_htonl (info.spacing); if (write (fd, &header, sizeof (header)) != sizeof (header)) return FALSE; if (write (fd, name, strlen (name) + 1) != strlen (name) + 1) return FALSE; buffer = g_malloc (pixel_rgn->w * pixel_rgn->bpp); for (y = 0; y < pixel_rgn->h; y++) { guint x; gimp_pixel_rgn_get_row (pixel_rgn, buffer, 0 + pixel_rgn->x, y + pixel_rgn->y, pixel_rgn->w); switch (pixel_rgn->bpp) { case 1: /* GRAY */ for (x = 0; x < pixel_rgn->w; x++) { const guchar value = 255 - buffer[x]; if (write (fd, &value, 1) != 1) { g_free (buffer); return FALSE; } } break; case 2: /* GRAYA, alpha channel is ignored */ for (x = 0; x < pixel_rgn->w; x++) { const guchar value = 255 - buffer[2 * x]; if (write (fd, &value, 1) != 1) { g_free (buffer); return FALSE; } } break; case 3: /* RGB, alpha channel is added */ for (x = 0; x < pixel_rgn->w; x++) { guchar value[4]; value[0] = buffer[3 * x + 0]; value[1] = buffer[3 * x + 1]; value[2] = buffer[3 * x + 2]; value[3] = 255; if (write (fd, value, 4) != 4) { g_free (buffer); return FALSE; } } break; case 4: /* RGBA */ if (write (fd, buffer, pixel_rgn->w * pixel_rgn->bpp) != pixel_rgn->w * pixel_rgn->bpp) { g_free (buffer); return FALSE; } break; default: g_assert_not_reached (); break; } } g_free (buffer); return TRUE; } static gboolean gih_save_image (const gchar *filename, gint32 image_ID, gint32 orig_image_ID, gint32 drawable_ID, GError **error) { GimpParasite *pipe_parasite; gchar *header; gchar *parstring; gint32 *layer_ID; gint fd; gint nlayers, layer; gint row, col; gint imagew, imageh; gint offsetx, offsety; gint k; if (gihparams.ncells < 1) return FALSE; imagew = gimp_image_width (image_ID); imageh = gimp_image_height (image_ID); gimp_tile_cache_size (gimp_tile_height () * imagew * 4); fd = g_open (filename, O_CREAT | O_TRUNC | O_WRONLY | _O_BINARY, 0666); if (fd == -1) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for writing: %s"), gimp_filename_to_utf8 (filename), g_strerror (errno)); return FALSE; } gimp_progress_init_printf (_("Saving '%s'"), gimp_filename_to_utf8 (filename)); parstring = gimp_pixpipe_params_build (&gihparams); header = g_strdup_printf ("%s\n%d %s\n", info.description, gihparams.ncells, parstring); if (write (fd, header, strlen (header)) != strlen (header)) { g_free (parstring); g_free (header); close (fd); return FALSE; } g_free (header); pipe_parasite = gimp_parasite_new ("gimp-brush-pipe-parameters", GIMP_PARASITE_PERSISTENT, strlen (parstring) + 1, parstring); gimp_image_attach_parasite (orig_image_ID, pipe_parasite); gimp_parasite_free (pipe_parasite); g_free (parstring); layer_ID = gimp_image_get_layers (image_ID, &nlayers); for (layer = 0, k = 0; layer < nlayers; layer++) { GimpDrawable *drawable = gimp_drawable_get (layer_ID[layer]); gchar *name = gimp_item_get_name (drawable->drawable_id); gimp_drawable_offsets (drawable->drawable_id, &offsetx, &offsety); for (row = 0; row < gihparams.rows; row++) { gint y, ynext; gint thisy, thish; y = (row * imageh) / gihparams.rows; ynext = ((row + 1) * imageh / gihparams.rows); /* Assume layer is offset to positive direction in x and y. * That's reasonable, as otherwise all of the layer * won't be visible. * thisy and thisx are in the drawable's coordinate space. */ thisy = MAX (0, y - offsety); thish = (ynext - offsety) - thisy; thish = MIN (thish, drawable->height - thisy); for (col = 0; col < gihparams.cols; col++) { GimpPixelRgn pixel_rgn; gint x, xnext; gint thisx, thisw; x = (col * imagew / gihparams.cols); xnext = ((col + 1) * imagew / gihparams.cols); thisx = MAX (0, x - offsetx); thisw = (xnext - offsetx) - thisx; thisw = MIN (thisw, drawable->width - thisx); gimp_pixel_rgn_init (&pixel_rgn, drawable, thisx, thisy, thisw, thish, FALSE, FALSE); if (! gih_save_one_brush (fd, &pixel_rgn, name)) { close (fd); return FALSE; } k++; gimp_progress_update ((gdouble) k / gihparams.ncells); } } g_free (name); gimp_drawable_detach (drawable); } gimp_progress_update (1.0); g_free (layer_ID); close (fd); return TRUE; }