dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/gimpressionist/presets.c

1103 lines
32 KiB
C
Raw Permalink Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <glib/gstdio.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "gimpressionist.h"
#include "presets.h"
#include "color.h"
#include "general.h"
#include "orientation.h"
#include "placement.h"
#include "size.h"
#include "libgimp/stdplugins-intl.h"
#ifdef G_OS_WIN32
#include "libgimpbase/gimpwin32-io.h"
#endif
#define PRESETMAGIC "Preset"
static GtkWidget *presetnameentry = NULL;
static GtkWidget *presetlist = NULL;
static GtkWidget *presetdesclabel = NULL;
static GtkWidget *presetsavebutton = NULL;
static GtkWidget *delete_button = NULL;
static GtkListStore *store = NULL;
static gchar *selected_preset_orig_name = NULL;
static gchar *selected_preset_filename = NULL;
static gboolean
can_delete_preset (const gchar *abs)
{
gchar *user_data_dir;
gboolean ret;
user_data_dir = g_strconcat (gimp_directory (),
G_DIR_SEPARATOR_S,
NULL);
ret = (!strncmp (abs, user_data_dir, strlen (user_data_dir)));
g_free (user_data_dir);
return ret;
}
void
preset_save_button_set_sensitive (gboolean s)
{
if (GTK_IS_WIDGET (presetsavebutton))
gtk_widget_set_sensitive (GTK_WIDGET (presetsavebutton), s);
}
void
preset_free (void)
{
g_free (selected_preset_orig_name);
g_free (selected_preset_filename);
}
static void set_preset_description_text (const gchar *text)
{
gtk_label_set_text (GTK_LABEL (presetdesclabel), text);
}
static char presetdesc[4096] = "";
static const char *factory_defaults = "<Factory defaults>";
static gchar *
get_early_line_from_preset (gchar *full_path, const gchar *prefix)
{
FILE *f;
gchar line[4096];
gint prefix_len, line_idx;
prefix_len = strlen (prefix);
f = g_fopen (full_path, "rt");
if (f)
{
/* Skip the preset magic. */
fgets (line, 10, f);
if (!strncmp (line, PRESETMAGIC, 4))
{
for (line_idx = 0; line_idx < 5; line_idx++)
{
if (!fgets (line, sizeof (line), f))
break;
g_strchomp (line);
if (!strncmp (line, prefix, prefix_len))
{
fclose(f);
return g_strdup (line+prefix_len);
}
}
}
fclose (f);
}
return NULL;
}
static gchar *
get_object_name (const gchar *dir,
gchar *filename,
void *context)
{
gchar *ret = NULL, *unprocessed_line = NULL;
gchar *full_path = NULL;
/* First try to extract the object's name (= user-friendly description)
* from the preset file
* */
full_path = g_build_filename (dir, filename, NULL);
unprocessed_line = get_early_line_from_preset (full_path, "name=");
if (unprocessed_line)
{
ret = g_strcompress (unprocessed_line);
g_free (unprocessed_line);
}
else
{
/* The object name defaults to a filename-derived description */
ret = g_filename_display_basename (full_path);
}
g_free (full_path);
return ret;
}
static void
preset_read_dir_into_list (void)
{
readdirintolist_extended ("Presets", presetlist, NULL, TRUE,
get_object_name, NULL);
}
static gchar *
preset_create_filename (const gchar *basename,
const gchar *dest_dir)
{
gchar *fullpath;
gchar *safe_name;
gint i;
gint unum = 1;
g_return_val_if_fail (basename != NULL, NULL);
g_return_val_if_fail (dest_dir != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (dest_dir), NULL);
safe_name = g_filename_from_utf8 (basename, -1, NULL, NULL, NULL);
if (safe_name[0] == '.')
safe_name[0] = '-';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || g_ascii_isspace (safe_name[i]))
safe_name[i] = '-';
fullpath = g_build_filename (dest_dir, safe_name, NULL);
while (g_file_test (fullpath, G_FILE_TEST_EXISTS))
{
gchar *filename;
g_free (fullpath);
filename = g_strdup_printf ("%s-%d", safe_name, unum++);
fullpath = g_build_filename (dest_dir, filename, NULL);
g_free (filename);
}
g_free (safe_name);
return fullpath;
}
static void
add_factory_defaults (void)
{
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
/* Set the filename. */
gtk_list_store_set (store, &iter, PRESETS_LIST_COLUMN_FILENAME,
factory_defaults, -1);
/* Set the object name. */
gtk_list_store_set (store, &iter, PRESETS_LIST_COLUMN_OBJECT_NAME,
factory_defaults, -1);
}
static void
preset_refresh_presets (void)
{
gtk_list_store_clear (store);
add_factory_defaults ();
preset_read_dir_into_list ();
}
static int
load_old_preset (const gchar *fname)
{
FILE *f;
int len;
f = g_fopen (fname, "rb");
if (!f)
{
g_printerr ("Error opening file \"%s\" for reading!\n",
gimp_filename_to_utf8 (fname));
return -1;
}
len = fread (&pcvals, 1, sizeof (pcvals), f);
fclose (f);
return (len != sizeof (pcvals)) ? -1 : 0;
}
static unsigned int
hexval (char c)
{
c = g_ascii_tolower (c);
if ((c >= 'a') && (c <= 'f'))
return c - 'a' + 10;
if ((c >= '0') && (c <= '9'))
return c - '0';
return 0;
}
static char *
parse_rgb_string (const gchar *s)
{
static char col[3];
col[0] = (hexval (s[0]) << 4) | hexval (s[1]);
col[1] = (hexval (s[2]) << 4) | hexval (s[3]);
col[2] = (hexval (s[4]) << 4) | hexval (s[5]);
return col;
}
static void
set_orient_vector (const gchar *str)
{
const gchar *tmps = str;
int n;
n = atoi (tmps);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].x = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].y = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].dir = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].dx = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].dy = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].str = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.orient_vectors[n].type = atoi (++tmps);
}
static void set_size_vector (const gchar *str)
{
const gchar *tmps = str;
int n;
n = atoi (tmps);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.size_vectors[n].x = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.size_vectors[n].y = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.size_vectors[n].siz = g_ascii_strtod (++tmps, NULL);
if (!(tmps = strchr (tmps, ',')))
return;
pcvals.size_vectors[n].str = g_ascii_strtod (++tmps, NULL);
}
static void
parse_desc (const gchar *str, gchar *d, gssize d_len)
{
gchar *dest = g_strcompress (str);
g_strlcpy (d, dest, d_len);
g_free (dest);
}
static void
set_values (const gchar *key, const gchar *val)
{
if (!strcmp (key, "desc"))
parse_desc (val, presetdesc, sizeof (presetdesc));
else if (!strcmp (key, "orientnum"))
pcvals.orient_num = atoi (val);
else if (!strcmp (key, "orientfirst"))
pcvals.orient_first = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "orientlast"))
pcvals.orient_last = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "orienttype"))
pcvals.orient_type = orientation_type_input (atoi (val));
else if (!strcmp (key, "sizenum"))
pcvals.size_num = atoi (val);
else if (!strcmp (key, "sizefirst"))
pcvals.size_first = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "sizelast"))
pcvals.size_last = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "sizetype"))
pcvals.size_type = size_type_input (atoi (val));
else if (!strcmp (key, "brushrelief"))
pcvals.brush_relief = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "brushscale"))
{
/* For compatibility */
pcvals.size_num = 1;
pcvals.size_first = pcvals.size_last = g_ascii_strtod (val, NULL);
}
else if (!strcmp (key, "brushdensity"))
pcvals.brush_density = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "brushgamma"))
pcvals.brushgamma = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "brushaspect"))
pcvals.brush_aspect = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "generalbgtype"))
pcvals.general_background_type = general_bg_type_input (atoi (val));
else if (!strcmp (key, "generaldarkedge"))
pcvals.general_dark_edge = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "generalpaintedges"))
pcvals.general_paint_edges = atoi (val);
else if (!strcmp (key, "generaltileable"))
pcvals.general_tileable = atoi (val);
else if (!strcmp (key, "generaldropshadow"))
pcvals.general_drop_shadow = atoi (val);
else if (!strcmp (key, "generalshadowdarkness"))
pcvals.general_shadow_darkness = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "generalshadowdepth"))
pcvals.general_shadow_depth = atoi (val);
else if (!strcmp (key, "generalshadowblur"))
pcvals.general_shadow_blur = atoi (val);
else if (!strcmp (key, "devthresh"))
pcvals.devthresh = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "paperrelief"))
pcvals.paper_relief = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "paperscale"))
pcvals.paper_scale = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "paperinvert"))
pcvals.paper_invert = atoi (val);
else if (!strcmp (key, "paperoverlay"))
pcvals.paper_overlay = atoi (val);
else if (!strcmp (key, "placetype"))
pcvals.place_type = place_type_input (atoi (val));
else if (!strcmp (key, "placecenter"))
pcvals.placement_center = atoi (val);
else if (!strcmp (key, "selectedbrush"))
g_strlcpy (pcvals.selected_brush, val, sizeof (pcvals.selected_brush));
else if (!strcmp (key, "selectedpaper"))
g_strlcpy (pcvals.selected_paper, val, sizeof (pcvals.selected_paper));
else if (!strcmp (key, "color"))
{
char *c = parse_rgb_string (val);
if (pcvals.color == NULL)
pcvals.color = gegl_color_new (NULL);
gegl_color_set_pixel (pcvals.color, babl_format ("R'G'B' u8"), c);
}
else if (!strcmp (key, "numorientvector"))
pcvals.num_orient_vectors = atoi (val);
else if (!strcmp (key, "orientvector"))
set_orient_vector (val);
else if (!strcmp (key, "orientangoff"))
pcvals.orient_angle_offset = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "orientstrexp"))
pcvals.orient_strength_exponent = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "orientvoronoi"))
pcvals.orient_voronoi = atoi (val);
else if (!strcmp (key, "numsizevector"))
pcvals.num_size_vectors = atoi (val);
else if (!strcmp (key, "sizevector"))
set_size_vector (val);
else if (!strcmp (key, "sizestrexp"))
pcvals.size_strength_exponent = g_ascii_strtod (val, NULL);
else if (!strcmp (key, "sizevoronoi"))
pcvals.size_voronoi = atoi (val);
else if (!strcmp (key, "colortype"))
pcvals.color_type = color_type_input (atoi (val));
else if (!strcmp (key, "colornoise"))
pcvals.color_noise = g_ascii_strtod (val, NULL);
}
static int
load_preset (const gchar *fn)
{
char line[1024] = "";
FILE *f;
f = g_fopen (fn, "rt");
if (!f)
{
g_printerr ("Error opening file \"%s\" for reading!\n",
gimp_filename_to_utf8 (fn));
return -1;
}
fgets (line, 10, f);
if (strncmp (line, PRESETMAGIC, 4))
{
fclose (f);
return load_old_preset (fn);
}
restore_default_values ();
while (!feof (f))
{
char *tmps;
if (!fgets (line, 1024, f))
break;
g_strchomp (line);
tmps = strchr (line, '=');
if (!tmps)
continue;
*tmps = '\0';
tmps++;
set_values (line, tmps);
}
fclose (f);
return 0;
}
int
select_preset (const gchar *preset)
{
int ret = SELECT_PRESET_OK;
/* I'm copying this behavior as is. As it seems applying the
* factory_defaults preset does nothing, which I'm not sure
* if that was what the author intended.
* -- Shlomi Fish
*/
if (strcmp (preset, factory_defaults))
{
gchar *rel = g_build_filename ("Presets", preset, NULL);
gchar *abs = findfile (rel);
g_free (rel);
if (abs)
{
if (load_preset (abs))
ret = SELECT_PRESET_LOAD_FAILED;
g_free (abs);
}
else
{
ret = SELECT_PRESET_FILE_NOT_FOUND;
}
}
if (ret == SELECT_PRESET_OK)
{
/* This is so the colorbrushes param (that is not stored in the
* preset will be set correctly upon the preset loading.
* */
set_colorbrushes (pcvals.selected_brush);
}
return ret;
}
static void
apply_preset (GtkWidget *w, GtkTreeSelection *selection)
{
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gchar *preset;
gtk_tree_model_get (model, &iter, PRESETS_LIST_COLUMN_FILENAME,
&preset, -1);
select_preset (preset);
restore_values ();
/* g_free (preset); */
g_free (selected_preset_filename);
selected_preset_filename = preset;
}
}
static void
delete_preset (GtkWidget *w, GtkTreeSelection *selection)
{
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gchar *preset;
gtk_tree_model_get (model, &iter, PRESETS_LIST_COLUMN_FILENAME,
&preset, -1);
if (preset)
{
gchar *rel = g_build_filename ("Presets", preset, NULL);
gchar *abs = findfile (rel);
g_free (rel);
if (abs)
{
/* Don't delete global presets - bug # 147483 */
if (can_delete_preset (abs))
g_unlink (abs);
g_free (abs);
}
preset_refresh_presets ();
g_free (preset);
}
}
}
static void save_preset (void);
static void
preset_desc_callback (GtkTextBuffer *buffer, gpointer data)
{
char *str;
GtkTextIter start, end;
gtk_text_buffer_get_bounds (buffer, &start, &end);
str = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
g_strlcpy (presetdesc, str, sizeof (presetdesc));
g_free (str);
}
static void
save_preset_response (GtkWidget *widget,
gint response_id,
gpointer data)
{
gtk_widget_destroy (widget);
if (response_id == GTK_RESPONSE_OK)
save_preset ();
}
static void
create_save_preset (GtkWidget *parent)
{
static GtkWidget *window = NULL;
GtkWidget *box, *label;
GtkWidget *swin, *text;
GtkTextBuffer *buffer;
if (window)
{
gtk_window_present (GTK_WINDOW (window));
return;
}
window = gimp_dialog_new (_("Save Current"), PLUG_IN_ROLE,
gtk_widget_get_toplevel (parent), 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (window),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (window, "response",
G_CALLBACK (save_preset_response),
NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
box, TRUE, TRUE, 0);
gtk_widget_show (box);
label = gtk_label_new (_("Description:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_widget_show (label);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (box), swin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (swin);
buffer = gtk_text_buffer_new (NULL);
g_signal_connect (buffer, "changed",
G_CALLBACK (preset_desc_callback), NULL);
gtk_text_buffer_set_text (buffer, presetdesc, -1);
text = gtk_text_view_new_with_buffer (buffer);
gtk_widget_set_size_request (text, -1, 192);
gtk_container_add (GTK_CONTAINER (swin), text);
gtk_widget_show (text);
gtk_widget_show (window);
}
static void
save_preset (void)
{
const gchar *preset_name;
gchar *fname, *presets_dir_path;
FILE *f;
GList *thispath;
gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
gchar vbuf[6][G_ASCII_DTOSTR_BUF_SIZE];
guchar color[3];
gint i;
gchar *desc_escaped, *preset_name_escaped;
preset_name = gtk_entry_get_text (GTK_ENTRY (presetnameentry));
thispath = parsepath ();
store_values ();
if (!thispath)
{
g_printerr ("Internal error: (save_preset) thispath == NULL\n");
return;
}
/* Create the ~/.gimp-$VER/gimpressionist/Presets directory if
* it doesn't already exists.
*
*/
presets_dir_path = g_build_filename ((const gchar *) thispath->data,
"Presets",
NULL);
if (! g_file_test (presets_dir_path, G_FILE_TEST_IS_DIR))
{
if (g_mkdir (presets_dir_path,
S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP |
S_IROTH | S_IXOTH) == -1)
{
g_printerr ("Error creating folder \"%s\"!\n",
gimp_filename_to_utf8 (presets_dir_path));
g_free (presets_dir_path);
return;
}
}
/* Check if the user-friendly name has changed. If so, then save it
* under a new file. If not - use the same file name.
*/
if (selected_preset_orig_name &&
strcmp (preset_name, selected_preset_orig_name) == 0)
{
fname = g_build_filename (presets_dir_path,
selected_preset_filename,
NULL);
}
else
{
fname = preset_create_filename (preset_name, presets_dir_path);
}
g_free (presets_dir_path);
if (!fname)
{
g_printerr ("Error building a filename for preset \"%s\"!\n",
preset_name);
return;
}
f = g_fopen (fname, "wt");
if (!f)
{
g_printerr ("Error opening file \"%s\" for writing!\n",
gimp_filename_to_utf8 (fname));
g_free (fname);
return;
}
fprintf (f, "%s\n", PRESETMAGIC);
desc_escaped = g_strescape (presetdesc, NULL);
fprintf (f, "desc=%s\n", desc_escaped);
g_free (desc_escaped);
preset_name_escaped = g_strescape (preset_name, NULL);
fprintf (f, "name=%s\n", preset_name_escaped);
g_free (preset_name_escaped);
fprintf (f, "orientnum=%d\n", pcvals.orient_num);
fprintf (f, "orientfirst=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_first));
fprintf (f, "orientlast=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_last));
fprintf (f, "orienttype=%d\n", pcvals.orient_type);
fprintf (f, "sizenum=%d\n", pcvals.size_num);
fprintf (f, "sizefirst=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_first));
fprintf (f, "sizelast=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_last));
fprintf (f, "sizetype=%d\n", pcvals.size_type);
fprintf (f, "brushrelief=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.brush_relief));
fprintf (f, "brushdensity=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.brush_density));
fprintf (f, "brushgamma=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.brushgamma));
fprintf (f, "brushaspect=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.brush_aspect));
fprintf (f, "generalbgtype=%d\n", pcvals.general_background_type);
fprintf (f, "generaldarkedge=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.general_dark_edge));
fprintf (f, "generalpaintedges=%d\n", pcvals.general_paint_edges);
fprintf (f, "generaltileable=%d\n", pcvals.general_tileable);
fprintf (f, "generaldropshadow=%d\n", pcvals.general_drop_shadow);
fprintf (f, "generalshadowdarkness=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.general_shadow_darkness));
fprintf (f, "generalshadowdepth=%d\n", pcvals.general_shadow_depth);
fprintf (f, "generalshadowblur=%d\n", pcvals.general_shadow_blur);
fprintf (f, "devthresh=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.devthresh));
fprintf (f, "paperrelief=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.paper_relief));
fprintf (f, "paperscale=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.paper_scale));
fprintf (f, "paperinvert=%d\n", pcvals.paper_invert);
fprintf (f, "paperoverlay=%d\n", pcvals.paper_overlay);
fprintf (f, "selectedbrush=%s\n", pcvals.selected_brush);
fprintf (f, "selectedpaper=%s\n", pcvals.selected_paper);
gegl_color_get_pixel (pcvals.color, babl_format ("R'G'B' u8"), color);
fprintf (f, "color=%02x%02x%02x\n", color[0], color[1], color[2]);
fprintf (f, "placetype=%d\n", pcvals.place_type);
fprintf (f, "placecenter=%d\n", pcvals.placement_center);
fprintf (f, "numorientvector=%d\n", pcvals.num_orient_vectors);
for (i = 0; i < pcvals.num_orient_vectors; i++)
{
g_ascii_dtostr (vbuf[0], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].x);
g_ascii_dtostr (vbuf[1], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].y);
g_ascii_dtostr (vbuf[2], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].dir);
g_ascii_dtostr (vbuf[3], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].dx);
g_ascii_dtostr (vbuf[4], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].dy);
g_ascii_dtostr (vbuf[5], G_ASCII_DTOSTR_BUF_SIZE, pcvals.orient_vectors[i].str);
fprintf (f, "orientvector=%d,%s,%s,%s,%s,%s,%s,%d\n", i,
vbuf[0], vbuf[1], vbuf[2], vbuf[3], vbuf[4], vbuf[5],
pcvals.orient_vectors[i].type);
}
fprintf (f, "orientangoff=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
pcvals.orient_angle_offset));
fprintf (f, "orientstrexp=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
pcvals.orient_strength_exponent));
fprintf (f, "orientvoronoi=%d\n", pcvals.orient_voronoi);
fprintf (f, "numsizevector=%d\n", pcvals.num_size_vectors);
for (i = 0; i < pcvals.num_size_vectors; i++)
{
g_ascii_dtostr (vbuf[0], G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_vectors[i].x);
g_ascii_dtostr (vbuf[1], G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_vectors[i].y);
g_ascii_dtostr (vbuf[2], G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_vectors[i].siz);
g_ascii_dtostr (vbuf[3], G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_vectors[i].str);
fprintf (f, "sizevector=%d,%s,%s,%s,%s\n", i,
vbuf[0], vbuf[1], vbuf[2], vbuf[3]);
}
fprintf (f, "sizestrexp=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.size_strength_exponent));
fprintf (f, "sizevoronoi=%d\n", pcvals.size_voronoi);
fprintf (f, "colortype=%d\n", pcvals.color_type);
fprintf (f, "colornoise=%s\n",
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, pcvals.color_noise));
fclose (f);
preset_refresh_presets ();
reselect (presetlist, fname);
g_free (fname);
}
static void
read_description (const char *fn)
{
char *rel_fname;
char *fname;
gchar *unprocessed_line;
rel_fname = g_build_filename ("Presets", fn, NULL);
fname = findfile (rel_fname);
g_free (rel_fname);
if (!fname)
{
if (!strcmp (fn, factory_defaults))
{
gtk_widget_set_sensitive (delete_button, FALSE);
set_preset_description_text (_("Gimpressionist Defaults"));
}
else
{
set_preset_description_text ("");
}
return;
}
/* Don't delete global presets - bug # 147483 */
gtk_widget_set_sensitive (delete_button, can_delete_preset (fname));
unprocessed_line = get_early_line_from_preset (fname, "desc=");
g_free (fname);
if (unprocessed_line)
{
char tmplabel[4096];
parse_desc (unprocessed_line, tmplabel, sizeof (tmplabel));
g_free (unprocessed_line);
set_preset_description_text (tmplabel);
}
else
{
set_preset_description_text ("");
}
}
static void
presets_list_select_preset (GtkTreeSelection *selection,
gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gchar *preset_name;
gchar *preset_filename;
gtk_tree_model_get (model, &iter, PRESETS_LIST_COLUMN_OBJECT_NAME,
&preset_name, -1);
gtk_tree_model_get (model, &iter, PRESETS_LIST_COLUMN_FILENAME,
&preset_filename, -1);
/* TODO : Maybe make the factory defaults behavior in regards
* to the preset's object name and filename more robust?
*
*/
if (strcmp (preset_filename, factory_defaults))
{
gtk_entry_set_text (GTK_ENTRY (presetnameentry), preset_name);
g_free (selected_preset_orig_name);
g_free (selected_preset_filename);
selected_preset_orig_name = g_strdup (preset_name);
selected_preset_filename = g_strdup (selected_preset_filename);
}
read_description (preset_filename);
g_free (preset_name);
g_free (preset_filename);
}
}
static GtkWidget *
create_presets_list (GtkWidget *parent)
{
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *swin, *view;
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (parent), swin, FALSE, FALSE, 0);
gtk_widget_show (swin);
gtk_widget_set_size_request (swin, 200, -1);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
g_object_unref (store);
gtk_widget_show (view);
renderer = gtk_cell_renderer_text_new ();
column =
gtk_tree_view_column_new_with_attributes ("Preset", renderer,
"text",
PRESETS_LIST_COLUMN_OBJECT_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
gtk_container_add (GTK_CONTAINER (swin), view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (presets_list_select_preset),
NULL);
return view;
}
void
create_presetpage (GtkNotebook *notebook)
{
GtkWidget *vbox, *hbox, *box1, *box2, *thispage;
GtkWidget *view;
GtkWidget *tmpw;
GtkWidget *label;
GtkTreeSelection *selection;
label = gtk_label_new_with_mnemonic (_("_Presets"));
thispage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (thispage), 12);
gtk_widget_show (thispage);
box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (thispage), box1, FALSE, FALSE, 0);
gtk_widget_show (box1);
presetnameentry = tmpw = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box1), tmpw, FALSE, FALSE, 0);
gtk_widget_set_size_request (tmpw, 200, -1);
gtk_widget_show (tmpw);
presetsavebutton = tmpw = gtk_button_new_with_label ( _("Save Current..."));
gtk_button_set_image (GTK_BUTTON (presetsavebutton),
gtk_image_new_from_icon_name (GIMP_ICON_DOCUMENT_SAVE,
GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start (GTK_BOX (box1), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (create_save_preset), NULL);
gimp_help_set_help_data
(tmpw, _("Save the current settings to the specified file"), NULL);
box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (thispage), box1, TRUE, TRUE, 0);
gtk_widget_show (box1);
presetlist = view = create_presets_list (box1);
store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
add_factory_defaults ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (box1), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
tmpw = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (apply_preset), selection);
gimp_help_set_help_data
(tmpw, _("Reads the selected Preset into memory"), NULL);
tmpw = delete_button = gtk_button_new_with_mnemonic (_("_Delete"));
gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE,0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (delete_preset), selection);
gimp_help_set_help_data (tmpw, _("Deletes the selected Preset"), NULL);
tmpw = gtk_button_new_with_mnemonic (_("_Refresh"));
gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE,0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (preset_refresh_presets), NULL);
gimp_help_set_help_data (tmpw, _("Reread the folder of Presets"), NULL);
presetdesclabel = tmpw = gtk_label_new (NULL);
gimp_label_set_attributes (GTK_LABEL (tmpw),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_label_set_line_wrap (GTK_LABEL (tmpw), TRUE);
/*
* Make sure the label's width is reasonable and it won't stretch
* the dialog more than its width.
* */
gtk_widget_set_size_request (tmpw, 240, -1);
gtk_label_set_xalign (GTK_LABEL (tmpw), 0.0);
gtk_label_set_yalign (GTK_LABEL (tmpw), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), tmpw, TRUE, TRUE, 0);
gtk_widget_show (tmpw);
preset_read_dir_into_list ();
gtk_notebook_append_page_menu (notebook, thispage, label, NULL);
}
Reference in New Issue View Git Blame Copy Permalink