diff options
Diffstat (limited to 'tools/glade/glade/glade_project_options.c')
| -rw-r--r-- | tools/glade/glade/glade_project_options.c | 1433 |
1 files changed, 1433 insertions, 0 deletions
diff --git a/tools/glade/glade/glade_project_options.c b/tools/glade/glade/glade_project_options.c new file mode 100644 index 00000000..a1f19624 --- /dev/null +++ b/tools/glade/glade/glade_project_options.c @@ -0,0 +1,1433 @@ +/* Gtk+ User Interface Builder + * Copyright (C) 1998 Damon Chaplin + * + * 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 <ctype.h> +#include <string.h> + +#include <gtk/gtkalignment.h> +#include <gtk/gtkentry.h> +#include <gtk/gtkeventbox.h> +#include <gtk/gtkfilechooserdialog.h> +#include <gtk/gtkframe.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkhbbox.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkmain.h> +#include <gtk/gtkmenu.h> +#include <gtk/gtkmenuitem.h> +#include <gtk/gtknotebook.h> +#include <gtk/gtkoptionmenu.h> +#include <gtk/gtkradiobutton.h> +#include <gtk/gtkstock.h> +#include <gtk/gtkvbox.h> + +#include "gladeconfig.h" + +#ifdef USE_GNOME +#include <gnome.h> +#endif + +#include "glade_project_options.h" +#include "utils.h" + + +static GtkWindowClass *parent_class = NULL; + + +static void glade_project_options_class_init (GladeProjectOptionsClass * klass); +static void glade_project_options_init (GladeProjectOptions * project_options); +static void glade_project_options_destroy (GtkObject *object); + +static void glade_project_options_set_project (GladeProjectOptions *options, + GladeProject *project); +static void glade_project_options_directory_changed (GtkWidget * entry, + GladeProjectOptions *options); +static void glade_project_options_name_changed (GtkWidget * entry, + GladeProjectOptions *options); +static void glade_project_options_program_name_changed (GtkWidget * entry, + GladeProjectOptions *options); +static void glade_project_options_xml_filename_changed (GtkWidget * entry, + GladeProjectOptions *options); +static void glade_project_options_generate_name (GladeProjectOptions *options); +static void glade_project_options_generate_program_name (GladeProjectOptions *options); +static void glade_project_options_generate_xml_filename (GladeProjectOptions *options); +static gchar* glade_project_options_generate_project_name_from_directory (gchar *directory); +static gchar* glade_project_options_generate_program_name_from_project_name (gchar *project_name); +static gchar* glade_project_options_generate_xml_filename_from_program_name (gchar *program_name); +static void glade_project_options_translatable_strings_toggled (GtkWidget *widget, + GladeProjectOptions *options); +static void glade_project_options_show_file_selection (GtkWidget *widget, + gpointer data); +static void on_filesel_response (GtkWidget *widget, + gint response_id, + GladeProjectOptions *options); +static void glade_project_options_ok (GtkWidget *widget, + GladeProjectOptions *options); +static gchar* get_entry_text (GtkWidget *entry); +static gboolean glade_project_options_check_valid (GladeProjectOptions *options); + +GType +glade_project_options_get_type (void) +{ + static GType glade_project_options_type = 0; + + if (!glade_project_options_type) + { + GtkTypeInfo glade_project_options_info = + { + "GladeProjectOptions", + sizeof (GladeProjectOptions), + sizeof (GladeProjectOptionsClass), + (GtkClassInitFunc) glade_project_options_class_init, + (GtkObjectInitFunc) glade_project_options_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + glade_project_options_type = gtk_type_unique (gtk_window_get_type (), + &glade_project_options_info); + } + return glade_project_options_type; +} + + +static void +glade_project_options_class_init (GladeProjectOptionsClass * klass) +{ + GtkObjectClass *object_class; + + object_class = (GtkObjectClass *) klass; + + parent_class = gtk_type_class (gtk_window_get_type ()); + + object_class->destroy = glade_project_options_destroy; +} + +static void +set_accessible_description (GtkWidget *widget, const gchar *desc) +{ + AtkObject *atk_widget; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + + atk_widget = gtk_widget_get_accessible (widget); + + if (desc) + atk_object_set_description (atk_widget, desc); +} + + +static void +glade_project_options_init (GladeProjectOptions * options) +{ + GtkTooltips *tooltips; + GtkWidget *main_vbox, *notebook; + GtkWidget *general_options_vbox, *c_options_vbox, *libglade_options_vbox; + GtkWidget *vbox, *table, *label, *button, *eventbox, *alignment; + GtkWidget *hbox, *hbbox, *radio_button, *frame; + gint row, language; + GSList *group; + + options->generate_program_name = FALSE; + options->generate_xml_filename = FALSE; + options->language_buttons = NULL; + options->filesel = NULL; + options->auto_generation_level = 0; + + tooltips = gtk_tooltips_new (); + + gtk_container_set_border_width (GTK_CONTAINER (options), 4); + gtk_window_set_position (GTK_WINDOW (options), GTK_WIN_POS_MOUSE); + gtk_window_set_title (GTK_WINDOW (options), _("Project Options")); + gtk_window_set_policy (GTK_WINDOW (options), FALSE, TRUE, FALSE); + gtk_window_set_wmclass (GTK_WINDOW (options), "project_options", "Glade"); + + main_vbox = gtk_vbox_new (FALSE, 4); + gtk_container_add (GTK_CONTAINER (options), main_vbox); + gtk_widget_show (main_vbox); + + notebook = gtk_notebook_new (); + gtk_widget_show (notebook); + gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0); + + + /* + * General Page. + */ + + label = gtk_label_new (_("General")); + gtk_widget_show (label); + + general_options_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (general_options_vbox); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), general_options_vbox, + label); + gtk_container_set_border_width (GTK_CONTAINER (general_options_vbox), 7); + + frame = gtk_frame_new (_("Basic Options:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (general_options_vbox), frame, FALSE, TRUE, 4); + + table = gtk_table_new (3, 4, TRUE); + gtk_widget_show (table); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_container_set_border_width (GTK_CONTAINER (table), 4); + + /* Project Directory. */ + row = 0; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The project directory"), NULL); + + label = gtk_label_new (_("Project Directory:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + hbox = gtk_hbox_new (FALSE, 4); + gtk_widget_show (hbox); + gtk_table_attach (GTK_TABLE (table), hbox, + 1, 4, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + + options->directory_entry = gtk_entry_new (); + gtk_widget_show (options->directory_entry); + gtk_box_pack_start (GTK_BOX (hbox), options->directory_entry, + TRUE, TRUE, 0); + gtk_signal_connect (GTK_OBJECT (options->directory_entry), "changed", + GTK_SIGNAL_FUNC (glade_project_options_directory_changed), + options); + + button = gtk_button_new_with_label (_("Browse...")); + gtk_widget_show (button); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 8, 0); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (glade_project_options_show_file_selection), + NULL); + + /* Project Name. */ + row++; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The name of the current project"), NULL); + + label = gtk_label_new (_("Project Name:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->name_entry = gtk_entry_new (); + gtk_widget_set_usize (options->name_entry, 80, -1); + gtk_widget_show (options->name_entry); + gtk_table_attach (GTK_TABLE (table), options->name_entry, + 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + gtk_signal_connect (GTK_OBJECT (options->name_entry), "changed", + GTK_SIGNAL_FUNC (glade_project_options_name_changed), + options); + + /* Program Name. */ + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 2, 3, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The name of the program"), NULL); + + label = gtk_label_new (_("Program Name:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->program_name_entry = gtk_entry_new (); + gtk_widget_set_usize (options->program_name_entry, 80, -1); + gtk_widget_show (options->program_name_entry); + gtk_table_attach (GTK_TABLE (table), options->program_name_entry, + 3, 4, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + gtk_signal_connect (GTK_OBJECT (options->program_name_entry), "changed", + GTK_SIGNAL_FUNC (glade_project_options_program_name_changed), + options); + + /* Project XML File. */ + row++; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The project file"), NULL); + + label = gtk_label_new (_("Project File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->xml_filename_entry = gtk_entry_new (); + gtk_widget_set_usize (options->xml_filename_entry, 80, -1); + gtk_widget_show (options->xml_filename_entry); + gtk_table_attach (GTK_TABLE (table), options->xml_filename_entry, + 1, 4, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + gtk_signal_connect (GTK_OBJECT (options->xml_filename_entry), "changed", + GTK_SIGNAL_FUNC (glade_project_options_xml_filename_changed), + options); + + + /* Project Source Directory. */ + frame = gtk_frame_new (_("Subdirectories:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (general_options_vbox), frame, FALSE, TRUE, 4); + + table = gtk_table_new (1, 4, TRUE); + gtk_widget_show (table); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_container_set_border_width (GTK_CONTAINER (table), 4); + + row = 0; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The directory to save generated source code"), + NULL); + + label = gtk_label_new (_("Source Directory:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->source_directory_entry = gtk_entry_new (); + gtk_widget_set_usize (options->source_directory_entry, 80, -1); + gtk_widget_show (options->source_directory_entry); + gtk_table_attach (GTK_TABLE (table), options->source_directory_entry, + 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + + + /* Project Pixmaps Directory. */ + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 2, 3, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The directory to store pixmaps"), + NULL); + + label = gtk_label_new (_("Pixmaps Directory:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->pixmaps_directory_entry = gtk_entry_new (); + gtk_widget_set_usize (options->pixmaps_directory_entry, 80, -1); + gtk_widget_show (options->pixmaps_directory_entry); + gtk_table_attach (GTK_TABLE (table), options->pixmaps_directory_entry, + 3, 4, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + + + /* Project License. */ + /* Take this out until we actually use it. */ +#if 0 + row++; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The license which is added at the top of generated files"), NULL); + + label = gtk_label_new (_("License:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->license_option_menu = gtk_option_menu_new (); + gtk_widget_show (options->license_option_menu); + gtk_table_attach (GTK_TABLE (table), options->license_option_menu, + 1, 3, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + + menu = gtk_menu_new (); + menuitem = gtk_menu_item_new_with_label ("GNU General Public License"); + gtk_widget_show (menuitem); + gtk_container_add (GTK_CONTAINER (menu), menuitem); + gtk_option_menu_set_menu (GTK_OPTION_MENU (options->license_option_menu), + menu); +#endif + + /* Source Language. */ + frame = gtk_frame_new (_("Language:")); + /* Change this to 0 if you don't want the language option (C/C++/Perl). */ +#if 1 + gtk_widget_show (frame); +#endif + gtk_box_pack_start (GTK_BOX (general_options_vbox), frame, FALSE, TRUE, 4); + + alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + gtk_widget_show (alignment); + gtk_container_add (GTK_CONTAINER (frame), alignment); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); + gtk_container_add (GTK_CONTAINER (alignment), hbox); + + options->language_buttons = g_new (GtkWidget*, GladeNumLanguages); + group = NULL; + for (language = 0; language < GladeNumLanguages; language++) + { + radio_button = gtk_radio_button_new_with_label (group, + GladeLanguages[language]); + gtk_widget_show (radio_button); + gtk_box_pack_start (GTK_BOX (hbox), radio_button, FALSE, TRUE, 4); + group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_button)); + + options->language_buttons[language] = radio_button; + } + + /* Gnome Support. */ +#ifdef USE_GNOME + frame = gtk_frame_new (_("Gnome:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (general_options_vbox), frame, FALSE, TRUE, 4); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_add (GTK_CONTAINER (frame), hbox); + + options->gnome_support = gtk_check_button_new_with_label (_("Enable Gnome Support")); + /* This can't be changed now. */ + gtk_widget_set_sensitive (options->gnome_support, FALSE); + gtk_widget_show (options->gnome_support); + gtk_box_pack_start (GTK_BOX (hbox), options->gnome_support, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, options->gnome_support, + _("If a Gnome application is to be built"), NULL); + +#ifdef USE_GNOME_DB + options->gnome_db_support = gtk_check_button_new_with_label (_("Enable Gnome DB Support")); + gtk_widget_show (options->gnome_db_support); + gtk_box_pack_start (GTK_BOX (hbox), options->gnome_db_support, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, options->gnome_db_support, + _("If a Gnome DB application is to be built"), NULL); +#endif /* USE_GNOME_DB */ + +#endif /* USE_GNOME */ + + + /* + * C Options Page. + */ + + label = gtk_label_new (_("C Options")); + gtk_widget_show (label); + + c_options_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (c_options_vbox); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), c_options_vbox, label); + gtk_container_set_border_width (GTK_CONTAINER (c_options_vbox), 7); + + label = gtk_label_new (NULL); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Note:</b> for large applications the use of libglade is recommended.")); + gtk_widget_set_size_request (label, 400, -1); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_widget_show (label); + gtk_box_pack_start (GTK_BOX (c_options_vbox), label, FALSE, TRUE, 4); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); + gtk_box_pack_start (GTK_BOX (c_options_vbox), hbox, FALSE, TRUE, 4); + + frame = gtk_frame_new (_("General Options:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); + + vbox = gtk_vbox_new (TRUE, 0); + gtk_widget_show (vbox); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); + gtk_container_add (GTK_CONTAINER (frame), vbox); + + /* Gettext Support. */ + options->gettext_support = gtk_check_button_new_with_label (_("Gettext Support")); + gtk_widget_show (options->gettext_support); + gtk_box_pack_start (GTK_BOX (vbox), options->gettext_support, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->gettext_support, + _("If strings are marked for translation by gettext"), + NULL); + + /* Setting widget names. */ + options->use_widget_names = gtk_check_button_new_with_label (_("Set Widget Names")); + gtk_widget_show (options->use_widget_names); + gtk_box_pack_start (GTK_BOX (vbox), options->use_widget_names, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->use_widget_names, + _("If widget names are set in the source code"), + NULL); + + /* Backing up source files. */ + options->backup_source_files = gtk_check_button_new_with_label (_("Backup Source Files")); + gtk_widget_show (options->backup_source_files); + gtk_box_pack_start (GTK_BOX (vbox), options->backup_source_files, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->backup_source_files, + _("If copies of old source files are made"), + NULL); + + /* Gnome Help System support. */ + options->gnome_help_support = gtk_check_button_new_with_label (_("Gnome Help Support")); +#ifdef USE_GNOME + gtk_widget_show (options->gnome_help_support); +#endif + gtk_box_pack_start (GTK_BOX (vbox), options->gnome_help_support, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->gnome_help_support, + _("If support for the Gnome Help system should be included"), + NULL); + + frame = gtk_frame_new (_("File Output Options:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); + + vbox = gtk_vbox_new (TRUE, 0); + gtk_widget_show (vbox); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); + gtk_container_add (GTK_CONTAINER (frame), vbox); + + /* Outputting main file. */ + options->output_main_file = gtk_check_button_new_with_label (_("Output main.c File")); + gtk_widget_show (options->output_main_file); + gtk_box_pack_start (GTK_BOX (vbox), options->output_main_file, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->output_main_file, + _("If a main.c file is output containing a main() function, if it doesn't already exist"), + NULL); + + /* Outputting support files. */ + options->output_support_files = gtk_check_button_new_with_label (_("Output Support Functions")); + gtk_widget_show (options->output_support_files); + gtk_box_pack_start (GTK_BOX (vbox), options->output_support_files, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->output_support_files, + _("If the support functions are output"), + NULL); + + /* Outputting build files. */ + options->output_build_files = gtk_check_button_new_with_label (_("Output Build Files")); + gtk_widget_show (options->output_build_files); + gtk_box_pack_start (GTK_BOX (vbox), options->output_build_files, + FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, options->output_build_files, + _("If files for building the source code are output, including Makefile.am and configure.in, if they don't already exist"), + NULL); + + /* Main source file. */ + frame = gtk_frame_new (_("Interface Creation Functions:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (c_options_vbox), frame, FALSE, TRUE, 4); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (frame), hbox); + + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the functions to create the interface are written"), NULL); + + label = gtk_label_new (_("Source File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->main_source_entry = gtk_entry_new (); + gtk_widget_show (options->main_source_entry); + gtk_widget_set_usize (options->main_source_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->main_source_entry, + TRUE, TRUE, 0); + + /* Main header file. */ + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the declarations of the functions to create the interface are written"), NULL); + + label = gtk_label_new (_("Header File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->main_header_entry = gtk_entry_new (); + gtk_widget_show (options->main_header_entry); + gtk_widget_set_usize (options->main_header_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->main_header_entry, + TRUE, TRUE, 0); + + set_accessible_description (options->main_source_entry, _("Source file for interface creation functions")); + set_accessible_description (options->main_header_entry, _("Header file for interface creation functions")); + + /* Handler source file. */ + frame = gtk_frame_new (_("Signal Handler & Callback Functions:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (c_options_vbox), frame, FALSE, TRUE, 4); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (frame), hbox); + + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the empty signal handler and callback functions are written"), NULL); + + label = gtk_label_new (_("Source File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->handler_source_entry = gtk_entry_new (); + gtk_widget_show (options->handler_source_entry); + gtk_widget_set_usize (options->handler_source_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->handler_source_entry, + TRUE, TRUE, 0); + + /* Handler header file. */ + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the declarations of the signal handler and callback functions are written"), NULL); + + label = gtk_label_new (_("Header File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->handler_header_entry = gtk_entry_new (); + gtk_widget_show (options->handler_header_entry); + gtk_widget_set_usize (options->handler_header_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->handler_header_entry, + TRUE, TRUE, 0); + + set_accessible_description (options->handler_source_entry, _("Source file for signal handler and callback functions")); + set_accessible_description (options->handler_header_entry, _("Header file for signal handler and callback functions")); + + /* Support source file. */ + frame = gtk_frame_new (_("Support Functions:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (c_options_vbox), frame, FALSE, TRUE, 4); + + hbox = gtk_hbox_new (TRUE, 4); + gtk_widget_show (hbox); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (frame), hbox); + + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the support functions are written"), NULL); + + label = gtk_label_new (_("Source File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->support_source_entry = gtk_entry_new (); + gtk_widget_show (options->support_source_entry); + gtk_widget_set_usize (options->support_source_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->support_source_entry, + TRUE, TRUE, 0); + + /* Support header file. */ + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_box_pack_start (GTK_BOX (hbox), eventbox, FALSE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, eventbox, _("The file in which the declarations of the support functions are written"), NULL); + + label = gtk_label_new (_("Header File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + + options->support_header_entry = gtk_entry_new (); + gtk_widget_show (options->support_header_entry); + gtk_widget_set_usize (options->support_header_entry, 80, -1); + gtk_box_pack_start (GTK_BOX (hbox), options->support_header_entry, + TRUE, TRUE, 0); + + set_accessible_description (options->support_source_entry, _("Source file for support functions")); + set_accessible_description (options->support_header_entry, _("Header file for support functions")); + + /* + * libglade Options Page. + */ + + label = gtk_label_new (_("LibGlade Options")); + gtk_widget_show (label); + + libglade_options_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (libglade_options_vbox); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), libglade_options_vbox, + label); + gtk_container_set_border_width (GTK_CONTAINER (libglade_options_vbox), 7); + + frame = gtk_frame_new (_("Translatable Strings:")); + gtk_widget_show (frame); + gtk_box_pack_start (GTK_BOX (libglade_options_vbox), frame, FALSE, TRUE, 4); + + table = gtk_table_new (2, 3, FALSE); + gtk_widget_show (table); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_table_set_col_spacings (GTK_TABLE (table), 2); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_container_set_border_width (GTK_CONTAINER (table), 4); + + row = 0; + + label = gtk_label_new (NULL); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Note:</b> this option is deprecated - use intltool instead.")); + gtk_widget_set_size_request (label, 400, -1); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, + 0, 3, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + row++; + + /* Output translatable strings. */ + options->output_translatable_strings = gtk_check_button_new_with_label (_("Save Translatable Strings")); + gtk_widget_show (options->output_translatable_strings); + gtk_table_attach (GTK_TABLE (table), options->output_translatable_strings, + 0, 3, row, row + 1, GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, options->output_translatable_strings, + _("If translatable strings are saved in a separate C source file, to enable translation of interfaces loaded by libglade"), + NULL); + + /* Translatable Strings File. */ + row++; + eventbox = gtk_event_box_new (); + gtk_widget_show (eventbox); + gtk_table_attach (GTK_TABLE (table), eventbox, 0, 1, row, row + 1, + GTK_FILL, 0, 0, 0); + gtk_tooltips_set_tip (tooltips, eventbox, + _("The C source file to save all translatable strings in"), NULL); + + label = gtk_label_new (_("File:")); + gtk_widget_show (label); + gtk_container_add (GTK_CONTAINER (eventbox), label); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + options->translatable_strings_filename_label = label; + + options->translatable_strings_filename_entry = gtk_entry_new (); + gtk_widget_show (options->translatable_strings_filename_entry); + gtk_table_attach (GTK_TABLE (table), + options->translatable_strings_filename_entry, + 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); + + + /* The button box with OK & Cancel buttons. */ + hbbox = gtk_hbutton_box_new (); + gtk_widget_show (hbbox); + gtk_box_pack_start (GTK_BOX (main_vbox), hbbox, TRUE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (hbbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (hbbox), 8); + + options->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); + GTK_WIDGET_SET_FLAGS (options->cancel_button, GTK_CAN_DEFAULT); + gtk_widget_show (options->cancel_button); + gtk_container_add (GTK_CONTAINER (hbbox), options->cancel_button); + gtk_signal_connect_object (GTK_OBJECT (options->cancel_button), "clicked", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (options)); + + options->ok_button = gtk_button_new_from_stock (GTK_STOCK_OK); + GTK_WIDGET_SET_FLAGS (options->ok_button, GTK_CAN_DEFAULT); + gtk_widget_show (options->ok_button); + gtk_container_add (GTK_CONTAINER (hbbox), options->ok_button); + gtk_widget_grab_default (options->ok_button); + gtk_signal_connect (GTK_OBJECT (options->ok_button), "clicked", + GTK_SIGNAL_FUNC (glade_project_options_ok), options); + + gtk_signal_connect (GTK_OBJECT (options), "key_press_event", + GTK_SIGNAL_FUNC (glade_util_check_key_is_esc), + GINT_TO_POINTER (GladeEscDestroys)); + + gtk_widget_grab_focus (options->directory_entry); +} + + +GtkWidget * +glade_project_options_new (GladeProject *project) +{ + GladeProjectOptions *options; + + g_return_val_if_fail (GLADE_IS_PROJECT (project), NULL); + + options = GLADE_PROJECT_OPTIONS (gtk_type_new (glade_project_options_get_type ())); + glade_project_options_set_project (options, project); + + return GTK_WIDGET (options); +} + + +static void +glade_project_options_destroy (GtkObject *object) +{ + GladeProjectOptions *options; + + options = GLADE_PROJECT_OPTIONS (object); + + g_free (options->language_buttons); + options->language_buttons = NULL; + + /* FIXME: Maybe we need to disconnect the destroy signal handler added to + the project. */ + + if (options->filesel) + { + gtk_widget_destroy (options->filesel); + options->filesel = NULL; + } +} + + +/* This sets which project which we show the options of. */ +static void +glade_project_options_set_project (GladeProjectOptions *options, + GladeProject *project) +{ + GladeError *error; + gchar *base = NULL, *next_project_dir = NULL; + gint next_project_num = -1; + + g_return_if_fail (GLADE_IS_PROJECT (project)); + + options->project = project; + options->generate_name = FALSE; + options->generate_program_name = FALSE; + options->generate_xml_filename = FALSE; + + /* If the project directory has been set, we show it, else we show the + next free project directory in $HOME/Projects as the default. */ + if (project->directory && project->directory[0]) + { + base = project->directory; + gtk_entry_set_text (GTK_ENTRY (options->directory_entry), base); + } + else + { + error = glade_util_get_next_free_project_directory (&next_project_dir, + &next_project_num); + if (!error) + { + base = next_project_dir; + gtk_entry_set_text (GTK_ENTRY (options->directory_entry), base); + } + else + { + g_warning ("Couldn't find next free project directory."); + gtk_entry_set_text (GTK_ENTRY (options->directory_entry), ""); + } + } + + /* Project name. */ + if (project->name && project->name[0]) + { + gchar *generated_project_name; + + gtk_entry_set_text (GTK_ENTRY (options->name_entry), project->name); + + /* See if it matches what would have been auto-generated. */ + generated_project_name = glade_project_options_generate_project_name_from_directory (base); + if (!strcmp (generated_project_name, project->name)) + options->generate_name = TRUE; + g_free (generated_project_name); + } + else + { + glade_project_options_generate_name (options); + options->generate_name = TRUE; + } + + /* Program name. */ + if (project->program_name && project->program_name[0]) + { + gchar *generated_program_name; + + gtk_entry_set_text (GTK_ENTRY (options->program_name_entry), + project->program_name); + + /* See if it matches what would have been auto-generated. */ + generated_program_name = glade_project_options_generate_program_name_from_project_name (project->name); + if (!strcmp (generated_program_name, project->program_name)) + options->generate_program_name = TRUE; + g_free (generated_program_name); + } + else + { + glade_project_options_generate_program_name (options); + options->generate_program_name = TRUE; + } + + /* XML filename. */ + if (project->xml_filename && project->xml_filename[0]) + { + gchar *xml_filename_relative, *generated_filename; + + xml_filename_relative = glade_util_make_relative_path (base, project->xml_filename); + gtk_entry_set_text (GTK_ENTRY (options->xml_filename_entry), + xml_filename_relative); + + /* See if it matches what would have been auto-generated. */ + generated_filename = glade_project_options_generate_xml_filename_from_program_name (project->program_name); + if (!strcmp (generated_filename, xml_filename_relative)) + options->generate_xml_filename = TRUE; + g_free (generated_filename); + g_free (xml_filename_relative); + } + else + { + glade_project_options_generate_xml_filename (options); + options->generate_xml_filename = TRUE; + } + + /* Source directory. */ + if (project->source_directory && project->source_directory[0]) + { + gchar *srcdir_relative; + + srcdir_relative = glade_util_make_relative_path (base, project->source_directory); + gtk_entry_set_text (GTK_ENTRY (options->source_directory_entry), + srcdir_relative); + g_free (srcdir_relative); + } + else + { + gtk_entry_set_text (GTK_ENTRY (options->source_directory_entry), + "src"); + } + + /* Pixmaps directory. */ + if (project->pixmaps_directory && project->pixmaps_directory[0]) + { + gchar *pixmaps_relative; + + pixmaps_relative = glade_util_make_relative_path (base, project->pixmaps_directory); + gtk_entry_set_text (GTK_ENTRY (options->pixmaps_directory_entry), + pixmaps_relative); + g_free (pixmaps_relative); + } + else + { + gtk_entry_set_text (GTK_ENTRY (options->pixmaps_directory_entry), + "pixmaps"); + } + + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->language_buttons[project->language]), TRUE); + +#ifdef USE_GNOME + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->gnome_support), + project->gnome_support); +#ifdef USE_GNOME_DB + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->gnome_db_support), + project->gnome_db_support); +#endif +#endif + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->gettext_support), + project->gettext_support); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->use_widget_names), + project->use_widget_names); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->output_main_file), + project->output_main_file); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->output_support_files), + project->output_support_files); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->output_build_files), + project->output_build_files); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->backup_source_files), + project->backup_source_files); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->gnome_help_support), + project->gnome_help_support); + + gtk_entry_set_text (GTK_ENTRY (options->main_source_entry), + project->main_source_file + ? project->main_source_file : ""); + gtk_entry_set_text (GTK_ENTRY (options->main_header_entry), + project->main_header_file + ? project->main_header_file : ""); + gtk_entry_set_text (GTK_ENTRY (options->handler_source_entry), + project->handler_source_file + ? project->handler_source_file : ""); + gtk_entry_set_text (GTK_ENTRY (options->handler_header_entry), + project->handler_header_file + ? project->handler_header_file : ""); + + gtk_entry_set_text (GTK_ENTRY (options->support_source_entry), + project->support_source_file + ? project->support_source_file : ""); + gtk_entry_set_text (GTK_ENTRY (options->support_header_entry), + project->support_header_file + ? project->support_header_file : ""); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->output_translatable_strings), + project->output_translatable_strings); + if (project->translatable_strings_file + && project->translatable_strings_file[0]) + { + gchar *filename; + + filename = glade_util_make_relative_path (base, project->translatable_strings_file); + gtk_entry_set_text (GTK_ENTRY (options->translatable_strings_filename_entry), + filename); + g_free (filename); + } + else + { + gtk_entry_set_text (GTK_ENTRY (options->translatable_strings_filename_entry), ""); + } + gtk_signal_connect (GTK_OBJECT (options->output_translatable_strings), + "toggled", + GTK_SIGNAL_FUNC (glade_project_options_translatable_strings_toggled), + options); + + /* Set the sensitivity of the options. */ + gtk_widget_set_sensitive (options->translatable_strings_filename_label, + project->output_translatable_strings); + gtk_widget_set_sensitive (options->translatable_strings_filename_entry, + project->output_translatable_strings); + + + /* Connect to the project's destroy signal so we can destroy ourself. */ + gtk_signal_connect_object (GTK_OBJECT (project), "destroy", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (options)); + + g_free (next_project_dir); +} + + +static void +glade_project_options_directory_changed (GtkWidget * entry, + GladeProjectOptions *options) +{ + if (options->generate_name) + glade_project_options_generate_name (options); +} + + +static void +glade_project_options_name_changed (GtkWidget * entry, + GladeProjectOptions *options) +{ + if (options->generate_program_name) + glade_project_options_generate_program_name (options); + + /* If this option has been edited by the user, turn auto-generation off. */ + if (options->auto_generation_level == 0) + options->generate_name = FALSE; +} + + +static void +glade_project_options_program_name_changed (GtkWidget * entry, + GladeProjectOptions *options) +{ + if (options->generate_xml_filename) + glade_project_options_generate_xml_filename (options); + + /* If this option has been edited by the user, turn auto-generation off. */ + if (options->auto_generation_level == 0) + options->generate_program_name = FALSE; +} + + +static void +glade_project_options_xml_filename_changed (GtkWidget * entry, + GladeProjectOptions *options) +{ + /* If this option has been edited by the user, turn auto-generation off. */ + if (options->auto_generation_level == 0) + options->generate_xml_filename = FALSE; +} + + +static void +glade_project_options_generate_name (GladeProjectOptions *options) +{ + gchar *directory, *project_name; + + directory = (char*) gtk_entry_get_text (GTK_ENTRY (options->directory_entry)); + project_name = glade_project_options_generate_project_name_from_directory (directory); + options->auto_generation_level++; + gtk_entry_set_text (GTK_ENTRY (options->name_entry), project_name); + options->auto_generation_level--; + g_free (project_name); +} + + +static gchar* +glade_project_options_generate_project_name_from_directory (gchar *directory) +{ + gchar *project_name; + + if (directory == NULL) + return g_strdup (""); + + project_name = g_strdup (g_basename (directory)); + if (project_name[0] != '\0') + project_name[0] = toupper (project_name[0]); + return project_name; +} + + +static void +glade_project_options_generate_program_name (GladeProjectOptions *options) +{ + gchar *project_name, *program_name; + + project_name = (char*) gtk_entry_get_text (GTK_ENTRY (options->name_entry)); + program_name = glade_project_options_generate_program_name_from_project_name (project_name); + options->auto_generation_level++; + gtk_entry_set_text (GTK_ENTRY (options->program_name_entry), program_name); + options->auto_generation_level--; + g_free (program_name); +} + + +static gchar* +glade_project_options_generate_program_name_from_project_name (gchar *project_name) +{ + gchar *program_name, *pos; + + if (project_name == NULL) + return g_strdup (""); + + program_name = g_strdup (project_name); + g_strdown (program_name); + /* Try to convert any characters which shouldn't be in a program name to '-'. + We'll allow alphanumerics and characters in [.+-_] */ + for (pos = program_name; *pos; pos++) + { + if (!(isalnum (*pos) || *pos == '.' || *pos == '+' || *pos == '-' + || *pos == '_')) + *pos = '-'; + } + return program_name; +} + + +static void +glade_project_options_generate_xml_filename (GladeProjectOptions *options) +{ + gchar *program_name, *xml_filename; + + program_name = (char*) gtk_entry_get_text (GTK_ENTRY (options->program_name_entry)); + xml_filename = glade_project_options_generate_xml_filename_from_program_name (program_name); + options->auto_generation_level++; + gtk_entry_set_text (GTK_ENTRY (options->xml_filename_entry), xml_filename); + options->auto_generation_level--; + g_free (xml_filename); +} + + +static gchar* +glade_project_options_generate_xml_filename_from_program_name (gchar *program_name) +{ + gchar *xml_filename; + + if (program_name == NULL) + return g_strdup (""); + + xml_filename = g_strdup_printf ("%s.glade", program_name); + return xml_filename; +} + + +static void +glade_project_options_translatable_strings_toggled (GtkWidget *widget, + GladeProjectOptions *options) +{ + gboolean sensitive; + + sensitive = GTK_TOGGLE_BUTTON (options->output_translatable_strings)->active; + + /* Set the sensitivity of the options. */ + gtk_widget_set_sensitive (options->translatable_strings_filename_label, + sensitive); + gtk_widget_set_sensitive (options->translatable_strings_filename_entry, + sensitive); +} + + +static void +glade_project_options_show_file_selection (GtkWidget *widget, + gpointer data) +{ + GladeProjectOptions *options; + gchar *filename; + + options = GLADE_PROJECT_OPTIONS (gtk_widget_get_toplevel (widget)); + + if (options->filesel == NULL) + { + options->filesel = gtk_file_chooser_dialog_new (_("Select the Project Directory"), + GTK_WINDOW (options), + GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, + NULL); + gtk_dialog_set_default_response (GTK_DIALOG (options->filesel), + GTK_RESPONSE_OK); + + g_signal_connect (options->filesel, "response", + GTK_SIGNAL_FUNC (on_filesel_response), options); + g_signal_connect (options->filesel, "delete_event", + G_CALLBACK (gtk_true), NULL); + } + + filename = (char*) gtk_entry_get_text (GTK_ENTRY (options->directory_entry)); + if (glade_util_file_exists (filename)) + { + glade_util_set_file_selection_filename (options->filesel, filename); + } + + gtk_window_present (GTK_WINDOW (options->filesel)); +} + + +static void +on_filesel_response (GtkWidget *widget, + gint response_id, + GladeProjectOptions *options) +{ + gchar *filename; + + if (response_id == GTK_RESPONSE_OK) + { + filename = glade_util_get_file_selection_filename (options->filesel); + if (filename) + gtk_entry_set_text (GTK_ENTRY (options->directory_entry), filename); + g_free (filename); + } + + glade_util_close_window (options->filesel); +} + + +static void +glade_project_options_ok (GtkWidget *widget, + GladeProjectOptions *options) +{ + GladeProject *project; + gchar *xml_filename, *directory, *source_directory, *pixmaps_directory; + gchar *strings_filename; + gint language; + + project = options->project; + + /* First check that the options are valid, according to the requested action. + If not, we need to stop the signal so the dialog isn't closed. */ + if (!glade_project_options_check_valid (options)) + { + gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "clicked"); + return; + } + + /* The project directory is the only aboslute path. Everything else is + relative to it, so needs to be turned into an absolute path here. */ + directory = get_entry_text (options->directory_entry); + glade_project_set_directory (project, directory); + + glade_project_set_name (project, get_entry_text (options->name_entry)); + glade_project_set_program_name (project, get_entry_text (options->program_name_entry)); + + pixmaps_directory = get_entry_text (options->pixmaps_directory_entry); + pixmaps_directory = glade_util_make_absolute_path (directory, + pixmaps_directory); + glade_project_set_pixmaps_directory (project, pixmaps_directory); + g_free (pixmaps_directory); + + source_directory = get_entry_text (options->source_directory_entry); + source_directory = glade_util_make_absolute_path (directory, + source_directory); + glade_project_set_source_directory (project, source_directory); + g_free (source_directory); + + xml_filename = get_entry_text (options->xml_filename_entry); + xml_filename = glade_util_make_absolute_path (directory, xml_filename); + glade_project_set_xml_filename (project, xml_filename); + g_free (xml_filename); + + for (language = 0; language < GladeNumLanguages; language++) + { + + if (GTK_TOGGLE_BUTTON (options->language_buttons[language])->active) + { + glade_project_set_language_name (project, GladeLanguages[language]); + break; + } + } + + +#ifdef USE_GNOME + glade_project_set_gnome_support (project, GTK_TOGGLE_BUTTON (options->gnome_support)->active ? TRUE : FALSE); +#ifdef USE_GNOME_DB + glade_project_set_gnome_db_support (project, GTK_TOGGLE_BUTTON (options->gnome_db_support)->active ? TRUE : FALSE); +#endif +#endif + + glade_project_set_gettext_support (project, GTK_TOGGLE_BUTTON (options->gettext_support)->active ? TRUE : FALSE); + + glade_project_set_use_widget_names (project, GTK_TOGGLE_BUTTON (options->use_widget_names)->active ? TRUE : FALSE); + + glade_project_set_output_main_file (project, GTK_TOGGLE_BUTTON (options->output_main_file)->active ? TRUE : FALSE); + + glade_project_set_output_support_files (project, GTK_TOGGLE_BUTTON (options->output_support_files)->active ? TRUE : FALSE); + + glade_project_set_output_build_files (project, GTK_TOGGLE_BUTTON (options->output_build_files)->active ? TRUE : FALSE); + + glade_project_set_backup_source_files (project, GTK_TOGGLE_BUTTON (options->backup_source_files)->active ? TRUE : FALSE); + + glade_project_set_gnome_help_support (project, GTK_TOGGLE_BUTTON (options->gnome_help_support)->active ? TRUE : FALSE); + + glade_project_set_source_files (project, + get_entry_text (options->main_source_entry), + get_entry_text (options->main_header_entry), + get_entry_text (options->handler_source_entry), + get_entry_text (options->handler_header_entry)); + glade_project_set_support_source_file (project, get_entry_text (options->support_source_entry)); + glade_project_set_support_header_file (project, get_entry_text (options->support_header_entry)); + + glade_project_set_output_translatable_strings (project, GTK_TOGGLE_BUTTON (options->output_translatable_strings)->active ? TRUE : FALSE); + + strings_filename = get_entry_text (options->translatable_strings_filename_entry); + strings_filename = glade_util_make_absolute_path (directory, + strings_filename); + glade_project_set_translatable_strings_file (project, strings_filename); + g_free (strings_filename); + + g_free (directory); + gtk_widget_destroy (GTK_WIDGET (options)); +} + + +/* This returns a pointer to the text in the given entry, or NULL if the entry + is empty. */ +static gchar* +get_entry_text (GtkWidget *entry) +{ + gchar *text; + + text = (char*) gtk_entry_get_text (GTK_ENTRY (entry)); + if (text && text[0] != '\0') + return text; + else + return NULL; +} + + +void +glade_project_options_set_action (GladeProjectOptions *options, + GladeProjectOptionsAction action) +{ + options->action = action; +} + + +/* This checks that all the options needed for the required action have been + set, and returns TRUE if so. */ +static gboolean +glade_project_options_check_valid (GladeProjectOptions *options) +{ + gchar *error = NULL; + gchar *directory, *xml_filename, *project_name, *program_name; + gchar *source_directory, *pixmaps_directory; + gboolean output_translatable_strings; + gchar *translatable_strings_filename; + + directory = get_entry_text (options->directory_entry); + xml_filename = get_entry_text (options->xml_filename_entry); + project_name = get_entry_text (options->name_entry); + program_name = get_entry_text (options->program_name_entry); + source_directory = get_entry_text (options->source_directory_entry); + pixmaps_directory = get_entry_text (options->pixmaps_directory_entry); + output_translatable_strings = GTK_TOGGLE_BUTTON (options->output_translatable_strings)->active; + translatable_strings_filename = get_entry_text (options->translatable_strings_filename_entry); + + switch (options->action) + { + case GLADE_PROJECT_OPTIONS_ACTION_NORMAL: + if (output_translatable_strings + && (translatable_strings_filename == NULL + || translatable_strings_filename[0] == '\0')) + error = _("You need to set the Translatable Strings File option"); + break; + case GLADE_PROJECT_OPTIONS_ACTION_SAVE: + if (directory == NULL || directory[0] == '\0') + error = _("You need to set the Project Directory option"); + else if (xml_filename == NULL || xml_filename[0] == '\0') + error = _("You need to set the Project File option"); + else if (output_translatable_strings + && (translatable_strings_filename == NULL + || translatable_strings_filename[0] == '\0')) + error = _("You need to set the Translatable Strings File option"); + break; + case GLADE_PROJECT_OPTIONS_ACTION_BUILD: + if (directory == NULL || directory[0] == '\0') + error = _("You need to set the Project Directory option"); + else if (xml_filename == NULL || xml_filename[0] == '\0') + error = _("You need to set the Project File option"); + else if (output_translatable_strings + && (translatable_strings_filename == NULL + || translatable_strings_filename[0] == '\0')) + error = _("You need to set the Translatable Strings File option"); + else if (project_name == NULL || project_name[0] == '\0') + error = _("You need to set the Project Name option"); + else if (program_name == NULL || program_name[0] == '\0') + error = _("You need to set the Program Name option"); +#if 0 + else if (source_directory == NULL || source_directory[0] == '\0') + error = _("You need to set the Source Directory option"); +#endif + else if (pixmaps_directory == NULL || pixmaps_directory[0] == '\0') + error = _("You need to set the Pixmaps Directory option"); + break; + } + + if (error) + { + glade_util_show_message_box (error, GTK_WIDGET (options)); + return FALSE; + } + + return TRUE; +} |