From e494bbd557005d841cc7afee508218a862d5d759 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Tue, 18 May 1999 17:33:39 +0000 Subject: [PATCH] store resolution values as doubles, not floats. 1999-05-18 Michael Natterer * app/app_procs.c (and many of the files below): store resolution values as doubles, not floats. * app/brush_select.c * app/pattern_select.c: hide the "refresh" button in client dialogs. Don't know if this is desired but it fixes a SEGV. * app/file_new_dialog.c: New ui using code/ideas from Austin, Marco and Nick. The "size" frame is still a bit bloated but I didn't want to reduce it's functionality right now. It's closer to the result of the last discussion but not perfect yet... Added a dialog to confirm image sizes larger than the new max_new_image_size value. The new "reset" button uses the values from gimprc. Removed some #include's, added the copyright header. * app/gimprc.[ch]: new rc variable max_new_image_size. * app/preferences_dialog.c: added the "max image size" option. Generalized the mem size unit code. * app/resize.c: an additional box lets the offset widget always shrink correctly. * app/text_tool.c: fixed a minor memory leak. * libgimp/Makefile.am: add all widgets to libgimpui.* * libgimp/gimpfileselection.c: cosmetic changes. * libgimp/gimplimits.h: a maximum image size which should satisfy everybody ;) * libgimp/gimpsizeentry.c: allow the creation of sizeentries without fields. This (finally) enables arbitrary layout of the spinbuttons. * plug-ins/script-fu/script-fu-scripts.c: use the fileselection widget for script parameter SF_FILENAME. --- ChangeLog | 48 +- app/app_procs.c | 6 +- app/brush_select.c | 5 +- app/dialogs/image-new-dialog.c | 905 +++++++++++++++-------- app/dialogs/preferences-dialog.c | 233 ++++-- app/dialogs/resize-dialog.c | 7 +- app/file_new_dialog.c | 905 +++++++++++++++-------- app/gimprc.c | 34 +- app/gimprc.h | 9 +- app/gui/brush-select.c | 5 +- app/gui/file-new-dialog.c | 905 +++++++++++++++-------- app/gui/pattern-select.c | 5 +- app/gui/preferences-dialog.c | 233 ++++-- app/gui/resize-dialog.c | 7 +- app/pattern_select.c | 5 +- app/preferences_dialog.c | 233 ++++-- app/resize.c | 7 +- app/text_tool.c | 8 +- app/tools/gimptexttool.c | 8 +- app/tools/text_tool.c | 8 +- libgimp/Makefile.am | 7 +- libgimp/gimpfileselection.c | 14 +- libgimp/gimplimits.h | 2 +- libgimp/gimpsizeentry.c | 2 +- libgimpbase/gimplimits.h | 2 +- libgimpwidgets/gimpfileentry.c | 14 +- libgimpwidgets/gimpfileselection.c | 14 +- libgimpwidgets/gimpsizeentry.c | 2 +- plug-ins/script-fu/script-fu-interface.c | 144 +--- plug-ins/script-fu/script-fu-scripts.c | 144 +--- 30 files changed, 2525 insertions(+), 1396 deletions(-) diff --git a/ChangeLog b/ChangeLog index 0c1cf4d987..7eb54c2ec6 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,45 @@ +1999-05-18 Michael Natterer + + * app/app_procs.c (and many of the files below): store resolution + values as doubles, not floats. + + * app/brush_select.c + * app/pattern_select.c: hide the "refresh" button in client + dialogs. Don't know if this is desired but it fixes a SEGV. + + * app/file_new_dialog.c: New ui using code/ideas from Austin, + Marco and Nick. The "size" frame is still a bit bloated but I + didn't want to reduce it's functionality right now. It's closer to + the result of the last discussion but not perfect yet... + Added a dialog to confirm image sizes larger than the new + max_new_image_size value. + The new "reset" button uses the values from gimprc. + Removed some #include's, added the copyright header. + + * app/gimprc.[ch]: new rc variable max_new_image_size. + + * app/preferences_dialog.c: added the "max image size" + option. Generalized the mem size unit code. + + * app/resize.c: an additional box lets the offset widget always + shrink correctly. + + * app/text_tool.c: fixed a minor memory leak. + + * libgimp/Makefile.am: add all widgets to libgimpui.* + + * libgimp/gimpfileselection.c: cosmetic changes. + + * libgimp/gimplimits.h: a maximum image size which should satisfy + everybody ;) + + * libgimp/gimpsizeentry.c: allow the creation of sizeentries + without fields. This (finally) enables arbitrary layout of the + spinbuttons. + + * plug-ins/script-fu/script-fu-scripts.c: use the fileselection + widget for script parameter SF_FILENAME. + Tue May 18 01:14:55 BST 1999 Austin Donnelly * app/app_procs.c: run cleanup code on shutdown in many more @@ -19,7 +61,7 @@ Tue May 18 01:14:55 BST 1999 Austin Donnelly Mon May 17 14:25:11 1999 ape@lrdpf.spacetec.no (Asbjorn Pettersen) * plug-ins/mail/mail.c (save_image): Add OS/2 patches. popen(),spawnl,, - + 1999-05-17 Jay Cox * app/xcf.c: fixed bogus computation of the maximum size @@ -59,7 +101,7 @@ Sun May 16 17:16:59 BST 1999 Adam D. Moss * app/about_dialog.c: Removed unnecessarly #include of interface.h. - + * app/crop.c (crop_image): Fixed a potential linked list race condition (i.e. accessing freed memory) when cropping deletes a layer. May fix a bug reported by Sven. @@ -70,7 +112,7 @@ Sat May 15 14:11:46 MEST 1999 Sven Neumann * app/paint_core.c: handle the clone tool differently (works as usual without the line preview) until I figure out something nicer. - + Sat May 15 03:15:49 MEST 1999 Sven Neumann * app/paint_core.c: Works even better if the cursor position is diff --git a/app/app_procs.c b/app/app_procs.c index ba1d32a673..6be23452f8 100644 --- a/app/app_procs.c +++ b/app/app_procs.c @@ -499,7 +499,11 @@ app_init (void) /* make sure the monitor resolution is valid */ if (monitor_xres < 1e-5 || monitor_yres < 1e-5) { - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; using_xserver_resolution = TRUE; } diff --git a/app/brush_select.c b/app/brush_select.c index 50d7d4f5be..0ce6ae2d3c 100644 --- a/app/brush_select.c +++ b/app/brush_select.c @@ -358,7 +358,10 @@ brush_select_new (gchar *title, /* The action area */ action_items[0].user_data = bsp; action_items[1].user_data = bsp; - build_action_area (GTK_DIALOG (bsp->shell), action_items, 2, 1); + if (title) + build_action_area (GTK_DIALOG (bsp->shell), &action_items[1], 1, 0); + else + build_action_area (GTK_DIALOG (bsp->shell), action_items, 2, 1); gtk_widget_show (bsp->options_box); gtk_widget_show (hbox); diff --git a/app/dialogs/image-new-dialog.c b/app/dialogs/image-new-dialog.c index cbd6bb5304..4b557d7c67 100644 --- a/app/dialogs/image-new-dialog.c +++ b/app/dialogs/image-new-dialog.c @@ -1,8 +1,23 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995-1999 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ #include "appenv.h" #include "actionarea.h" -#include "app_procs.h" #include "commands.h" -#include "general.h" #include "gimage.h" #include "gimprc.h" #include "global_edit.h" @@ -16,87 +31,72 @@ #include "libgimp/gimpsizeentry.h" #include "libgimp/gimpintl.h" -typedef struct { +typedef struct +{ GtkWidget *dlg; - GtkWidget *size_sizeentry; - GtkWidget *simple_res; - GtkWidget *resolution_sizeentry; + GtkWidget *confirm_dlg; + + GtkWidget *size_frame; + GtkWidget *size_se; + GtkWidget *resolution_se; GtkWidget *couple_resolutions; - int width; - int height; + GtkWidget *type_w[2]; + GtkWidget *fill_type_w[4]; + + gint width; + gint height; GUnit unit; - float xresolution; - float yresolution; + gdouble xresolution; + gdouble yresolution; GUnit res_unit; - int type; - int fill_type; + gdouble size; /* in bytes */ + + gint type; + gint fill_type; } NewImageValues; /* new image local functions */ +static void file_new_create_image (NewImageValues *); +static void file_new_confirm_dialog (NewImageValues *); +static gchar * file_new_print_size (gdouble); + static void file_new_ok_callback (GtkWidget *, gpointer); -static void file_new_cancel_callback (GtkWidget *, gpointer); +static void file_new_reset_callback (GtkWidget *, gpointer); static gint file_new_delete_callback (GtkWidget *, GdkEvent *, gpointer); +static void file_new_cancel_callback (GtkWidget *, gpointer); static void file_new_toggle_callback (GtkWidget *, gpointer); static void file_new_resolution_callback (GtkWidget *, gpointer); -static void file_new_advanced_res_callback (GtkWidget *, gpointer); +static void file_new_image_size_callback (GtkWidget *, gpointer); /* static variables */ -static int last_width = 256; -static int last_height = 256; -static int last_type = RGB; -static int last_fill_type = BACKGROUND_FILL; -static float last_xresolution = 72.0; /* always in DPI */ -static float last_yresolution = 72.0; -static GUnit last_unit = UNIT_INCH; -static GUnit last_res_unit = UNIT_INCH; -static gboolean last_new_image = FALSE; +static gint last_width = 256; +static gint last_height = 256; +static GUnit last_unit = UNIT_INCH; -static int new_dialog_run = 0; +static gdouble last_xresolution = 72.0; +static gdouble last_yresolution = 72.0; +static GUnit last_res_unit = UNIT_INCH; -extern TileManager *global_buf; +static gint last_type = RGB; +static gint last_fill_type = BACKGROUND_FILL; -/* the action area structure */ -static ActionAreaItem action_items[] = -{ - { N_("OK"), file_new_ok_callback, NULL, NULL }, - { N_("Cancel"), file_new_cancel_callback, NULL, NULL } -}; +static gboolean last_new_image = FALSE; +static gboolean new_dialog_run = FALSE; +extern TileManager *global_buf; + +/* functions */ static void -file_new_ok_callback (GtkWidget *widget, - gpointer data) +file_new_create_image (NewImageValues *vals) { - NewImageValues *vals; - GImage *gimage; - GDisplay *gdisplay; - Layer *layer; - int type; - - vals = data; - - /* get the image size in pixels */ - vals->width = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0); - vals->height = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1); - - /* get the resolution in dpi */ - vals->xresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0); - vals->yresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1); - - /* get the units */ - vals->unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_sizeentry)); - vals->res_unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_sizeentry)); - - gtk_widget_destroy (vals->dlg); + GImage *gimage; + GDisplay *gdisplay; + Layer *layer; + gint type; last_width = vals->width; last_height = vals->height; @@ -107,7 +107,7 @@ file_new_ok_callback (GtkWidget *widget, last_unit = vals->unit; last_res_unit = vals->res_unit; last_new_image = TRUE; - + switch (vals->fill_type) { case BACKGROUND_FILL: @@ -149,16 +149,91 @@ file_new_ok_callback (GtkWidget *widget, g_free (vals); } +static void +file_new_ok_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + /* get the image size in pixels */ + vals->width = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + vals->height = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + /* get the resolution in dpi */ + vals->xresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 0); + vals->yresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 1); + + /* get the units */ + vals->unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_se)); + vals->res_unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_se)); + + if (vals->size > max_new_image_size) + { + file_new_confirm_dialog (vals); + } + else + { + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); + } +} + +static void +file_new_reset_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (default_xresolution - default_yresolution) < GIMP_MIN_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, default_xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, default_yresolution); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->resolution_se), + default_resolution_units); + + gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_xresolution, TRUE); + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_yresolution, TRUE); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_height); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->size_se), + default_units); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vals->type_w[default_type]), + TRUE); + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (vals->fill_type_w[BACKGROUND_FILL]), TRUE); +} + static gint file_new_delete_callback (GtkWidget *widget, GdkEvent *event, gpointer data) { file_new_cancel_callback (widget, data); - return TRUE; } - static void file_new_cancel_callback (GtkWidget *widget, @@ -172,11 +247,97 @@ file_new_cancel_callback (GtkWidget *widget, g_free (vals); } +/* local callbacks of file_new_confirm_dialog() */ +static void +file_new_confirm_dialog_ok_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); +} + +static void +file_new_confirm_dialog_cancel_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + vals->confirm_dlg = NULL; + gtk_widget_set_sensitive (vals->dlg, TRUE); +} + +static gint +file_new_confirm_dialog_delete_callback (GtkWidget *widget, + GdkEvent *event, + NewImageValues *vals) +{ + file_new_confirm_dialog_cancel_callback (widget, vals); + return TRUE; +} + +static void +file_new_confirm_dialog (NewImageValues *vals) +{ + GtkWidget *label; + gchar *size; + gchar *max_size; + gchar *text; + + static ActionAreaItem action_items[] = + { + { N_("OK"), + (ActionCallback) file_new_confirm_dialog_ok_callback, NULL, NULL }, + { N_("Cancel"), + (ActionCallback) file_new_confirm_dialog_cancel_callback, NULL, NULL } + }; + + gtk_widget_set_sensitive (vals->dlg, FALSE); + + vals->confirm_dlg = gtk_dialog_new (); + gtk_window_set_wmclass (GTK_WINDOW (vals->confirm_dlg), + "really_create", "Gimp"); + gtk_window_set_title (GTK_WINDOW (vals->confirm_dlg), _("Confirm Image Size")); + gtk_window_position (GTK_WINDOW (vals->confirm_dlg), GTK_WIN_POS_MOUSE); + + /* Handle the wm close signal */ + gtk_signal_connect (GTK_OBJECT (vals->confirm_dlg), "delete_event", + (GtkSignalFunc) file_new_confirm_dialog_delete_callback, + vals); + + /* The action area */ + action_items[0].user_data = vals; + action_items[1].user_data = vals; + build_action_area (GTK_DIALOG (vals->confirm_dlg), action_items, 2, 0); + + text = g_strdup_printf (_("You are trying to create an image which\n" + "has an initial size of %s.\n\n" + "Choose OK to create this image anyway.\n" + "Choose Cancel if you didn't mean to\n" + "create such a large image.\n\n" + "To prevent this dialog from appearing,\n" + "increase the \"Maximum Image Size\"\n" + "setting (currently %s) in the\n" + "preferences dialog."), + size = file_new_print_size (vals->size), + max_size = file_new_print_size (max_new_image_size)); + label = gtk_label_new (text); + gtk_misc_set_padding (GTK_MISC (label), 6, 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->confirm_dlg)->vbox), label, + TRUE, TRUE, 0); + gtk_widget_show (label); + + g_free (text); + g_free (max_size); + g_free (size); + + gtk_widget_show (vals->confirm_dlg); +} + static void file_new_toggle_callback (GtkWidget *widget, gpointer data) { - int *val; + gint *val; if (GTK_TOGGLE_BUTTON (widget)->active) { @@ -185,78 +346,102 @@ file_new_toggle_callback (GtkWidget *widget, } } -static void -file_new_advanced_res_callback (GtkWidget *widget, - gpointer data) -{ - NewImageValues *vals; - - vals = data; - - gtk_widget_hide (vals->simple_res); - gtk_widget_show (vals->resolution_sizeentry); -} - static void file_new_resolution_callback (GtkWidget *widget, gpointer data) { NewImageValues *vals; - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; vals = data; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); + new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - if (widget == vals->simple_res) + if (gimp_chain_button_get_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) { + gtk_signal_handler_block_by_data + (GTK_OBJECT (vals->resolution_se), vals); + if (new_xres != xres) { yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, xres); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, yres); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); } - } - else + + if (new_yres != yres) + { + xres = new_xres = yres = new_yres; + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); + } + + gtk_signal_handler_unblock_by_data + (GTK_OBJECT (vals->resolution_se), vals); + } + else { - new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - if (gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) - { - if (new_xres != xres) - { - yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); - } - - if (new_yres != yres) - { - xres = new_xres = yres = new_yres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); - } - } - else - { - if (new_xres != xres) - xres = new_xres; - if (new_yres != yres) - yres = new_yres; - } + if (new_xres != xres) + xres = new_xres; + if (new_yres != yres) + yres = new_yres; } - gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, xres, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, yres, FALSE); + + file_new_image_size_callback (widget, data); +} + +static gchar * +file_new_print_size (gdouble size) +{ + if (size < 4096) + return g_strdup_printf (_("%d Bytes"), (gint) size); + else if (size < 1024 * 10) + return g_strdup_printf (_("%.2f KB"), size / 1024); + else if (size < 1024 * 100) + return g_strdup_printf (_("%.1f KB"), size / 1024); + else if (size < 1024 * 1024) + return g_strdup_printf (_("%d KB"), (gint) size / 1024); + else if (size < 1024 * 1024 * 10) + return g_strdup_printf (_("%.2f MB"), size / 1024 / 1024); + else + return g_strdup_printf (_("%.1f MB"), size / 1024 / 1024); +} + +static void +file_new_image_size_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + gdouble width, height, size; + gchar *text; + gchar *label; + + vals = (NewImageValues *) data; + + width = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + height = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + size = + width * height * + ((vals->type == RGB ? 3 : 1) + /* bytes per pixel */ + (vals->fill_type == TRANSPARENT_FILL ? 1 : 0)); /* alpha channel */ + + text = file_new_print_size (size); + label = g_strdup_printf (_("Image Size: %s"), text); + gtk_frame_set_label (GTK_FRAME (vals->size_frame), label); + g_free (label); + g_free (text); + + vals->size = size; } void @@ -267,26 +452,57 @@ file_new_cmd_callback (GtkWidget *widget, GDisplay *gdisp; NewImageValues *vals; - GtkWidget *top_vbox; - GtkWidget *button; - GtkWidget *hbox; - GtkWidget *frame; - GtkWidget *radio_box; - gboolean advanced_options = FALSE; - GSList *group; + GtkWidget *top_vbox; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *abox; + GtkWidget *frame; + GtkWidget *table; + GtkWidget *separator; + GtkWidget *label; + GtkWidget *button; + GtkObject *adjustment; + GtkWidget *spinbutton; + GtkWidget *spinbutton2; + GtkWidget *radio_box; + GSList *group; + gint i; + + static ActionAreaItem action_items[] = + { + { N_("OK"), file_new_ok_callback, NULL, NULL }, + { N_("Reset"), file_new_reset_callback, NULL, NULL }, + { N_("Cancel"), file_new_cancel_callback, NULL, NULL } + }; + + static gchar *type_names[] = + { + N_("RGB"), + N_("Grayscale") + }; + + static gchar *fill_type_names[] = + { + N_("Foreground"), + N_("Background"), + N_("White"), + N_("Transparent") + }; if(!new_dialog_run) { /* all from gimprc */ last_width = default_width; last_height = default_height; - last_type = default_type; + last_unit = default_units; + last_xresolution = default_xresolution; last_yresolution = default_yresolution; - last_unit = default_units; last_res_unit = default_resolution_units; - new_dialog_run = 1; + last_type = default_type; + + new_dialog_run = TRUE; } /* Before we try to determine the responsible gdisplay, @@ -298,55 +514,54 @@ file_new_cmd_callback (GtkWidget *widget, gdisp = NULL; vals = g_malloc (sizeof (NewImageValues)); + vals->confirm_dlg = NULL; + vals->size = 0.0; + vals->res_unit = last_res_unit; vals->fill_type = last_fill_type; if (gdisp) { vals->width = gdisp->gimage->width; vals->height = gdisp->gimage->height; - vals->type = gimage_base_type (gdisp->gimage); + vals->unit = gdisp->gimage->unit; + vals->xresolution = gdisp->gimage->xresolution; vals->yresolution = gdisp->gimage->yresolution; - vals->unit = gdisp->gimage->unit; - vals->res_unit = last_res_unit; + + vals->type = gimage_base_type (gdisp->gimage); } else { vals->width = last_width; vals->height = last_height; - vals->type = last_type; + vals->unit = last_unit; + vals->xresolution = last_xresolution; vals->yresolution = last_yresolution; - vals->unit = last_unit; - vals->res_unit = last_res_unit; - } - if (ABS (vals->xresolution - vals->yresolution) > 1e-5) - advanced_options = TRUE; + vals->type = last_type; + } if (vals->type == INDEXED) vals->type = RGB; /* no indexed images */ - /* if a cut buffer exist, default to using its size for the new image */ - /* also check to see if a new_image has been opened */ + /* If a cut buffer exists, default to using its size for the new image + * also check to see if a new_image has been opened + */ if(global_buf && !last_new_image) { vals->width = global_buf->width; vals->height = global_buf->height; - /* It would be good to set the resolution here, but that would - * require TileManagers to know about the resolution of tiles - * they're dealing with. It's not clear we want to go down that - * road. -- austin */ } vals->dlg = gtk_dialog_new (); gtk_window_set_wmclass (GTK_WINDOW (vals->dlg), "new_image", "Gimp"); gtk_window_set_title (GTK_WINDOW (vals->dlg), _("New Image")); gtk_window_set_position (GTK_WINDOW (vals->dlg), GTK_WIN_POS_MOUSE); - gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, FALSE); + gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, TRUE); - /* handle the wm close signal */ + /* Handle the wm close signal */ gtk_signal_connect (GTK_OBJECT (vals->dlg), "delete_event", GTK_SIGNAL_FUNC (file_new_delete_callback), vals); @@ -354,123 +569,232 @@ file_new_cmd_callback (GtkWidget *widget, /* The action area */ action_items[0].user_data = vals; action_items[1].user_data = vals; - build_action_area (GTK_DIALOG (vals->dlg), action_items, 2, 1); + action_items[2].user_data = vals; + build_action_area (GTK_DIALOG (vals->dlg), action_items, 3, 2); - /* vbox holding the rest of the dialog */ + /* vbox holding the rest of the dialog */ top_vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 4); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dlg)->vbox), top_vbox, TRUE, TRUE, 0); gtk_widget_show (top_vbox); - hbox = gtk_hbox_new (FALSE, 0); - gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); + /* Image size frame */ + vals->size_frame = gtk_frame_new (NULL); + gtk_box_pack_start (GTK_BOX (top_vbox), vals->size_frame, FALSE, FALSE, 0); + gtk_widget_show (vals->size_frame); + + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); + gtk_container_add (GTK_CONTAINER (vals->size_frame), vbox); + gtk_widget_show (vbox); + + table = gtk_table_new (7, 2, FALSE); + gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); + gtk_table_set_row_spacing (GTK_TABLE (table), 1, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 2, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 4, 4); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + gtk_widget_show (table); + + /* the pixel size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* a separator after the pixel section */ + separator = gtk_hseparator_new (); + gtk_table_attach_defaults (GTK_TABLE (table), separator, 0, 2, 2, 3); + gtk_widget_show (separator); + + /* the unit size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* create the sizeentry which keeps it all together */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 3, 5); + vals->size_se = + gimp_size_entry_new (0, vals->unit, "%a", FALSE, FALSE, TRUE, 75, + GIMP_SIZE_ENTRY_UPDATE_SIZE); + gtk_table_set_col_spacing (GTK_TABLE (vals->size_se), 1, 2); + gtk_container_add (GTK_CONTAINER (abox), vals->size_se); + gtk_widget_show (vals->size_se); + gtk_widget_show (abox); + + /* height in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "height in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 2, 3); + gtk_widget_show (spinbutton); + + /* height in pixels */ + hbox = gtk_hbox_new (FALSE, 2); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton2, FALSE, FALSE, 0); + gtk_widget_show (spinbutton2); + + label = gtk_label_new (_("Pixels")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + /* add the "height in pixels" spinbutton to the main table */ + gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 1, 2); gtk_widget_show (hbox); - vals->size_sizeentry = gimp_size_entry_new (2, vals->unit, "%p", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_SIZE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + /* register the height spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* width in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "width in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 1, 2); + gtk_widget_show (spinbutton); + + /* width in pixels */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 0, 1); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + /* add the "width in pixels" spinbutton to the main table */ + gtk_container_add (GTK_CONTAINER (abox), spinbutton2); + gtk_widget_show (spinbutton2); + gtk_widget_show (abox); + + /* register the width spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* initialize the sizeentry */ + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->xresolution, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->yresolution, FALSE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - vals->width); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - vals->height); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Width"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Height"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Pixels"), 1, 4, 0.0); - gtk_box_pack_start (GTK_BOX (hbox), vals->size_sizeentry, FALSE, FALSE, 4); - gtk_widget_show (vals->size_sizeentry); - /* resolution frame */ - frame = gtk_frame_new (_("Resolution")); - gtk_box_pack_start (GTK_BOX (top_vbox), frame, FALSE, FALSE, 0); - gtk_widget_show (frame); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 0, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 1, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); - hbox = gtk_hbox_new (FALSE, 0); - gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); - gtk_container_add (GTK_CONTAINER (frame), hbox); - gtk_widget_show (hbox); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->height); - vals->simple_res = gimp_size_entry_new (1, vals->res_unit, "%s", - FALSE, FALSE, FALSE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->simple_res), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->simple_res), 0, - MIN(vals->xresolution, vals->yresolution)); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->simple_res), - _("Pixels per "), 1, 2, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->simple_res), "value_changed", + gtk_signal_connect (GTK_OBJECT (vals->size_se), "refval_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + gtk_signal_connect (GTK_OBJECT (vals->size_se), "value_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + + /* initialize the size label */ + file_new_image_size_callback (vals->size_se, vals); + + /* the resolution labels */ + label = gtk_label_new (_("Resolution X:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Y:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* the resolution sizeentry */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + + vals->resolution_se = + gimp_size_entry_new (1, default_resolution_units, _("pixels/%a"), + FALSE, FALSE, FALSE, 75, + GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 1, 2); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 2, 2); + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->resolution_se), + GTK_SPIN_BUTTON (spinbutton), NULL); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), spinbutton, + 1, 2, 0, 1); + gtk_widget_show (spinbutton); + gtk_table_attach (GTK_TABLE (table), vals->resolution_se, 1, 2, 5, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (vals->resolution_se); + + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, vals->xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, vals->yresolution); + + gtk_signal_connect (GTK_OBJECT (vals->resolution_se), "value_changed", (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->simple_res, FALSE, FALSE, 0); - gtk_table_set_row_spacings (GTK_TABLE (vals->simple_res), 2); - button = gtk_button_new_with_label (_("Advanced options >>")); - gtk_table_attach_defaults (GTK_TABLE (vals->simple_res), - button, 1, 4, 3, 4); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - (GtkSignalFunc) file_new_advanced_res_callback, vals); - gtk_widget_show (button); - /* the advanced resolution stuff - (not shown by default, but used to keep track of all the variables) */ - vals->resolution_sizeentry = - gimp_size_entry_new (2, vals->res_unit, "%s", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - vals->xresolution); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - vals->yresolution); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Horizontal"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Vertical"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "value_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "refval_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->resolution_sizeentry, - FALSE, FALSE, 0); - vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); - if (ABS (vals->xresolution - vals->yresolution) < 1e-5) - gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions), - TRUE); - gtk_table_attach_defaults (GTK_TABLE (vals->resolution_sizeentry), - vals->couple_resolutions, 1, 3, 3, 4); + /* the resolution chainbutton */ + vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_RIGHT); + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (vals->xresolution - vals->yresolution) < GIMP_MIN_RESOLUTION); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), + vals->couple_resolutions, 2, 3, 0, 2); gtk_widget_show (vals->couple_resolutions); - if (advanced_options != FALSE) - gtk_widget_show (vals->resolution_sizeentry); - else - gtk_widget_show (vals->simple_res); - - /* hbox containing the Image type and fill type frames */ - hbox = gtk_hbox_new(FALSE, 2); + /* hbox containing the Image type and fill type frames */ + hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); - gtk_widget_show(hbox); + gtk_widget_show (hbox); /* frame for Image Type */ frame = gtk_frame_new (_("Image Type")); @@ -483,29 +807,26 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("RGB")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) RGB); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == RGB) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 2; i++) + { + button = gtk_radio_button_new_with_label (group, gettext (type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Grayscale")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) GRAY); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == GRAY) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->type_w[i] = button; + } - /* frame for fill type */ + /* frame for Fill Type */ frame = gtk_frame_new (_("Fill Type")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); @@ -515,51 +836,27 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("Foreground")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) FOREGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == FOREGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 4; i++) + { + button = + gtk_radio_button_new_with_label (group, gettext (fill_type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->fill_type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->fill_type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Background")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) BACKGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == BACKGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->fill_type_w[i] = button; + } - button = gtk_radio_button_new_with_label (group, _("White")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) WHITE_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == WHITE_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - button = gtk_radio_button_new_with_label (group, _("Transparent")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) TRANSPARENT_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == TRANSPARENT_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_sizeentry)); + gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_se)); gtk_widget_show (vals->dlg); } diff --git a/app/dialogs/preferences-dialog.c b/app/dialogs/preferences-dialog.c index dc46004f99..48e3976601 100644 --- a/app/dialogs/preferences-dialog.c +++ b/app/dialogs/preferences-dialog.c @@ -42,6 +42,7 @@ static void file_prefs_cancel_callback (GtkWidget *, GtkWidget *); static void file_prefs_toggle_callback (GtkWidget *, gpointer); static void file_prefs_preview_size_callback (GtkWidget *, gpointer); +static void file_prefs_mem_size_callback (GtkWidget *, gpointer); static void file_prefs_mem_size_unit_callback (GtkWidget *, gpointer); static void file_prefs_int_adjustment_callback (GtkAdjustment *, gpointer); static void file_prefs_string_callback (GtkWidget *, gpointer); @@ -74,8 +75,8 @@ static int old_always_restore_session; static int old_default_width; static int old_default_height; static GUnit old_default_units; -static float old_default_xresolution; -static float old_default_yresolution; +static double old_default_xresolution; +static double old_default_yresolution; static GUnit old_default_resolution_units; static int old_default_type; static int old_stingy_memory_use; @@ -91,12 +92,13 @@ static char * old_brush_path; static char * old_pattern_path; static char * old_palette_path; static char * old_gradient_path; -static float old_monitor_xres; -static float old_monitor_yres; +static double old_monitor_xres; +static double old_monitor_yres; static int old_using_xserver_resolution; static int old_num_processors; static char * old_image_title_format; static int old_global_paint_options; +static int old_max_new_image_size; /* variables which can't be changed on the fly */ static int edit_stingy_memory_use; @@ -116,9 +118,11 @@ static char * edit_gradient_path = NULL; static GtkWidget *prefs_dlg = NULL; -static GtkObject *tile_cache_size_adjustment = NULL; static int divided_tile_cache_size; -static int mem_size_unit; +static int tile_cache_size_unit; + +static int divided_max_new_image_size; +static int max_new_image_size_unit; static GtkWidget *default_size_sizeentry = NULL; static GtkWidget *default_resolution_sizeentry = NULL; @@ -204,8 +208,6 @@ static void file_prefs_ok_callback (GtkWidget *widget, GtkWidget *dlg) { - edit_tile_cache_size = mem_size_unit * divided_tile_cache_size; - if (levels_of_undo < 0) { g_message (_("Error: Levels of undo must be zero or greater.")); @@ -273,7 +275,6 @@ file_prefs_ok_callback (GtkWidget *widget, gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -503,11 +504,19 @@ file_prefs_save_callback (GtkWidget *widget, update = g_list_append (update, "global-paint-options"); remove = g_list_append (remove, "no-global-paint-options"); } + if (max_new_image_size != old_max_new_image_size) + update = g_list_append (update, "max-new-image-size"); save_gimprc (&update, &remove); if (using_xserver_resolution) - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + { + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; + } /* Restore variables which must not change */ stingy_memory_use = save_stingy_memory_use; @@ -539,7 +548,6 @@ file_prefs_cancel_callback (GtkWidget *widget, { gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -569,6 +577,7 @@ file_prefs_cancel_callback (GtkWidget *widget, monitor_yres = old_monitor_yres; using_xserver_resolution = old_using_xserver_resolution; num_processors = old_num_processors; + max_new_image_size = old_max_new_image_size; if (preview_size != old_preview_size) { @@ -672,22 +681,66 @@ file_prefs_preview_size_callback (GtkWidget *widget, layer_select_update_preview_size (); } +static void +file_prefs_mem_size_callback (GtkWidget *widget, + gpointer data) +{ + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (widget), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (widget), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (widget), + "mem_size_unit"))) + return; + + *divided_mem_size = GTK_ADJUSTMENT (widget)->value; + *mem_size = *divided_mem_size * *mem_size_unit; +} + static void file_prefs_mem_size_unit_callback (GtkWidget *widget, gpointer data) { - int new_unit; + GtkObject *adjustment; + int new_unit; + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; - new_unit = (int)data; + adjustment = GTK_OBJECT (data); - if (new_unit != mem_size_unit) + if (! (new_unit = (int) gtk_object_get_user_data (GTK_OBJECT (widget)))) + return; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (adjustment), + "mem_size_unit"))) + return; + + if (new_unit != *mem_size_unit) { - divided_tile_cache_size = - divided_tile_cache_size * mem_size_unit / new_unit; - mem_size_unit = new_unit; + *divided_mem_size = *mem_size / new_unit; + *mem_size_unit = new_unit; - gtk_adjustment_set_value (GTK_ADJUSTMENT (tile_cache_size_adjustment), - (float)divided_tile_cache_size); + gtk_signal_handler_block_by_data (GTK_OBJECT (adjustment), + divided_mem_size); + gtk_adjustment_set_value (GTK_ADJUSTMENT (adjustment), + (float) *divided_mem_size); + gtk_signal_handler_unblock_by_data (GTK_OBJECT (adjustment), + divided_mem_size); } } @@ -752,10 +805,10 @@ static void file_prefs_default_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -810,7 +863,11 @@ file_prefs_res_source_callback (GtkWidget *widget, if (GTK_TOGGLE_BUTTON (widget)->active) { - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; using_xserver_resolution = TRUE; } else @@ -830,10 +887,10 @@ static void file_prefs_monitor_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -1191,6 +1248,7 @@ gimp_table_attach_aligned (GtkTable *table, label = gtk_label_new (text); gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); @@ -1199,7 +1257,7 @@ gimp_table_attach_aligned (GtkTable *table, { GtkWidget *alignment; - alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + alignment = gtk_alignment_new (0.0, 1.0, 0.0, 0.0); gtk_table_attach_defaults (table, alignment, 1, 2, row, row + 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (alignment), widget); @@ -1373,6 +1431,7 @@ file_pref_cmd_callback (GtkWidget *widget, old_num_processors = num_processors; old_image_title_format = file_prefs_strdup (image_title_format); old_global_paint_options = global_paint_options; + old_max_new_image_size = max_new_image_size; file_prefs_strset (&old_temp_path, edit_temp_path); file_prefs_strset (&old_swap_path, edit_swap_path); @@ -1383,14 +1442,23 @@ file_pref_cmd_callback (GtkWidget *widget, file_prefs_strset (&old_palette_path, edit_palette_path); file_prefs_strset (&old_gradient_path, edit_gradient_path); - mem_size_unit = 1; + tile_cache_size_unit = 1; for (i = 0; i < 3; i++) { - if (edit_tile_cache_size % (mem_size_unit * 1024) != 0) + if (edit_tile_cache_size % (tile_cache_size_unit * 1024) != 0) break; - mem_size_unit *= 1024; + tile_cache_size_unit *= 1024; } - divided_tile_cache_size = edit_tile_cache_size / mem_size_unit; + divided_tile_cache_size = edit_tile_cache_size / tile_cache_size_unit; + + max_new_image_size_unit = 1; + for (i = 0; i < 3; i++) + { + if (max_new_image_size % (max_new_image_size_unit * 1024) != 0) + break; + max_new_image_size_unit *= 1024; + } + divided_max_new_image_size = max_new_image_size / max_new_image_size_unit; /* Create the dialog */ prefs_dlg = @@ -1466,8 +1534,10 @@ file_pref_cmd_callback (GtkWidget *widget, 0, default_xresolution, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, default_yresolution, FALSE); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, default_width); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, @@ -1498,11 +1568,13 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); default_resolution_sizeentry = - gimp_size_entry_new (2, default_resolution_units, "%s", + gimp_size_entry_new (2, default_resolution_units, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, default_xresolution); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), @@ -1512,9 +1584,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (default_resolution_sizeentry), "unit_changed", (GtkSignalFunc)file_prefs_default_resolution_callback, @@ -1920,9 +1990,9 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); #ifdef ENABLE_MP - table = gtk_table_new (2, 2, FALSE); + table = gtk_table_new (3, 2, FALSE); #else - table = gtk_table_new (1, 2, FALSE); + table = gtk_table_new (2, 2, FALSE); #endif /* ENABLE_MP */ gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); @@ -1930,31 +2000,72 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0); gtk_widget_show (table); + /* The tile cache size */ hbox = gtk_hbox_new (FALSE, 2); spinbutton = - gimp_spin_button_new (&tile_cache_size_adjustment, + gimp_spin_button_new (&adjustment, divided_tile_cache_size, 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, 1.0, 0.0); - gtk_signal_connect (GTK_OBJECT (tile_cache_size_adjustment), "value_changed", - (GtkSignalFunc) file_prefs_int_adjustment_callback, + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, ÷d_tile_cache_size); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); - + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &edit_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &tile_cache_size_unit); + optionmenu = gimp_option_menu_new (file_prefs_mem_size_unit_callback, - (gpointer) mem_size_unit, - _("Bytes"), (gpointer) 1, (gpointer) 1, - _("KiloBytes"), (gpointer) 1024, (gpointer) 1024, - _("MegaBytes"), - (gpointer) (1024*1024), (gpointer) (1024*1024), + (gpointer) tile_cache_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), NULL); gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); gtk_widget_show (optionmenu); gimp_table_attach_aligned (GTK_TABLE (table), 0, _("Tile Cache Size:"), 1.0, 0.5, hbox, TRUE); + /* The maximum size of a new image */ + hbox = gtk_hbox_new (FALSE, 2); + spinbutton = + gimp_spin_button_new (&adjustment, + divided_max_new_image_size, + 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, + 1.0, 0.0); + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, + ÷d_max_new_image_size); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); + gtk_widget_show (spinbutton); + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &max_new_image_size_unit); + + optionmenu = + gimp_option_menu_new (file_prefs_mem_size_unit_callback, + (gpointer) max_new_image_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), + NULL); + gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); + gtk_widget_show (optionmenu); + gimp_table_attach_aligned (GTK_TABLE (table), 1, + _("Maximum Image Size:"), 1.0, 0.5, hbox, TRUE); + #ifdef ENABLE_MP spinbutton = gimp_spin_button_new (&adjustment, @@ -1962,7 +2073,7 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) file_prefs_int_adjustment_callback, &num_processors); - gimp_table_attach_aligned (GTK_TABLE (table), 1, + gimp_table_attach_aligned (GTK_TABLE (table), 2, _("Number of Processors to Use:"), 1.0, 0.5, spinbutton, TRUE); #endif /* ENABLE_MP */ @@ -2094,8 +2205,8 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); { - float xres, yres; - char buf[80]; + gfloat xres, yres; + gchar buf[80]; gdisplay_xserver_resolution (&xres, &yres); @@ -2120,10 +2231,12 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); monitor_resolution_sizeentry = - gimp_size_entry_new (2, UNIT_INCH, "%s", FALSE, FALSE, TRUE, 75, + gimp_size_entry_new (2, UNIT_INCH, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, monitor_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), @@ -2133,9 +2246,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (monitor_resolution_sizeentry), "value_changed", (GtkSignalFunc)file_prefs_monitor_resolution_callback, diff --git a/app/dialogs/resize-dialog.c b/app/dialogs/resize-dialog.c index 7d3909300a..da2b0af474 100644 --- a/app/dialogs/resize-dialog.c +++ b/app/dialogs/resize-dialog.c @@ -102,6 +102,7 @@ resize_widget_new (ResizeType type, GtkWidget *table; GtkWidget *table2; GtkWidget *hbox; + GtkWidget *hbox2; GtkWidget *label; GtkWidget *frame; GtkWidget *spinbutton; @@ -459,9 +460,12 @@ resize_widget_new (ResizeType type, gtk_widget_show (table); /* frame to hold drawing area */ + hbox2 = gtk_hbox_new (0, FALSE); + gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); + frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); - gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, FALSE, 0); private->drawing_area = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (private->drawing_area), private->area_width, private->area_height); @@ -474,6 +478,7 @@ resize_widget_new (ResizeType type, gtk_widget_show (private->drawing_area); gtk_widget_show (frame); + gtk_widget_show (hbox2); gtk_widget_show (vbox2); gtk_widget_show (hbox); } diff --git a/app/file_new_dialog.c b/app/file_new_dialog.c index cbd6bb5304..4b557d7c67 100644 --- a/app/file_new_dialog.c +++ b/app/file_new_dialog.c @@ -1,8 +1,23 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995-1999 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ #include "appenv.h" #include "actionarea.h" -#include "app_procs.h" #include "commands.h" -#include "general.h" #include "gimage.h" #include "gimprc.h" #include "global_edit.h" @@ -16,87 +31,72 @@ #include "libgimp/gimpsizeentry.h" #include "libgimp/gimpintl.h" -typedef struct { +typedef struct +{ GtkWidget *dlg; - GtkWidget *size_sizeentry; - GtkWidget *simple_res; - GtkWidget *resolution_sizeentry; + GtkWidget *confirm_dlg; + + GtkWidget *size_frame; + GtkWidget *size_se; + GtkWidget *resolution_se; GtkWidget *couple_resolutions; - int width; - int height; + GtkWidget *type_w[2]; + GtkWidget *fill_type_w[4]; + + gint width; + gint height; GUnit unit; - float xresolution; - float yresolution; + gdouble xresolution; + gdouble yresolution; GUnit res_unit; - int type; - int fill_type; + gdouble size; /* in bytes */ + + gint type; + gint fill_type; } NewImageValues; /* new image local functions */ +static void file_new_create_image (NewImageValues *); +static void file_new_confirm_dialog (NewImageValues *); +static gchar * file_new_print_size (gdouble); + static void file_new_ok_callback (GtkWidget *, gpointer); -static void file_new_cancel_callback (GtkWidget *, gpointer); +static void file_new_reset_callback (GtkWidget *, gpointer); static gint file_new_delete_callback (GtkWidget *, GdkEvent *, gpointer); +static void file_new_cancel_callback (GtkWidget *, gpointer); static void file_new_toggle_callback (GtkWidget *, gpointer); static void file_new_resolution_callback (GtkWidget *, gpointer); -static void file_new_advanced_res_callback (GtkWidget *, gpointer); +static void file_new_image_size_callback (GtkWidget *, gpointer); /* static variables */ -static int last_width = 256; -static int last_height = 256; -static int last_type = RGB; -static int last_fill_type = BACKGROUND_FILL; -static float last_xresolution = 72.0; /* always in DPI */ -static float last_yresolution = 72.0; -static GUnit last_unit = UNIT_INCH; -static GUnit last_res_unit = UNIT_INCH; -static gboolean last_new_image = FALSE; +static gint last_width = 256; +static gint last_height = 256; +static GUnit last_unit = UNIT_INCH; -static int new_dialog_run = 0; +static gdouble last_xresolution = 72.0; +static gdouble last_yresolution = 72.0; +static GUnit last_res_unit = UNIT_INCH; -extern TileManager *global_buf; +static gint last_type = RGB; +static gint last_fill_type = BACKGROUND_FILL; -/* the action area structure */ -static ActionAreaItem action_items[] = -{ - { N_("OK"), file_new_ok_callback, NULL, NULL }, - { N_("Cancel"), file_new_cancel_callback, NULL, NULL } -}; +static gboolean last_new_image = FALSE; +static gboolean new_dialog_run = FALSE; +extern TileManager *global_buf; + +/* functions */ static void -file_new_ok_callback (GtkWidget *widget, - gpointer data) +file_new_create_image (NewImageValues *vals) { - NewImageValues *vals; - GImage *gimage; - GDisplay *gdisplay; - Layer *layer; - int type; - - vals = data; - - /* get the image size in pixels */ - vals->width = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0); - vals->height = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1); - - /* get the resolution in dpi */ - vals->xresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0); - vals->yresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1); - - /* get the units */ - vals->unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_sizeentry)); - vals->res_unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_sizeentry)); - - gtk_widget_destroy (vals->dlg); + GImage *gimage; + GDisplay *gdisplay; + Layer *layer; + gint type; last_width = vals->width; last_height = vals->height; @@ -107,7 +107,7 @@ file_new_ok_callback (GtkWidget *widget, last_unit = vals->unit; last_res_unit = vals->res_unit; last_new_image = TRUE; - + switch (vals->fill_type) { case BACKGROUND_FILL: @@ -149,16 +149,91 @@ file_new_ok_callback (GtkWidget *widget, g_free (vals); } +static void +file_new_ok_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + /* get the image size in pixels */ + vals->width = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + vals->height = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + /* get the resolution in dpi */ + vals->xresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 0); + vals->yresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 1); + + /* get the units */ + vals->unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_se)); + vals->res_unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_se)); + + if (vals->size > max_new_image_size) + { + file_new_confirm_dialog (vals); + } + else + { + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); + } +} + +static void +file_new_reset_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (default_xresolution - default_yresolution) < GIMP_MIN_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, default_xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, default_yresolution); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->resolution_se), + default_resolution_units); + + gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_xresolution, TRUE); + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_yresolution, TRUE); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_height); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->size_se), + default_units); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vals->type_w[default_type]), + TRUE); + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (vals->fill_type_w[BACKGROUND_FILL]), TRUE); +} + static gint file_new_delete_callback (GtkWidget *widget, GdkEvent *event, gpointer data) { file_new_cancel_callback (widget, data); - return TRUE; } - static void file_new_cancel_callback (GtkWidget *widget, @@ -172,11 +247,97 @@ file_new_cancel_callback (GtkWidget *widget, g_free (vals); } +/* local callbacks of file_new_confirm_dialog() */ +static void +file_new_confirm_dialog_ok_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); +} + +static void +file_new_confirm_dialog_cancel_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + vals->confirm_dlg = NULL; + gtk_widget_set_sensitive (vals->dlg, TRUE); +} + +static gint +file_new_confirm_dialog_delete_callback (GtkWidget *widget, + GdkEvent *event, + NewImageValues *vals) +{ + file_new_confirm_dialog_cancel_callback (widget, vals); + return TRUE; +} + +static void +file_new_confirm_dialog (NewImageValues *vals) +{ + GtkWidget *label; + gchar *size; + gchar *max_size; + gchar *text; + + static ActionAreaItem action_items[] = + { + { N_("OK"), + (ActionCallback) file_new_confirm_dialog_ok_callback, NULL, NULL }, + { N_("Cancel"), + (ActionCallback) file_new_confirm_dialog_cancel_callback, NULL, NULL } + }; + + gtk_widget_set_sensitive (vals->dlg, FALSE); + + vals->confirm_dlg = gtk_dialog_new (); + gtk_window_set_wmclass (GTK_WINDOW (vals->confirm_dlg), + "really_create", "Gimp"); + gtk_window_set_title (GTK_WINDOW (vals->confirm_dlg), _("Confirm Image Size")); + gtk_window_position (GTK_WINDOW (vals->confirm_dlg), GTK_WIN_POS_MOUSE); + + /* Handle the wm close signal */ + gtk_signal_connect (GTK_OBJECT (vals->confirm_dlg), "delete_event", + (GtkSignalFunc) file_new_confirm_dialog_delete_callback, + vals); + + /* The action area */ + action_items[0].user_data = vals; + action_items[1].user_data = vals; + build_action_area (GTK_DIALOG (vals->confirm_dlg), action_items, 2, 0); + + text = g_strdup_printf (_("You are trying to create an image which\n" + "has an initial size of %s.\n\n" + "Choose OK to create this image anyway.\n" + "Choose Cancel if you didn't mean to\n" + "create such a large image.\n\n" + "To prevent this dialog from appearing,\n" + "increase the \"Maximum Image Size\"\n" + "setting (currently %s) in the\n" + "preferences dialog."), + size = file_new_print_size (vals->size), + max_size = file_new_print_size (max_new_image_size)); + label = gtk_label_new (text); + gtk_misc_set_padding (GTK_MISC (label), 6, 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->confirm_dlg)->vbox), label, + TRUE, TRUE, 0); + gtk_widget_show (label); + + g_free (text); + g_free (max_size); + g_free (size); + + gtk_widget_show (vals->confirm_dlg); +} + static void file_new_toggle_callback (GtkWidget *widget, gpointer data) { - int *val; + gint *val; if (GTK_TOGGLE_BUTTON (widget)->active) { @@ -185,78 +346,102 @@ file_new_toggle_callback (GtkWidget *widget, } } -static void -file_new_advanced_res_callback (GtkWidget *widget, - gpointer data) -{ - NewImageValues *vals; - - vals = data; - - gtk_widget_hide (vals->simple_res); - gtk_widget_show (vals->resolution_sizeentry); -} - static void file_new_resolution_callback (GtkWidget *widget, gpointer data) { NewImageValues *vals; - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; vals = data; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); + new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - if (widget == vals->simple_res) + if (gimp_chain_button_get_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) { + gtk_signal_handler_block_by_data + (GTK_OBJECT (vals->resolution_se), vals); + if (new_xres != xres) { yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, xres); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, yres); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); } - } - else + + if (new_yres != yres) + { + xres = new_xres = yres = new_yres; + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); + } + + gtk_signal_handler_unblock_by_data + (GTK_OBJECT (vals->resolution_se), vals); + } + else { - new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - if (gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) - { - if (new_xres != xres) - { - yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); - } - - if (new_yres != yres) - { - xres = new_xres = yres = new_yres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); - } - } - else - { - if (new_xres != xres) - xres = new_xres; - if (new_yres != yres) - yres = new_yres; - } + if (new_xres != xres) + xres = new_xres; + if (new_yres != yres) + yres = new_yres; } - gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, xres, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, yres, FALSE); + + file_new_image_size_callback (widget, data); +} + +static gchar * +file_new_print_size (gdouble size) +{ + if (size < 4096) + return g_strdup_printf (_("%d Bytes"), (gint) size); + else if (size < 1024 * 10) + return g_strdup_printf (_("%.2f KB"), size / 1024); + else if (size < 1024 * 100) + return g_strdup_printf (_("%.1f KB"), size / 1024); + else if (size < 1024 * 1024) + return g_strdup_printf (_("%d KB"), (gint) size / 1024); + else if (size < 1024 * 1024 * 10) + return g_strdup_printf (_("%.2f MB"), size / 1024 / 1024); + else + return g_strdup_printf (_("%.1f MB"), size / 1024 / 1024); +} + +static void +file_new_image_size_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + gdouble width, height, size; + gchar *text; + gchar *label; + + vals = (NewImageValues *) data; + + width = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + height = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + size = + width * height * + ((vals->type == RGB ? 3 : 1) + /* bytes per pixel */ + (vals->fill_type == TRANSPARENT_FILL ? 1 : 0)); /* alpha channel */ + + text = file_new_print_size (size); + label = g_strdup_printf (_("Image Size: %s"), text); + gtk_frame_set_label (GTK_FRAME (vals->size_frame), label); + g_free (label); + g_free (text); + + vals->size = size; } void @@ -267,26 +452,57 @@ file_new_cmd_callback (GtkWidget *widget, GDisplay *gdisp; NewImageValues *vals; - GtkWidget *top_vbox; - GtkWidget *button; - GtkWidget *hbox; - GtkWidget *frame; - GtkWidget *radio_box; - gboolean advanced_options = FALSE; - GSList *group; + GtkWidget *top_vbox; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *abox; + GtkWidget *frame; + GtkWidget *table; + GtkWidget *separator; + GtkWidget *label; + GtkWidget *button; + GtkObject *adjustment; + GtkWidget *spinbutton; + GtkWidget *spinbutton2; + GtkWidget *radio_box; + GSList *group; + gint i; + + static ActionAreaItem action_items[] = + { + { N_("OK"), file_new_ok_callback, NULL, NULL }, + { N_("Reset"), file_new_reset_callback, NULL, NULL }, + { N_("Cancel"), file_new_cancel_callback, NULL, NULL } + }; + + static gchar *type_names[] = + { + N_("RGB"), + N_("Grayscale") + }; + + static gchar *fill_type_names[] = + { + N_("Foreground"), + N_("Background"), + N_("White"), + N_("Transparent") + }; if(!new_dialog_run) { /* all from gimprc */ last_width = default_width; last_height = default_height; - last_type = default_type; + last_unit = default_units; + last_xresolution = default_xresolution; last_yresolution = default_yresolution; - last_unit = default_units; last_res_unit = default_resolution_units; - new_dialog_run = 1; + last_type = default_type; + + new_dialog_run = TRUE; } /* Before we try to determine the responsible gdisplay, @@ -298,55 +514,54 @@ file_new_cmd_callback (GtkWidget *widget, gdisp = NULL; vals = g_malloc (sizeof (NewImageValues)); + vals->confirm_dlg = NULL; + vals->size = 0.0; + vals->res_unit = last_res_unit; vals->fill_type = last_fill_type; if (gdisp) { vals->width = gdisp->gimage->width; vals->height = gdisp->gimage->height; - vals->type = gimage_base_type (gdisp->gimage); + vals->unit = gdisp->gimage->unit; + vals->xresolution = gdisp->gimage->xresolution; vals->yresolution = gdisp->gimage->yresolution; - vals->unit = gdisp->gimage->unit; - vals->res_unit = last_res_unit; + + vals->type = gimage_base_type (gdisp->gimage); } else { vals->width = last_width; vals->height = last_height; - vals->type = last_type; + vals->unit = last_unit; + vals->xresolution = last_xresolution; vals->yresolution = last_yresolution; - vals->unit = last_unit; - vals->res_unit = last_res_unit; - } - if (ABS (vals->xresolution - vals->yresolution) > 1e-5) - advanced_options = TRUE; + vals->type = last_type; + } if (vals->type == INDEXED) vals->type = RGB; /* no indexed images */ - /* if a cut buffer exist, default to using its size for the new image */ - /* also check to see if a new_image has been opened */ + /* If a cut buffer exists, default to using its size for the new image + * also check to see if a new_image has been opened + */ if(global_buf && !last_new_image) { vals->width = global_buf->width; vals->height = global_buf->height; - /* It would be good to set the resolution here, but that would - * require TileManagers to know about the resolution of tiles - * they're dealing with. It's not clear we want to go down that - * road. -- austin */ } vals->dlg = gtk_dialog_new (); gtk_window_set_wmclass (GTK_WINDOW (vals->dlg), "new_image", "Gimp"); gtk_window_set_title (GTK_WINDOW (vals->dlg), _("New Image")); gtk_window_set_position (GTK_WINDOW (vals->dlg), GTK_WIN_POS_MOUSE); - gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, FALSE); + gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, TRUE); - /* handle the wm close signal */ + /* Handle the wm close signal */ gtk_signal_connect (GTK_OBJECT (vals->dlg), "delete_event", GTK_SIGNAL_FUNC (file_new_delete_callback), vals); @@ -354,123 +569,232 @@ file_new_cmd_callback (GtkWidget *widget, /* The action area */ action_items[0].user_data = vals; action_items[1].user_data = vals; - build_action_area (GTK_DIALOG (vals->dlg), action_items, 2, 1); + action_items[2].user_data = vals; + build_action_area (GTK_DIALOG (vals->dlg), action_items, 3, 2); - /* vbox holding the rest of the dialog */ + /* vbox holding the rest of the dialog */ top_vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 4); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dlg)->vbox), top_vbox, TRUE, TRUE, 0); gtk_widget_show (top_vbox); - hbox = gtk_hbox_new (FALSE, 0); - gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); + /* Image size frame */ + vals->size_frame = gtk_frame_new (NULL); + gtk_box_pack_start (GTK_BOX (top_vbox), vals->size_frame, FALSE, FALSE, 0); + gtk_widget_show (vals->size_frame); + + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); + gtk_container_add (GTK_CONTAINER (vals->size_frame), vbox); + gtk_widget_show (vbox); + + table = gtk_table_new (7, 2, FALSE); + gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); + gtk_table_set_row_spacing (GTK_TABLE (table), 1, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 2, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 4, 4); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + gtk_widget_show (table); + + /* the pixel size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* a separator after the pixel section */ + separator = gtk_hseparator_new (); + gtk_table_attach_defaults (GTK_TABLE (table), separator, 0, 2, 2, 3); + gtk_widget_show (separator); + + /* the unit size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* create the sizeentry which keeps it all together */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 3, 5); + vals->size_se = + gimp_size_entry_new (0, vals->unit, "%a", FALSE, FALSE, TRUE, 75, + GIMP_SIZE_ENTRY_UPDATE_SIZE); + gtk_table_set_col_spacing (GTK_TABLE (vals->size_se), 1, 2); + gtk_container_add (GTK_CONTAINER (abox), vals->size_se); + gtk_widget_show (vals->size_se); + gtk_widget_show (abox); + + /* height in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "height in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 2, 3); + gtk_widget_show (spinbutton); + + /* height in pixels */ + hbox = gtk_hbox_new (FALSE, 2); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton2, FALSE, FALSE, 0); + gtk_widget_show (spinbutton2); + + label = gtk_label_new (_("Pixels")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + /* add the "height in pixels" spinbutton to the main table */ + gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 1, 2); gtk_widget_show (hbox); - vals->size_sizeentry = gimp_size_entry_new (2, vals->unit, "%p", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_SIZE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + /* register the height spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* width in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "width in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 1, 2); + gtk_widget_show (spinbutton); + + /* width in pixels */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 0, 1); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + /* add the "width in pixels" spinbutton to the main table */ + gtk_container_add (GTK_CONTAINER (abox), spinbutton2); + gtk_widget_show (spinbutton2); + gtk_widget_show (abox); + + /* register the width spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* initialize the sizeentry */ + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->xresolution, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->yresolution, FALSE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - vals->width); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - vals->height); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Width"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Height"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Pixels"), 1, 4, 0.0); - gtk_box_pack_start (GTK_BOX (hbox), vals->size_sizeentry, FALSE, FALSE, 4); - gtk_widget_show (vals->size_sizeentry); - /* resolution frame */ - frame = gtk_frame_new (_("Resolution")); - gtk_box_pack_start (GTK_BOX (top_vbox), frame, FALSE, FALSE, 0); - gtk_widget_show (frame); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 0, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 1, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); - hbox = gtk_hbox_new (FALSE, 0); - gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); - gtk_container_add (GTK_CONTAINER (frame), hbox); - gtk_widget_show (hbox); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->height); - vals->simple_res = gimp_size_entry_new (1, vals->res_unit, "%s", - FALSE, FALSE, FALSE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->simple_res), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->simple_res), 0, - MIN(vals->xresolution, vals->yresolution)); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->simple_res), - _("Pixels per "), 1, 2, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->simple_res), "value_changed", + gtk_signal_connect (GTK_OBJECT (vals->size_se), "refval_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + gtk_signal_connect (GTK_OBJECT (vals->size_se), "value_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + + /* initialize the size label */ + file_new_image_size_callback (vals->size_se, vals); + + /* the resolution labels */ + label = gtk_label_new (_("Resolution X:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Y:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* the resolution sizeentry */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + + vals->resolution_se = + gimp_size_entry_new (1, default_resolution_units, _("pixels/%a"), + FALSE, FALSE, FALSE, 75, + GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 1, 2); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 2, 2); + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->resolution_se), + GTK_SPIN_BUTTON (spinbutton), NULL); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), spinbutton, + 1, 2, 0, 1); + gtk_widget_show (spinbutton); + gtk_table_attach (GTK_TABLE (table), vals->resolution_se, 1, 2, 5, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (vals->resolution_se); + + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, vals->xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, vals->yresolution); + + gtk_signal_connect (GTK_OBJECT (vals->resolution_se), "value_changed", (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->simple_res, FALSE, FALSE, 0); - gtk_table_set_row_spacings (GTK_TABLE (vals->simple_res), 2); - button = gtk_button_new_with_label (_("Advanced options >>")); - gtk_table_attach_defaults (GTK_TABLE (vals->simple_res), - button, 1, 4, 3, 4); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - (GtkSignalFunc) file_new_advanced_res_callback, vals); - gtk_widget_show (button); - /* the advanced resolution stuff - (not shown by default, but used to keep track of all the variables) */ - vals->resolution_sizeentry = - gimp_size_entry_new (2, vals->res_unit, "%s", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - vals->xresolution); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - vals->yresolution); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Horizontal"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Vertical"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "value_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "refval_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->resolution_sizeentry, - FALSE, FALSE, 0); - vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); - if (ABS (vals->xresolution - vals->yresolution) < 1e-5) - gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions), - TRUE); - gtk_table_attach_defaults (GTK_TABLE (vals->resolution_sizeentry), - vals->couple_resolutions, 1, 3, 3, 4); + /* the resolution chainbutton */ + vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_RIGHT); + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (vals->xresolution - vals->yresolution) < GIMP_MIN_RESOLUTION); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), + vals->couple_resolutions, 2, 3, 0, 2); gtk_widget_show (vals->couple_resolutions); - if (advanced_options != FALSE) - gtk_widget_show (vals->resolution_sizeentry); - else - gtk_widget_show (vals->simple_res); - - /* hbox containing the Image type and fill type frames */ - hbox = gtk_hbox_new(FALSE, 2); + /* hbox containing the Image type and fill type frames */ + hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); - gtk_widget_show(hbox); + gtk_widget_show (hbox); /* frame for Image Type */ frame = gtk_frame_new (_("Image Type")); @@ -483,29 +807,26 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("RGB")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) RGB); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == RGB) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 2; i++) + { + button = gtk_radio_button_new_with_label (group, gettext (type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Grayscale")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) GRAY); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == GRAY) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->type_w[i] = button; + } - /* frame for fill type */ + /* frame for Fill Type */ frame = gtk_frame_new (_("Fill Type")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); @@ -515,51 +836,27 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("Foreground")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) FOREGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == FOREGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 4; i++) + { + button = + gtk_radio_button_new_with_label (group, gettext (fill_type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->fill_type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->fill_type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Background")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) BACKGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == BACKGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->fill_type_w[i] = button; + } - button = gtk_radio_button_new_with_label (group, _("White")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) WHITE_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == WHITE_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - button = gtk_radio_button_new_with_label (group, _("Transparent")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) TRANSPARENT_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == TRANSPARENT_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_sizeentry)); + gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_se)); gtk_widget_show (vals->dlg); } diff --git a/app/gimprc.c b/app/gimprc.c index df869962d6..912ae2081e 100644 --- a/app/gimprc.c +++ b/app/gimprc.c @@ -138,18 +138,19 @@ int always_restore_session = FALSE; int default_width = 256; int default_height = 256; int default_type = RGB; -float default_xresolution = 72.0; -float default_yresolution = 72.0; +double default_xresolution = 72.0; +double default_yresolution = 72.0; GUnit default_resolution_units = UNIT_INCH; int show_tips = TRUE; int last_tip = -1; int show_tool_tips = TRUE; -float monitor_xres = 72.0; -float monitor_yres = 72.0; +double monitor_xres = 72.0; +double monitor_yres = 72.0; int using_xserver_resolution = FALSE; int num_processors = 1; char * image_title_format = NULL; int global_paint_options = TRUE; +int max_new_image_size = 33554432; /* 32 MB */ extern char * module_db_load_inhibit; @@ -272,8 +273,8 @@ static ParseFunc funcs[] = { "dont-show-tool-tips", TT_BOOLEAN, NULL, &show_tool_tips }, { "default-image-size", TT_POSITION, &default_width, &default_height }, { "default-image-type", TT_IMAGETYPE, &default_type, NULL }, - { "default-xresolution", TT_FLOAT, &default_xresolution, NULL }, - { "default-yresolution", TT_FLOAT, &default_yresolution, NULL }, + { "default-xresolution", TT_DOUBLE, &default_xresolution, NULL }, + { "default-yresolution", TT_DOUBLE, &default_yresolution, NULL }, { "default-resolution-units", TT_XUNIT, &default_resolution_units, NULL }, { "plug-in", TT_XPLUGIN, NULL, NULL }, { "plug-in-def", TT_XPLUGINDEF, NULL, NULL }, @@ -281,14 +282,15 @@ static ParseFunc funcs[] = { "device", TT_XDEVICE, NULL, NULL }, { "session-info", TT_XSESSIONINFO, NULL, NULL }, { "unit-info", TT_XUNITINFO, NULL, NULL }, - { "monitor-xresolution", TT_FLOAT, &monitor_xres, NULL }, - { "monitor-yresolution", TT_FLOAT, &monitor_yres, NULL }, + { "monitor-xresolution", TT_DOUBLE, &monitor_xres, NULL }, + { "monitor-yresolution", TT_DOUBLE, &monitor_yres, NULL }, { "num-processors", TT_INT, &num_processors, NULL }, { "image-title-format", TT_STRING, &image_title_format, NULL }, { "parasite", TT_XPARASITE, NULL, NULL }, { "global-paint-options", TT_BOOLEAN, &global_paint_options, NULL }, { "no-global-paint-options",TT_BOOLEAN, NULL, &global_paint_options }, - { "module-load-inhibit", TT_PATH, &module_db_load_inhibit, NULL } + { "module-load-inhibit", TT_PATH, &module_db_load_inhibit, NULL }, + { "max-new-image-size", TT_MEMSIZE, &max_new_image_size, NULL } }; static int nfuncs = sizeof (funcs) / sizeof (funcs[0]); @@ -2051,13 +2053,13 @@ parse_unit_info (gpointer val1p, GUnit unit; - gchar *identifier = NULL; - float factor = 1.0; - int digits = 2.0; - gchar *symbol = NULL; - gchar *abbreviation = NULL; - gchar *singular = NULL; - gchar *plural = NULL; + gchar *identifier = NULL; + double factor = 1.0; + int digits = 2.0; + gchar *symbol = NULL; + gchar *abbreviation = NULL; + gchar *singular = NULL; + gchar *plural = NULL; token = peek_next_token (); if (!token || (token != TOKEN_STRING)) diff --git a/app/gimprc.h b/app/gimprc.h index 263fe0c6c3..3e0b09c45b 100644 --- a/app/gimprc.h +++ b/app/gimprc.h @@ -60,20 +60,21 @@ extern int confirm_on_close; extern int default_width, default_height; extern int default_type; extern GUnit default_resolution_units; -extern float default_xresolution; -extern float default_yresolution; +extern double default_xresolution; +extern double default_yresolution; extern int save_session_info; extern int save_device_status; extern int always_restore_session; extern int show_tips; extern int last_tip; extern int show_tool_tips; -extern float monitor_xres; -extern float monitor_yres; +extern double monitor_xres; +extern double monitor_yres; extern int using_xserver_resolution; extern int num_processors; extern char * image_title_format; extern int global_paint_options; +extern int max_new_image_size; /* function prototypes */ diff --git a/app/gui/brush-select.c b/app/gui/brush-select.c index 50d7d4f5be..0ce6ae2d3c 100644 --- a/app/gui/brush-select.c +++ b/app/gui/brush-select.c @@ -358,7 +358,10 @@ brush_select_new (gchar *title, /* The action area */ action_items[0].user_data = bsp; action_items[1].user_data = bsp; - build_action_area (GTK_DIALOG (bsp->shell), action_items, 2, 1); + if (title) + build_action_area (GTK_DIALOG (bsp->shell), &action_items[1], 1, 0); + else + build_action_area (GTK_DIALOG (bsp->shell), action_items, 2, 1); gtk_widget_show (bsp->options_box); gtk_widget_show (hbox); diff --git a/app/gui/file-new-dialog.c b/app/gui/file-new-dialog.c index cbd6bb5304..4b557d7c67 100644 --- a/app/gui/file-new-dialog.c +++ b/app/gui/file-new-dialog.c @@ -1,8 +1,23 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995-1999 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ #include "appenv.h" #include "actionarea.h" -#include "app_procs.h" #include "commands.h" -#include "general.h" #include "gimage.h" #include "gimprc.h" #include "global_edit.h" @@ -16,87 +31,72 @@ #include "libgimp/gimpsizeentry.h" #include "libgimp/gimpintl.h" -typedef struct { +typedef struct +{ GtkWidget *dlg; - GtkWidget *size_sizeentry; - GtkWidget *simple_res; - GtkWidget *resolution_sizeentry; + GtkWidget *confirm_dlg; + + GtkWidget *size_frame; + GtkWidget *size_se; + GtkWidget *resolution_se; GtkWidget *couple_resolutions; - int width; - int height; + GtkWidget *type_w[2]; + GtkWidget *fill_type_w[4]; + + gint width; + gint height; GUnit unit; - float xresolution; - float yresolution; + gdouble xresolution; + gdouble yresolution; GUnit res_unit; - int type; - int fill_type; + gdouble size; /* in bytes */ + + gint type; + gint fill_type; } NewImageValues; /* new image local functions */ +static void file_new_create_image (NewImageValues *); +static void file_new_confirm_dialog (NewImageValues *); +static gchar * file_new_print_size (gdouble); + static void file_new_ok_callback (GtkWidget *, gpointer); -static void file_new_cancel_callback (GtkWidget *, gpointer); +static void file_new_reset_callback (GtkWidget *, gpointer); static gint file_new_delete_callback (GtkWidget *, GdkEvent *, gpointer); +static void file_new_cancel_callback (GtkWidget *, gpointer); static void file_new_toggle_callback (GtkWidget *, gpointer); static void file_new_resolution_callback (GtkWidget *, gpointer); -static void file_new_advanced_res_callback (GtkWidget *, gpointer); +static void file_new_image_size_callback (GtkWidget *, gpointer); /* static variables */ -static int last_width = 256; -static int last_height = 256; -static int last_type = RGB; -static int last_fill_type = BACKGROUND_FILL; -static float last_xresolution = 72.0; /* always in DPI */ -static float last_yresolution = 72.0; -static GUnit last_unit = UNIT_INCH; -static GUnit last_res_unit = UNIT_INCH; -static gboolean last_new_image = FALSE; +static gint last_width = 256; +static gint last_height = 256; +static GUnit last_unit = UNIT_INCH; -static int new_dialog_run = 0; +static gdouble last_xresolution = 72.0; +static gdouble last_yresolution = 72.0; +static GUnit last_res_unit = UNIT_INCH; -extern TileManager *global_buf; +static gint last_type = RGB; +static gint last_fill_type = BACKGROUND_FILL; -/* the action area structure */ -static ActionAreaItem action_items[] = -{ - { N_("OK"), file_new_ok_callback, NULL, NULL }, - { N_("Cancel"), file_new_cancel_callback, NULL, NULL } -}; +static gboolean last_new_image = FALSE; +static gboolean new_dialog_run = FALSE; +extern TileManager *global_buf; + +/* functions */ static void -file_new_ok_callback (GtkWidget *widget, - gpointer data) +file_new_create_image (NewImageValues *vals) { - NewImageValues *vals; - GImage *gimage; - GDisplay *gdisplay; - Layer *layer; - int type; - - vals = data; - - /* get the image size in pixels */ - vals->width = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0); - vals->height = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1); - - /* get the resolution in dpi */ - vals->xresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0); - vals->yresolution = - gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1); - - /* get the units */ - vals->unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_sizeentry)); - vals->res_unit = - gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_sizeentry)); - - gtk_widget_destroy (vals->dlg); + GImage *gimage; + GDisplay *gdisplay; + Layer *layer; + gint type; last_width = vals->width; last_height = vals->height; @@ -107,7 +107,7 @@ file_new_ok_callback (GtkWidget *widget, last_unit = vals->unit; last_res_unit = vals->res_unit; last_new_image = TRUE; - + switch (vals->fill_type) { case BACKGROUND_FILL: @@ -149,16 +149,91 @@ file_new_ok_callback (GtkWidget *widget, g_free (vals); } +static void +file_new_ok_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + /* get the image size in pixels */ + vals->width = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + vals->height = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + /* get the resolution in dpi */ + vals->xresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 0); + vals->yresolution = + gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->resolution_se), 1); + + /* get the units */ + vals->unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->size_se)); + vals->res_unit = + gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (vals->resolution_se)); + + if (vals->size > max_new_image_size) + { + file_new_confirm_dialog (vals); + } + else + { + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); + } +} + +static void +file_new_reset_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + + vals = data; + + gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (default_xresolution - default_yresolution) < GIMP_MIN_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, default_xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, default_yresolution); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->resolution_se), + default_resolution_units); + + gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_se), vals); + + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_xresolution, TRUE); + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_yresolution, TRUE); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 0, default_width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), + 1, default_height); + gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (vals->size_se), + default_units); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vals->type_w[default_type]), + TRUE); + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (vals->fill_type_w[BACKGROUND_FILL]), TRUE); +} + static gint file_new_delete_callback (GtkWidget *widget, GdkEvent *event, gpointer data) { file_new_cancel_callback (widget, data); - return TRUE; } - static void file_new_cancel_callback (GtkWidget *widget, @@ -172,11 +247,97 @@ file_new_cancel_callback (GtkWidget *widget, g_free (vals); } +/* local callbacks of file_new_confirm_dialog() */ +static void +file_new_confirm_dialog_ok_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + gtk_widget_destroy (vals->dlg); + file_new_create_image (vals); +} + +static void +file_new_confirm_dialog_cancel_callback (GtkWidget *widget, + NewImageValues *vals) +{ + gtk_widget_destroy (vals->confirm_dlg); + vals->confirm_dlg = NULL; + gtk_widget_set_sensitive (vals->dlg, TRUE); +} + +static gint +file_new_confirm_dialog_delete_callback (GtkWidget *widget, + GdkEvent *event, + NewImageValues *vals) +{ + file_new_confirm_dialog_cancel_callback (widget, vals); + return TRUE; +} + +static void +file_new_confirm_dialog (NewImageValues *vals) +{ + GtkWidget *label; + gchar *size; + gchar *max_size; + gchar *text; + + static ActionAreaItem action_items[] = + { + { N_("OK"), + (ActionCallback) file_new_confirm_dialog_ok_callback, NULL, NULL }, + { N_("Cancel"), + (ActionCallback) file_new_confirm_dialog_cancel_callback, NULL, NULL } + }; + + gtk_widget_set_sensitive (vals->dlg, FALSE); + + vals->confirm_dlg = gtk_dialog_new (); + gtk_window_set_wmclass (GTK_WINDOW (vals->confirm_dlg), + "really_create", "Gimp"); + gtk_window_set_title (GTK_WINDOW (vals->confirm_dlg), _("Confirm Image Size")); + gtk_window_position (GTK_WINDOW (vals->confirm_dlg), GTK_WIN_POS_MOUSE); + + /* Handle the wm close signal */ + gtk_signal_connect (GTK_OBJECT (vals->confirm_dlg), "delete_event", + (GtkSignalFunc) file_new_confirm_dialog_delete_callback, + vals); + + /* The action area */ + action_items[0].user_data = vals; + action_items[1].user_data = vals; + build_action_area (GTK_DIALOG (vals->confirm_dlg), action_items, 2, 0); + + text = g_strdup_printf (_("You are trying to create an image which\n" + "has an initial size of %s.\n\n" + "Choose OK to create this image anyway.\n" + "Choose Cancel if you didn't mean to\n" + "create such a large image.\n\n" + "To prevent this dialog from appearing,\n" + "increase the \"Maximum Image Size\"\n" + "setting (currently %s) in the\n" + "preferences dialog."), + size = file_new_print_size (vals->size), + max_size = file_new_print_size (max_new_image_size)); + label = gtk_label_new (text); + gtk_misc_set_padding (GTK_MISC (label), 6, 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->confirm_dlg)->vbox), label, + TRUE, TRUE, 0); + gtk_widget_show (label); + + g_free (text); + g_free (max_size); + g_free (size); + + gtk_widget_show (vals->confirm_dlg); +} + static void file_new_toggle_callback (GtkWidget *widget, gpointer data) { - int *val; + gint *val; if (GTK_TOGGLE_BUTTON (widget)->active) { @@ -185,78 +346,102 @@ file_new_toggle_callback (GtkWidget *widget, } } -static void -file_new_advanced_res_callback (GtkWidget *widget, - gpointer data) -{ - NewImageValues *vals; - - vals = data; - - gtk_widget_hide (vals->simple_res); - gtk_widget_show (vals->resolution_sizeentry); -} - static void file_new_resolution_callback (GtkWidget *widget, gpointer data) { NewImageValues *vals; - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; vals = data; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); + new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - gtk_signal_handler_block_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - if (widget == vals->simple_res) + if (gimp_chain_button_get_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) { + gtk_signal_handler_block_by_data + (GTK_OBJECT (vals->resolution_se), vals); + if (new_xres != xres) { yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, xres); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, yres); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); } - } - else + + if (new_yres != yres) + { + xres = new_xres = yres = new_yres; + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); + } + + gtk_signal_handler_unblock_by_data + (GTK_OBJECT (vals->resolution_se), vals); + } + else { - new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); - if (gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions))) - { - if (new_xres != xres) - { - yres = new_yres = xres = new_xres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, yres); - } - - if (new_yres != yres) - { - xres = new_xres = yres = new_yres; - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, xres); - } - } - else - { - if (new_xres != xres) - xres = new_xres; - if (new_yres != yres) - yres = new_yres; - } + if (new_xres != xres) + xres = new_xres; + if (new_yres != yres) + yres = new_yres; } - gtk_signal_handler_unblock_by_data (GTK_OBJECT (vals->resolution_sizeentry), - vals); - - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, xres, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, yres, FALSE); + + file_new_image_size_callback (widget, data); +} + +static gchar * +file_new_print_size (gdouble size) +{ + if (size < 4096) + return g_strdup_printf (_("%d Bytes"), (gint) size); + else if (size < 1024 * 10) + return g_strdup_printf (_("%.2f KB"), size / 1024); + else if (size < 1024 * 100) + return g_strdup_printf (_("%.1f KB"), size / 1024); + else if (size < 1024 * 1024) + return g_strdup_printf (_("%d KB"), (gint) size / 1024); + else if (size < 1024 * 1024 * 10) + return g_strdup_printf (_("%.2f MB"), size / 1024 / 1024); + else + return g_strdup_printf (_("%.1f MB"), size / 1024 / 1024); +} + +static void +file_new_image_size_callback (GtkWidget *widget, + gpointer data) +{ + NewImageValues *vals; + gdouble width, height, size; + gchar *text; + gchar *label; + + vals = (NewImageValues *) data; + + width = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 0); + height = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (vals->size_se), 1); + + size = + width * height * + ((vals->type == RGB ? 3 : 1) + /* bytes per pixel */ + (vals->fill_type == TRANSPARENT_FILL ? 1 : 0)); /* alpha channel */ + + text = file_new_print_size (size); + label = g_strdup_printf (_("Image Size: %s"), text); + gtk_frame_set_label (GTK_FRAME (vals->size_frame), label); + g_free (label); + g_free (text); + + vals->size = size; } void @@ -267,26 +452,57 @@ file_new_cmd_callback (GtkWidget *widget, GDisplay *gdisp; NewImageValues *vals; - GtkWidget *top_vbox; - GtkWidget *button; - GtkWidget *hbox; - GtkWidget *frame; - GtkWidget *radio_box; - gboolean advanced_options = FALSE; - GSList *group; + GtkWidget *top_vbox; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *abox; + GtkWidget *frame; + GtkWidget *table; + GtkWidget *separator; + GtkWidget *label; + GtkWidget *button; + GtkObject *adjustment; + GtkWidget *spinbutton; + GtkWidget *spinbutton2; + GtkWidget *radio_box; + GSList *group; + gint i; + + static ActionAreaItem action_items[] = + { + { N_("OK"), file_new_ok_callback, NULL, NULL }, + { N_("Reset"), file_new_reset_callback, NULL, NULL }, + { N_("Cancel"), file_new_cancel_callback, NULL, NULL } + }; + + static gchar *type_names[] = + { + N_("RGB"), + N_("Grayscale") + }; + + static gchar *fill_type_names[] = + { + N_("Foreground"), + N_("Background"), + N_("White"), + N_("Transparent") + }; if(!new_dialog_run) { /* all from gimprc */ last_width = default_width; last_height = default_height; - last_type = default_type; + last_unit = default_units; + last_xresolution = default_xresolution; last_yresolution = default_yresolution; - last_unit = default_units; last_res_unit = default_resolution_units; - new_dialog_run = 1; + last_type = default_type; + + new_dialog_run = TRUE; } /* Before we try to determine the responsible gdisplay, @@ -298,55 +514,54 @@ file_new_cmd_callback (GtkWidget *widget, gdisp = NULL; vals = g_malloc (sizeof (NewImageValues)); + vals->confirm_dlg = NULL; + vals->size = 0.0; + vals->res_unit = last_res_unit; vals->fill_type = last_fill_type; if (gdisp) { vals->width = gdisp->gimage->width; vals->height = gdisp->gimage->height; - vals->type = gimage_base_type (gdisp->gimage); + vals->unit = gdisp->gimage->unit; + vals->xresolution = gdisp->gimage->xresolution; vals->yresolution = gdisp->gimage->yresolution; - vals->unit = gdisp->gimage->unit; - vals->res_unit = last_res_unit; + + vals->type = gimage_base_type (gdisp->gimage); } else { vals->width = last_width; vals->height = last_height; - vals->type = last_type; + vals->unit = last_unit; + vals->xresolution = last_xresolution; vals->yresolution = last_yresolution; - vals->unit = last_unit; - vals->res_unit = last_res_unit; - } - if (ABS (vals->xresolution - vals->yresolution) > 1e-5) - advanced_options = TRUE; + vals->type = last_type; + } if (vals->type == INDEXED) vals->type = RGB; /* no indexed images */ - /* if a cut buffer exist, default to using its size for the new image */ - /* also check to see if a new_image has been opened */ + /* If a cut buffer exists, default to using its size for the new image + * also check to see if a new_image has been opened + */ if(global_buf && !last_new_image) { vals->width = global_buf->width; vals->height = global_buf->height; - /* It would be good to set the resolution here, but that would - * require TileManagers to know about the resolution of tiles - * they're dealing with. It's not clear we want to go down that - * road. -- austin */ } vals->dlg = gtk_dialog_new (); gtk_window_set_wmclass (GTK_WINDOW (vals->dlg), "new_image", "Gimp"); gtk_window_set_title (GTK_WINDOW (vals->dlg), _("New Image")); gtk_window_set_position (GTK_WINDOW (vals->dlg), GTK_WIN_POS_MOUSE); - gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, FALSE); + gtk_window_set_policy(GTK_WINDOW (vals->dlg), FALSE, FALSE, TRUE); - /* handle the wm close signal */ + /* Handle the wm close signal */ gtk_signal_connect (GTK_OBJECT (vals->dlg), "delete_event", GTK_SIGNAL_FUNC (file_new_delete_callback), vals); @@ -354,123 +569,232 @@ file_new_cmd_callback (GtkWidget *widget, /* The action area */ action_items[0].user_data = vals; action_items[1].user_data = vals; - build_action_area (GTK_DIALOG (vals->dlg), action_items, 2, 1); + action_items[2].user_data = vals; + build_action_area (GTK_DIALOG (vals->dlg), action_items, 3, 2); - /* vbox holding the rest of the dialog */ + /* vbox holding the rest of the dialog */ top_vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 4); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dlg)->vbox), top_vbox, TRUE, TRUE, 0); gtk_widget_show (top_vbox); - hbox = gtk_hbox_new (FALSE, 0); - gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); + /* Image size frame */ + vals->size_frame = gtk_frame_new (NULL); + gtk_box_pack_start (GTK_BOX (top_vbox), vals->size_frame, FALSE, FALSE, 0); + gtk_widget_show (vals->size_frame); + + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); + gtk_container_add (GTK_CONTAINER (vals->size_frame), vbox); + gtk_widget_show (vbox); + + table = gtk_table_new (7, 2, FALSE); + gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); + gtk_table_set_row_spacing (GTK_TABLE (table), 1, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 2, 4); + gtk_table_set_row_spacing (GTK_TABLE (table), 4, 4); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + gtk_widget_show (table); + + /* the pixel size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* a separator after the pixel section */ + separator = gtk_hseparator_new (); + gtk_table_attach_defaults (GTK_TABLE (table), separator, 0, 2, 2, 3); + gtk_widget_show (separator); + + /* the unit size labels */ + label = gtk_label_new (_("Width:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Height:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* create the sizeentry which keeps it all together */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 3, 5); + vals->size_se = + gimp_size_entry_new (0, vals->unit, "%a", FALSE, FALSE, TRUE, 75, + GIMP_SIZE_ENTRY_UPDATE_SIZE); + gtk_table_set_col_spacing (GTK_TABLE (vals->size_se), 1, 2); + gtk_container_add (GTK_CONTAINER (abox), vals->size_se); + gtk_widget_show (vals->size_se); + gtk_widget_show (abox); + + /* height in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "height in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 2, 3); + gtk_widget_show (spinbutton); + + /* height in pixels */ + hbox = gtk_hbox_new (FALSE, 2); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton2, FALSE, FALSE, 0); + gtk_widget_show (spinbutton2); + + label = gtk_label_new (_("Pixels")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + /* add the "height in pixels" spinbutton to the main table */ + gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 1, 2); gtk_widget_show (hbox); - vals->size_sizeentry = gimp_size_entry_new (2, vals->unit, "%p", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_SIZE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, + /* register the height spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* width in units */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + /* add the "width in units" spinbutton to the sizeentry */ + gtk_table_attach_defaults (GTK_TABLE (vals->size_se), spinbutton, + 0, 1, 1, 2); + gtk_widget_show (spinbutton); + + /* width in pixels */ + abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_table_attach_defaults (GTK_TABLE (table), abox, 1, 2, 0, 1); + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 0); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton2), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); + gtk_widget_set_usize (spinbutton2, 75, 0); + /* add the "width in pixels" spinbutton to the main table */ + gtk_container_add (GTK_CONTAINER (abox), spinbutton2); + gtk_widget_show (spinbutton2); + gtk_widget_show (abox); + + /* register the width spinbuttons with the sizeentry */ + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->size_se), + GTK_SPIN_BUTTON (spinbutton), + GTK_SPIN_BUTTON (spinbutton2)); + + /* initialize the sizeentry */ + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->xresolution, FALSE); - gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, + gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->yresolution, FALSE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 0, - vals->width); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_sizeentry), 1, - vals->height); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Width"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Height"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->size_sizeentry), - _("Pixels"), 1, 4, 0.0); - gtk_box_pack_start (GTK_BOX (hbox), vals->size_sizeentry, FALSE, FALSE, 4); - gtk_widget_show (vals->size_sizeentry); - /* resolution frame */ - frame = gtk_frame_new (_("Resolution")); - gtk_box_pack_start (GTK_BOX (top_vbox), frame, FALSE, FALSE, 0); - gtk_widget_show (frame); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 0, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->size_se), 1, + GIMP_MIN_IMAGE_SIZE, + GIMP_MAX_IMAGE_SIZE); - hbox = gtk_hbox_new (FALSE, 0); - gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); - gtk_container_add (GTK_CONTAINER (frame), hbox); - gtk_widget_show (hbox); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 0, vals->width); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->size_se), 1, vals->height); - vals->simple_res = gimp_size_entry_new (1, vals->res_unit, "%s", - FALSE, FALSE, FALSE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->simple_res), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->simple_res), 0, - MIN(vals->xresolution, vals->yresolution)); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->simple_res), - _("Pixels per "), 1, 2, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->simple_res), "value_changed", + gtk_signal_connect (GTK_OBJECT (vals->size_se), "refval_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + gtk_signal_connect (GTK_OBJECT (vals->size_se), "value_changed", + (GtkSignalFunc) file_new_image_size_callback, vals); + + /* initialize the size label */ + file_new_image_size_callback (vals->size_se, vals); + + /* the resolution labels */ + label = gtk_label_new (_("Resolution X:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + label = gtk_label_new (_("Y:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + /* the resolution sizeentry */ + adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1); + spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton), + GTK_SHADOW_NONE); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_widget_set_usize (spinbutton, 75, 0); + + vals->resolution_se = + gimp_size_entry_new (1, default_resolution_units, _("pixels/%a"), + FALSE, FALSE, FALSE, 75, + GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 1, 2); + gtk_table_set_col_spacing (GTK_TABLE (vals->resolution_se), 2, 2); + gimp_size_entry_add_field (GIMP_SIZE_ENTRY (vals->resolution_se), + GTK_SPIN_BUTTON (spinbutton), NULL); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), spinbutton, + 1, 2, 0, 1); + gtk_widget_show (spinbutton); + gtk_table_attach (GTK_TABLE (table), vals->resolution_se, 1, 2, 5, 7, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (vals->resolution_se); + + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, GIMP_MIN_RESOLUTION, + GIMP_MAX_RESOLUTION); + + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 0, vals->xresolution); + gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_se), + 1, vals->yresolution); + + gtk_signal_connect (GTK_OBJECT (vals->resolution_se), "value_changed", (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->simple_res, FALSE, FALSE, 0); - gtk_table_set_row_spacings (GTK_TABLE (vals->simple_res), 2); - button = gtk_button_new_with_label (_("Advanced options >>")); - gtk_table_attach_defaults (GTK_TABLE (vals->simple_res), - button, 1, 4, 3, 4); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - (GtkSignalFunc) file_new_advanced_res_callback, vals); - gtk_widget_show (button); - /* the advanced resolution stuff - (not shown by default, but used to keep track of all the variables) */ - vals->resolution_sizeentry = - gimp_size_entry_new (2, vals->res_unit, "%s", - FALSE, FALSE, TRUE, 75, - GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval_boundaries - (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 0, - vals->xresolution); - gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), 1, - vals->yresolution); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Horizontal"), 0, 1, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Vertical"), 0, 2, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (vals->resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "value_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_signal_connect (GTK_OBJECT (vals->resolution_sizeentry), "refval_changed", - (GtkSignalFunc) file_new_resolution_callback, vals); - gtk_box_pack_start (GTK_BOX (hbox), vals->resolution_sizeentry, - FALSE, FALSE, 0); - vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); - if (ABS (vals->xresolution - vals->yresolution) < 1e-5) - gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (vals->couple_resolutions), - TRUE); - gtk_table_attach_defaults (GTK_TABLE (vals->resolution_sizeentry), - vals->couple_resolutions, 1, 3, 3, 4); + /* the resolution chainbutton */ + vals->couple_resolutions = gimp_chain_button_new (GIMP_CHAIN_RIGHT); + gimp_chain_button_set_active + (GIMP_CHAIN_BUTTON (vals->couple_resolutions), + ABS (vals->xresolution - vals->yresolution) < GIMP_MIN_RESOLUTION); + gtk_table_attach_defaults (GTK_TABLE (vals->resolution_se), + vals->couple_resolutions, 2, 3, 0, 2); gtk_widget_show (vals->couple_resolutions); - if (advanced_options != FALSE) - gtk_widget_show (vals->resolution_sizeentry); - else - gtk_widget_show (vals->simple_res); - - /* hbox containing the Image type and fill type frames */ - hbox = gtk_hbox_new(FALSE, 2); + /* hbox containing the Image type and fill type frames */ + hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (top_vbox), hbox, FALSE, FALSE, 0); - gtk_widget_show(hbox); + gtk_widget_show (hbox); /* frame for Image Type */ frame = gtk_frame_new (_("Image Type")); @@ -483,29 +807,26 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("RGB")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) RGB); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == RGB) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 2; i++) + { + button = gtk_radio_button_new_with_label (group, gettext (type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Grayscale")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, FALSE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) GRAY); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->type); - if (vals->type == GRAY) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->type_w[i] = button; + } - /* frame for fill type */ + /* frame for Fill Type */ frame = gtk_frame_new (_("Fill Type")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); @@ -515,51 +836,27 @@ file_new_cmd_callback (GtkWidget *widget, gtk_container_add (GTK_CONTAINER (frame), radio_box); gtk_widget_show (radio_box); - button = gtk_radio_button_new_with_label (NULL, _("Foreground")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) FOREGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == FOREGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + group = NULL; + for (i = 0; i < 4; i++) + { + button = + gtk_radio_button_new_with_label (group, gettext (fill_type_names[i])); + group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); + gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); + gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) i); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_toggle_callback, + &vals->fill_type); + gtk_signal_connect (GTK_OBJECT (button), "toggled", + (GtkSignalFunc) file_new_image_size_callback, vals); + if (vals->fill_type == i) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + gtk_widget_show (button); - button = gtk_radio_button_new_with_label (group, _("Background")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) BACKGROUND_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == BACKGROUND_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); + vals->fill_type_w[i] = button; + } - button = gtk_radio_button_new_with_label (group, _("White")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) WHITE_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == WHITE_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - button = gtk_radio_button_new_with_label (group, _("Transparent")); - group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); - gtk_box_pack_start (GTK_BOX (radio_box), button, TRUE, TRUE, 0); - gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) TRANSPARENT_FILL); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - (GtkSignalFunc) file_new_toggle_callback, - &vals->fill_type); - if (vals->fill_type == TRANSPARENT_FILL) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_widget_show (button); - - gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_sizeentry)); + gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (vals->size_se)); gtk_widget_show (vals->dlg); } diff --git a/app/gui/pattern-select.c b/app/gui/pattern-select.c index 3ff4cfd827..cc289ab8f2 100644 --- a/app/gui/pattern-select.c +++ b/app/gui/pattern-select.c @@ -196,7 +196,10 @@ pattern_select_new (gchar *title, /* The action area */ action_items[0].user_data = psp; action_items[1].user_data = psp; - build_action_area (GTK_DIALOG (psp->shell), action_items, 2, 1); + if (title) + build_action_area (GTK_DIALOG (psp->shell), &action_items[1], 1, 0); + else + build_action_area (GTK_DIALOG (psp->shell), action_items, 2, 1); gtk_widget_show (psp->options_box); gtk_widget_show (vbox); diff --git a/app/gui/preferences-dialog.c b/app/gui/preferences-dialog.c index dc46004f99..48e3976601 100644 --- a/app/gui/preferences-dialog.c +++ b/app/gui/preferences-dialog.c @@ -42,6 +42,7 @@ static void file_prefs_cancel_callback (GtkWidget *, GtkWidget *); static void file_prefs_toggle_callback (GtkWidget *, gpointer); static void file_prefs_preview_size_callback (GtkWidget *, gpointer); +static void file_prefs_mem_size_callback (GtkWidget *, gpointer); static void file_prefs_mem_size_unit_callback (GtkWidget *, gpointer); static void file_prefs_int_adjustment_callback (GtkAdjustment *, gpointer); static void file_prefs_string_callback (GtkWidget *, gpointer); @@ -74,8 +75,8 @@ static int old_always_restore_session; static int old_default_width; static int old_default_height; static GUnit old_default_units; -static float old_default_xresolution; -static float old_default_yresolution; +static double old_default_xresolution; +static double old_default_yresolution; static GUnit old_default_resolution_units; static int old_default_type; static int old_stingy_memory_use; @@ -91,12 +92,13 @@ static char * old_brush_path; static char * old_pattern_path; static char * old_palette_path; static char * old_gradient_path; -static float old_monitor_xres; -static float old_monitor_yres; +static double old_monitor_xres; +static double old_monitor_yres; static int old_using_xserver_resolution; static int old_num_processors; static char * old_image_title_format; static int old_global_paint_options; +static int old_max_new_image_size; /* variables which can't be changed on the fly */ static int edit_stingy_memory_use; @@ -116,9 +118,11 @@ static char * edit_gradient_path = NULL; static GtkWidget *prefs_dlg = NULL; -static GtkObject *tile_cache_size_adjustment = NULL; static int divided_tile_cache_size; -static int mem_size_unit; +static int tile_cache_size_unit; + +static int divided_max_new_image_size; +static int max_new_image_size_unit; static GtkWidget *default_size_sizeentry = NULL; static GtkWidget *default_resolution_sizeentry = NULL; @@ -204,8 +208,6 @@ static void file_prefs_ok_callback (GtkWidget *widget, GtkWidget *dlg) { - edit_tile_cache_size = mem_size_unit * divided_tile_cache_size; - if (levels_of_undo < 0) { g_message (_("Error: Levels of undo must be zero or greater.")); @@ -273,7 +275,6 @@ file_prefs_ok_callback (GtkWidget *widget, gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -503,11 +504,19 @@ file_prefs_save_callback (GtkWidget *widget, update = g_list_append (update, "global-paint-options"); remove = g_list_append (remove, "no-global-paint-options"); } + if (max_new_image_size != old_max_new_image_size) + update = g_list_append (update, "max-new-image-size"); save_gimprc (&update, &remove); if (using_xserver_resolution) - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + { + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; + } /* Restore variables which must not change */ stingy_memory_use = save_stingy_memory_use; @@ -539,7 +548,6 @@ file_prefs_cancel_callback (GtkWidget *widget, { gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -569,6 +577,7 @@ file_prefs_cancel_callback (GtkWidget *widget, monitor_yres = old_monitor_yres; using_xserver_resolution = old_using_xserver_resolution; num_processors = old_num_processors; + max_new_image_size = old_max_new_image_size; if (preview_size != old_preview_size) { @@ -672,22 +681,66 @@ file_prefs_preview_size_callback (GtkWidget *widget, layer_select_update_preview_size (); } +static void +file_prefs_mem_size_callback (GtkWidget *widget, + gpointer data) +{ + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (widget), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (widget), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (widget), + "mem_size_unit"))) + return; + + *divided_mem_size = GTK_ADJUSTMENT (widget)->value; + *mem_size = *divided_mem_size * *mem_size_unit; +} + static void file_prefs_mem_size_unit_callback (GtkWidget *widget, gpointer data) { - int new_unit; + GtkObject *adjustment; + int new_unit; + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; - new_unit = (int)data; + adjustment = GTK_OBJECT (data); - if (new_unit != mem_size_unit) + if (! (new_unit = (int) gtk_object_get_user_data (GTK_OBJECT (widget)))) + return; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (adjustment), + "mem_size_unit"))) + return; + + if (new_unit != *mem_size_unit) { - divided_tile_cache_size = - divided_tile_cache_size * mem_size_unit / new_unit; - mem_size_unit = new_unit; + *divided_mem_size = *mem_size / new_unit; + *mem_size_unit = new_unit; - gtk_adjustment_set_value (GTK_ADJUSTMENT (tile_cache_size_adjustment), - (float)divided_tile_cache_size); + gtk_signal_handler_block_by_data (GTK_OBJECT (adjustment), + divided_mem_size); + gtk_adjustment_set_value (GTK_ADJUSTMENT (adjustment), + (float) *divided_mem_size); + gtk_signal_handler_unblock_by_data (GTK_OBJECT (adjustment), + divided_mem_size); } } @@ -752,10 +805,10 @@ static void file_prefs_default_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -810,7 +863,11 @@ file_prefs_res_source_callback (GtkWidget *widget, if (GTK_TOGGLE_BUTTON (widget)->active) { - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; using_xserver_resolution = TRUE; } else @@ -830,10 +887,10 @@ static void file_prefs_monitor_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -1191,6 +1248,7 @@ gimp_table_attach_aligned (GtkTable *table, label = gtk_label_new (text); gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); @@ -1199,7 +1257,7 @@ gimp_table_attach_aligned (GtkTable *table, { GtkWidget *alignment; - alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + alignment = gtk_alignment_new (0.0, 1.0, 0.0, 0.0); gtk_table_attach_defaults (table, alignment, 1, 2, row, row + 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (alignment), widget); @@ -1373,6 +1431,7 @@ file_pref_cmd_callback (GtkWidget *widget, old_num_processors = num_processors; old_image_title_format = file_prefs_strdup (image_title_format); old_global_paint_options = global_paint_options; + old_max_new_image_size = max_new_image_size; file_prefs_strset (&old_temp_path, edit_temp_path); file_prefs_strset (&old_swap_path, edit_swap_path); @@ -1383,14 +1442,23 @@ file_pref_cmd_callback (GtkWidget *widget, file_prefs_strset (&old_palette_path, edit_palette_path); file_prefs_strset (&old_gradient_path, edit_gradient_path); - mem_size_unit = 1; + tile_cache_size_unit = 1; for (i = 0; i < 3; i++) { - if (edit_tile_cache_size % (mem_size_unit * 1024) != 0) + if (edit_tile_cache_size % (tile_cache_size_unit * 1024) != 0) break; - mem_size_unit *= 1024; + tile_cache_size_unit *= 1024; } - divided_tile_cache_size = edit_tile_cache_size / mem_size_unit; + divided_tile_cache_size = edit_tile_cache_size / tile_cache_size_unit; + + max_new_image_size_unit = 1; + for (i = 0; i < 3; i++) + { + if (max_new_image_size % (max_new_image_size_unit * 1024) != 0) + break; + max_new_image_size_unit *= 1024; + } + divided_max_new_image_size = max_new_image_size / max_new_image_size_unit; /* Create the dialog */ prefs_dlg = @@ -1466,8 +1534,10 @@ file_pref_cmd_callback (GtkWidget *widget, 0, default_xresolution, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, default_yresolution, FALSE); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, default_width); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, @@ -1498,11 +1568,13 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); default_resolution_sizeentry = - gimp_size_entry_new (2, default_resolution_units, "%s", + gimp_size_entry_new (2, default_resolution_units, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, default_xresolution); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), @@ -1512,9 +1584,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (default_resolution_sizeentry), "unit_changed", (GtkSignalFunc)file_prefs_default_resolution_callback, @@ -1920,9 +1990,9 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); #ifdef ENABLE_MP - table = gtk_table_new (2, 2, FALSE); + table = gtk_table_new (3, 2, FALSE); #else - table = gtk_table_new (1, 2, FALSE); + table = gtk_table_new (2, 2, FALSE); #endif /* ENABLE_MP */ gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); @@ -1930,31 +2000,72 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0); gtk_widget_show (table); + /* The tile cache size */ hbox = gtk_hbox_new (FALSE, 2); spinbutton = - gimp_spin_button_new (&tile_cache_size_adjustment, + gimp_spin_button_new (&adjustment, divided_tile_cache_size, 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, 1.0, 0.0); - gtk_signal_connect (GTK_OBJECT (tile_cache_size_adjustment), "value_changed", - (GtkSignalFunc) file_prefs_int_adjustment_callback, + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, ÷d_tile_cache_size); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); - + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &edit_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &tile_cache_size_unit); + optionmenu = gimp_option_menu_new (file_prefs_mem_size_unit_callback, - (gpointer) mem_size_unit, - _("Bytes"), (gpointer) 1, (gpointer) 1, - _("KiloBytes"), (gpointer) 1024, (gpointer) 1024, - _("MegaBytes"), - (gpointer) (1024*1024), (gpointer) (1024*1024), + (gpointer) tile_cache_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), NULL); gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); gtk_widget_show (optionmenu); gimp_table_attach_aligned (GTK_TABLE (table), 0, _("Tile Cache Size:"), 1.0, 0.5, hbox, TRUE); + /* The maximum size of a new image */ + hbox = gtk_hbox_new (FALSE, 2); + spinbutton = + gimp_spin_button_new (&adjustment, + divided_max_new_image_size, + 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, + 1.0, 0.0); + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, + ÷d_max_new_image_size); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); + gtk_widget_show (spinbutton); + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &max_new_image_size_unit); + + optionmenu = + gimp_option_menu_new (file_prefs_mem_size_unit_callback, + (gpointer) max_new_image_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), + NULL); + gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); + gtk_widget_show (optionmenu); + gimp_table_attach_aligned (GTK_TABLE (table), 1, + _("Maximum Image Size:"), 1.0, 0.5, hbox, TRUE); + #ifdef ENABLE_MP spinbutton = gimp_spin_button_new (&adjustment, @@ -1962,7 +2073,7 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) file_prefs_int_adjustment_callback, &num_processors); - gimp_table_attach_aligned (GTK_TABLE (table), 1, + gimp_table_attach_aligned (GTK_TABLE (table), 2, _("Number of Processors to Use:"), 1.0, 0.5, spinbutton, TRUE); #endif /* ENABLE_MP */ @@ -2094,8 +2205,8 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); { - float xres, yres; - char buf[80]; + gfloat xres, yres; + gchar buf[80]; gdisplay_xserver_resolution (&xres, &yres); @@ -2120,10 +2231,12 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); monitor_resolution_sizeentry = - gimp_size_entry_new (2, UNIT_INCH, "%s", FALSE, FALSE, TRUE, 75, + gimp_size_entry_new (2, UNIT_INCH, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, monitor_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), @@ -2133,9 +2246,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (monitor_resolution_sizeentry), "value_changed", (GtkSignalFunc)file_prefs_monitor_resolution_callback, diff --git a/app/gui/resize-dialog.c b/app/gui/resize-dialog.c index 7d3909300a..da2b0af474 100644 --- a/app/gui/resize-dialog.c +++ b/app/gui/resize-dialog.c @@ -102,6 +102,7 @@ resize_widget_new (ResizeType type, GtkWidget *table; GtkWidget *table2; GtkWidget *hbox; + GtkWidget *hbox2; GtkWidget *label; GtkWidget *frame; GtkWidget *spinbutton; @@ -459,9 +460,12 @@ resize_widget_new (ResizeType type, gtk_widget_show (table); /* frame to hold drawing area */ + hbox2 = gtk_hbox_new (0, FALSE); + gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); + frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); - gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, FALSE, 0); private->drawing_area = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (private->drawing_area), private->area_width, private->area_height); @@ -474,6 +478,7 @@ resize_widget_new (ResizeType type, gtk_widget_show (private->drawing_area); gtk_widget_show (frame); + gtk_widget_show (hbox2); gtk_widget_show (vbox2); gtk_widget_show (hbox); } diff --git a/app/pattern_select.c b/app/pattern_select.c index 3ff4cfd827..cc289ab8f2 100644 --- a/app/pattern_select.c +++ b/app/pattern_select.c @@ -196,7 +196,10 @@ pattern_select_new (gchar *title, /* The action area */ action_items[0].user_data = psp; action_items[1].user_data = psp; - build_action_area (GTK_DIALOG (psp->shell), action_items, 2, 1); + if (title) + build_action_area (GTK_DIALOG (psp->shell), &action_items[1], 1, 0); + else + build_action_area (GTK_DIALOG (psp->shell), action_items, 2, 1); gtk_widget_show (psp->options_box); gtk_widget_show (vbox); diff --git a/app/preferences_dialog.c b/app/preferences_dialog.c index dc46004f99..48e3976601 100644 --- a/app/preferences_dialog.c +++ b/app/preferences_dialog.c @@ -42,6 +42,7 @@ static void file_prefs_cancel_callback (GtkWidget *, GtkWidget *); static void file_prefs_toggle_callback (GtkWidget *, gpointer); static void file_prefs_preview_size_callback (GtkWidget *, gpointer); +static void file_prefs_mem_size_callback (GtkWidget *, gpointer); static void file_prefs_mem_size_unit_callback (GtkWidget *, gpointer); static void file_prefs_int_adjustment_callback (GtkAdjustment *, gpointer); static void file_prefs_string_callback (GtkWidget *, gpointer); @@ -74,8 +75,8 @@ static int old_always_restore_session; static int old_default_width; static int old_default_height; static GUnit old_default_units; -static float old_default_xresolution; -static float old_default_yresolution; +static double old_default_xresolution; +static double old_default_yresolution; static GUnit old_default_resolution_units; static int old_default_type; static int old_stingy_memory_use; @@ -91,12 +92,13 @@ static char * old_brush_path; static char * old_pattern_path; static char * old_palette_path; static char * old_gradient_path; -static float old_monitor_xres; -static float old_monitor_yres; +static double old_monitor_xres; +static double old_monitor_yres; static int old_using_xserver_resolution; static int old_num_processors; static char * old_image_title_format; static int old_global_paint_options; +static int old_max_new_image_size; /* variables which can't be changed on the fly */ static int edit_stingy_memory_use; @@ -116,9 +118,11 @@ static char * edit_gradient_path = NULL; static GtkWidget *prefs_dlg = NULL; -static GtkObject *tile_cache_size_adjustment = NULL; static int divided_tile_cache_size; -static int mem_size_unit; +static int tile_cache_size_unit; + +static int divided_max_new_image_size; +static int max_new_image_size_unit; static GtkWidget *default_size_sizeentry = NULL; static GtkWidget *default_resolution_sizeentry = NULL; @@ -204,8 +208,6 @@ static void file_prefs_ok_callback (GtkWidget *widget, GtkWidget *dlg) { - edit_tile_cache_size = mem_size_unit * divided_tile_cache_size; - if (levels_of_undo < 0) { g_message (_("Error: Levels of undo must be zero or greater.")); @@ -273,7 +275,6 @@ file_prefs_ok_callback (GtkWidget *widget, gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -503,11 +504,19 @@ file_prefs_save_callback (GtkWidget *widget, update = g_list_append (update, "global-paint-options"); remove = g_list_append (remove, "no-global-paint-options"); } + if (max_new_image_size != old_max_new_image_size) + update = g_list_append (update, "max-new-image-size"); save_gimprc (&update, &remove); if (using_xserver_resolution) - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + { + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; + } /* Restore variables which must not change */ stingy_memory_use = save_stingy_memory_use; @@ -539,7 +548,6 @@ file_prefs_cancel_callback (GtkWidget *widget, { gtk_widget_destroy (dlg); prefs_dlg = NULL; - tile_cache_size_adjustment = NULL; default_size_sizeentry = NULL; default_resolution_sizeentry = NULL; resolution_xserver_label = NULL; @@ -569,6 +577,7 @@ file_prefs_cancel_callback (GtkWidget *widget, monitor_yres = old_monitor_yres; using_xserver_resolution = old_using_xserver_resolution; num_processors = old_num_processors; + max_new_image_size = old_max_new_image_size; if (preview_size != old_preview_size) { @@ -672,22 +681,66 @@ file_prefs_preview_size_callback (GtkWidget *widget, layer_select_update_preview_size (); } +static void +file_prefs_mem_size_callback (GtkWidget *widget, + gpointer data) +{ + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (widget), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (widget), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (widget), + "mem_size_unit"))) + return; + + *divided_mem_size = GTK_ADJUSTMENT (widget)->value; + *mem_size = *divided_mem_size * *mem_size_unit; +} + static void file_prefs_mem_size_unit_callback (GtkWidget *widget, gpointer data) { - int new_unit; + GtkObject *adjustment; + int new_unit; + int *mem_size; + int *divided_mem_size; + int *mem_size_unit; - new_unit = (int)data; + adjustment = GTK_OBJECT (data); - if (new_unit != mem_size_unit) + if (! (new_unit = (int) gtk_object_get_user_data (GTK_OBJECT (widget)))) + return; + + if (! (mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), "mem_size"))) + return; + + if (! (divided_mem_size = gtk_object_get_data (GTK_OBJECT (adjustment), + "divided_mem_size"))) + return; + + if (! (mem_size_unit = gtk_object_get_data (GTK_OBJECT (adjustment), + "mem_size_unit"))) + return; + + if (new_unit != *mem_size_unit) { - divided_tile_cache_size = - divided_tile_cache_size * mem_size_unit / new_unit; - mem_size_unit = new_unit; + *divided_mem_size = *mem_size / new_unit; + *mem_size_unit = new_unit; - gtk_adjustment_set_value (GTK_ADJUSTMENT (tile_cache_size_adjustment), - (float)divided_tile_cache_size); + gtk_signal_handler_block_by_data (GTK_OBJECT (adjustment), + divided_mem_size); + gtk_adjustment_set_value (GTK_ADJUSTMENT (adjustment), + (float) *divided_mem_size); + gtk_signal_handler_unblock_by_data (GTK_OBJECT (adjustment), + divided_mem_size); } } @@ -752,10 +805,10 @@ static void file_prefs_default_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -810,7 +863,11 @@ file_prefs_res_source_callback (GtkWidget *widget, if (GTK_TOGGLE_BUTTON (widget)->active) { - gdisplay_xserver_resolution (&monitor_xres, &monitor_yres); + gfloat xres, yres; + + gdisplay_xserver_resolution (&xres, &yres); + monitor_xres = xres; + monitor_yres = yres; using_xserver_resolution = TRUE; } else @@ -830,10 +887,10 @@ static void file_prefs_monitor_resolution_callback (GtkWidget *widget, gpointer data) { - static float xres = 0.0; - static float yres = 0.0; - float new_xres; - float new_yres; + static gdouble xres = 0.0; + static gdouble yres = 0.0; + gdouble new_xres; + gdouble new_yres; new_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); @@ -1191,6 +1248,7 @@ gimp_table_attach_aligned (GtkTable *table, label = gtk_label_new (text); gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); @@ -1199,7 +1257,7 @@ gimp_table_attach_aligned (GtkTable *table, { GtkWidget *alignment; - alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + alignment = gtk_alignment_new (0.0, 1.0, 0.0, 0.0); gtk_table_attach_defaults (table, alignment, 1, 2, row, row + 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (alignment), widget); @@ -1373,6 +1431,7 @@ file_pref_cmd_callback (GtkWidget *widget, old_num_processors = num_processors; old_image_title_format = file_prefs_strdup (image_title_format); old_global_paint_options = global_paint_options; + old_max_new_image_size = max_new_image_size; file_prefs_strset (&old_temp_path, edit_temp_path); file_prefs_strset (&old_swap_path, edit_swap_path); @@ -1383,14 +1442,23 @@ file_pref_cmd_callback (GtkWidget *widget, file_prefs_strset (&old_palette_path, edit_palette_path); file_prefs_strset (&old_gradient_path, edit_gradient_path); - mem_size_unit = 1; + tile_cache_size_unit = 1; for (i = 0; i < 3; i++) { - if (edit_tile_cache_size % (mem_size_unit * 1024) != 0) + if (edit_tile_cache_size % (tile_cache_size_unit * 1024) != 0) break; - mem_size_unit *= 1024; + tile_cache_size_unit *= 1024; } - divided_tile_cache_size = edit_tile_cache_size / mem_size_unit; + divided_tile_cache_size = edit_tile_cache_size / tile_cache_size_unit; + + max_new_image_size_unit = 1; + for (i = 0; i < 3; i++) + { + if (max_new_image_size % (max_new_image_size_unit * 1024) != 0) + break; + max_new_image_size_unit *= 1024; + } + divided_max_new_image_size = max_new_image_size / max_new_image_size_unit; /* Create the dialog */ prefs_dlg = @@ -1466,8 +1534,10 @@ file_pref_cmd_callback (GtkWidget *widget, 0, default_xresolution, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, default_yresolution, FALSE); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 0, default_width); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_size_sizeentry), 1, @@ -1498,11 +1568,13 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); default_resolution_sizeentry = - gimp_size_entry_new (2, default_resolution_units, "%s", + gimp_size_entry_new (2, default_resolution_units, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), 0, default_xresolution); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (default_resolution_sizeentry), @@ -1512,9 +1584,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (default_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (default_resolution_sizeentry), "unit_changed", (GtkSignalFunc)file_prefs_default_resolution_callback, @@ -1920,9 +1990,9 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); #ifdef ENABLE_MP - table = gtk_table_new (2, 2, FALSE); + table = gtk_table_new (3, 2, FALSE); #else - table = gtk_table_new (1, 2, FALSE); + table = gtk_table_new (2, 2, FALSE); #endif /* ENABLE_MP */ gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); @@ -1930,31 +2000,72 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0); gtk_widget_show (table); + /* The tile cache size */ hbox = gtk_hbox_new (FALSE, 2); spinbutton = - gimp_spin_button_new (&tile_cache_size_adjustment, + gimp_spin_button_new (&adjustment, divided_tile_cache_size, 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, 1.0, 0.0); - gtk_signal_connect (GTK_OBJECT (tile_cache_size_adjustment), "value_changed", - (GtkSignalFunc) file_prefs_int_adjustment_callback, + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, ÷d_tile_cache_size); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); - + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &edit_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_tile_cache_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &tile_cache_size_unit); + optionmenu = gimp_option_menu_new (file_prefs_mem_size_unit_callback, - (gpointer) mem_size_unit, - _("Bytes"), (gpointer) 1, (gpointer) 1, - _("KiloBytes"), (gpointer) 1024, (gpointer) 1024, - _("MegaBytes"), - (gpointer) (1024*1024), (gpointer) (1024*1024), + (gpointer) tile_cache_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), NULL); gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); gtk_widget_show (optionmenu); gimp_table_attach_aligned (GTK_TABLE (table), 0, _("Tile Cache Size:"), 1.0, 0.5, hbox, TRUE); + /* The maximum size of a new image */ + hbox = gtk_hbox_new (FALSE, 2); + spinbutton = + gimp_spin_button_new (&adjustment, + divided_max_new_image_size, + 0.0, (4069.0 * 1024 * 1024), 1.0, 16.0, 0.0, + 1.0, 0.0); + gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", + (GtkSignalFunc) file_prefs_mem_size_callback, + ÷d_max_new_image_size); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); + gtk_widget_show (spinbutton); + + /* for the mem_size_unit callback */ + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size", + &max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "divided_mem_size", + ÷d_max_new_image_size); + gtk_object_set_data (GTK_OBJECT (adjustment), "mem_size_unit", + &max_new_image_size_unit); + + optionmenu = + gimp_option_menu_new (file_prefs_mem_size_unit_callback, + (gpointer) max_new_image_size_unit, + _("Bytes"), adjustment, (gpointer) 1, + _("KiloBytes"), adjustment, (gpointer) 1024, + _("MegaBytes"), adjustment, (gpointer) (1024*1024), + NULL); + gtk_box_pack_start (GTK_BOX (hbox), optionmenu, FALSE, FALSE, 0); + gtk_widget_show (optionmenu); + gimp_table_attach_aligned (GTK_TABLE (table), 1, + _("Maximum Image Size:"), 1.0, 0.5, hbox, TRUE); + #ifdef ENABLE_MP spinbutton = gimp_spin_button_new (&adjustment, @@ -1962,7 +2073,7 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", (GtkSignalFunc) file_prefs_int_adjustment_callback, &num_processors); - gimp_table_attach_aligned (GTK_TABLE (table), 1, + gimp_table_attach_aligned (GTK_TABLE (table), 2, _("Number of Processors to Use:"), 1.0, 0.5, spinbutton, TRUE); #endif /* ENABLE_MP */ @@ -2094,8 +2205,8 @@ file_pref_cmd_callback (GtkWidget *widget, gtk_widget_show (button); { - float xres, yres; - char buf[80]; + gfloat xres, yres; + gchar buf[80]; gdisplay_xserver_resolution (&xres, &yres); @@ -2120,10 +2231,12 @@ file_pref_cmd_callback (GtkWidget *widget, button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); monitor_resolution_sizeentry = - gimp_size_entry_new (2, UNIT_INCH, "%s", FALSE, FALSE, TRUE, 75, + gimp_size_entry_new (2, UNIT_INCH, "Pixels/%s", FALSE, FALSE, TRUE, 75, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); - gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, 1, 32767); + gimp_size_entry_set_refval_boundaries + (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 1, 1, 32767); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), 0, monitor_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), @@ -2133,9 +2246,7 @@ file_pref_cmd_callback (GtkWidget *widget, gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), _("Vertical"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("dpi"), 1, 3, 0.0); - gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (monitor_resolution_sizeentry), - _("Pixels per "), 2, 3, 0.0); + _("dpi"), 1, 4, 0.0); gtk_signal_connect (GTK_OBJECT (monitor_resolution_sizeentry), "value_changed", (GtkSignalFunc)file_prefs_monitor_resolution_callback, diff --git a/app/resize.c b/app/resize.c index 7d3909300a..da2b0af474 100644 --- a/app/resize.c +++ b/app/resize.c @@ -102,6 +102,7 @@ resize_widget_new (ResizeType type, GtkWidget *table; GtkWidget *table2; GtkWidget *hbox; + GtkWidget *hbox2; GtkWidget *label; GtkWidget *frame; GtkWidget *spinbutton; @@ -459,9 +460,12 @@ resize_widget_new (ResizeType type, gtk_widget_show (table); /* frame to hold drawing area */ + hbox2 = gtk_hbox_new (0, FALSE); + gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); + frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); - gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, FALSE, 0); private->drawing_area = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (private->drawing_area), private->area_width, private->area_height); @@ -474,6 +478,7 @@ resize_widget_new (ResizeType type, gtk_widget_show (private->drawing_area); gtk_widget_show (frame); + gtk_widget_show (hbox2); gtk_widget_show (vbox2); gtk_widget_show (hbox); } diff --git a/app/text_tool.c b/app/text_tool.c index 5d92965925..c55a53d77c 100644 --- a/app/text_tool.c +++ b/app/text_tool.c @@ -204,7 +204,7 @@ text_options_new (void) gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0); gtk_widget_show (sep); - /* antialias toggle */ + /* the dynamic text toggle */ options->use_dyntext_w = gtk_check_button_new_with_label (_("Use Dynamic Text")); gtk_signal_connect (GTK_OBJECT (options->use_dyntext_w), "toggled", @@ -267,6 +267,7 @@ void tools_free_text (Tool *tool) { g_free (tool->private); + the_text_tool = NULL; if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); @@ -396,7 +397,6 @@ text_control (Tool *tool, case HALT : if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); - the_text_tool = NULL; break; } } @@ -880,8 +880,8 @@ text_field_edges(char *fontname, * *fontname is replaced by a fresh allocation of the correct size. */ static void -text_size_multiply(char **fontname, - int mul) +text_size_multiply (char **fontname, + int mul) { char *pixel_str; char *point_str; diff --git a/app/tools/gimptexttool.c b/app/tools/gimptexttool.c index 5d92965925..c55a53d77c 100644 --- a/app/tools/gimptexttool.c +++ b/app/tools/gimptexttool.c @@ -204,7 +204,7 @@ text_options_new (void) gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0); gtk_widget_show (sep); - /* antialias toggle */ + /* the dynamic text toggle */ options->use_dyntext_w = gtk_check_button_new_with_label (_("Use Dynamic Text")); gtk_signal_connect (GTK_OBJECT (options->use_dyntext_w), "toggled", @@ -267,6 +267,7 @@ void tools_free_text (Tool *tool) { g_free (tool->private); + the_text_tool = NULL; if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); @@ -396,7 +397,6 @@ text_control (Tool *tool, case HALT : if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); - the_text_tool = NULL; break; } } @@ -880,8 +880,8 @@ text_field_edges(char *fontname, * *fontname is replaced by a fresh allocation of the correct size. */ static void -text_size_multiply(char **fontname, - int mul) +text_size_multiply (char **fontname, + int mul) { char *pixel_str; char *point_str; diff --git a/app/tools/text_tool.c b/app/tools/text_tool.c index 5d92965925..c55a53d77c 100644 --- a/app/tools/text_tool.c +++ b/app/tools/text_tool.c @@ -204,7 +204,7 @@ text_options_new (void) gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0); gtk_widget_show (sep); - /* antialias toggle */ + /* the dynamic text toggle */ options->use_dyntext_w = gtk_check_button_new_with_label (_("Use Dynamic Text")); gtk_signal_connect (GTK_OBJECT (options->use_dyntext_w), "toggled", @@ -267,6 +267,7 @@ void tools_free_text (Tool *tool) { g_free (tool->private); + the_text_tool = NULL; if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); @@ -396,7 +397,6 @@ text_control (Tool *tool, case HALT : if (text_tool_shell && GTK_WIDGET_VISIBLE (text_tool_shell)) gtk_widget_hide (text_tool_shell); - the_text_tool = NULL; break; } } @@ -880,8 +880,8 @@ text_field_edges(char *fontname, * *fontname is replaced by a fresh allocation of the correct size. */ static void -text_size_multiply(char **fontname, - int mul) +text_size_multiply (char **fontname, + int mul) { char *pixel_str; char *point_str; diff --git a/libgimp/Makefile.am b/libgimp/Makefile.am index 74c76ed2ea..336cd2a96e 100644 --- a/libgimp/Makefile.am +++ b/libgimp/Makefile.am @@ -93,7 +93,12 @@ libgimpui_la_SOURCES = \ gimpmenu.c \ gimpbrushmenu.c \ gimpgradientmenu.c \ - gimppatternmenu.c + gimppatternmenu.c \ + gimpchainbutton.c \ + gimpfileselection.c \ + gimppatheditor.c \ + gimpsizeentry.c \ + gimpunitmenu.c gimpinclude_HEADERS = \ color_selector.h \ diff --git a/libgimp/gimpfileselection.c b/libgimp/gimpfileselection.c index 08c6fb3537..6e5cd66384 100644 --- a/libgimp/gimpfileselection.c +++ b/libgimp/gimpfileselection.c @@ -83,6 +83,9 @@ gimp_file_selection_class_destroy (GtkObject *object) if (gfs->file_selection) gtk_widget_destroy (gfs->file_selection); + if (gfs->title) + g_free (gfs->title); + if (GTK_OBJECT_CLASS (parent_class)->destroy) (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); } @@ -118,14 +121,17 @@ gimp_file_selection_init (GimpFileSelection *gfs) gfs->file_exists = FALSE; gfs->check_valid = FALSE; + gtk_box_set_spacing (GTK_BOX (gfs), 2); + gtk_box_set_homogeneous (GTK_BOX (gfs), FALSE); + gfs->browse_button = gtk_button_new_with_label (" ... "); - gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, TRUE, 0); + gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(gfs->browse_button), "clicked", GTK_SIGNAL_FUNC(gimp_file_selection_browse_callback), gfs); gtk_widget_show (gfs->browse_button); gfs->entry = gtk_entry_new (); - gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 2); + gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(gfs->entry), "activate", (GtkSignalFunc) gimp_file_selection_entry_callback, gfs); gtk_signal_connect (GTK_OBJECT(gfs->entry), "focus_out_event", @@ -177,7 +183,7 @@ gimp_file_selection_new (gchar *title, gfs->title = g_strdup (title); gfs->dir_only = dir_only; gfs->check_valid = check_valid; - gtk_entry_set_text (GTK_ENTRY (gfs->entry), filename); + gimp_file_selection_set_filename (gfs, filename); return GTK_WIDGET (gfs); } @@ -274,6 +280,8 @@ gimp_file_selection_entry_callback (GtkWidget *widget, gimp_file_selection_check_filename (gfs); + gtk_entry_set_position (GTK_ENTRY (gfs->entry), -1); + gtk_signal_emit (GTK_OBJECT (gfs), gimp_file_selection_signals[GFS_FILENAME_CHANGED_SIGNAL]); } diff --git a/libgimp/gimplimits.h b/libgimp/gimplimits.h index b6f430c357..9dd23e525f 100644 --- a/libgimp/gimplimits.h +++ b/libgimp/gimplimits.h @@ -25,7 +25,7 @@ /* pixel sizes */ #define GIMP_MIN_IMAGE_SIZE 1 -#define GIMP_MAX_IMAGE_SIZE 65536 +#define GIMP_MAX_IMAGE_SIZE 16777216 /* dots per inch */ diff --git a/libgimp/gimpsizeentry.c b/libgimp/gimpsizeentry.c index eaa6cad74a..050f758cf6 100644 --- a/libgimp/gimpsizeentry.c +++ b/libgimp/gimpsizeentry.c @@ -183,7 +183,7 @@ gimp_size_entry_new (gint number_of_fields, GimpSizeEntry *gse; gint i; - g_return_val_if_fail ((number_of_fields > 0) && (number_of_fields <= 16), + g_return_val_if_fail ((number_of_fields >= 0) && (number_of_fields <= 16), NULL); gse = gtk_type_new (gimp_size_entry_get_type ()); diff --git a/libgimpbase/gimplimits.h b/libgimpbase/gimplimits.h index b6f430c357..9dd23e525f 100644 --- a/libgimpbase/gimplimits.h +++ b/libgimpbase/gimplimits.h @@ -25,7 +25,7 @@ /* pixel sizes */ #define GIMP_MIN_IMAGE_SIZE 1 -#define GIMP_MAX_IMAGE_SIZE 65536 +#define GIMP_MAX_IMAGE_SIZE 16777216 /* dots per inch */ diff --git a/libgimpwidgets/gimpfileentry.c b/libgimpwidgets/gimpfileentry.c index 08c6fb3537..6e5cd66384 100644 --- a/libgimpwidgets/gimpfileentry.c +++ b/libgimpwidgets/gimpfileentry.c @@ -83,6 +83,9 @@ gimp_file_selection_class_destroy (GtkObject *object) if (gfs->file_selection) gtk_widget_destroy (gfs->file_selection); + if (gfs->title) + g_free (gfs->title); + if (GTK_OBJECT_CLASS (parent_class)->destroy) (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); } @@ -118,14 +121,17 @@ gimp_file_selection_init (GimpFileSelection *gfs) gfs->file_exists = FALSE; gfs->check_valid = FALSE; + gtk_box_set_spacing (GTK_BOX (gfs), 2); + gtk_box_set_homogeneous (GTK_BOX (gfs), FALSE); + gfs->browse_button = gtk_button_new_with_label (" ... "); - gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, TRUE, 0); + gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(gfs->browse_button), "clicked", GTK_SIGNAL_FUNC(gimp_file_selection_browse_callback), gfs); gtk_widget_show (gfs->browse_button); gfs->entry = gtk_entry_new (); - gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 2); + gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(gfs->entry), "activate", (GtkSignalFunc) gimp_file_selection_entry_callback, gfs); gtk_signal_connect (GTK_OBJECT(gfs->entry), "focus_out_event", @@ -177,7 +183,7 @@ gimp_file_selection_new (gchar *title, gfs->title = g_strdup (title); gfs->dir_only = dir_only; gfs->check_valid = check_valid; - gtk_entry_set_text (GTK_ENTRY (gfs->entry), filename); + gimp_file_selection_set_filename (gfs, filename); return GTK_WIDGET (gfs); } @@ -274,6 +280,8 @@ gimp_file_selection_entry_callback (GtkWidget *widget, gimp_file_selection_check_filename (gfs); + gtk_entry_set_position (GTK_ENTRY (gfs->entry), -1); + gtk_signal_emit (GTK_OBJECT (gfs), gimp_file_selection_signals[GFS_FILENAME_CHANGED_SIGNAL]); } diff --git a/libgimpwidgets/gimpfileselection.c b/libgimpwidgets/gimpfileselection.c index 08c6fb3537..6e5cd66384 100644 --- a/libgimpwidgets/gimpfileselection.c +++ b/libgimpwidgets/gimpfileselection.c @@ -83,6 +83,9 @@ gimp_file_selection_class_destroy (GtkObject *object) if (gfs->file_selection) gtk_widget_destroy (gfs->file_selection); + if (gfs->title) + g_free (gfs->title); + if (GTK_OBJECT_CLASS (parent_class)->destroy) (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); } @@ -118,14 +121,17 @@ gimp_file_selection_init (GimpFileSelection *gfs) gfs->file_exists = FALSE; gfs->check_valid = FALSE; + gtk_box_set_spacing (GTK_BOX (gfs), 2); + gtk_box_set_homogeneous (GTK_BOX (gfs), FALSE); + gfs->browse_button = gtk_button_new_with_label (" ... "); - gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, TRUE, 0); + gtk_box_pack_end (GTK_BOX (gfs), gfs->browse_button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(gfs->browse_button), "clicked", GTK_SIGNAL_FUNC(gimp_file_selection_browse_callback), gfs); gtk_widget_show (gfs->browse_button); gfs->entry = gtk_entry_new (); - gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 2); + gtk_box_pack_end (GTK_BOX (gfs), gfs->entry, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(gfs->entry), "activate", (GtkSignalFunc) gimp_file_selection_entry_callback, gfs); gtk_signal_connect (GTK_OBJECT(gfs->entry), "focus_out_event", @@ -177,7 +183,7 @@ gimp_file_selection_new (gchar *title, gfs->title = g_strdup (title); gfs->dir_only = dir_only; gfs->check_valid = check_valid; - gtk_entry_set_text (GTK_ENTRY (gfs->entry), filename); + gimp_file_selection_set_filename (gfs, filename); return GTK_WIDGET (gfs); } @@ -274,6 +280,8 @@ gimp_file_selection_entry_callback (GtkWidget *widget, gimp_file_selection_check_filename (gfs); + gtk_entry_set_position (GTK_ENTRY (gfs->entry), -1); + gtk_signal_emit (GTK_OBJECT (gfs), gimp_file_selection_signals[GFS_FILENAME_CHANGED_SIGNAL]); } diff --git a/libgimpwidgets/gimpsizeentry.c b/libgimpwidgets/gimpsizeentry.c index eaa6cad74a..050f758cf6 100644 --- a/libgimpwidgets/gimpsizeentry.c +++ b/libgimpwidgets/gimpsizeentry.c @@ -183,7 +183,7 @@ gimp_size_entry_new (gint number_of_fields, GimpSizeEntry *gse; gint i; - g_return_val_if_fail ((number_of_fields > 0) && (number_of_fields <= 16), + g_return_val_if_fail ((number_of_fields >= 0) && (number_of_fields <= 16), NULL); gse = gtk_type_new (gimp_size_entry_get_type ()); diff --git a/plug-ins/script-fu/script-fu-interface.c b/plug-ins/script-fu/script-fu-interface.c index 1f48331da2..c6fcee61bd 100644 --- a/plug-ins/script-fu/script-fu-interface.c +++ b/plug-ins/script-fu/script-fu-interface.c @@ -26,6 +26,7 @@ #include "gtk/gtk.h" #include "libgimp/gimp.h" #include "libgimp/gimpui.h" +#include "libgimp/gimpfileselection.h" #include "siod.h" #include "script-fu-scripts.h" @@ -71,8 +72,7 @@ typedef struct typedef struct { - GtkWidget *preview; - GtkWidget *dialog; + GtkWidget *fileselection; gchar *filename; } SFFilename; @@ -149,8 +149,6 @@ static void script_fu_disable_cc (gint err_msg); static void script_fu_interface (SFScript *script); static void script_fu_color_preview (GtkWidget *preview, gdouble *color); -static void script_fu_file_preview (GtkWidget *preview, - gchar *fontname); static void script_fu_font_preview (GtkWidget *preview, gchar *fontname); static void script_fu_cleanup_widgets (SFScript *script); @@ -175,14 +173,7 @@ static void script_fu_color_preview_cancel (GtkWidget *widget, static gint script_fu_color_preview_delete (GtkWidget *widget, GdkEvent *event, gpointer data); -static void script_fu_file_preview_callback (GtkWidget *widget, - gpointer data); -static void script_fu_file_dialog_ok (GtkWidget *widget, - gpointer data); -static void script_fu_file_dialog_cancel (GtkWidget *widget, - gpointer data); -static gint script_fu_file_dialog_delete (GtkWidget *widget, - GdkEvent *event, +static void script_fu_file_selection_callback(GtkWidget *widget, gpointer data); static void script_fu_font_preview_callback (GtkWidget *widget, gpointer data); @@ -601,13 +592,12 @@ script_fu_add_script (LISP a) if (!TYPEP (car (a), tc_string)) return my_err ("script-fu-register: filename defaults must be string values", NIL); script->arg_defaults[i].sfa_file.filename = g_strdup (get_c_string (car (a))); - script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); - script->arg_values[i].sfa_file.preview = NULL; - script->arg_values[i].sfa_file.dialog = NULL; + script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); + script->arg_values[i].sfa_file.fileselection = NULL; - args[i + 1].type = PARAM_STRING; - args[i + 1].name = "filename"; - args[i + 1].description = script->arg_labels[i]; + args[i + 1].type = PARAM_STRING; + args[i + 1].name = "filename"; + args[i + 1].description = script->arg_labels[i]; break; case SF_FONT: @@ -1239,18 +1229,15 @@ script_fu_interface (SFScript *script) break; case SF_FILENAME: - script->args_widgets[i] = gtk_button_new(); - script->arg_values[i].sfa_file.preview = gtk_label_new (""); - gtk_widget_set_usize (script->args_widgets[i], TEXT_WIDTH, 0); - gtk_container_add (GTK_CONTAINER (script->args_widgets[i]), - script->arg_values[i].sfa_file.preview); - gtk_widget_show (script->arg_values[i].sfa_file.preview); - - script_fu_file_preview (script->arg_values[i].sfa_file.preview, - script->arg_values[i].sfa_file.filename); + script->args_widgets[i] = + gimp_file_selection_new ("Script-Fu File Selection", + script->arg_values[i].sfa_file.filename, + FALSE, TRUE); + script->arg_values[i].sfa_file.fileselection = script->args_widgets[i]; - gtk_signal_connect (GTK_OBJECT (script->args_widgets[i]), "clicked", - (GtkSignalFunc) script_fu_file_preview_callback, + gtk_signal_connect (GTK_OBJECT (script->args_widgets[i]), + "filename_changed", + (GtkSignalFunc) script_fu_file_selection_callback, &script->arg_values[i].sfa_file); break; @@ -1444,20 +1431,6 @@ script_fu_brush_preview(char * name, /* Name */ brush->paint_mode = paint_mode; } - - -static void -script_fu_file_preview (GtkWidget *preview, - gchar *data) -{ - if (data == NULL) - return; - - gtk_label_set_text (GTK_LABEL (preview), g_basename((gchar *) data)); -} - - - static void script_fu_font_preview (GtkWidget *preview, gchar *data) @@ -1518,11 +1491,6 @@ script_fu_cleanup_widgets (SFScript *script) } break; case SF_FILENAME: - if (script->arg_values[i].sfa_file.dialog != NULL) - { - gtk_widget_destroy (script->arg_values[i].sfa_file.dialog); - script->arg_values[i].sfa_file.dialog = NULL; - } break; case SF_FONT: if (script->arg_values[i].sfa_font.dialog != NULL) @@ -1926,12 +1894,7 @@ script_fu_reset_callback (GtkWidget *widget, case SF_FILENAME: g_free (script->arg_values[i].sfa_file.filename); script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); - if (script->arg_values[i].sfa_file.dialog) - { - gtk_file_selection_set_filename (GTK_FILE_SELECTION (script->arg_values[i].sfa_file.dialog), script->arg_values[i].sfa_file.filename); - } - script_fu_file_preview (script->arg_values[i].sfa_file.preview, - script->arg_values[i].sfa_file.filename); + gimp_file_selection_set_filename (GIMP_FILE_SELECTION (script->arg_values[i].sfa_file.fileselection), script->arg_values[i].sfa_file.filename); break; case SF_FONT: g_free (script->arg_values[i].sfa_font.fontname); @@ -2068,76 +2031,19 @@ script_fu_color_preview_delete (GtkWidget *widget, } static void -script_fu_file_preview_callback (GtkWidget *widget, - gpointer data) +script_fu_file_selection_callback (GtkWidget *widget, + gpointer data) { - GtkFileSelection *fs; SFFilename *file; file = (SFFilename *) data; - if (!file->dialog) - { - file->dialog = gtk_file_selection_new ("Script-Fu File Selection"); - fs = GTK_FILE_SELECTION (file->dialog); + if (file->filename) + g_free (file->filename); - gtk_signal_connect (GTK_OBJECT (fs->ok_button), "clicked", - (GtkSignalFunc) script_fu_file_dialog_ok, - file); - gtk_signal_connect (GTK_OBJECT (fs), "delete_event", - (GtkSignalFunc) script_fu_file_dialog_delete, - file); - gtk_signal_connect (GTK_OBJECT (fs->cancel_button), "clicked", - (GtkSignalFunc) script_fu_file_dialog_cancel, - file); - } - else - fs = GTK_FILE_SELECTION (file->dialog); - - gtk_file_selection_set_filename (GTK_FILE_SELECTION (fs), file->filename); - gtk_window_position (GTK_WINDOW (file->dialog), GTK_WIN_POS_MOUSE); - gtk_widget_show (file->dialog); + file->filename = gimp_file_selection_get_filename (GIMP_FILE_SELECTION (file->fileselection)); } -static void -script_fu_file_dialog_ok (GtkWidget *widget, - gpointer data) -{ - SFFilename *file; - gchar *filename; - - file = (SFFilename *) data; - - filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (file->dialog)); - if (filename != NULL) - { - g_free (file->filename); - file->filename = g_strdup(filename); - } - gtk_widget_hide (file->dialog); - - script_fu_file_preview (file->preview, file->filename); -} - -static void -script_fu_file_dialog_cancel (GtkWidget *widget, - gpointer data) -{ - SFFilename *file; - file = (SFFilename *) data; - - gtk_widget_hide (file->dialog); -} - -static gint -script_fu_file_dialog_delete (GtkWidget *widget, - GdkEvent *event, - gpointer data) -{ - script_fu_file_dialog_cancel (widget, data); - return TRUE; - } - static void script_fu_font_preview_callback (GtkWidget *widget, gpointer data) @@ -2229,9 +2135,3 @@ script_fu_about_dialog_delete (GtkWidget *widget, script_fu_about_dialog_close (widget, data); return TRUE; } - - - - - - diff --git a/plug-ins/script-fu/script-fu-scripts.c b/plug-ins/script-fu/script-fu-scripts.c index 1f48331da2..c6fcee61bd 100644 --- a/plug-ins/script-fu/script-fu-scripts.c +++ b/plug-ins/script-fu/script-fu-scripts.c @@ -26,6 +26,7 @@ #include "gtk/gtk.h" #include "libgimp/gimp.h" #include "libgimp/gimpui.h" +#include "libgimp/gimpfileselection.h" #include "siod.h" #include "script-fu-scripts.h" @@ -71,8 +72,7 @@ typedef struct typedef struct { - GtkWidget *preview; - GtkWidget *dialog; + GtkWidget *fileselection; gchar *filename; } SFFilename; @@ -149,8 +149,6 @@ static void script_fu_disable_cc (gint err_msg); static void script_fu_interface (SFScript *script); static void script_fu_color_preview (GtkWidget *preview, gdouble *color); -static void script_fu_file_preview (GtkWidget *preview, - gchar *fontname); static void script_fu_font_preview (GtkWidget *preview, gchar *fontname); static void script_fu_cleanup_widgets (SFScript *script); @@ -175,14 +173,7 @@ static void script_fu_color_preview_cancel (GtkWidget *widget, static gint script_fu_color_preview_delete (GtkWidget *widget, GdkEvent *event, gpointer data); -static void script_fu_file_preview_callback (GtkWidget *widget, - gpointer data); -static void script_fu_file_dialog_ok (GtkWidget *widget, - gpointer data); -static void script_fu_file_dialog_cancel (GtkWidget *widget, - gpointer data); -static gint script_fu_file_dialog_delete (GtkWidget *widget, - GdkEvent *event, +static void script_fu_file_selection_callback(GtkWidget *widget, gpointer data); static void script_fu_font_preview_callback (GtkWidget *widget, gpointer data); @@ -601,13 +592,12 @@ script_fu_add_script (LISP a) if (!TYPEP (car (a), tc_string)) return my_err ("script-fu-register: filename defaults must be string values", NIL); script->arg_defaults[i].sfa_file.filename = g_strdup (get_c_string (car (a))); - script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); - script->arg_values[i].sfa_file.preview = NULL; - script->arg_values[i].sfa_file.dialog = NULL; + script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); + script->arg_values[i].sfa_file.fileselection = NULL; - args[i + 1].type = PARAM_STRING; - args[i + 1].name = "filename"; - args[i + 1].description = script->arg_labels[i]; + args[i + 1].type = PARAM_STRING; + args[i + 1].name = "filename"; + args[i + 1].description = script->arg_labels[i]; break; case SF_FONT: @@ -1239,18 +1229,15 @@ script_fu_interface (SFScript *script) break; case SF_FILENAME: - script->args_widgets[i] = gtk_button_new(); - script->arg_values[i].sfa_file.preview = gtk_label_new (""); - gtk_widget_set_usize (script->args_widgets[i], TEXT_WIDTH, 0); - gtk_container_add (GTK_CONTAINER (script->args_widgets[i]), - script->arg_values[i].sfa_file.preview); - gtk_widget_show (script->arg_values[i].sfa_file.preview); - - script_fu_file_preview (script->arg_values[i].sfa_file.preview, - script->arg_values[i].sfa_file.filename); + script->args_widgets[i] = + gimp_file_selection_new ("Script-Fu File Selection", + script->arg_values[i].sfa_file.filename, + FALSE, TRUE); + script->arg_values[i].sfa_file.fileselection = script->args_widgets[i]; - gtk_signal_connect (GTK_OBJECT (script->args_widgets[i]), "clicked", - (GtkSignalFunc) script_fu_file_preview_callback, + gtk_signal_connect (GTK_OBJECT (script->args_widgets[i]), + "filename_changed", + (GtkSignalFunc) script_fu_file_selection_callback, &script->arg_values[i].sfa_file); break; @@ -1444,20 +1431,6 @@ script_fu_brush_preview(char * name, /* Name */ brush->paint_mode = paint_mode; } - - -static void -script_fu_file_preview (GtkWidget *preview, - gchar *data) -{ - if (data == NULL) - return; - - gtk_label_set_text (GTK_LABEL (preview), g_basename((gchar *) data)); -} - - - static void script_fu_font_preview (GtkWidget *preview, gchar *data) @@ -1518,11 +1491,6 @@ script_fu_cleanup_widgets (SFScript *script) } break; case SF_FILENAME: - if (script->arg_values[i].sfa_file.dialog != NULL) - { - gtk_widget_destroy (script->arg_values[i].sfa_file.dialog); - script->arg_values[i].sfa_file.dialog = NULL; - } break; case SF_FONT: if (script->arg_values[i].sfa_font.dialog != NULL) @@ -1926,12 +1894,7 @@ script_fu_reset_callback (GtkWidget *widget, case SF_FILENAME: g_free (script->arg_values[i].sfa_file.filename); script->arg_values[i].sfa_file.filename = g_strdup (script->arg_defaults[i].sfa_file.filename); - if (script->arg_values[i].sfa_file.dialog) - { - gtk_file_selection_set_filename (GTK_FILE_SELECTION (script->arg_values[i].sfa_file.dialog), script->arg_values[i].sfa_file.filename); - } - script_fu_file_preview (script->arg_values[i].sfa_file.preview, - script->arg_values[i].sfa_file.filename); + gimp_file_selection_set_filename (GIMP_FILE_SELECTION (script->arg_values[i].sfa_file.fileselection), script->arg_values[i].sfa_file.filename); break; case SF_FONT: g_free (script->arg_values[i].sfa_font.fontname); @@ -2068,76 +2031,19 @@ script_fu_color_preview_delete (GtkWidget *widget, } static void -script_fu_file_preview_callback (GtkWidget *widget, - gpointer data) +script_fu_file_selection_callback (GtkWidget *widget, + gpointer data) { - GtkFileSelection *fs; SFFilename *file; file = (SFFilename *) data; - if (!file->dialog) - { - file->dialog = gtk_file_selection_new ("Script-Fu File Selection"); - fs = GTK_FILE_SELECTION (file->dialog); + if (file->filename) + g_free (file->filename); - gtk_signal_connect (GTK_OBJECT (fs->ok_button), "clicked", - (GtkSignalFunc) script_fu_file_dialog_ok, - file); - gtk_signal_connect (GTK_OBJECT (fs), "delete_event", - (GtkSignalFunc) script_fu_file_dialog_delete, - file); - gtk_signal_connect (GTK_OBJECT (fs->cancel_button), "clicked", - (GtkSignalFunc) script_fu_file_dialog_cancel, - file); - } - else - fs = GTK_FILE_SELECTION (file->dialog); - - gtk_file_selection_set_filename (GTK_FILE_SELECTION (fs), file->filename); - gtk_window_position (GTK_WINDOW (file->dialog), GTK_WIN_POS_MOUSE); - gtk_widget_show (file->dialog); + file->filename = gimp_file_selection_get_filename (GIMP_FILE_SELECTION (file->fileselection)); } -static void -script_fu_file_dialog_ok (GtkWidget *widget, - gpointer data) -{ - SFFilename *file; - gchar *filename; - - file = (SFFilename *) data; - - filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (file->dialog)); - if (filename != NULL) - { - g_free (file->filename); - file->filename = g_strdup(filename); - } - gtk_widget_hide (file->dialog); - - script_fu_file_preview (file->preview, file->filename); -} - -static void -script_fu_file_dialog_cancel (GtkWidget *widget, - gpointer data) -{ - SFFilename *file; - file = (SFFilename *) data; - - gtk_widget_hide (file->dialog); -} - -static gint -script_fu_file_dialog_delete (GtkWidget *widget, - GdkEvent *event, - gpointer data) -{ - script_fu_file_dialog_cancel (widget, data); - return TRUE; - } - static void script_fu_font_preview_callback (GtkWidget *widget, gpointer data) @@ -2229,9 +2135,3 @@ script_fu_about_dialog_delete (GtkWidget *widget, script_fu_about_dialog_close (widget, data); return TRUE; } - - - - - -