From 528c1e5ff51e213936e800fc5a9a25da99c0bdf2 Mon Sep 17 00:00:00 2001 From: Perberos Date: Mon, 7 Nov 2011 16:46:58 -0300 Subject: initial --- gedit/dialogs/Makefile.am | 31 + gedit/dialogs/gedit-close-confirmation-dialog.c | 790 +++++++++++++++ gedit/dialogs/gedit-close-confirmation-dialog.h | 75 ++ gedit/dialogs/gedit-encodings-dialog.c | 499 ++++++++++ gedit/dialogs/gedit-encodings-dialog.h | 86 ++ gedit/dialogs/gedit-encodings-dialog.ui | 256 +++++ gedit/dialogs/gedit-preferences-dialog.c | 1189 +++++++++++++++++++++++ gedit/dialogs/gedit-preferences-dialog.h | 87 ++ gedit/dialogs/gedit-preferences-dialog.ui | 1107 +++++++++++++++++++++ gedit/dialogs/gedit-search-dialog.c | 634 ++++++++++++ gedit/dialogs/gedit-search-dialog.h | 128 +++ gedit/dialogs/gedit-search-dialog.ui | 255 +++++ 12 files changed, 5137 insertions(+) create mode 100755 gedit/dialogs/Makefile.am create mode 100755 gedit/dialogs/gedit-close-confirmation-dialog.c create mode 100755 gedit/dialogs/gedit-close-confirmation-dialog.h create mode 100755 gedit/dialogs/gedit-encodings-dialog.c create mode 100755 gedit/dialogs/gedit-encodings-dialog.h create mode 100755 gedit/dialogs/gedit-encodings-dialog.ui create mode 100755 gedit/dialogs/gedit-preferences-dialog.c create mode 100755 gedit/dialogs/gedit-preferences-dialog.h create mode 100755 gedit/dialogs/gedit-preferences-dialog.ui create mode 100755 gedit/dialogs/gedit-search-dialog.c create mode 100755 gedit/dialogs/gedit-search-dialog.h create mode 100755 gedit/dialogs/gedit-search-dialog.ui (limited to 'gedit/dialogs') diff --git a/gedit/dialogs/Makefile.am b/gedit/dialogs/Makefile.am new file mode 100755 index 00000000..c0762571 --- /dev/null +++ b/gedit/dialogs/Makefile.am @@ -0,0 +1,31 @@ +uidir = $(datadir)/gedit-2/ui/ + +INCLUDES = \ + -I$(top_srcdir) \ + -I$(top_builddir) \ + -I$(top_srcdir)/gedit \ + -I$(top_builddir)/gedit \ + $(GEDIT_CFLAGS) \ + $(WARN_CFLAGS) \ + $(DISABLE_DEPRECATED_CFLAGS) + +noinst_LTLIBRARIES = libdialogs.la + +libdialogs_la_SOURCES = \ + gedit-preferences-dialog.h \ + gedit-preferences-dialog.c \ + gedit-close-confirmation-dialog.c \ + gedit-close-confirmation-dialog.h \ + gedit-encodings-dialog.c \ + gedit-encodings-dialog.h \ + gedit-search-dialog.h \ + gedit-search-dialog.c + +ui_DATA = \ + gedit-encodings-dialog.ui \ + gedit-preferences-dialog.ui \ + gedit-search-dialog.ui + +EXTRA_DIST = $(ui_DATA) + +-include $(top_srcdir)/git.mk diff --git a/gedit/dialogs/gedit-close-confirmation-dialog.c b/gedit/dialogs/gedit-close-confirmation-dialog.c new file mode 100755 index 00000000..36cbf117 --- /dev/null +++ b/gedit/dialogs/gedit-close-confirmation-dialog.c @@ -0,0 +1,790 @@ +/* + * gedit-close-confirmation-dialog.c + * This file is part of gedit + * + * Copyright (C) 2004-2005 MATE Foundation + * + * 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. + */ + +/* + * Modified by the gedit Team, 2004-2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include "gedit-close-confirmation-dialog.h" +#include +#include +#include + + +/* Properties */ +enum +{ + PROP_0, + PROP_UNSAVED_DOCUMENTS, + PROP_LOGOUT_MODE +}; + +/* Mode */ +enum +{ + SINGLE_DOC_MODE, + MULTIPLE_DOCS_MODE +}; + +/* Columns */ +enum +{ + SAVE_COLUMN, + NAME_COLUMN, + DOC_COLUMN, /* a handy pointer to the document */ + N_COLUMNS +}; + +struct _GeditCloseConfirmationDialogPrivate +{ + gboolean logout_mode; + + GList *unsaved_documents; + + GList *selected_documents; + + GtkTreeModel *list_store; + + gboolean disable_save_to_disk; +}; + +#define GEDIT_CLOSE_CONFIRMATION_DIALOG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \ + GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG, \ + GeditCloseConfirmationDialogPrivate)) + +#define GET_MODE(priv) (((priv->unsaved_documents != NULL) && \ + (priv->unsaved_documents->next == NULL)) ? \ + SINGLE_DOC_MODE : MULTIPLE_DOCS_MODE) + +G_DEFINE_TYPE(GeditCloseConfirmationDialog, gedit_close_confirmation_dialog, GTK_TYPE_DIALOG) + +static void set_unsaved_document (GeditCloseConfirmationDialog *dlg, + const GList *list); + +static GList *get_selected_docs (GtkTreeModel *store); + +/* Since we connect in the costructor we are sure this handler will be called + * before the user ones + */ +static void +response_cb (GeditCloseConfirmationDialog *dlg, + gint response_id, + gpointer data) +{ + GeditCloseConfirmationDialogPrivate *priv; + + g_return_if_fail (GEDIT_IS_CLOSE_CONFIRMATION_DIALOG (dlg)); + + priv = dlg->priv; + + if (priv->selected_documents != NULL) + g_list_free (priv->selected_documents); + + if (response_id == GTK_RESPONSE_YES) + { + if (GET_MODE (priv) == SINGLE_DOC_MODE) + { + priv->selected_documents = + g_list_copy (priv->unsaved_documents); + } + else + { + g_return_if_fail (priv->list_store); + + priv->selected_documents = + get_selected_docs (priv->list_store); + } + } + else + priv->selected_documents = NULL; +} + +static void +set_logout_mode (GeditCloseConfirmationDialog *dlg, + gboolean logout_mode) +{ + dlg->priv->logout_mode = logout_mode; + + if (logout_mode) + { + gtk_dialog_add_button (GTK_DIALOG (dlg), + _("Log Out _without Saving"), + GTK_RESPONSE_NO); + + gedit_dialog_add_button (GTK_DIALOG (dlg), + _("_Cancel Logout"), + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL); + } + else + { + gtk_dialog_add_button (GTK_DIALOG (dlg), + _("Close _without Saving"), + GTK_RESPONSE_NO); + + gtk_dialog_add_button (GTK_DIALOG (dlg), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); + } + + if (dlg->priv->disable_save_to_disk) + { + gtk_dialog_set_default_response (GTK_DIALOG (dlg), + GTK_RESPONSE_NO); + } + else + { + const gchar *stock_id = GTK_STOCK_SAVE; + + if (GET_MODE (dlg->priv) == SINGLE_DOC_MODE) + { + GeditDocument *doc; + + doc = GEDIT_DOCUMENT (dlg->priv->unsaved_documents->data); + + if (gedit_document_get_readonly (doc) || + gedit_document_is_untitled (doc)) + stock_id = GTK_STOCK_SAVE_AS; + } + + gtk_dialog_add_button (GTK_DIALOG (dlg), + stock_id, + GTK_RESPONSE_YES); + + gtk_dialog_set_default_response (GTK_DIALOG (dlg), + GTK_RESPONSE_YES); + } +} + +static void +gedit_close_confirmation_dialog_init (GeditCloseConfirmationDialog *dlg) +{ + AtkObject *atk_obj; + + dlg->priv = GEDIT_CLOSE_CONFIRMATION_DIALOG_GET_PRIVATE (dlg); + + dlg->priv->disable_save_to_disk = + gedit_app_get_lockdown (gedit_app_get_default ()) + & GEDIT_LOCKDOWN_SAVE_TO_DISK; + + gtk_container_set_border_width (GTK_CONTAINER (dlg), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + 14); + gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), TRUE); + + gtk_window_set_title (GTK_WINDOW (dlg), ""); + + gtk_window_set_modal (GTK_WINDOW (dlg), TRUE); + gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE); + + atk_obj = gtk_widget_get_accessible (GTK_WIDGET (dlg)); + atk_object_set_role (atk_obj, ATK_ROLE_ALERT); + atk_object_set_name (atk_obj, _("Question")); + + g_signal_connect (dlg, + "response", + G_CALLBACK (response_cb), + NULL); +} + +static void +gedit_close_confirmation_dialog_finalize (GObject *object) +{ + GeditCloseConfirmationDialogPrivate *priv; + + priv = GEDIT_CLOSE_CONFIRMATION_DIALOG (object)->priv; + + if (priv->unsaved_documents != NULL) + g_list_free (priv->unsaved_documents); + + if (priv->selected_documents != NULL) + g_list_free (priv->selected_documents); + + /* Call the parent's destructor */ + G_OBJECT_CLASS (gedit_close_confirmation_dialog_parent_class)->finalize (object); +} + +static void +gedit_close_confirmation_dialog_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GeditCloseConfirmationDialog *dlg; + + dlg = GEDIT_CLOSE_CONFIRMATION_DIALOG (object); + + switch (prop_id) + { + case PROP_UNSAVED_DOCUMENTS: + set_unsaved_document (dlg, g_value_get_pointer (value)); + break; + + case PROP_LOGOUT_MODE: + set_logout_mode (dlg, g_value_get_boolean (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gedit_close_confirmation_dialog_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GeditCloseConfirmationDialogPrivate *priv; + + priv = GEDIT_CLOSE_CONFIRMATION_DIALOG (object)->priv; + + switch( prop_id ) + { + case PROP_UNSAVED_DOCUMENTS: + g_value_set_pointer (value, priv->unsaved_documents); + break; + + case PROP_LOGOUT_MODE: + g_value_set_boolean (value, priv->logout_mode); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gedit_close_confirmation_dialog_class_init (GeditCloseConfirmationDialogClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = gedit_close_confirmation_dialog_set_property; + gobject_class->get_property = gedit_close_confirmation_dialog_get_property; + gobject_class->finalize = gedit_close_confirmation_dialog_finalize; + + g_type_class_add_private (klass, sizeof (GeditCloseConfirmationDialogPrivate)); + + g_object_class_install_property (gobject_class, + PROP_UNSAVED_DOCUMENTS, + g_param_spec_pointer ("unsaved_documents", + "Unsaved Documents", + "List of Unsaved Documents", + (G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY))); + + g_object_class_install_property (gobject_class, + PROP_LOGOUT_MODE, + g_param_spec_boolean ("logout_mode", + "Logout Mode", + "Whether the dialog is in logout mode", + FALSE, + (G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY))); +} + +static GList * +get_selected_docs (GtkTreeModel *store) +{ + GList *list; + gboolean valid; + GtkTreeIter iter; + + list = NULL; + valid = gtk_tree_model_get_iter_first (store, &iter); + + while (valid) + { + gboolean to_save; + GeditDocument *doc; + + gtk_tree_model_get (store, &iter, + SAVE_COLUMN, &to_save, + DOC_COLUMN, &doc, + -1); + if (to_save) + list = g_list_prepend (list, doc); + + valid = gtk_tree_model_iter_next (store, &iter); + } + + list = g_list_reverse (list); + + return list; +} + +GList * +gedit_close_confirmation_dialog_get_selected_documents (GeditCloseConfirmationDialog *dlg) +{ + g_return_val_if_fail (GEDIT_IS_CLOSE_CONFIRMATION_DIALOG (dlg), NULL); + + return g_list_copy (dlg->priv->selected_documents); +} + +GtkWidget * +gedit_close_confirmation_dialog_new (GtkWindow *parent, + GList *unsaved_documents, + gboolean logout_mode) +{ + GtkWidget *dlg; + g_return_val_if_fail (unsaved_documents != NULL, NULL); + + dlg = GTK_WIDGET (g_object_new (GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG, + "unsaved_documents", unsaved_documents, + "logout_mode", logout_mode, + NULL)); + g_return_val_if_fail (dlg != NULL, NULL); + + if (parent != NULL) + { + gtk_window_group_add_window (gedit_window_get_group (GEDIT_WINDOW (parent)), + GTK_WINDOW (dlg)); + + gtk_window_set_transient_for (GTK_WINDOW (dlg), parent); + } + + return dlg; +} + +GtkWidget * +gedit_close_confirmation_dialog_new_single (GtkWindow *parent, + GeditDocument *doc, + gboolean logout_mode) +{ + GtkWidget *dlg; + GList *unsaved_documents; + g_return_val_if_fail (doc != NULL, NULL); + + unsaved_documents = g_list_prepend (NULL, doc); + + dlg = gedit_close_confirmation_dialog_new (parent, + unsaved_documents, + logout_mode); + + g_list_free (unsaved_documents); + + return dlg; +} + +static gchar * +get_text_secondary_label (GeditDocument *doc) +{ + glong seconds; + gchar *secondary_msg; + + seconds = MAX (1, _gedit_document_get_seconds_since_last_save_or_load (doc)); + + if (seconds < 55) + { + secondary_msg = g_strdup_printf ( + ngettext ("If you don't save, changes from the last %ld second " + "will be permanently lost.", + "If you don't save, changes from the last %ld seconds " + "will be permanently lost.", + seconds), + seconds); + } + else if (seconds < 75) /* 55 <= seconds < 75 */ + { + secondary_msg = g_strdup (_("If you don't save, changes from the last minute " + "will be permanently lost.")); + } + else if (seconds < 110) /* 75 <= seconds < 110 */ + { + secondary_msg = g_strdup_printf ( + ngettext ("If you don't save, changes from the last minute and %ld " + "second will be permanently lost.", + "If you don't save, changes from the last minute and %ld " + "seconds will be permanently lost.", + seconds - 60 ), + seconds - 60); + } + else if (seconds < 3600) + { + secondary_msg = g_strdup_printf ( + ngettext ("If you don't save, changes from the last %ld minute " + "will be permanently lost.", + "If you don't save, changes from the last %ld minutes " + "will be permanently lost.", + seconds / 60), + seconds / 60); + } + else if (seconds < 7200) + { + gint minutes; + seconds -= 3600; + + minutes = seconds / 60; + if (minutes < 5) + { + secondary_msg = g_strdup (_("If you don't save, changes from the last hour " + "will be permanently lost.")); + } + else + { + secondary_msg = g_strdup_printf ( + ngettext ("If you don't save, changes from the last hour and %d " + "minute will be permanently lost.", + "If you don't save, changes from the last hour and %d " + "minutes will be permanently lost.", + minutes), + minutes); + } + } + else + { + gint hours; + + hours = seconds / 3600; + + secondary_msg = g_strdup_printf ( + ngettext ("If you don't save, changes from the last %d hour " + "will be permanently lost.", + "If you don't save, changes from the last %d hours " + "will be permanently lost.", + hours), + hours); + } + + return secondary_msg; +} + +static void +build_single_doc_dialog (GeditCloseConfirmationDialog *dlg) +{ + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *primary_label; + GtkWidget *secondary_label; + GtkWidget *image; + GeditDocument *doc; + gchar *doc_name; + gchar *str; + gchar *markup_str; + + g_return_if_fail (dlg->priv->unsaved_documents->data != NULL); + doc = GEDIT_DOCUMENT (dlg->priv->unsaved_documents->data); + + /* Image */ + image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, + GTK_ICON_SIZE_DIALOG); + gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); + + /* Primary label */ + primary_label = gtk_label_new (NULL); + gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE); + gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (primary_label), 0.0, 0.5); + gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE); + + doc_name = gedit_document_get_short_name_for_display (doc); + + if (dlg->priv->disable_save_to_disk) + { + str = g_markup_printf_escaped (_("Changes to document \"%s\" will be permanently lost."), + doc_name); + } + else + { + str = g_markup_printf_escaped (_("Save changes to document \"%s\" before closing?"), + doc_name); + } + + g_free (doc_name); + + markup_str = g_strconcat ("", str, "", NULL); + g_free (str); + + gtk_label_set_markup (GTK_LABEL (primary_label), markup_str); + g_free (markup_str); + + /* Secondary label */ + if (dlg->priv->disable_save_to_disk) + str = g_strdup (_("Saving has been disabled by the system administrator.")); + else + str = get_text_secondary_label (doc); + secondary_label = gtk_label_new (str); + g_free (str); + gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (secondary_label), 0.0, 0.5); + gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE); + + hbox = gtk_hbox_new (FALSE, 12); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); + + gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); + + vbox = gtk_vbox_new (FALSE, 12); + + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + + gtk_box_pack_start (GTK_BOX (vbox), primary_label, FALSE, FALSE, 0); + + gtk_box_pack_start (GTK_BOX (vbox), secondary_label, FALSE, FALSE, 0); + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + hbox, + FALSE, + FALSE, + 0); + + gtk_widget_show_all (hbox); +} + +static void +populate_model (GtkTreeModel *store, GList *docs) +{ + GtkTreeIter iter; + + while (docs != NULL) + { + GeditDocument *doc; + gchar *name; + + doc = GEDIT_DOCUMENT (docs->data); + + name = gedit_document_get_short_name_for_display (doc); + + gtk_list_store_append (GTK_LIST_STORE (store), &iter); + gtk_list_store_set (GTK_LIST_STORE (store), &iter, + SAVE_COLUMN, TRUE, + NAME_COLUMN, name, + DOC_COLUMN, doc, + -1); + + g_free (name); + + docs = g_list_next (docs); + } +} + +static void +save_toggled (GtkCellRendererToggle *renderer, gchar *path_str, GtkTreeModel *store) +{ + GtkTreePath *path = gtk_tree_path_new_from_string (path_str); + GtkTreeIter iter; + gboolean active; + + gtk_tree_model_get_iter (store, &iter, path); + gtk_tree_model_get (store, &iter, SAVE_COLUMN, &active, -1); + + active ^= 1; + + gtk_list_store_set (GTK_LIST_STORE (store), &iter, + SAVE_COLUMN, active, -1); + + gtk_tree_path_free (path); +} + +static GtkWidget * +create_treeview (GeditCloseConfirmationDialogPrivate *priv) +{ + GtkListStore *store; + GtkWidget *treeview; + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + + treeview = gtk_tree_view_new (); + gtk_widget_set_size_request (treeview, 260, 120); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); + gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), FALSE); + + /* Create and populate the model */ + store = gtk_list_store_new (N_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); + populate_model (GTK_TREE_MODEL (store), priv->unsaved_documents); + + /* Set model to the treeview */ + gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store)); + g_object_unref (store); + + priv->list_store = GTK_TREE_MODEL (store); + + /* Add columns */ + if (!priv->disable_save_to_disk) + { + renderer = gtk_cell_renderer_toggle_new (); + g_signal_connect (renderer, "toggled", + G_CALLBACK (save_toggled), store); + + column = gtk_tree_view_column_new_with_attributes ("Save?", + renderer, + "active", + SAVE_COLUMN, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); + } + + renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes ("Name", + renderer, + "text", + NAME_COLUMN, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); + + return treeview; +} + +static void +build_multiple_docs_dialog (GeditCloseConfirmationDialog *dlg) +{ + GeditCloseConfirmationDialogPrivate *priv; + GtkWidget *hbox; + GtkWidget *image; + GtkWidget *vbox; + GtkWidget *primary_label; + GtkWidget *vbox2; + GtkWidget *select_label; + GtkWidget *scrolledwindow; + GtkWidget *treeview; + GtkWidget *secondary_label; + gchar *str; + gchar *markup_str; + + priv = dlg->priv; + + hbox = gtk_hbox_new (FALSE, 12); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + hbox, TRUE, TRUE, 0); + + /* Image */ + image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, + GTK_ICON_SIZE_DIALOG); + gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); + gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); + + vbox = gtk_vbox_new (FALSE, 12); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); + + /* Primary label */ + primary_label = gtk_label_new (NULL); + gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE); + gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (primary_label), 0.0, 0.5); + gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE); + + if (priv->disable_save_to_disk) + str = g_strdup_printf ( + ngettext ("Changes to %d document will be permanently lost.", + "Changes to %d documents will be permanently lost.", + g_list_length (priv->unsaved_documents)), + g_list_length (priv->unsaved_documents)); + else + str = g_strdup_printf ( + ngettext ("There is %d document with unsaved changes. " + "Save changes before closing?", + "There are %d documents with unsaved changes. " + "Save changes before closing?", + g_list_length (priv->unsaved_documents)), + g_list_length (priv->unsaved_documents)); + + markup_str = g_strconcat ("", str, "", NULL); + g_free (str); + + gtk_label_set_markup (GTK_LABEL (primary_label), markup_str); + g_free (markup_str); + gtk_box_pack_start (GTK_BOX (vbox), primary_label, FALSE, FALSE, 0); + + vbox2 = gtk_vbox_new (FALSE, 8); + gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); + + if (priv->disable_save_to_disk) + select_label = gtk_label_new_with_mnemonic (_("Docum_ents with unsaved changes:")); + else + select_label = gtk_label_new_with_mnemonic (_("S_elect the documents you want to save:")); + + gtk_box_pack_start (GTK_BOX (vbox2), select_label, FALSE, FALSE, 0); + gtk_label_set_line_wrap (GTK_LABEL (select_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (select_label), 0.0, 0.5); + + scrolledwindow = gtk_scrolled_window_new (NULL, NULL); + gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow, TRUE, TRUE, 0); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), + GTK_SHADOW_IN); + + treeview = create_treeview (priv); + gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview); + + /* Secondary label */ + if (priv->disable_save_to_disk) + secondary_label = gtk_label_new (_("Saving has been disabled by the system administrator.")); + else + secondary_label = gtk_label_new (_("If you don't save, " + "all your changes will be permanently lost.")); + + gtk_box_pack_start (GTK_BOX (vbox2), secondary_label, FALSE, FALSE, 0); + gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5); + gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE); + + gtk_label_set_mnemonic_widget (GTK_LABEL (select_label), treeview); + + gtk_widget_show_all (hbox); +} + +static void +set_unsaved_document (GeditCloseConfirmationDialog *dlg, + const GList *list) +{ + GeditCloseConfirmationDialogPrivate *priv; + + g_return_if_fail (list != NULL); + + priv = dlg->priv; + g_return_if_fail (priv->unsaved_documents == NULL); + + priv->unsaved_documents = g_list_copy ((GList *)list); + + if (GET_MODE (priv) == SINGLE_DOC_MODE) + { + build_single_doc_dialog (dlg); + } + else + { + build_multiple_docs_dialog (dlg); + } +} + +const GList * +gedit_close_confirmation_dialog_get_unsaved_documents (GeditCloseConfirmationDialog *dlg) +{ + g_return_val_if_fail (GEDIT_IS_CLOSE_CONFIRMATION_DIALOG (dlg), NULL); + + return dlg->priv->unsaved_documents; +} diff --git a/gedit/dialogs/gedit-close-confirmation-dialog.h b/gedit/dialogs/gedit-close-confirmation-dialog.h new file mode 100755 index 00000000..887fc1b4 --- /dev/null +++ b/gedit/dialogs/gedit-close-confirmation-dialog.h @@ -0,0 +1,75 @@ +/* + * gedit-close-confirmation-dialog.h + * This file is part of gedit + * + * Copyright (C) 2004-2005 MATE Foundation + * + * 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. + */ + +/* + * Modified by the gedit Team, 2004-2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + */ + +#ifndef __GEDIT_CLOSE_CONFIRMATION_DIALOG_H__ +#define __GEDIT_CLOSE_CONFIRMATION_DIALOG_H__ + +#include +#include + +#include + +#define GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG (gedit_close_confirmation_dialog_get_type ()) +#define GEDIT_CLOSE_CONFIRMATION_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG, GeditCloseConfirmationDialog)) +#define GEDIT_CLOSE_CONFIRMATION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG, GeditCloseConfirmationDialogClass)) +#define GEDIT_IS_CLOSE_CONFIRMATION_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG)) +#define GEDIT_IS_CLOSE_CONFIRMATION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG)) +#define GEDIT_CLOSE_CONFIRMATION_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),GEDIT_TYPE_CLOSE_CONFIRMATION_DIALOG, GeditCloseConfirmationDialogClass)) + +typedef struct _GeditCloseConfirmationDialog GeditCloseConfirmationDialog; +typedef struct _GeditCloseConfirmationDialogClass GeditCloseConfirmationDialogClass; +typedef struct _GeditCloseConfirmationDialogPrivate GeditCloseConfirmationDialogPrivate; + +struct _GeditCloseConfirmationDialog +{ + GtkDialog parent; + + /*< private > */ + GeditCloseConfirmationDialogPrivate *priv; +}; + +struct _GeditCloseConfirmationDialogClass +{ + GtkDialogClass parent_class; +}; + +GType gedit_close_confirmation_dialog_get_type (void) G_GNUC_CONST; + +GtkWidget *gedit_close_confirmation_dialog_new (GtkWindow *parent, + GList *unsaved_documents, + gboolean logout_mode); +GtkWidget *gedit_close_confirmation_dialog_new_single (GtkWindow *parent, + GeditDocument *doc, + gboolean logout_mode); + +const GList *gedit_close_confirmation_dialog_get_unsaved_documents (GeditCloseConfirmationDialog *dlg); + +GList *gedit_close_confirmation_dialog_get_selected_documents (GeditCloseConfirmationDialog *dlg); + +#endif /* __GEDIT_CLOSE_CONFIRMATION_DIALOG_H__ */ + diff --git a/gedit/dialogs/gedit-encodings-dialog.c b/gedit/dialogs/gedit-encodings-dialog.c new file mode 100755 index 00000000..b4800805 --- /dev/null +++ b/gedit/dialogs/gedit-encodings-dialog.c @@ -0,0 +1,499 @@ +/* + * gedit-encodings-dialog.c + * This file is part of gedit + * + * Copyright (C) 2002-2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2002-2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include +#include +#include + +#include "gedit-encodings-dialog.h" +#include "gedit-encodings.h" +#include "gedit-prefs-manager.h" +#include "gedit-utils.h" +#include "gedit-debug.h" +#include "gedit-help.h" +#include "gedit-dirs.h" + +#define GEDIT_ENCODINGS_DIALOG_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), \ + GEDIT_TYPE_ENCODINGS_DIALOG, \ + GeditEncodingsDialogPrivate)) + +struct _GeditEncodingsDialogPrivate +{ + GtkListStore *available_liststore; + GtkListStore *displayed_liststore; + GtkWidget *available_treeview; + GtkWidget *displayed_treeview; + GtkWidget *add_button; + GtkWidget *remove_button; + + GSList *show_in_menu_list; +}; + +G_DEFINE_TYPE(GeditEncodingsDialog, gedit_encodings_dialog, GTK_TYPE_DIALOG) + +static void +gedit_encodings_dialog_finalize (GObject *object) +{ + GeditEncodingsDialogPrivate *priv = GEDIT_ENCODINGS_DIALOG (object)->priv; + + g_slist_free (priv->show_in_menu_list); + + G_OBJECT_CLASS (gedit_encodings_dialog_parent_class)->finalize (object); +} + +static void +gedit_encodings_dialog_class_init (GeditEncodingsDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gedit_encodings_dialog_finalize; + + g_type_class_add_private (object_class, sizeof (GeditEncodingsDialogPrivate)); +} + +enum { + COLUMN_NAME, + COLUMN_CHARSET, + N_COLUMNS +}; + +static void +count_selected_items_func (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data) +{ + int *count = data; + + *count += 1; +} + +static void +available_selection_changed_callback (GtkTreeSelection *selection, + GeditEncodingsDialog *dialogs) +{ + int count; + + count = 0; + gtk_tree_selection_selected_foreach (selection, + count_selected_items_func, + &count); + + gtk_widget_set_sensitive (dialogs->priv->add_button, count > 0); +} + +static void +displayed_selection_changed_callback (GtkTreeSelection *selection, + GeditEncodingsDialog *dialogs) +{ + int count; + + count = 0; + gtk_tree_selection_selected_foreach (selection, + count_selected_items_func, + &count); + + gtk_widget_set_sensitive (dialogs->priv->remove_button, count > 0); +} + +static void +get_selected_encodings_func (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data) +{ + GSList **list = data; + gchar *charset; + const GeditEncoding *enc; + + charset = NULL; + gtk_tree_model_get (model, iter, COLUMN_CHARSET, &charset, -1); + + enc = gedit_encoding_get_from_charset (charset); + g_free (charset); + + *list = g_slist_prepend (*list, (gpointer)enc); +} + +static void +update_shown_in_menu_tree_model (GtkListStore *store, + GSList *list) +{ + GtkTreeIter iter; + + gtk_list_store_clear (store); + + while (list != NULL) + { + const GeditEncoding *enc; + + enc = (const GeditEncoding*) list->data; + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_CHARSET, + gedit_encoding_get_charset (enc), + COLUMN_NAME, + gedit_encoding_get_name (enc), -1); + + list = g_slist_next (list); + } +} + +static void +add_button_clicked_callback (GtkWidget *button, + GeditEncodingsDialog *dialog) +{ + GtkTreeSelection *selection; + GSList *encodings; + GSList *tmp; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->available_treeview)); + + encodings = NULL; + gtk_tree_selection_selected_foreach (selection, + get_selected_encodings_func, + &encodings); + + tmp = encodings; + while (tmp != NULL) + { + if (g_slist_find (dialog->priv->show_in_menu_list, tmp->data) == NULL) + dialog->priv->show_in_menu_list = g_slist_prepend (dialog->priv->show_in_menu_list, + tmp->data); + + tmp = g_slist_next (tmp); + } + + g_slist_free (encodings); + + update_shown_in_menu_tree_model (GTK_LIST_STORE (dialog->priv->displayed_liststore), + dialog->priv->show_in_menu_list); +} + +static void +remove_button_clicked_callback (GtkWidget *button, + GeditEncodingsDialog *dialog) +{ + GtkTreeSelection *selection; + GSList *encodings; + GSList *tmp; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->displayed_treeview)); + + encodings = NULL; + gtk_tree_selection_selected_foreach (selection, + get_selected_encodings_func, + &encodings); + + tmp = encodings; + while (tmp != NULL) + { + dialog->priv->show_in_menu_list = g_slist_remove (dialog->priv->show_in_menu_list, + tmp->data); + + tmp = g_slist_next (tmp); + } + + g_slist_free (encodings); + + update_shown_in_menu_tree_model (GTK_LIST_STORE (dialog->priv->displayed_liststore), + dialog->priv->show_in_menu_list); +} + +static void +init_shown_in_menu_tree_model (GeditEncodingsDialog *dialog) +{ + GtkTreeIter iter; + GSList *list, *tmp; + + /* add data to the list store */ + list = gedit_prefs_manager_get_shown_in_menu_encodings (); + + tmp = list; + + while (tmp != NULL) + { + const GeditEncoding *enc; + + enc = (const GeditEncoding *) tmp->data; + + dialog->priv->show_in_menu_list = g_slist_prepend (dialog->priv->show_in_menu_list, + tmp->data); + + gtk_list_store_append (dialog->priv->displayed_liststore, + &iter); + gtk_list_store_set (dialog->priv->displayed_liststore, + &iter, + COLUMN_CHARSET, + gedit_encoding_get_charset (enc), + COLUMN_NAME, + gedit_encoding_get_name (enc), -1); + + tmp = g_slist_next (tmp); + } + + g_slist_free (list); +} + +static void +response_handler (GtkDialog *dialog, + gint response_id, + GeditEncodingsDialog *dlg) +{ + if (response_id == GTK_RESPONSE_HELP) + { + gedit_help_display (GTK_WINDOW (dialog), "gedit", NULL); + g_signal_stop_emission_by_name (dialog, "response"); + return; + } + + if (response_id == GTK_RESPONSE_OK) + { + g_return_if_fail (gedit_prefs_manager_shown_in_menu_encodings_can_set ()); + gedit_prefs_manager_set_shown_in_menu_encodings (dlg->priv->show_in_menu_list); + } +} + +static void +gedit_encodings_dialog_init (GeditEncodingsDialog *dlg) +{ + GtkWidget *content; + GtkCellRenderer *cell_renderer; + GtkTreeModel *sort_model; + GtkTreeViewColumn *column; + GtkTreeIter parent_iter; + GtkTreeSelection *selection; + const GeditEncoding *enc; + GtkWidget *error_widget; + int i; + gboolean ret; + gchar *file; + gchar *root_objects[] = { + "encodings-dialog-contents", + NULL + }; + + dlg->priv = GEDIT_ENCODINGS_DIALOG_GET_PRIVATE (dlg); + + gtk_dialog_add_buttons (GTK_DIALOG (dlg), + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, + GTK_RESPONSE_OK, + GTK_STOCK_HELP, + GTK_RESPONSE_HELP, + NULL); + + gtk_window_set_title (GTK_WINDOW (dlg), _("Character Encodings")); + gtk_window_set_default_size (GTK_WINDOW (dlg), 650, 400); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + + /* HIG defaults */ + gtk_container_set_border_width (GTK_CONTAINER (dlg), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + 2); /* 2 * 5 + 2 = 12 */ + gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), + 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), 6); + + gtk_dialog_set_default_response (GTK_DIALOG (dlg), + GTK_RESPONSE_OK); + + g_signal_connect (dlg, + "response", + G_CALLBACK (response_handler), + dlg); + + file = gedit_dirs_get_ui_file ("gedit-encodings-dialog.ui"); + ret = gedit_utils_get_ui_objects (file, + root_objects, + &error_widget, + "encodings-dialog-contents", &content, + "add-button", &dlg->priv->add_button, + "remove-button", &dlg->priv->remove_button, + "available-treeview", &dlg->priv->available_treeview, + "displayed-treeview", &dlg->priv->displayed_treeview, + NULL); + g_free (file); + + if (!ret) + { + gtk_widget_show (error_widget); + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + error_widget, + TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (error_widget), 5); + + return; + } + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + content, TRUE, TRUE, 0); + g_object_unref (content); + gtk_container_set_border_width (GTK_CONTAINER (content), 5); + + g_signal_connect (dlg->priv->add_button, + "clicked", + G_CALLBACK (add_button_clicked_callback), + dlg); + g_signal_connect (dlg->priv->remove_button, + "clicked", + G_CALLBACK (remove_button_clicked_callback), + dlg); + + /* Tree view of available encodings */ + dlg->priv->available_liststore = gtk_list_store_new (N_COLUMNS, + G_TYPE_STRING, + G_TYPE_STRING); + + cell_renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes (_("_Description"), + cell_renderer, + "text", COLUMN_NAME, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->available_treeview), + column); + gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); + + cell_renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes (_("_Encoding"), + cell_renderer, + "text", + COLUMN_CHARSET, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->available_treeview), + column); + gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET); + + /* Add the data */ + i = 0; + while ((enc = gedit_encoding_get_from_index (i)) != NULL) + { + gtk_list_store_append (dlg->priv->available_liststore, + &parent_iter); + gtk_list_store_set (dlg->priv->available_liststore, + &parent_iter, + COLUMN_CHARSET, + gedit_encoding_get_charset (enc), + COLUMN_NAME, + gedit_encoding_get_name (enc), -1); + + ++i; + } + + /* Sort model */ + sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (dlg->priv->available_liststore)); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), + COLUMN_NAME, + GTK_SORT_ASCENDING); + + gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->available_treeview), + sort_model); + g_object_unref (G_OBJECT (dlg->priv->available_liststore)); + g_object_unref (G_OBJECT (sort_model)); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->available_treeview)); + gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), + GTK_SELECTION_MULTIPLE); + + available_selection_changed_callback (selection, dlg); + g_signal_connect (selection, + "changed", + G_CALLBACK (available_selection_changed_callback), + dlg); + + /* Tree view of selected encodings */ + dlg->priv->displayed_liststore = gtk_list_store_new (N_COLUMNS, + G_TYPE_STRING, + G_TYPE_STRING); + + cell_renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes (_("_Description"), + cell_renderer, + "text", COLUMN_NAME, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->displayed_treeview), + column); + gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); + + cell_renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes (_("_Encoding"), + cell_renderer, + "text", + COLUMN_CHARSET, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->displayed_treeview), + column); + gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET); + + /* Add the data */ + init_shown_in_menu_tree_model (dlg); + + /* Sort model */ + sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (dlg->priv->displayed_liststore)); + + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE + (sort_model), COLUMN_NAME, + GTK_SORT_ASCENDING); + + gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->displayed_treeview), + sort_model); + g_object_unref (G_OBJECT (sort_model)); + g_object_unref (G_OBJECT (dlg->priv->displayed_liststore)); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->displayed_treeview)); + gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), + GTK_SELECTION_MULTIPLE); + + displayed_selection_changed_callback (selection, dlg); + g_signal_connect (selection, + "changed", + G_CALLBACK (displayed_selection_changed_callback), + dlg); +} + +GtkWidget * +gedit_encodings_dialog_new (void) +{ + GtkWidget *dlg; + + dlg = GTK_WIDGET (g_object_new (GEDIT_TYPE_ENCODINGS_DIALOG, NULL)); + + return dlg; +} + diff --git a/gedit/dialogs/gedit-encodings-dialog.h b/gedit/dialogs/gedit-encodings-dialog.h new file mode 100755 index 00000000..a09cbe5c --- /dev/null +++ b/gedit/dialogs/gedit-encodings-dialog.h @@ -0,0 +1,86 @@ +/* + * gedit-encodings-dialog.h + * This file is part of gedit + * + * Copyright (C) 2003-2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2003-2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifndef __GEDIT_ENCODINGS_DIALOG_H__ +#define __GEDIT_ENCODINGS_DIALOG_H__ + +#include + +G_BEGIN_DECLS + +/* + * Type checking and casting macros + */ +#define GEDIT_TYPE_ENCODINGS_DIALOG (gedit_encodings_dialog_get_type()) +#define GEDIT_ENCODINGS_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_ENCODINGS_DIALOG, GeditEncodingsDialog)) +#define GEDIT_ENCODINGS_DIALOG_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_ENCODINGS_DIALOG, GeditEncodingsDialog const)) +#define GEDIT_ENCODINGS_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GEDIT_TYPE_ENCODINGS_DIALOG, GeditEncodingsDialogClass)) +#define GEDIT_IS_ENCODINGS_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEDIT_TYPE_ENCODINGS_DIALOG)) +#define GEDIT_IS_ENCODINGS_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_ENCODINGS_DIALOG)) +#define GEDIT_ENCODINGS_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GEDIT_TYPE_ENCODINGS_DIALOG, GeditEncodingsDialogClass)) + + +/* Private structure type */ +typedef struct _GeditEncodingsDialogPrivate GeditEncodingsDialogPrivate; + +/* + * Main object structure + */ +typedef struct _GeditEncodingsDialog GeditEncodingsDialog; + +struct _GeditEncodingsDialog +{ + GtkDialog dialog; + + /*< private > */ + GeditEncodingsDialogPrivate *priv; +}; + +/* + * Class definition + */ +typedef struct _GeditEncodingsDialogClass GeditEncodingsDialogClass; + +struct _GeditEncodingsDialogClass +{ + GtkDialogClass parent_class; +}; + +/* + * Public methods + */ +GType gedit_encodings_dialog_get_type (void) G_GNUC_CONST; + +GtkWidget *gedit_encodings_dialog_new (void); + +G_END_DECLS + +#endif /* __GEDIT_ENCODINGS_DIALOG_H__ */ + diff --git a/gedit/dialogs/gedit-encodings-dialog.ui b/gedit/dialogs/gedit-encodings-dialog.ui new file mode 100755 index 00000000..0f37b432 --- /dev/null +++ b/gedit/dialogs/gedit-encodings-dialog.ui @@ -0,0 +1,256 @@ + + + + + 650 + 400 + Character encodings + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + True + False + + + True + False + 0 + + + True + GTK_BUTTONBOX_END + + + True + True + True + gtk-help + True + GTK_RELIEF_NORMAL + + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + + 0 + False + True + GTK_PACK_END + + + + + 6 + True + True + 6 + + + True + False + 6 + + + True + A_vailable encodings: + True + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + available-treeview + + + 0 + False + False + + + + + True + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + GTK_SHADOW_ETCHED_IN + GTK_CORNER_TOP_LEFT + + + True + True + True + True + False + True + + + + + 0 + True + True + + + + + True + False + 0 + + + True + True + gtk-add + True + GTK_RELIEF_NORMAL + + + 0 + False + False + + + + + + + + 0 + False + False + + + + + 0 + True + True + + + + + True + False + 6 + + + True + E_ncodings shown in menu: + True + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + displayed-treeview + + + 0 + False + False + + + + + True + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + GTK_SHADOW_ETCHED_IN + GTK_CORNER_TOP_LEFT + + + True + True + True + True + False + True + + + + + 0 + True + True + + + + + True + False + 0 + + + True + True + gtk-remove + True + GTK_RELIEF_NORMAL + + + 0 + False + False + + + + + + + + 0 + False + False + + + + + 0 + True + True + + + + + 0 + True + True + + + + + + helpbutton1 + closebutton1 + button1 + + + diff --git a/gedit/dialogs/gedit-preferences-dialog.c b/gedit/dialogs/gedit-preferences-dialog.c new file mode 100755 index 00000000..52f180fa --- /dev/null +++ b/gedit/dialogs/gedit-preferences-dialog.c @@ -0,0 +1,1189 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * gedit-preferences-dialog.c + * This file is part of gedit + * + * Copyright (C) 2001-2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2001-2003. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include +#include + +#include + +#include "gedit-preferences-dialog.h" +#include "gedit-utils.h" +#include "gedit-debug.h" +#include "gedit-document.h" +#include "gedit-style-scheme-manager.h" +#include "gedit-plugin-manager.h" +#include "gedit-help.h" +#include "gedit-dirs.h" + +/* + * gedit-preferences dialog is a singleton since we don't + * want two dialogs showing an inconsistent state of the + * preferences. + * When gedit_show_preferences_dialog is called and there + * is already a prefs dialog dialog open, it is reparented + * and shown. + */ + +static GtkWidget *preferences_dialog = NULL; + + +enum +{ + ID_COLUMN = 0, + NAME_COLUMN, + DESC_COLUMN, + NUM_COLUMNS +}; + + +#define GEDIT_PREFERENCES_DIALOG_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), \ + GEDIT_TYPE_PREFERENCES_DIALOG, \ + GeditPreferencesDialogPrivate)) + +struct _GeditPreferencesDialogPrivate +{ + GtkWidget *notebook; + + /* Font */ + GtkWidget *default_font_checkbutton; + GtkWidget *font_button; + GtkWidget *font_hbox; + + /* Style Scheme */ + GtkListStore *schemes_treeview_model; + GtkWidget *schemes_treeview; + GtkWidget *install_scheme_button; + GtkWidget *uninstall_scheme_button; + + GtkWidget *install_scheme_file_schooser; + + /* Tabs */ + GtkWidget *tabs_width_spinbutton; + GtkWidget *insert_spaces_checkbutton; + GtkWidget *tabs_width_hbox; + + /* Auto indentation */ + GtkWidget *auto_indent_checkbutton; + + /* Text Wrapping */ + GtkWidget *wrap_text_checkbutton; + GtkWidget *split_checkbutton; + + /* File Saving */ + GtkWidget *backup_copy_checkbutton; + GtkWidget *auto_save_checkbutton; + GtkWidget *auto_save_spinbutton; + GtkWidget *autosave_hbox; + + /* Line numbers */ + GtkWidget *display_line_numbers_checkbutton; + + /* Highlight current line */ + GtkWidget *highlight_current_line_checkbutton; + + /* Highlight matching bracket */ + GtkWidget *bracket_matching_checkbutton; + + /* Right margin */ + GtkWidget *right_margin_checkbutton; + GtkWidget *right_margin_position_spinbutton; + GtkWidget *right_margin_position_hbox; + + /* Plugins manager */ + GtkWidget *plugin_manager_place_holder; + + /* Style Scheme editor dialog */ + GtkWidget *style_scheme_dialog; +}; + + +G_DEFINE_TYPE(GeditPreferencesDialog, gedit_preferences_dialog, GTK_TYPE_DIALOG) + + +static void +gedit_preferences_dialog_class_init (GeditPreferencesDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (object_class, sizeof (GeditPreferencesDialogPrivate)); +} + +static void +dialog_response_handler (GtkDialog *dlg, + gint res_id) +{ + gedit_debug (DEBUG_PREFS); + + switch (res_id) + { + case GTK_RESPONSE_HELP: + gedit_help_display (GTK_WINDOW (dlg), + NULL, + "gedit-prefs"); + + g_signal_stop_emission_by_name (dlg, "response"); + + break; + + default: + gtk_widget_destroy (GTK_WIDGET(dlg)); + } +} + +static void +tabs_width_spinbutton_value_changed (GtkSpinButton *spin_button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (spin_button == GTK_SPIN_BUTTON (dlg->priv->tabs_width_spinbutton)); + + gedit_prefs_manager_set_tabs_size (gtk_spin_button_get_value_as_int (spin_button)); +} + +static void +insert_spaces_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->insert_spaces_checkbutton)); + + gedit_prefs_manager_set_insert_spaces (gtk_toggle_button_get_active (button)); +} + +static void +auto_indent_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->auto_indent_checkbutton)); + + gedit_prefs_manager_set_auto_indent (gtk_toggle_button_get_active (button)); +} + +static void +auto_save_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->auto_save_checkbutton)); + + if (gtk_toggle_button_get_active (button)) + { + gtk_widget_set_sensitive (dlg->priv->auto_save_spinbutton, + gedit_prefs_manager_auto_save_interval_can_set()); + + gedit_prefs_manager_set_auto_save (TRUE); + } + else + { + gtk_widget_set_sensitive (dlg->priv->auto_save_spinbutton, FALSE); + gedit_prefs_manager_set_auto_save (FALSE); + } +} + +static void +backup_copy_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->backup_copy_checkbutton)); + + gedit_prefs_manager_set_create_backup_copy (gtk_toggle_button_get_active (button)); +} + +static void +auto_save_spinbutton_value_changed (GtkSpinButton *spin_button, + GeditPreferencesDialog *dlg) +{ + g_return_if_fail (spin_button == GTK_SPIN_BUTTON (dlg->priv->auto_save_spinbutton)); + + gedit_prefs_manager_set_auto_save_interval ( + MAX (1, gtk_spin_button_get_value_as_int (spin_button))); +} + +static void +setup_editor_page (GeditPreferencesDialog *dlg) +{ + gboolean auto_save; + gint auto_save_interval; + + gedit_debug (DEBUG_PREFS); + + /* Set initial state */ + gtk_spin_button_set_value (GTK_SPIN_BUTTON (dlg->priv->tabs_width_spinbutton), + (guint) gedit_prefs_manager_get_tabs_size ()); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->insert_spaces_checkbutton), + gedit_prefs_manager_get_insert_spaces ()); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->auto_indent_checkbutton), + gedit_prefs_manager_get_auto_indent ()); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->backup_copy_checkbutton), + gedit_prefs_manager_get_create_backup_copy ()); + + auto_save = gedit_prefs_manager_get_auto_save (); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->auto_save_checkbutton), + auto_save); + + auto_save_interval = gedit_prefs_manager_get_auto_save_interval (); + if (auto_save_interval <= 0) + auto_save_interval = GPM_DEFAULT_AUTO_SAVE_INTERVAL; + + gtk_spin_button_set_value (GTK_SPIN_BUTTON (dlg->priv->auto_save_spinbutton), + auto_save_interval); + + /* Set widget sensitivity */ + gtk_widget_set_sensitive (dlg->priv->tabs_width_hbox, + gedit_prefs_manager_tabs_size_can_set ()); + gtk_widget_set_sensitive (dlg->priv->insert_spaces_checkbutton, + gedit_prefs_manager_insert_spaces_can_set ()); + gtk_widget_set_sensitive (dlg->priv->auto_indent_checkbutton, + gedit_prefs_manager_auto_indent_can_set ()); + gtk_widget_set_sensitive (dlg->priv->backup_copy_checkbutton, + gedit_prefs_manager_create_backup_copy_can_set ()); + gtk_widget_set_sensitive (dlg->priv->autosave_hbox, + gedit_prefs_manager_auto_save_can_set ()); + gtk_widget_set_sensitive (dlg->priv->auto_save_spinbutton, + auto_save && + gedit_prefs_manager_auto_save_interval_can_set ()); + + /* Connect signal */ + g_signal_connect (dlg->priv->tabs_width_spinbutton, + "value_changed", + G_CALLBACK (tabs_width_spinbutton_value_changed), + dlg); + g_signal_connect (dlg->priv->insert_spaces_checkbutton, + "toggled", + G_CALLBACK (insert_spaces_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->auto_indent_checkbutton, + "toggled", + G_CALLBACK (auto_indent_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->auto_save_checkbutton, + "toggled", + G_CALLBACK (auto_save_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->backup_copy_checkbutton, + "toggled", + G_CALLBACK (backup_copy_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->auto_save_spinbutton, + "value_changed", + G_CALLBACK (auto_save_spinbutton_value_changed), + dlg); +} + +static void +display_line_numbers_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + g_return_if_fail (button == + GTK_TOGGLE_BUTTON (dlg->priv->display_line_numbers_checkbutton)); + + gedit_prefs_manager_set_display_line_numbers (gtk_toggle_button_get_active (button)); +} + +static void +highlight_current_line_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + g_return_if_fail (button == + GTK_TOGGLE_BUTTON (dlg->priv->highlight_current_line_checkbutton)); + + gedit_prefs_manager_set_highlight_current_line (gtk_toggle_button_get_active (button)); +} + +static void +bracket_matching_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + g_return_if_fail (button == + GTK_TOGGLE_BUTTON (dlg->priv->bracket_matching_checkbutton)); + + gedit_prefs_manager_set_bracket_matching ( + gtk_toggle_button_get_active (button)); +} + +static gboolean split_button_state = TRUE; + +static void +wrap_mode_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dlg->priv->wrap_text_checkbutton))) + { + gedit_prefs_manager_set_wrap_mode (GTK_WRAP_NONE); + + gtk_widget_set_sensitive (dlg->priv->split_checkbutton, + FALSE); + gtk_toggle_button_set_inconsistent ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), TRUE); + } + else + { + gtk_widget_set_sensitive (dlg->priv->split_checkbutton, + TRUE); + + gtk_toggle_button_set_inconsistent ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), FALSE); + + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton))) + { + split_button_state = TRUE; + + gedit_prefs_manager_set_wrap_mode (GTK_WRAP_WORD); + } + else + { + split_button_state = FALSE; + + gedit_prefs_manager_set_wrap_mode (GTK_WRAP_CHAR); + } + } +} + +static void +right_margin_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gboolean active; + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->right_margin_checkbutton)); + + active = gtk_toggle_button_get_active (button); + + gedit_prefs_manager_set_display_right_margin (active); + + gtk_widget_set_sensitive (dlg->priv->right_margin_position_hbox, + active && + gedit_prefs_manager_right_margin_position_can_set ()); +} + +static void +right_margin_position_spinbutton_value_changed (GtkSpinButton *spin_button, + GeditPreferencesDialog *dlg) +{ + gint value; + + g_return_if_fail (spin_button == GTK_SPIN_BUTTON (dlg->priv->right_margin_position_spinbutton)); + + value = CLAMP (gtk_spin_button_get_value_as_int (spin_button), 1, 160); + + gedit_prefs_manager_set_right_margin_position (value); +} + +static void +setup_view_page (GeditPreferencesDialog *dlg) +{ + GtkWrapMode wrap_mode; + gboolean display_right_margin; + gboolean wrap_mode_can_set; + + gedit_debug (DEBUG_PREFS); + + /* Set initial state */ + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->display_line_numbers_checkbutton), + gedit_prefs_manager_get_display_line_numbers ()); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->highlight_current_line_checkbutton), + gedit_prefs_manager_get_highlight_current_line ()); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->bracket_matching_checkbutton), + gedit_prefs_manager_get_bracket_matching ()); + + wrap_mode = gedit_prefs_manager_get_wrap_mode (); + switch (wrap_mode ) + { + case GTK_WRAP_WORD: + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->wrap_text_checkbutton), TRUE); + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), TRUE); + break; + case GTK_WRAP_CHAR: + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->wrap_text_checkbutton), TRUE); + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), FALSE); + break; + default: + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->wrap_text_checkbutton), FALSE); + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), split_button_state); + gtk_toggle_button_set_inconsistent ( + GTK_TOGGLE_BUTTON (dlg->priv->split_checkbutton), TRUE); + + } + + display_right_margin = gedit_prefs_manager_get_display_right_margin (); + + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (dlg->priv->right_margin_checkbutton), + display_right_margin); + + gtk_spin_button_set_value ( + GTK_SPIN_BUTTON (dlg->priv->right_margin_position_spinbutton), + (guint)CLAMP (gedit_prefs_manager_get_right_margin_position (), 1, 160)); + + /* Set widgets sensitivity */ + gtk_widget_set_sensitive (dlg->priv->display_line_numbers_checkbutton, + gedit_prefs_manager_display_line_numbers_can_set ()); + gtk_widget_set_sensitive (dlg->priv->highlight_current_line_checkbutton, + gedit_prefs_manager_highlight_current_line_can_set ()); + gtk_widget_set_sensitive (dlg->priv->bracket_matching_checkbutton, + gedit_prefs_manager_bracket_matching_can_set ()); + wrap_mode_can_set = gedit_prefs_manager_wrap_mode_can_set (); + gtk_widget_set_sensitive (dlg->priv->wrap_text_checkbutton, + wrap_mode_can_set); + gtk_widget_set_sensitive (dlg->priv->split_checkbutton, + wrap_mode_can_set && + (wrap_mode != GTK_WRAP_NONE)); + gtk_widget_set_sensitive (dlg->priv->right_margin_checkbutton, + gedit_prefs_manager_display_right_margin_can_set ()); + gtk_widget_set_sensitive (dlg->priv->right_margin_position_hbox, + display_right_margin && + gedit_prefs_manager_right_margin_position_can_set ()); + + /* Connect signals */ + g_signal_connect (dlg->priv->display_line_numbers_checkbutton, + "toggled", + G_CALLBACK (display_line_numbers_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->highlight_current_line_checkbutton, + "toggled", + G_CALLBACK (highlight_current_line_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->bracket_matching_checkbutton, + "toggled", + G_CALLBACK (bracket_matching_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->wrap_text_checkbutton, + "toggled", + G_CALLBACK (wrap_mode_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->split_checkbutton, + "toggled", + G_CALLBACK (wrap_mode_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->right_margin_checkbutton, + "toggled", + G_CALLBACK (right_margin_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->right_margin_position_spinbutton, + "value_changed", + G_CALLBACK (right_margin_position_spinbutton_value_changed), + dlg); +} + +static void +default_font_font_checkbutton_toggled (GtkToggleButton *button, + GeditPreferencesDialog *dlg) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (button == GTK_TOGGLE_BUTTON (dlg->priv->default_font_checkbutton)); + + if (gtk_toggle_button_get_active (button)) + { + gtk_widget_set_sensitive (dlg->priv->font_hbox, FALSE); + gedit_prefs_manager_set_use_default_font (TRUE); + } + else + { + gtk_widget_set_sensitive (dlg->priv->font_hbox, + gedit_prefs_manager_editor_font_can_set ()); + gedit_prefs_manager_set_use_default_font (FALSE); + } +} + +static void +editor_font_button_font_set (GtkFontButton *font_button, + GeditPreferencesDialog *dlg) +{ + const gchar *font_name; + + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (font_button == GTK_FONT_BUTTON (dlg->priv->font_button)); + + /* FIXME: Can this fail? Gtk docs are a bit terse... 21-02-2004 pbor */ + font_name = gtk_font_button_get_font_name (font_button); + if (!font_name) + { + g_warning ("Could not get font name"); + return; + } + + gedit_prefs_manager_set_editor_font (font_name); +} + +static void +setup_font_colors_page_font_section (GeditPreferencesDialog *dlg) +{ + gboolean use_default_font; + gchar *editor_font = NULL; + gchar *label; + + gedit_debug (DEBUG_PREFS); + + gtk_widget_set_tooltip_text (dlg->priv->font_button, + _("Click on this button to select the font to be used by the editor")); + + gedit_utils_set_atk_relation (dlg->priv->font_button, + dlg->priv->default_font_checkbutton, + ATK_RELATION_CONTROLLED_BY); + gedit_utils_set_atk_relation (dlg->priv->default_font_checkbutton, + dlg->priv->font_button, + ATK_RELATION_CONTROLLER_FOR); + + editor_font = gedit_prefs_manager_get_system_font (); + label = g_strdup_printf(_("_Use the system fixed width font (%s)"), + editor_font); + gtk_button_set_label (GTK_BUTTON (dlg->priv->default_font_checkbutton), + label); + g_free (editor_font); + g_free (label); + + /* read current config and setup initial state */ + use_default_font = gedit_prefs_manager_get_use_default_font (); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->priv->default_font_checkbutton), + use_default_font); + + editor_font = gedit_prefs_manager_get_editor_font (); + if (editor_font != NULL) + { + gtk_font_button_set_font_name (GTK_FONT_BUTTON (dlg->priv->font_button), + editor_font); + g_free (editor_font); + } + + /* Connect signals */ + g_signal_connect (dlg->priv->default_font_checkbutton, + "toggled", + G_CALLBACK (default_font_font_checkbutton_toggled), + dlg); + g_signal_connect (dlg->priv->font_button, + "font_set", + G_CALLBACK (editor_font_button_font_set), + dlg); + + /* Set initial widget sensitivity */ + gtk_widget_set_sensitive (dlg->priv->default_font_checkbutton, + gedit_prefs_manager_use_default_font_can_set ()); + + if (use_default_font) + gtk_widget_set_sensitive (dlg->priv->font_hbox, FALSE); + else + gtk_widget_set_sensitive (dlg->priv->font_hbox, + gedit_prefs_manager_editor_font_can_set ()); +} + +static void +set_buttons_sensisitivity_according_to_scheme (GeditPreferencesDialog *dlg, + const gchar *scheme_id) +{ + gboolean editable; + + editable = (scheme_id != NULL) && + _gedit_style_scheme_manager_scheme_is_gedit_user_scheme ( + gedit_get_style_scheme_manager (), + scheme_id); + + gtk_widget_set_sensitive (dlg->priv->uninstall_scheme_button, + editable); +} + +static void +style_scheme_changed (GtkWidget *treeview, + GeditPreferencesDialog *dlg) +{ + GtkTreePath *path; + GtkTreeIter iter; + gchar *id; + + gtk_tree_view_get_cursor (GTK_TREE_VIEW (dlg->priv->schemes_treeview), &path, NULL); + gtk_tree_model_get_iter (GTK_TREE_MODEL (dlg->priv->schemes_treeview_model), + &iter, path); + gtk_tree_path_free (path); + gtk_tree_model_get (GTK_TREE_MODEL (dlg->priv->schemes_treeview_model), + &iter, ID_COLUMN, &id, -1); + + gedit_prefs_manager_set_source_style_scheme (id); + + set_buttons_sensisitivity_according_to_scheme (dlg, id); + + g_free (id); +} + +static const gchar * +ensure_color_scheme_id (const gchar *id) +{ + GtkSourceStyleScheme *scheme = NULL; + GtkSourceStyleSchemeManager *manager = gedit_get_style_scheme_manager (); + + if (id == NULL) + { + gchar *pref_id; + + pref_id = gedit_prefs_manager_get_source_style_scheme (); + scheme = gtk_source_style_scheme_manager_get_scheme (manager, + pref_id); + g_free (pref_id); + } + else + { + scheme = gtk_source_style_scheme_manager_get_scheme (manager, + id); + } + + if (scheme == NULL) + { + /* Fall-back to classic style scheme */ + scheme = gtk_source_style_scheme_manager_get_scheme (manager, + "classic"); + } + + if (scheme == NULL) + { + /* Cannot determine default style scheme -> broken GtkSourceView installation */ + return NULL; + } + + return gtk_source_style_scheme_get_id (scheme); +} + +/* If def_id is NULL, use the default scheme as returned by + * gedit_style_scheme_manager_get_default_scheme. If this one returns NULL + * use the first available scheme as default */ +static const gchar * +populate_color_scheme_list (GeditPreferencesDialog *dlg, const gchar *def_id) +{ + GSList *schemes; + GSList *l; + + gtk_list_store_clear (dlg->priv->schemes_treeview_model); + + def_id = ensure_color_scheme_id (def_id); + if (def_id == NULL) + { + g_warning ("Cannot build the list of available color schemes.\n" + "Please check your GtkSourceView installation."); + return NULL; + } + + schemes = gedit_style_scheme_manager_list_schemes_sorted (gedit_get_style_scheme_manager ()); + l = schemes; + while (l != NULL) + { + GtkSourceStyleScheme *scheme; + const gchar *id; + const gchar *name; + const gchar *description; + GtkTreeIter iter; + + scheme = GTK_SOURCE_STYLE_SCHEME (l->data); + + id = gtk_source_style_scheme_get_id (scheme); + name = gtk_source_style_scheme_get_name (scheme); + description = gtk_source_style_scheme_get_description (scheme); + + gtk_list_store_append (dlg->priv->schemes_treeview_model, &iter); + gtk_list_store_set (dlg->priv->schemes_treeview_model, + &iter, + ID_COLUMN, id, + NAME_COLUMN, name, + DESC_COLUMN, description, + -1); + + g_return_val_if_fail (def_id != NULL, NULL); + if (strcmp (id, def_id) == 0) + { + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->schemes_treeview)); + gtk_tree_selection_select_iter (selection, &iter); + } + + l = g_slist_next (l); + } + + g_slist_free (schemes); + + return def_id; +} + +static void +add_scheme_chooser_response_cb (GtkDialog *chooser, + gint res_id, + GeditPreferencesDialog *dlg) +{ + gchar* filename; + const gchar *scheme_id; + + if (res_id != GTK_RESPONSE_ACCEPT) + { + gtk_widget_hide (GTK_WIDGET (chooser)); + return; + } + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); + if (filename == NULL) + return; + + gtk_widget_hide (GTK_WIDGET (chooser)); + + scheme_id = _gedit_style_scheme_manager_install_scheme ( + gedit_get_style_scheme_manager (), + filename); + g_free (filename); + + if (scheme_id == NULL) + { + gedit_warning (GTK_WINDOW (dlg), + _("The selected color scheme cannot be installed.")); + + return; + } + + gedit_prefs_manager_set_source_style_scheme (scheme_id); + + scheme_id = populate_color_scheme_list (dlg, scheme_id); + + set_buttons_sensisitivity_according_to_scheme (dlg, scheme_id); +} + +static void +install_scheme_clicked (GtkButton *button, + GeditPreferencesDialog *dlg) +{ + GtkWidget *chooser; + GtkFileFilter *filter; + + if (dlg->priv->install_scheme_file_schooser != NULL) { + gtk_window_present (GTK_WINDOW (dlg->priv->install_scheme_file_schooser)); + gtk_widget_grab_focus (dlg->priv->install_scheme_file_schooser); + return; + } + + chooser = gtk_file_chooser_dialog_new (_("Add Scheme"), + GTK_WINDOW (dlg), + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + NULL); + + gedit_dialog_add_button (GTK_DIALOG (chooser), + _("A_dd Scheme"), + GTK_STOCK_ADD, + GTK_RESPONSE_ACCEPT); + + gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser), TRUE); + + /* Filters */ + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("Color Scheme Files")); + gtk_file_filter_add_pattern (filter, "*.xml"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); + + gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("All Files")); + gtk_file_filter_add_pattern (filter, "*"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); + + gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT); + + g_signal_connect (chooser, + "response", + G_CALLBACK (add_scheme_chooser_response_cb), + dlg); + + dlg->priv->install_scheme_file_schooser = chooser; + + g_object_add_weak_pointer (G_OBJECT (chooser), + (gpointer) &dlg->priv->install_scheme_file_schooser); + + gtk_widget_show (chooser); +} + +static void +uninstall_scheme_clicked (GtkButton *button, + GeditPreferencesDialog *dlg) +{ + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->schemes_treeview)); + model = GTK_TREE_MODEL (dlg->priv->schemes_treeview_model); + + if (gtk_tree_selection_get_selected (selection, + &model, + &iter)) + { + gchar *id; + gchar *name; + + gtk_tree_model_get (model, &iter, + ID_COLUMN, &id, + NAME_COLUMN, &name, + -1); + + if (!_gedit_style_scheme_manager_uninstall_scheme (gedit_get_style_scheme_manager (), id)) + { + gedit_warning (GTK_WINDOW (dlg), + _("Could not remove color scheme \"%s\"."), + name); + } + else + { + const gchar *real_new_id; + gchar *new_id = NULL; + GtkTreePath *path; + GtkTreeIter new_iter; + gboolean new_iter_set = FALSE; + + /* If the removed style scheme is the last of the list, + * set as new default style scheme the previous one, + * otherwise set the next one. + * To make this possible, we need to get the id of the + * new default style scheme before re-populating the list. + * Fall back to "classic" if it is not possible to get + * the id + */ + path = gtk_tree_model_get_path (model, &iter); + + /* Try to move to the next path */ + gtk_tree_path_next (path); + if (!gtk_tree_model_get_iter (model, &new_iter, path)) + { + /* It seems the removed style scheme was the + * last of the list. Try to move to the + * previous one */ + gtk_tree_path_free (path); + + path = gtk_tree_model_get_path (model, &iter); + + gtk_tree_path_prev (path); + if (gtk_tree_model_get_iter (model, &new_iter, path)) + new_iter_set = TRUE; + } + else + new_iter_set = TRUE; + + gtk_tree_path_free (path); + + if (new_iter_set) + gtk_tree_model_get (model, &new_iter, + ID_COLUMN, &new_id, + -1); + + real_new_id = populate_color_scheme_list (dlg, new_id); + g_free (new_id); + + set_buttons_sensisitivity_according_to_scheme (dlg, real_new_id); + + if (real_new_id != NULL) + gedit_prefs_manager_set_source_style_scheme (real_new_id); + } + + g_free (id); + g_free (name); + } +} + +static void +scheme_description_cell_data_func (GtkTreeViewColumn *column, + GtkCellRenderer *renderer, + GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + gchar *name; + gchar *desc; + gchar *text; + + gtk_tree_model_get (model, iter, + NAME_COLUMN, &name, + DESC_COLUMN, &desc, + -1); + + if (desc != NULL) + { + text = g_markup_printf_escaped ("%s - %s", + name, + desc); + } + else + { + text = g_markup_printf_escaped ("%s", + name); + } + + g_free (name); + g_free (desc); + + g_object_set (G_OBJECT (renderer), + "markup", + text, + NULL); + + g_free (text); +} + +static void +setup_font_colors_page_style_scheme_section (GeditPreferencesDialog *dlg) +{ + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + GtkTreeSelection *selection; + const gchar *def_id; + + gedit_debug (DEBUG_PREFS); + + /* Create GtkListStore for styles & setup treeview. */ + dlg->priv->schemes_treeview_model = gtk_list_store_new (NUM_COLUMNS, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING); + + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dlg->priv->schemes_treeview_model), + 0, + GTK_SORT_ASCENDING); + gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->schemes_treeview), + GTK_TREE_MODEL (dlg->priv->schemes_treeview_model)); + + column = gtk_tree_view_column_new (); + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); + gtk_tree_view_column_pack_start (column, renderer, TRUE); + gtk_tree_view_column_set_cell_data_func (column, + renderer, + scheme_description_cell_data_func, + dlg, + NULL); + + gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->schemes_treeview), + column); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->schemes_treeview)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); + + def_id = populate_color_scheme_list (dlg, NULL); + + /* Connect signals */ + g_signal_connect (dlg->priv->schemes_treeview, + "cursor-changed", + G_CALLBACK (style_scheme_changed), + dlg); + g_signal_connect (dlg->priv->install_scheme_button, + "clicked", + G_CALLBACK (install_scheme_clicked), + dlg); + g_signal_connect (dlg->priv->uninstall_scheme_button, + "clicked", + G_CALLBACK (uninstall_scheme_clicked), + dlg); + + /* Set initial widget sensitivity */ + set_buttons_sensisitivity_according_to_scheme (dlg, def_id); +} + +static void +setup_font_colors_page (GeditPreferencesDialog *dlg) +{ + setup_font_colors_page_font_section (dlg); + setup_font_colors_page_style_scheme_section (dlg); +} + +static void +setup_plugins_page (GeditPreferencesDialog *dlg) +{ + GtkWidget *page_content; + + gedit_debug (DEBUG_PREFS); + + page_content = gedit_plugin_manager_new (); + g_return_if_fail (page_content != NULL); + + gtk_box_pack_start (GTK_BOX (dlg->priv->plugin_manager_place_holder), + page_content, + TRUE, + TRUE, + 0); + + gtk_widget_show_all (page_content); +} + +static void +gedit_preferences_dialog_init (GeditPreferencesDialog *dlg) +{ + GtkWidget *error_widget; + gboolean ret; + gchar *file; + gchar *root_objects[] = { + "notebook", + "adjustment1", + "adjustment2", + "adjustment3", + "install_scheme_image", + NULL + }; + + gedit_debug (DEBUG_PREFS); + + dlg->priv = GEDIT_PREFERENCES_DIALOG_GET_PRIVATE (dlg); + + gtk_dialog_add_buttons (GTK_DIALOG (dlg), + GTK_STOCK_CLOSE, + GTK_RESPONSE_CLOSE, + GTK_STOCK_HELP, + GTK_RESPONSE_HELP, + NULL); + + gtk_window_set_title (GTK_WINDOW (dlg), _("gedit Preferences")); + gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE); + + /* HIG defaults */ + gtk_container_set_border_width (GTK_CONTAINER (dlg), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), 2); /* 2 * 5 + 2 = 12 */ + gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), 6); + + g_signal_connect (dlg, + "response", + G_CALLBACK (dialog_response_handler), + NULL); + + file = gedit_dirs_get_ui_file ("gedit-preferences-dialog.ui"); + ret = gedit_utils_get_ui_objects (file, + root_objects, + &error_widget, + + "notebook", &dlg->priv->notebook, + + "display_line_numbers_checkbutton", &dlg->priv->display_line_numbers_checkbutton, + "highlight_current_line_checkbutton", &dlg->priv->highlight_current_line_checkbutton, + "bracket_matching_checkbutton", &dlg->priv->bracket_matching_checkbutton, + "wrap_text_checkbutton", &dlg->priv->wrap_text_checkbutton, + "split_checkbutton", &dlg->priv->split_checkbutton, + + "right_margin_checkbutton", &dlg->priv->right_margin_checkbutton, + "right_margin_position_spinbutton", &dlg->priv->right_margin_position_spinbutton, + "right_margin_position_hbox", &dlg->priv->right_margin_position_hbox, + + "tabs_width_spinbutton", &dlg->priv->tabs_width_spinbutton, + "tabs_width_hbox", &dlg->priv->tabs_width_hbox, + "insert_spaces_checkbutton", &dlg->priv->insert_spaces_checkbutton, + + "auto_indent_checkbutton", &dlg->priv->auto_indent_checkbutton, + + "autosave_hbox", &dlg->priv->autosave_hbox, + "backup_copy_checkbutton", &dlg->priv->backup_copy_checkbutton, + "auto_save_checkbutton", &dlg->priv->auto_save_checkbutton, + "auto_save_spinbutton", &dlg->priv->auto_save_spinbutton, + + "default_font_checkbutton", &dlg->priv->default_font_checkbutton, + "font_button", &dlg->priv->font_button, + "font_hbox", &dlg->priv->font_hbox, + + "schemes_treeview", &dlg->priv->schemes_treeview, + "install_scheme_button", &dlg->priv->install_scheme_button, + "uninstall_scheme_button", &dlg->priv->uninstall_scheme_button, + + "plugin_manager_place_holder", &dlg->priv->plugin_manager_place_holder, + + NULL); + g_free (file); + + if (!ret) + { + gtk_widget_show (error_widget); + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + error_widget, + TRUE, TRUE, 0); + + return; + } + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + dlg->priv->notebook, FALSE, FALSE, 0); + g_object_unref (dlg->priv->notebook); + gtk_container_set_border_width (GTK_CONTAINER (dlg->priv->notebook), 5); + + setup_editor_page (dlg); + setup_view_page (dlg); + setup_font_colors_page (dlg); + setup_plugins_page (dlg); +} + +void +gedit_show_preferences_dialog (GeditWindow *parent) +{ + gedit_debug (DEBUG_PREFS); + + g_return_if_fail (GEDIT_IS_WINDOW (parent)); + + if (preferences_dialog == NULL) + { + preferences_dialog = GTK_WIDGET (g_object_new (GEDIT_TYPE_PREFERENCES_DIALOG, NULL)); + g_signal_connect (preferences_dialog, + "destroy", + G_CALLBACK (gtk_widget_destroyed), + &preferences_dialog); + } + + if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (preferences_dialog))) + { + gtk_window_set_transient_for (GTK_WINDOW (preferences_dialog), + GTK_WINDOW (parent)); + } + + gtk_window_present (GTK_WINDOW (preferences_dialog)); +} diff --git a/gedit/dialogs/gedit-preferences-dialog.h b/gedit/dialogs/gedit-preferences-dialog.h new file mode 100755 index 00000000..bafebb06 --- /dev/null +++ b/gedit/dialogs/gedit-preferences-dialog.h @@ -0,0 +1,87 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * gedit-preferences-dialog.c + * This file is part of gedit + * + * Copyright (C) 2001-2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2003. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifndef __GEDIT_PREFERENCES_DIALOG_H__ +#define __GEDIT_PREFERENCES_DIALOG_H__ + +#include "gedit-window.h" + +G_BEGIN_DECLS + +/* + * Type checking and casting macros + */ +#define GEDIT_TYPE_PREFERENCES_DIALOG (gedit_preferences_dialog_get_type()) +#define GEDIT_PREFERENCES_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_PREFERENCES_DIALOG, GeditPreferencesDialog)) +#define GEDIT_PREFERENCES_DIALOG_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_PREFERENCES_DIALOG, GeditPreferencesDialog const)) +#define GEDIT_PREFERENCES_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GEDIT_TYPE_PREFERENCES_DIALOG, GeditPreferencesDialogClass)) +#define GEDIT_IS_PREFERENCES_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEDIT_TYPE_PREFERENCES_DIALOG)) +#define GEDIT_IS_PREFERENCES_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_PREFERENCES_DIALOG)) +#define GEDIT_PREFERENCES_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GEDIT_TYPE_PREFERENCES_DIALOG, GeditPreferencesDialogClass)) + + +/* Private structure type */ +typedef struct _GeditPreferencesDialogPrivate GeditPreferencesDialogPrivate; + +/* + * Main object structure + */ +typedef struct _GeditPreferencesDialog GeditPreferencesDialog; + +struct _GeditPreferencesDialog +{ + GtkDialog dialog; + + /*< private > */ + GeditPreferencesDialogPrivate *priv; +}; + +/* + * Class definition + */ +typedef struct _GeditPreferencesDialogClass GeditPreferencesDialogClass; + +struct _GeditPreferencesDialogClass +{ + GtkDialogClass parent_class; +}; + +/* + * Public methods + */ +GType gedit_preferences_dialog_get_type (void) G_GNUC_CONST; + +void gedit_show_preferences_dialog (GeditWindow *parent); + +G_END_DECLS + +#endif /* __GEDIT_PREFERENCES_DIALOG_H__ */ + diff --git a/gedit/dialogs/gedit-preferences-dialog.ui b/gedit/dialogs/gedit-preferences-dialog.ui new file mode 100755 index 00000000..42d41e31 --- /dev/null +++ b/gedit/dialogs/gedit-preferences-dialog.ui @@ -0,0 +1,1107 @@ + + + + + + 80 + 1 + 160 + 1 + 10 + + + 8 + 1 + 24 + 1 + 4 + + + 8 + 1 + 100 + 1 + 10 + + + gtk-add + + + Preferences + False + True + dialog + False + + + True + vertical + + + True + True + 6 + + + True + 12 + vertical + 18 + + + True + vertical + 6 + + + True + 0 + Text Wrapping + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + Enable text _wrapping + True + True + False + True + True + + + False + False + 0 + + + + + Do not _split words over two lines + True + True + False + True + True + + + False + False + 1 + + + + + 1 + + + + + 1 + + + + + 0 + + + + + True + vertical + 6 + + + True + 0 + Line Numbers + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + 6 + + + _Display line numbers + True + True + False + True + True + + + False + False + 0 + + + + + 1 + + + + + 1 + + + + + False + False + 1 + + + + + True + vertical + 6 + + + True + 0 + Current Line + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + Highlight current _line + True + True + False + True + True + + + False + False + 0 + + + + + 1 + + + + + 1 + + + + + False + 2 + + + + + True + vertical + 6 + + + True + 0 + Right Margin + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + Display right _margin + True + True + False + True + True + + + False + False + 0 + + + + + True + 6 + + + True + 0 + _Right margin at column: + True + right_margin_position_spinbutton + + + False + False + 0 + + + + + True + True + adjustment1 + 1 + True + True + + + False + False + 1 + + + + + False + False + 1 + + + + + 1 + + + + + 1 + + + + + False + False + 3 + + + + + True + vertical + 6 + + + True + 0 + Bracket Matching + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + Highlight matching _bracket + True + True + False + True + True + + + False + False + 0 + + + + + 1 + + + + + 1 + + + + + 4 + + + + + + + True + View + + + False + + + + + True + 12 + vertical + 18 + + + True + vertical + 6 + + + True + 0 + Tab Stops + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + True + 6 + + + True + _Tab width: + True + center + tabs_width_spinbutton + + + False + False + 0 + + + + + True + True + adjustment2 + 1 + True + + + False + False + 1 + + + + + 0 + + + + + Insert _spaces instead of tabs + True + True + False + True + True + + + False + False + 1 + + + + + False + False + 1 + + + + + False + False + 1 + + + + + False + False + 0 + + + + + True + vertical + 6 + + + True + 0 + Automatic Indentation + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + _Enable automatic indentation + True + True + False + True + True + + + False + False + 1 + + + + + False + False + 1 + + + + + False + False + 1 + + + + + True + vertical + 6 + + + True + 0 + File Saving + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + Create a _backup copy of files before saving + True + True + False + True + True + + + False + False + 0 + + + + + True + 6 + + + _Autosave files every + True + True + False + True + True + + + False + False + 0 + + + + + True + True + adjustment3 + 1 + True + + + False + False + 1 + + + + + True + _minutes + True + center + auto_save_spinbutton + + + False + False + 2 + + + + + 1 + + + + + False + False + 1 + + + + + 1 + + + + + False + False + 2 + + + + + 1 + + + + + True + Editor + + + 1 + False + + + + + True + 12 + vertical + 18 + + + True + vertical + 6 + + + True + 0 + Font + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + _Use the system fixed width font (%s) + True + True + False + True + True + + + False + False + 0 + + + + + True + 12 + + + True + 0 + Editor _font: + True + center + font_button + + + False + False + 0 + + + + + True + True + False + Pick the editor font + True + + + 1 + + + + + False + False + 1 + + + + + 1 + + + + + 1 + + + + + False + False + 0 + + + + + True + vertical + 6 + + + True + 0 + Color Scheme + + + + + + False + False + 0 + + + + + True + + + True + + + + False + False + 0 + + + + + True + vertical + 6 + + + True + True + automatic + automatic + etched-in + + + True + True + GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK + False + True + + + + + 0 + + + + + True + 6 + end + + + _Add... + True + True + False + install_scheme_image + True + + + False + False + 0 + + + + + gtk-remove + True + True + False + True + + + False + False + 1 + + + + + False + 1 + + + + + 1 + + + + + 1 + + + + + 1 + + + + + 2 + + + + + True + Font & Colors + + + 2 + False + + + + + True + 12 + vertical + + + + + + 3 + + + + + True + Plugins + + + 3 + False + + + + + 1 + + + + + True + end + + + gtk-help + True + True + True + False + True + + + False + False + 0 + + + + + gtk-close + True + True + True + False + True + + + False + False + 1 + + + + + False + end + 0 + + + + + + helpbutton1 + closebutton1 + + + diff --git a/gedit/dialogs/gedit-search-dialog.c b/gedit/dialogs/gedit-search-dialog.c new file mode 100755 index 00000000..5a059932 --- /dev/null +++ b/gedit/dialogs/gedit-search-dialog.c @@ -0,0 +1,634 @@ +/* + * gedit-search-dialog.c + * This file is part of gedit + * + * Copyright (C) 2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include "gedit-search-dialog.h" +#include "gedit-history-entry.h" +#include "gedit-utils.h" +#include "gedit-marshal.h" +#include "gedit-dirs.h" + +#define GEDIT_SEARCH_DIALOG_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), \ + GEDIT_TYPE_SEARCH_DIALOG, \ + GeditSearchDialogPrivate)) + +/* Signals */ +enum +{ + SHOW_REPLACE, + LAST_SIGNAL +}; + +static guint dialog_signals [LAST_SIGNAL] = { 0 }; + +struct _GeditSearchDialogPrivate +{ + gboolean show_replace; + + GtkWidget *table; + GtkWidget *search_label; + GtkWidget *search_entry; + GtkWidget *search_text_entry; + GtkWidget *replace_label; + GtkWidget *replace_entry; + GtkWidget *replace_text_entry; + GtkWidget *match_case_checkbutton; + GtkWidget *entire_word_checkbutton; + GtkWidget *backwards_checkbutton; + GtkWidget *wrap_around_checkbutton; + GtkWidget *find_button; + GtkWidget *replace_button; + GtkWidget *replace_all_button; + + gboolean ui_error; +}; + +G_DEFINE_TYPE(GeditSearchDialog, gedit_search_dialog, GTK_TYPE_DIALOG) + +enum +{ + PROP_0, + PROP_SHOW_REPLACE +}; + +static void +gedit_search_dialog_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GeditSearchDialog *dlg = GEDIT_SEARCH_DIALOG (object); + + switch (prop_id) + { + case PROP_SHOW_REPLACE: + gedit_search_dialog_set_show_replace (dlg, + g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gedit_search_dialog_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GeditSearchDialog *dlg = GEDIT_SEARCH_DIALOG (object); + + switch (prop_id) + { + case PROP_SHOW_REPLACE: + g_value_set_boolean (value, dlg->priv->show_replace); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +void +gedit_search_dialog_present_with_time (GeditSearchDialog *dialog, + guint32 timestamp) +{ + g_return_if_fail (GEDIT_SEARCH_DIALOG (dialog)); + + gtk_window_present_with_time (GTK_WINDOW (dialog), timestamp); + + gtk_widget_grab_focus (dialog->priv->search_text_entry); +} + +static gboolean +show_replace (GeditSearchDialog *dlg) +{ + gedit_search_dialog_set_show_replace (dlg, TRUE); + + return TRUE; +} + +static void +gedit_search_dialog_class_init (GeditSearchDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkBindingSet *binding_set; + + object_class->set_property = gedit_search_dialog_set_property; + object_class->get_property = gedit_search_dialog_get_property; + + klass->show_replace = show_replace; + + dialog_signals[SHOW_REPLACE] = + g_signal_new ("show_replace", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GeditSearchDialogClass, show_replace), + NULL, NULL, + gedit_marshal_BOOLEAN__NONE, + G_TYPE_BOOLEAN, 0); + + g_object_class_install_property (object_class, PROP_SHOW_REPLACE, + g_param_spec_boolean ("show-replace", + "Show Replace", + "Whether the dialog is used for Search&Replace", + FALSE, + G_PARAM_READWRITE)); + + g_type_class_add_private (object_class, sizeof (GeditSearchDialogPrivate)); + + binding_set = gtk_binding_set_by_class (klass); + + /* Note: we cannot use the keyval/modifier associated with the + * GTK_STOCK_FIND_AND_REPLACE stock item since MATE HIG suggests Ctrl+h + * for Replace while gtk+ uses Ctrl+r */ + gtk_binding_entry_add_signal (binding_set, GDK_h, GDK_CONTROL_MASK, "show_replace", 0); + gtk_binding_entry_add_signal (binding_set, GDK_H, GDK_CONTROL_MASK, "show_replace", 0); +} + +static void +insert_text_handler (GtkEditable *editable, + const gchar *text, + gint length, + gint *position, + gpointer data) +{ + static gboolean insert_text = FALSE; + gchar *escaped_text; + gint new_len; + + /* To avoid recursive behavior */ + if (insert_text) + return; + + escaped_text = gedit_utils_escape_search_text (text); + + new_len = strlen (escaped_text); + + if (new_len == length) + { + g_free (escaped_text); + return; + } + + insert_text = TRUE; + + g_signal_stop_emission_by_name (editable, "insert_text"); + + gtk_editable_insert_text (editable, escaped_text, new_len, position); + + insert_text = FALSE; + + g_free (escaped_text); +} + +static void +search_text_entry_changed (GtkEditable *editable, + GeditSearchDialog *dialog) +{ + const gchar *search_string; + + search_string = gtk_entry_get_text (GTK_ENTRY (editable)); + g_return_if_fail (search_string != NULL); + + if (*search_string != '\0') + { + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_FIND_RESPONSE, TRUE); + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE, TRUE); + } + else + { + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_FIND_RESPONSE, FALSE); + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_REPLACE_RESPONSE, FALSE); + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE, FALSE); + } +} + +static void +response_handler (GeditSearchDialog *dialog, + gint response_id, + gpointer data) +{ + const gchar *str; + + switch (response_id) + { + case GEDIT_SEARCH_DIALOG_REPLACE_RESPONSE: + case GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE: + str = gtk_entry_get_text (GTK_ENTRY (dialog->priv->replace_text_entry)); + if (*str != '\0') + { + gchar *text; + + text = gedit_utils_unescape_search_text (str); + gedit_history_entry_prepend_text + (GEDIT_HISTORY_ENTRY (dialog->priv->replace_entry), + text); + + g_free (text); + } + /* fall through, so that we also save the find entry */ + case GEDIT_SEARCH_DIALOG_FIND_RESPONSE: + str = gtk_entry_get_text (GTK_ENTRY (dialog->priv->search_text_entry)); + if (*str != '\0') + { + gchar *text; + + text = gedit_utils_unescape_search_text (str); + gedit_history_entry_prepend_text + (GEDIT_HISTORY_ENTRY (dialog->priv->search_entry), + text); + + g_free (text); + } + } +} + +static void +show_replace_widgets (GeditSearchDialog *dlg, + gboolean show_replace) +{ + if (show_replace) + { + gtk_widget_show (dlg->priv->replace_label); + gtk_widget_show (dlg->priv->replace_entry); + gtk_widget_show (dlg->priv->replace_all_button); + gtk_widget_show (dlg->priv->replace_button); + + gtk_table_set_row_spacings (GTK_TABLE (dlg->priv->table), 12); + + gtk_window_set_title (GTK_WINDOW (dlg), _("Replace")); + } + else + { + gtk_widget_hide (dlg->priv->replace_label); + gtk_widget_hide (dlg->priv->replace_entry); + gtk_widget_hide (dlg->priv->replace_all_button); + gtk_widget_hide (dlg->priv->replace_button); + + gtk_table_set_row_spacings (GTK_TABLE (dlg->priv->table), 0); + + gtk_window_set_title (GTK_WINDOW (dlg), _("Find")); + } + + gtk_widget_show (dlg->priv->find_button); +} + +static void +gedit_search_dialog_init (GeditSearchDialog *dlg) +{ + GtkWidget *content; + GtkWidget *error_widget; + gboolean ret; + gchar *file; + gchar *root_objects[] = { + "search_dialog_content", + NULL + }; + + dlg->priv = GEDIT_SEARCH_DIALOG_GET_PRIVATE (dlg); + + gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE); + + gtk_dialog_add_buttons (GTK_DIALOG (dlg), + GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, + NULL); + + /* HIG defaults */ + gtk_container_set_border_width (GTK_CONTAINER (dlg), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + 2); /* 2 * 5 + 2 = 12 */ + gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), + 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), + 6); + + file = gedit_dirs_get_ui_file ("gedit-search-dialog.ui"); + ret = gedit_utils_get_ui_objects (file, + root_objects, + &error_widget, + "search_dialog_content", &content, + "table", &dlg->priv->table, + "search_label", &dlg->priv->search_label, + "replace_with_label", &dlg->priv->replace_label, + "match_case_checkbutton", &dlg->priv->match_case_checkbutton, + "entire_word_checkbutton", &dlg->priv->entire_word_checkbutton, + "search_backwards_checkbutton", &dlg->priv->backwards_checkbutton, + "wrap_around_checkbutton", &dlg->priv->wrap_around_checkbutton, + NULL); + g_free (file); + + if (!ret) + { + gtk_widget_show (error_widget); + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + error_widget, + TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (error_widget), + 5); + + dlg->priv->ui_error = TRUE; + + return; + } + + dlg->priv->search_entry = gedit_history_entry_new ("gedit2_search_for_entry", + TRUE); + gtk_widget_set_size_request (dlg->priv->search_entry, 300, -1); + gedit_history_entry_set_escape_func + (GEDIT_HISTORY_ENTRY (dlg->priv->search_entry), + (GeditHistoryEntryEscapeFunc) gedit_utils_escape_search_text); + + dlg->priv->search_text_entry = gedit_history_entry_get_entry + (GEDIT_HISTORY_ENTRY (dlg->priv->search_entry)); + gtk_entry_set_activates_default (GTK_ENTRY (dlg->priv->search_text_entry), + TRUE); + gtk_widget_show (dlg->priv->search_entry); + gtk_table_attach_defaults (GTK_TABLE (dlg->priv->table), + dlg->priv->search_entry, + 1, 2, 0, 1); + + dlg->priv->replace_entry = gedit_history_entry_new ("gedit2_replace_with_entry", + TRUE); + gedit_history_entry_set_escape_func + (GEDIT_HISTORY_ENTRY (dlg->priv->replace_entry), + (GeditHistoryEntryEscapeFunc) gedit_utils_escape_search_text); + + dlg->priv->replace_text_entry = gedit_history_entry_get_entry + (GEDIT_HISTORY_ENTRY (dlg->priv->replace_entry)); + gtk_entry_set_activates_default (GTK_ENTRY (dlg->priv->replace_text_entry), + TRUE); + gtk_widget_show (dlg->priv->replace_entry); + gtk_table_attach_defaults (GTK_TABLE (dlg->priv->table), + dlg->priv->replace_entry, + 1, 2, 1, 2); + + gtk_label_set_mnemonic_widget (GTK_LABEL (dlg->priv->search_label), + dlg->priv->search_entry); + gtk_label_set_mnemonic_widget (GTK_LABEL (dlg->priv->replace_label), + dlg->priv->replace_entry); + + dlg->priv->find_button = gtk_button_new_from_stock (GTK_STOCK_FIND); + dlg->priv->replace_all_button = gtk_button_new_with_mnemonic (_("Replace _All")); + dlg->priv->replace_button = gedit_gtk_button_new_with_stock_icon (_("_Replace"), + GTK_STOCK_FIND_AND_REPLACE); + + gtk_dialog_add_action_widget (GTK_DIALOG (dlg), + dlg->priv->replace_all_button, + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE); + gtk_dialog_add_action_widget (GTK_DIALOG (dlg), + dlg->priv->replace_button, + GEDIT_SEARCH_DIALOG_REPLACE_RESPONSE); + gtk_dialog_add_action_widget (GTK_DIALOG (dlg), + dlg->priv->find_button, + GEDIT_SEARCH_DIALOG_FIND_RESPONSE); + g_object_set (G_OBJECT (dlg->priv->find_button), + "can-default", TRUE, + NULL); + + gtk_dialog_set_default_response (GTK_DIALOG (dlg), + GEDIT_SEARCH_DIALOG_FIND_RESPONSE); + + /* insensitive by default */ + gtk_dialog_set_response_sensitive (GTK_DIALOG (dlg), + GEDIT_SEARCH_DIALOG_FIND_RESPONSE, + FALSE); + gtk_dialog_set_response_sensitive (GTK_DIALOG (dlg), + GEDIT_SEARCH_DIALOG_REPLACE_RESPONSE, + FALSE); + gtk_dialog_set_response_sensitive (GTK_DIALOG (dlg), + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE, + FALSE); + + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), + content, FALSE, FALSE, 0); + g_object_unref (content); + gtk_container_set_border_width (GTK_CONTAINER (content), 5); + + g_signal_connect (dlg->priv->search_text_entry, + "insert_text", + G_CALLBACK (insert_text_handler), + NULL); + g_signal_connect (dlg->priv->replace_text_entry, + "insert_text", + G_CALLBACK (insert_text_handler), + NULL); + g_signal_connect (dlg->priv->search_text_entry, + "changed", + G_CALLBACK (search_text_entry_changed), + dlg); + + g_signal_connect (dlg, + "response", + G_CALLBACK (response_handler), + NULL); +} + +GtkWidget * +gedit_search_dialog_new (GtkWindow *parent, + gboolean show_replace) +{ + GeditSearchDialog *dlg; + + dlg = g_object_new (GEDIT_TYPE_SEARCH_DIALOG, + "show-replace", show_replace, + NULL); + + if (parent != NULL) + { + gtk_window_set_transient_for (GTK_WINDOW (dlg), + parent); + + gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), + TRUE); + } + + return GTK_WIDGET (dlg); +} + +gboolean +gedit_search_dialog_get_show_replace (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), FALSE); + + return dialog->priv->show_replace; +} + +void +gedit_search_dialog_set_show_replace (GeditSearchDialog *dialog, + gboolean show_replace) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + + if (dialog->priv->ui_error) + return; + + dialog->priv->show_replace = show_replace != FALSE; + show_replace_widgets (dialog, dialog->priv->show_replace); + + g_object_notify (G_OBJECT (dialog), "show-replace"); +} + +void +gedit_search_dialog_set_search_text (GeditSearchDialog *dialog, + const gchar *text) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + g_return_if_fail (text != NULL); + + gtk_entry_set_text (GTK_ENTRY (dialog->priv->search_text_entry), + text); + + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_FIND_RESPONSE, + (text != '\0')); + + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE, + (text != '\0')); +} + +/* + * The text must be unescaped before searching. + */ +const gchar * +gedit_search_dialog_get_search_text (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), NULL); + + return gtk_entry_get_text (GTK_ENTRY (dialog->priv->search_text_entry)); +} + +void +gedit_search_dialog_set_replace_text (GeditSearchDialog *dialog, + const gchar *text) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + g_return_if_fail (text != NULL); + + gtk_entry_set_text (GTK_ENTRY (dialog->priv->replace_text_entry), + text); +} + +const gchar * +gedit_search_dialog_get_replace_text (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), NULL); + + return gtk_entry_get_text (GTK_ENTRY (dialog->priv->replace_text_entry)); +} + +void +gedit_search_dialog_set_match_case (GeditSearchDialog *dialog, + gboolean match_case) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->match_case_checkbutton), + match_case); +} + +gboolean +gedit_search_dialog_get_match_case (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), FALSE); + + return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->match_case_checkbutton)); +} + +void +gedit_search_dialog_set_entire_word (GeditSearchDialog *dialog, + gboolean entire_word) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->entire_word_checkbutton), + entire_word); +} + +gboolean +gedit_search_dialog_get_entire_word (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), FALSE); + + return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->entire_word_checkbutton)); +} + +void +gedit_search_dialog_set_backwards (GeditSearchDialog *dialog, + gboolean backwards) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->backwards_checkbutton), + backwards); +} + +gboolean +gedit_search_dialog_get_backwards (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), FALSE); + + return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->backwards_checkbutton)); +} + +void +gedit_search_dialog_set_wrap_around (GeditSearchDialog *dialog, + gboolean wrap_around) +{ + g_return_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog)); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->wrap_around_checkbutton), + wrap_around); +} + +gboolean +gedit_search_dialog_get_wrap_around (GeditSearchDialog *dialog) +{ + g_return_val_if_fail (GEDIT_IS_SEARCH_DIALOG (dialog), FALSE); + + return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->wrap_around_checkbutton)); +} diff --git a/gedit/dialogs/gedit-search-dialog.h b/gedit/dialogs/gedit-search-dialog.h new file mode 100755 index 00000000..a225be14 --- /dev/null +++ b/gedit/dialogs/gedit-search-dialog.h @@ -0,0 +1,128 @@ +/* + * gedit-search-dialog.h + * This file is part of gedit + * + * Copyright (C) 2005 Paolo Maggi + * + * 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. + */ + +/* + * Modified by the gedit Team, 2005. See the AUTHORS file for a + * list of people on the gedit Team. + * See the ChangeLog files for a list of changes. + * + * $Id$ + */ + +#ifndef __GEDIT_SEARCH_DIALOG_H__ +#define __GEDIT_SEARCH_DIALOG_H__ + +#include + +G_BEGIN_DECLS + +/* + * Type checking and casting macros + */ +#define GEDIT_TYPE_SEARCH_DIALOG (gedit_search_dialog_get_type()) +#define GEDIT_SEARCH_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_SEARCH_DIALOG, GeditSearchDialog)) +#define GEDIT_SEARCH_DIALOG_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_SEARCH_DIALOG, GeditSearchDialog const)) +#define GEDIT_SEARCH_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GEDIT_TYPE_SEARCH_DIALOG, GeditSearchDialogClass)) +#define GEDIT_IS_SEARCH_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEDIT_TYPE_SEARCH_DIALOG)) +#define GEDIT_IS_SEARCH_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_SEARCH_DIALOG)) +#define GEDIT_SEARCH_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GEDIT_TYPE_SEARCH_DIALOG, GeditSearchDialogClass)) + +/* Private structure type */ +typedef struct _GeditSearchDialogPrivate GeditSearchDialogPrivate; + +/* + * Main object structure + */ +typedef struct _GeditSearchDialog GeditSearchDialog; + +struct _GeditSearchDialog +{ + GtkDialog dialog; + + /*< private > */ + GeditSearchDialogPrivate *priv; +}; + +/* + * Class definition + */ +typedef struct _GeditSearchDialogClass GeditSearchDialogClass; + +struct _GeditSearchDialogClass +{ + GtkDialogClass parent_class; + + /* Key bindings */ + gboolean (* show_replace) (GeditSearchDialog *dlg); +}; + +enum +{ + GEDIT_SEARCH_DIALOG_FIND_RESPONSE = 100, + GEDIT_SEARCH_DIALOG_REPLACE_RESPONSE, + GEDIT_SEARCH_DIALOG_REPLACE_ALL_RESPONSE +}; + +/* + * Public methods + */ +GType gedit_search_dialog_get_type (void) G_GNUC_CONST; + +GtkWidget *gedit_search_dialog_new (GtkWindow *parent, + gboolean show_replace); + +void gedit_search_dialog_present_with_time (GeditSearchDialog *dialog, + guint32 timestamp); + +gboolean gedit_search_dialog_get_show_replace (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_show_replace (GeditSearchDialog *dialog, + gboolean show_replace); + + +void gedit_search_dialog_set_search_text (GeditSearchDialog *dialog, + const gchar *text); +const gchar *gedit_search_dialog_get_search_text (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_replace_text (GeditSearchDialog *dialog, + const gchar *text); +const gchar *gedit_search_dialog_get_replace_text (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_match_case (GeditSearchDialog *dialog, + gboolean match_case); +gboolean gedit_search_dialog_get_match_case (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_entire_word (GeditSearchDialog *dialog, + gboolean entire_word); +gboolean gedit_search_dialog_get_entire_word (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_backwards (GeditSearchDialog *dialog, + gboolean backwards); +gboolean gedit_search_dialog_get_backwards (GeditSearchDialog *dialog); + +void gedit_search_dialog_set_wrap_around (GeditSearchDialog *dialog, + gboolean wrap_around); +gboolean gedit_search_dialog_get_wrap_around (GeditSearchDialog *dialog); + +G_END_DECLS + +#endif /* __GEDIT_SEARCH_DIALOG_H__ */ diff --git a/gedit/dialogs/gedit-search-dialog.ui b/gedit/dialogs/gedit-search-dialog.ui new file mode 100755 index 00000000..35b6c390 --- /dev/null +++ b/gedit/dialogs/gedit-search-dialog.ui @@ -0,0 +1,255 @@ + + + + + Replace + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + False + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + False + False + + + True + False + 8 + + + True + GTK_BUTTONBOX_DEFAULT_STYLE + + + True + True + True + gtk-close + True + GTK_RELIEF_NORMAL + True + + + + + True + True + True + Replace All + True + GTK_RELIEF_NORMAL + True + + + + + True + True + True + Replace + True + GTK_RELIEF_NORMAL + True + + + + + True + True + True + gtk-find + True + GTK_RELIEF_NORMAL + True + + + + + 0 + False + False + GTK_PACK_END + + + + + 5 + True + False + 18 + + + True + 2 + 2 + False + 12 + 12 + + + True + _Search for: + True + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + 1 + 0 + 1 + fill + + + + + + True + Replace _with: + True + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + 1 + 1 + 2 + fill + + + + + + 0 + True + True + + + + + True + False + 12 + + + True + True + _Match case + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + True + True + Match _entire word only + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + True + True + Search _backwards + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + True + True + _Wrap around + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + False + False + + + + + 0 + True + True + + + + + 0 + True + True + + + + + + close_button + replace_all_button + replace_button + find_next_button + + + -- cgit v1.2.1