/* * mooeditwindow.c * * Copyright (C) 2004-2005 by Yevgen Muntyan * * 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. * * See COPYING file that comes with this distribution. */ #define MOOEDIT_COMPILATION #include "mooedit-private.h" #include "mooedit/mooeditor.h" #include "mooedit/mootextbuffer.h" #include "mooedit/mooeditprefs.h" #include "mooedit/mooplugin.h" #include "mooutils/moonotebook.h" #include "mooutils/moofileview/moofileview.h" #include "mooutils/moofileview/moobookmarkmgr.h" #include "mooutils/moostock.h" #include "mooutils/moomarshals.h" #include "mooutils/moomenuaction.h" #include #include #define ACTIVE_DOC moo_edit_window_get_active_doc #define ACTIVE_PAGE(window) (moo_notebook_get_current_page (window->priv->notebook)) #define LANG_ACTION_ID "LanguageMenu" #define STOP_ACTION_ID "StopJob" enum { TARGET_TEXT = 1, TARGET_URI = 2 }; struct _MooEditWindowPrivate { MooEditor *editor; GtkStatusbar *statusbar; guint statusbar_context_id; MooNotebook *notebook; char *prefix; gboolean use_fullname; GHashTable *panes; GHashTable *panes_to_save; /* char* */ guint save_params_idle; GSList *stop_clients; GSList *jobs; /* Job* */ }; GObject *moo_edit_window_constructor (GType type, guint n_props, GObjectConstructParam *props); static void moo_edit_window_finalize (GObject *object); static void moo_edit_window_destroy (GtkObject *object); static void moo_edit_window_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void moo_edit_window_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static gboolean moo_edit_window_close (MooEditWindow *window); static void drag_data_received (GtkWidget *widget, GdkDragContext *context, int x, int y, GtkSelectionData *data, guint info, guint time); static void setup_notebook (MooEditWindow *window); static void update_window_title (MooEditWindow *window); static void notebook_switch_page (MooNotebook *notebook, gpointer whatever, guint page_num, MooEditWindow *window); static gboolean notebook_populate_popup (MooNotebook *notebook, GtkWidget *child, GtkMenu *menu, MooEditWindow *window); static void proxy_boolean_property (MooEditWindow *window, GParamSpec *prop, MooEdit *doc); static void edit_changed (MooEditWindow *window, MooEdit *doc); static void edit_filename_changed (MooEditWindow *window, const char *filename, MooEdit *doc); static void edit_lang_changed (MooEditWindow *window, GParamSpec *pspec, MooEdit *doc); static GtkWidget *create_tab_label (MooEdit *edit); static void update_tab_label (MooEditWindow *window, MooEdit *doc); static void edit_cursor_moved (MooEditWindow *window, GtkTextIter *iter, MooEdit *edit); static void update_lang_menu (MooEditWindow *window); static void update_statusbar (MooEditWindow *window); static MooEdit *get_nth_tab (MooEditWindow *window, guint n); static int get_page_num (MooEditWindow *window, MooEdit *doc); static void apply_styles (MooEditWindow *window, MooEdit *edit); static MooAction *create_lang_action (MooEditWindow *window); static void create_paned (MooEditWindow *window); static MooPaneParams *load_pane_params (const char *pane_id); static gboolean save_pane_params (const char *pane_id, MooPaneParams *params); static void pane_params_changed (MooEditWindow *window, MooPanePosition position, guint index); static void pane_size_changed (MooEditWindow *window, MooPanePosition position); /* actions */ static void moo_edit_window_new (MooEditWindow *window); static void moo_edit_window_new_tab (MooEditWindow *window); static void moo_edit_window_open (MooEditWindow *window); static void moo_edit_window_reload (MooEditWindow *window); static void moo_edit_window_save (MooEditWindow *window); static void moo_edit_window_save_as (MooEditWindow *window); static void moo_edit_window_close_tab (MooEditWindow *window); static void moo_edit_window_close_all (MooEditWindow *window); static void moo_edit_window_previous_tab(MooEditWindow *window); static void moo_edit_window_next_tab (MooEditWindow *window); /* MOO_TYPE_EDIT_WINDOW */ G_DEFINE_TYPE (MooEditWindow, moo_edit_window, MOO_TYPE_WINDOW) enum { PROP_0, PROP_EDITOR, PROP_ACTIVE_DOC, /* aux properties */ PROP_CAN_RELOAD, PROP_HAS_OPEN_DOCUMENT, PROP_CAN_UNDO, PROP_CAN_REDO, PROP_HAS_SELECTION, PROP_HAS_TEXT, PROP_HAS_JOBS_RUNNING, PROP_HAS_STOP_CLIENTS }; enum { NEW_DOC, CLOSE_DOC, CLOSE_DOC_AFTER, NUM_SIGNALS }; static guint signals[NUM_SIGNALS]; #define INSTALL_PROP(prop_id,name) \ g_object_class_install_property (gobject_class, prop_id, \ g_param_spec_boolean (name, name, name, FALSE, G_PARAM_READABLE)) static void moo_edit_window_class_init (MooEditWindowClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); MooWindowClass *window_class = MOO_WINDOW_CLASS (klass); gobject_class->constructor = moo_edit_window_constructor; gobject_class->finalize = moo_edit_window_finalize; gobject_class->set_property = moo_edit_window_set_property; gobject_class->get_property = moo_edit_window_get_property; gtkobject_class->destroy = moo_edit_window_destroy; widget_class->drag_data_received = drag_data_received; window_class->close = (gboolean (*) (MooWindow*))moo_edit_window_close; g_object_class_install_property (gobject_class, PROP_EDITOR, g_param_spec_object ("editor", "editor", "editor", MOO_TYPE_EDITOR, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (gobject_class, PROP_ACTIVE_DOC, g_param_spec_object ("active-doc", "active-doc", "active-doc", MOO_TYPE_EDIT, G_PARAM_READWRITE)); signals[NEW_DOC] = g_signal_new ("new-doc", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (MooEditWindowClass, new_doc), NULL, NULL, _moo_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MOO_TYPE_EDIT); signals[CLOSE_DOC] = g_signal_new ("close-doc", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (MooEditWindowClass, close_doc), NULL, NULL, _moo_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MOO_TYPE_EDIT); signals[CLOSE_DOC_AFTER] = g_signal_new ("close-doc-after", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (MooEditWindowClass, close_doc_after), NULL, NULL, _moo_marshal_VOID__VOID, G_TYPE_NONE, 0); INSTALL_PROP (PROP_CAN_RELOAD, "can-reload"); INSTALL_PROP (PROP_HAS_OPEN_DOCUMENT, "has-open-document"); INSTALL_PROP (PROP_CAN_UNDO, "can-undo"); INSTALL_PROP (PROP_CAN_REDO, "can-redo"); INSTALL_PROP (PROP_HAS_SELECTION, "has-selection"); INSTALL_PROP (PROP_HAS_TEXT, "has-text"); INSTALL_PROP (PROP_HAS_JOBS_RUNNING, "has-jobs-running"); INSTALL_PROP (PROP_HAS_STOP_CLIENTS, "has-stop-clients"); moo_window_class_set_id (window_class, "Editor", "Editor"); moo_window_class_new_action (window_class, "NewWindow", "name", "New Window", "label", "_New Window", "tooltip", "Open new editor window", "icon-stock-id", GTK_STOCK_NEW, "accel", "N", "closure::callback", moo_edit_window_new, NULL); moo_window_class_new_action (window_class, "NewTab", "name", "New Tab", "label", "New _Tab", "tooltip", "Create new document tab", "icon-stock-id", GTK_STOCK_NEW, "accel", "T", "closure::callback", moo_edit_window_new_tab, NULL); moo_window_class_new_action (window_class, "Open", "name", "Open", "label", "_Open...", "tooltip", "Open...", "icon-stock-id", GTK_STOCK_OPEN, "accel", "O", "closure::callback", moo_edit_window_open, NULL); moo_window_class_new_action (window_class, "Reload", "name", "Reload", "label", "_Reload", "tooltip", "Reload document", "icon-stock-id", GTK_STOCK_REFRESH, "accel", "F5", "closure::callback", moo_edit_window_reload, "condition::sensitive", "can-reload", NULL); moo_window_class_new_action (window_class, "Save", "name", "Save", "label", "_Save", "tooltip", "Save document", "icon-stock-id", GTK_STOCK_SAVE, "accel", "S", "closure::callback", moo_edit_window_save, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "SaveAs", "name", "Save As", "label", "Save _As...", "tooltip", "Save as...", "icon-stock-id", GTK_STOCK_SAVE_AS, "accel", "S", "closure::callback", moo_edit_window_save_as, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "Close", "name", "Close", "label", "_Close", "tooltip", "Close document", "icon-stock-id", GTK_STOCK_CLOSE, "accel", "W", "closure::callback", moo_edit_window_close_tab, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "CloseAll", "name", "Close All", "label", "Close _All", "tooltip", "Close all documents", "accel", "W", "closure::callback", moo_edit_window_close_all, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "Undo", "name", "Undo", "label", "_Undo", "tooltip", "Undo", "icon-stock-id", GTK_STOCK_UNDO, "accel", "Z", "closure::signal", "undo", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "can-undo", NULL); moo_window_class_new_action (window_class, "Redo", "name", "Redo", "label", "_Redo", "tooltip", "Redo", "icon-stock-id", GTK_STOCK_REDO, "accel", "Z", "closure::signal", "redo", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "can-redo", NULL); moo_window_class_new_action (window_class, "Cut", "name", "Cut", "label", "Cu_t", "tooltip", "Cut", "icon-stock-id", GTK_STOCK_CUT, "accel", "X", "closure::signal", "cut-clipboard", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-selection", NULL); moo_window_class_new_action (window_class, "Copy", "name", "Copy", "label", "_Copy", "tooltip", "Copy", "icon-stock-id", GTK_STOCK_COPY, "accel", "C", "closure::signal", "copy-clipboard", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-selection", NULL); moo_window_class_new_action (window_class, "Paste", "name", "Paste", "label", "_Paste", "tooltip", "Paste", "icon-stock-id", GTK_STOCK_PASTE, "accel", "V", "closure::signal", "paste-clipboard", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "Delete", "name", "Delete", "label", "_Delete", "tooltip", "Delete", "icon-stock-id", GTK_STOCK_DELETE, "closure::signal", "delete-selection", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-selection", NULL); moo_window_class_new_action (window_class, "SelectAll", "name", "Select All", "label", "Select _All", "tooltip", "Select all", "accel", "A", "closure::callback", moo_text_view_select_all, "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-text", NULL); moo_window_class_new_action (window_class, "PreviousTab", "name", "Previous Tab", "label", "_Previous Tab", "tooltip", "Previous tab", "icon-stock-id", GTK_STOCK_GO_BACK, "accel", "Left", "closure::callback", moo_edit_window_previous_tab, NULL); moo_window_class_new_action (window_class, "NextTab", "name", "Next Tab", "label", "_Next Tab", "tooltip", "Next tab", "icon-stock-id", GTK_STOCK_GO_FORWARD, "accel", "Right", "closure::callback", moo_edit_window_next_tab, NULL); moo_window_class_new_action (window_class, "Find", "name", "Find", "label", "_Find", "tooltip", "Find", "icon-stock-id", GTK_STOCK_FIND, "accel", "F", "closure::signal", "find-interactive", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "FindNext", "name", "Find Next", "label", "Find _Next", "tooltip", "Find next", "icon-stock-id", GTK_STOCK_GO_FORWARD, "accel", "F3", "closure::signal", "find-next-interactive", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "FindPrevious", "name", "Find Previous", "label", "Find _Previous", "tooltip", "Find previous", "icon-stock-id", GTK_STOCK_GO_BACK, "accel", "F3", "closure::signal", "find-prev-interactive", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "Replace", "name", "Replace", "label", "_Replace", "tooltip", "Replace", "icon-stock-id", GTK_STOCK_FIND_AND_REPLACE, "accel", "R", "closure::signal", "replace-interactive", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "GoToLine", "name", "Go to Line", "label", "_Go to Line", "tooltip", "Go to line", "accel", "G", "closure::signal", "goto-line-interactive", "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, "FocusDoc", "name", "Focus Doc", "label", "_Focus Doc", "tooltip", "Focus Doc", "accel", "C", "closure::callback", gtk_widget_grab_focus, "closure::proxy-func", moo_edit_window_get_active_doc, "condition::sensitive", "has-open-document", NULL); moo_window_class_new_action (window_class, STOP_ACTION_ID, "name", "Stop", "label", "Stop", "tooltip", "Stop", "icon-stock-id", GTK_STOCK_STOP, "accel", "Escape", "closure::callback", moo_edit_window_abort_jobs, "condition::sensitive", "has-jobs-running", "condition::visible", "has-stop-clients", NULL); moo_window_class_new_action_custom (window_class, LANG_ACTION_ID, (MooWindowActionFunc) create_lang_action, NULL, NULL); } static void moo_edit_window_init (MooEditWindow *window) { GtkTargetList *targets; window->priv = g_new0 (MooEditWindowPrivate, 1); window->priv->prefix = g_strdup ("medit"); window->priv->panes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); window->priv->panes_to_save = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) moo_pane_params_free); g_object_set (G_OBJECT (window), "menubar-ui-name", "Editor/Menubar", "toolbar-ui-name", "Editor/Toolbar", NULL); window->priv->use_fullname = TRUE; targets = moo_window_get_target_list (MOO_WINDOW (window)); gtk_target_list_add_uri_targets (targets, TARGET_URI); gtk_target_list_add_text_targets (targets, TARGET_TEXT); } MooEditor *moo_edit_window_get_editor (MooEditWindow *window) { g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL); return window->priv->editor; } static void moo_edit_window_destroy (GtkObject *object) { MooEditWindow *window = MOO_EDIT_WINDOW (object); if (window->priv->stop_clients || window->priv->jobs) { GSList *list, *l; moo_edit_window_abort_jobs (window); g_slist_foreach (window->priv->jobs, (GFunc) g_free, NULL); g_slist_free (window->priv->jobs); window->priv->jobs = NULL; list = g_slist_copy (window->priv->stop_clients); for (l = list; l != NULL; l = l->next) moo_edit_window_remove_stop_client (window, l->data); g_assert (window->priv->stop_clients == NULL); g_slist_free (list); } GTK_OBJECT_CLASS(moo_edit_window_parent_class)->destroy (object); } static void moo_edit_window_finalize (GObject *object) { MooEditWindow *window = MOO_EDIT_WINDOW (object); /* XXX */ g_hash_table_destroy (window->priv->panes); if (window->priv->panes_to_save) g_hash_table_destroy (window->priv->panes_to_save); if (window->priv->save_params_idle) { g_warning ("%s: oops", G_STRLOC); g_source_remove (window->priv->save_params_idle); } g_free (window->priv->prefix); g_free (window->priv); G_OBJECT_CLASS (moo_edit_window_parent_class)->finalize (object); } static void moo_edit_window_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { MooEditWindow *window = MOO_EDIT_WINDOW (object); switch (prop_id) { case PROP_EDITOR: window->priv->editor = g_value_get_object (value); break; case PROP_ACTIVE_DOC: moo_edit_window_set_active_doc (window, g_value_get_object (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void moo_edit_window_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { MooEditWindow *window = MOO_EDIT_WINDOW (object); MooEdit *doc; switch (prop_id) { case PROP_EDITOR: g_value_set_object (value, window->priv->editor); break; case PROP_ACTIVE_DOC: g_value_set_object (value, moo_edit_window_get_active_doc (window)); break; case PROP_CAN_RELOAD: doc = ACTIVE_DOC (window); g_value_set_boolean (value, doc && moo_edit_get_filename (doc)); break; case PROP_HAS_OPEN_DOCUMENT: g_value_set_boolean (value, ACTIVE_DOC (window) != NULL); break; case PROP_CAN_UNDO: doc = ACTIVE_DOC (window); g_value_set_boolean (value, doc && moo_text_view_can_undo (MOO_TEXT_VIEW (doc))); break; case PROP_CAN_REDO: doc = ACTIVE_DOC (window); g_value_set_boolean (value, doc && moo_text_view_can_redo (MOO_TEXT_VIEW (doc))); break; case PROP_HAS_SELECTION: doc = ACTIVE_DOC (window); g_value_set_boolean (value, doc && moo_text_view_has_selection (MOO_TEXT_VIEW (doc))); break; case PROP_HAS_TEXT: doc = ACTIVE_DOC (window); g_value_set_boolean (value, doc && moo_text_view_has_text (MOO_TEXT_VIEW (doc))); break; case PROP_HAS_JOBS_RUNNING: g_value_set_boolean (value, window->priv->jobs != NULL); break; case PROP_HAS_STOP_CLIENTS: g_value_set_boolean (value, window->priv->stop_clients != NULL); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } void moo_edit_window_set_title_prefix (MooEditWindow *window, const char *prefix) { g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_free (window->priv->prefix); window->priv->prefix = g_strdup (prefix); if (GTK_WIDGET_REALIZED (GTK_WIDGET (window))) update_window_title (window); } static void drag_data_received (GtkWidget *widget, GdkDragContext *context, int x, int y, GtkSelectionData *data, guint info, guint time) { char **uris; char *text; MooEditWindow *window = MOO_EDIT_WINDOW (widget); if ((uris = gtk_selection_data_get_uris (data))) { char **p; for (p = uris; *p; ++p) { char *filename = g_filename_from_uri (*p, NULL, NULL); if (filename) { moo_editor_open_file (window->priv->editor, window, NULL, filename, NULL); g_free (filename); } } g_strfreev (uris); } else if ((text = gtk_selection_data_get_text (data))) { MooEdit *doc = moo_editor_new_doc (window->priv->editor, window); if (doc) { /* XXX MooEdit should have appropriate methods */ GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (doc)); gtk_text_buffer_insert_at_cursor (buffer, text, -1); } g_free (text); } GTK_WIDGET_CLASS(moo_edit_window_parent_class)->drag_data_received (widget, context, x, y, data, info, time); } /****************************************************************************/ /* Constructing */ GObject *moo_edit_window_constructor (GType type, guint n_props, GObjectConstructParam *props) { GtkWidget *notebook; MooEditWindow *window; GObject *object = G_OBJECT_CLASS(moo_edit_window_parent_class)->constructor (type, n_props, props); window = MOO_EDIT_WINDOW (object); g_return_val_if_fail (window->priv->editor != NULL, object); window->priv->statusbar = GTK_STATUSBAR (MOO_WINDOW(window)->statusbar); gtk_widget_show (MOO_WINDOW(window)->statusbar); window->priv->statusbar_context_id = gtk_statusbar_get_context_id (window->priv->statusbar, "MooEditWindow"); gtk_widget_show (MOO_WINDOW(window)->vbox); create_paned (window); notebook = g_object_new (MOO_TYPE_NOTEBOOK, "show-tabs", TRUE, "enable-popup", TRUE, "enable-reordering", TRUE, NULL); gtk_widget_show (notebook); moo_big_paned_add_child (window->paned, notebook); window->priv->notebook = MOO_NOTEBOOK (notebook); setup_notebook (window); g_signal_connect (window, "realize", G_CALLBACK (update_window_title), NULL); edit_changed (window, NULL); return object; } /* XXX */ static void update_window_title (MooEditWindow *window) { MooEdit *edit; const char *name; MooEditStatus status; GString *title; edit = ACTIVE_DOC (window); if (!edit) { gtk_window_set_title (GTK_WINDOW (window), window->priv->prefix ? window->priv->prefix : ""); return; } if (window->priv->use_fullname) name = moo_edit_get_display_filename (edit); else name = moo_edit_get_display_basename (edit); if (!name) name = "<\?\?\?\?\?>"; status = moo_edit_get_status (edit); title = g_string_new (""); if (window->priv->prefix) g_string_append_printf (title, "%s - ", window->priv->prefix); g_string_append_printf (title, "%s", name); if (status & MOO_EDIT_MODIFIED_ON_DISK) g_string_append (title, " [modified on disk]"); else if (status & MOO_EDIT_DELETED) g_string_append (title, " [deleted]"); if ((status & MOO_EDIT_MODIFIED) && !(status & MOO_EDIT_CLEAN)) g_string_append (title, " [modified]"); gtk_window_set_title (GTK_WINDOW (window), title->str); g_string_free (title, TRUE); } static void apply_styles (MooEditWindow *window, MooEdit *edit) { MooLangMgr *mgr; MooTextStyleScheme *scheme; mgr = moo_editor_get_lang_mgr (window->priv->editor); scheme = moo_lang_mgr_get_active_scheme (mgr); g_return_if_fail (scheme != NULL); moo_text_view_apply_scheme (MOO_TEXT_VIEW (edit), scheme); } /****************************************************************************/ /* Actions */ static gboolean moo_edit_window_close (MooEditWindow *window) { moo_editor_close_window (window->priv->editor, window); return TRUE; } static void moo_edit_window_new (MooEditWindow *window) { moo_editor_new_window (window->priv->editor); } static void moo_edit_window_new_tab (MooEditWindow *window) { moo_editor_new_doc (window->priv->editor, window); } static void moo_edit_window_open (MooEditWindow *window) { moo_editor_open (window->priv->editor, window, GTK_WIDGET (window), NULL); } static void moo_edit_window_reload (MooEditWindow *window) { MooEdit *edit = moo_edit_window_get_active_doc (window); g_return_if_fail (edit != NULL); _moo_editor_reload (window->priv->editor, edit); } static void moo_edit_window_save (MooEditWindow *window) { MooEdit *edit = moo_edit_window_get_active_doc (window); g_return_if_fail (edit != NULL); _moo_editor_save (window->priv->editor, edit); } static void moo_edit_window_save_as (MooEditWindow *window) { MooEdit *edit = moo_edit_window_get_active_doc (window); g_return_if_fail (edit != NULL); _moo_editor_save_as (window->priv->editor, edit, NULL, NULL); } static void moo_edit_window_close_tab (MooEditWindow *window) { MooEdit *edit = moo_edit_window_get_active_doc (window); g_return_if_fail (edit != NULL); moo_editor_close_doc (window->priv->editor, edit); } static void moo_edit_window_close_all (MooEditWindow *window) { GSList *docs = moo_edit_window_list_docs (window); moo_editor_close_docs (window->priv->editor, docs); g_slist_free (docs); } static void moo_edit_window_previous_tab (MooEditWindow *window) { MooEdit *doc; int n = moo_notebook_get_current_page (window->priv->notebook); if (n > 0) moo_notebook_set_current_page (window->priv->notebook, n - 1); else moo_notebook_set_current_page (window->priv->notebook, -1); doc = moo_edit_window_get_active_doc (window); if (doc) gtk_widget_grab_focus (GTK_WIDGET (doc)); } static void moo_edit_window_next_tab (MooEditWindow *window) { MooEdit *doc; int n = moo_notebook_get_current_page (window->priv->notebook); if (n < moo_notebook_get_n_pages (window->priv->notebook) - 1) moo_notebook_set_current_page (window->priv->notebook, n + 1); else moo_notebook_set_current_page (window->priv->notebook, 0); doc = moo_edit_window_get_active_doc (window); if (doc) gtk_widget_grab_focus (GTK_WIDGET (doc)); } /****************************************************************************/ /* Documents */ static void setup_notebook (MooEditWindow *window) { GtkWidget *button, *icon, *frame; g_signal_connect_after (window->priv->notebook, "switch-page", G_CALLBACK (notebook_switch_page), window); g_signal_connect (window->priv->notebook, "populate-popup", G_CALLBACK (notebook_populate_popup), window); frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, 1.0, FALSE); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); button = gtk_button_new (); gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE); g_signal_connect_swapped (button, "clicked", G_CALLBACK (moo_edit_window_close_tab), window); icon = gtk_image_new_from_stock (MOO_STOCK_CLOSE, MOO_ICON_SIZE_REAL_SMALL); gtk_container_add (GTK_CONTAINER (button), icon); gtk_container_add (GTK_CONTAINER (frame), button); gtk_widget_show_all (frame); moo_notebook_set_action_widget (window->priv->notebook, frame, TRUE); } static void notebook_switch_page (G_GNUC_UNUSED MooNotebook *notebook, G_GNUC_UNUSED gpointer whatever, guint page_num, MooEditWindow *window) { edit_changed (window, get_nth_tab (window, page_num)); g_object_notify (G_OBJECT (window), "active-doc"); } static void edit_changed (MooEditWindow *window, MooEdit *doc) { if (doc == ACTIVE_DOC (window)) { g_object_freeze_notify (G_OBJECT (window)); g_object_notify (G_OBJECT (window), "can-reload"); g_object_notify (G_OBJECT (window), "has-open-document"); g_object_notify (G_OBJECT (window), "can-undo"); g_object_notify (G_OBJECT (window), "can-redo"); g_object_notify (G_OBJECT (window), "has-selection"); g_object_notify (G_OBJECT (window), "has-text"); g_object_thaw_notify (G_OBJECT (window)); update_window_title (window); update_statusbar (window); update_lang_menu (window); } if (doc) update_tab_label (window, doc); } static void edit_filename_changed (MooEditWindow *window, G_GNUC_UNUSED const char *filename, MooEdit *doc) { edit_changed (window, doc); } static void proxy_boolean_property (MooEditWindow *window, GParamSpec *prop, MooEdit *doc) { if (doc == ACTIVE_DOC (window)) g_object_notify (G_OBJECT (window), prop->name); } MooEdit *moo_edit_window_get_active_doc (MooEditWindow *window) { GtkWidget *swin; int page; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL); if (!window->priv->notebook) return NULL; page = moo_notebook_get_current_page (window->priv->notebook); if (page < 0) return NULL; swin = moo_notebook_get_nth_page (window->priv->notebook, page); return MOO_EDIT (gtk_bin_get_child (GTK_BIN (swin))); } void moo_edit_window_set_active_doc (MooEditWindow *window, MooEdit *edit) { GtkWidget *swin; int page; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (MOO_IS_EDIT (edit)); swin = GTK_WIDGET(edit)->parent; page = moo_notebook_page_num (window->priv->notebook, swin); g_return_if_fail (page >= 0); moo_notebook_set_current_page (window->priv->notebook, page); } GSList *moo_edit_window_list_docs (MooEditWindow *window) { GSList *list = NULL; int num, i; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL); num = moo_notebook_get_n_pages (window->priv->notebook); for (i = 0; i < num; i++) list = g_slist_prepend (list, get_nth_tab (window, i)); return g_slist_reverse (list); } guint moo_edit_window_num_docs (MooEditWindow *window) { g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), 0); if (!window->priv->notebook) return 0; else return moo_notebook_get_n_pages (window->priv->notebook); } static MooEdit *get_nth_tab (MooEditWindow *window, guint n) { GtkWidget *swin; swin = moo_notebook_get_nth_page (window->priv->notebook, n); if (swin) return MOO_EDIT (gtk_bin_get_child (GTK_BIN (swin))); else return NULL; } static int get_page_num (MooEditWindow *window, MooEdit *doc) { GtkWidget *swin; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), -1); g_return_val_if_fail (MOO_IS_EDIT (doc), -1); swin = GTK_WIDGET(doc)->parent; return moo_notebook_page_num (window->priv->notebook, swin); } void _moo_edit_window_insert_doc (MooEditWindow *window, MooEdit *edit, int position) { GtkWidget *label; GtkWidget *scrolledwindow; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (MOO_IS_EDIT (edit)); label = create_tab_label (edit); gtk_widget_show (label); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); 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_ETCHED_IN); gtk_container_add (GTK_CONTAINER (scrolledwindow), GTK_WIDGET (edit)); gtk_widget_show_all (scrolledwindow); moo_notebook_insert_page (window->priv->notebook, scrolledwindow, label, position); g_signal_connect_swapped (edit, "doc_status_changed", G_CALLBACK (edit_changed), window); g_signal_connect_swapped (edit, "filename_changed", G_CALLBACK (edit_filename_changed), window); g_signal_connect_swapped (edit, "notify::can-undo", G_CALLBACK (proxy_boolean_property), window); g_signal_connect_swapped (edit, "notify::can-redo", G_CALLBACK (proxy_boolean_property), window); g_signal_connect_swapped (edit, "notify::has-selection", G_CALLBACK (proxy_boolean_property), window); g_signal_connect_swapped (edit, "notify::has-text", G_CALLBACK (proxy_boolean_property), window); g_signal_connect_swapped (edit, "notify::lang", G_CALLBACK (edit_lang_changed), window); g_signal_connect_swapped (edit, "cursor-moved", G_CALLBACK (edit_cursor_moved), window); g_signal_emit (window, signals[NEW_DOC], 0, edit); apply_styles (window, edit); _moo_doc_attach_plugins (window, edit); moo_edit_window_set_active_doc (window, edit); edit_changed (window, edit); gtk_widget_grab_focus (GTK_WIDGET (edit)); } void _moo_edit_window_remove_doc (MooEditWindow *window, MooEdit *doc) { int page; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (MOO_IS_EDIT (doc)); page = get_page_num (window, doc); g_return_if_fail (page >= 0); g_signal_emit (window, signals[CLOSE_DOC], 0, doc); g_signal_handlers_disconnect_by_func (doc, (gpointer) edit_changed, window); g_signal_handlers_disconnect_by_func (doc, (gpointer) edit_filename_changed, window); g_signal_handlers_disconnect_by_func (doc, (gpointer) proxy_boolean_property, window); g_signal_handlers_disconnect_by_func (doc, (gpointer) edit_cursor_moved, window); g_signal_handlers_disconnect_by_func (doc, (gpointer) edit_lang_changed, window); _moo_doc_detach_plugins (window, doc); moo_notebook_remove_page (window->priv->notebook, page); edit_changed (window, NULL); g_signal_emit (window, signals[CLOSE_DOC_AFTER], 0); g_object_notify (G_OBJECT (window), "active-doc"); } static GtkWidget *create_tab_label (MooEdit *edit) { GtkWidget *hbox, *modified_icon, *modified_on_disk_icon, *label; GtkSizeGroup *group; group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); hbox = gtk_hbox_new (FALSE, 3); gtk_widget_show (hbox); modified_on_disk_icon = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), modified_on_disk_icon, FALSE, FALSE, 0); modified_icon = gtk_image_new_from_stock (MOO_STOCK_DOC_MODIFIED, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), modified_icon, FALSE, FALSE, 0); label = gtk_label_new (moo_edit_get_display_basename (edit)); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_size_group_add_widget (group, modified_on_disk_icon); gtk_size_group_add_widget (group, modified_icon); gtk_size_group_add_widget (group, label); g_object_set_data (G_OBJECT (hbox), "moo-edit-modified-on-disk-icon", modified_on_disk_icon); g_object_set_data (G_OBJECT (hbox), "moo-edit-modified-icon", modified_icon); g_object_set_data (G_OBJECT (hbox), "moo-edit-label", label); return hbox; } static void update_tab_label (MooEditWindow *window, MooEdit *doc) { GtkWidget *hbox, *modified_icon, *modified_on_disk_icon, *label; MooEditStatus status; int page = get_page_num (window, doc); g_return_if_fail (page >= 0); hbox = moo_notebook_get_tab_label (window->priv->notebook, GTK_WIDGET(doc)->parent); modified_icon = g_object_get_data (G_OBJECT (hbox), "moo-edit-modified-icon"); modified_on_disk_icon = g_object_get_data (G_OBJECT (hbox), "moo-edit-modified-on-disk-icon"); label = g_object_get_data (G_OBJECT (hbox), "moo-edit-label"); g_return_if_fail (GTK_IS_WIDGET (hbox) && GTK_IS_WIDGET (modified_icon) && GTK_IS_WIDGET (modified_on_disk_icon)); status = moo_edit_get_status (doc); if (status & MOO_EDIT_MODIFIED_ON_DISK) { gtk_image_set_from_stock (GTK_IMAGE (modified_on_disk_icon), MOO_STOCK_DOC_MODIFIED_ON_DISK, GTK_ICON_SIZE_MENU); gtk_widget_show (modified_on_disk_icon); } else if (status & MOO_EDIT_DELETED) { gtk_image_set_from_stock (GTK_IMAGE (modified_on_disk_icon), MOO_STOCK_DOC_DELETED, GTK_ICON_SIZE_MENU); gtk_widget_show (modified_on_disk_icon); } else { gtk_widget_hide (modified_on_disk_icon); } if ((status & MOO_EDIT_MODIFIED) && !(status & MOO_EDIT_CLEAN)) gtk_widget_show (modified_icon); else gtk_widget_hide (modified_icon); gtk_label_set_text (GTK_LABEL (label), moo_edit_get_display_basename (doc)); } /****************************************************************************/ /* Notebook popup menu */ static void close_activated (GtkWidget *item, MooEditWindow *window) { MooEdit *edit = g_object_get_data (G_OBJECT (item), "moo-edit"); g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (MOO_IS_EDIT (edit)); moo_editor_close_doc (window->priv->editor, edit); } static void close_others_activated (GtkWidget *item, MooEditWindow *window) { GSList *list; MooEdit *edit = g_object_get_data (G_OBJECT (item), "moo-edit"); g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (MOO_IS_EDIT (edit)); list = moo_edit_window_list_docs (window); list = g_slist_remove (list, edit); moo_editor_close_docs (window->priv->editor, list); g_slist_free (list); } static gboolean notebook_populate_popup (MooNotebook *notebook, GtkWidget *child, GtkMenu *menu, MooEditWindow *window) { MooEdit *edit; GtkWidget *item; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), TRUE); g_return_val_if_fail (window->priv->notebook == notebook, TRUE); g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (child), TRUE); edit = MOO_EDIT (gtk_bin_get_child (GTK_BIN (child))); g_return_val_if_fail (MOO_IS_EDIT (edit), TRUE); item = gtk_menu_item_new_with_label ("Close"); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_set_data (G_OBJECT (item), "moo-edit", edit); g_signal_connect (item, "activate", G_CALLBACK (close_activated), window); if (moo_edit_window_num_docs (window) > 1) { item = gtk_menu_item_new_with_label ("Close All Others"); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_set_data (G_OBJECT (item), "moo-edit", edit); g_signal_connect (item, "activate", G_CALLBACK (close_others_activated), window); } return FALSE; } /****************************************************************************/ /* Panes */ static const char *PANE_POSITIONS[4] = { "left", "right", "top", "bottom" }; static void create_paned (MooEditWindow *window) { MooBigPaned *paned; guint i; paned = g_object_new (MOO_TYPE_BIG_PANED, "handle-cursor-type", GDK_FLEUR, "enable-detaching", TRUE, NULL); gtk_widget_show (GTK_WIDGET (paned)); gtk_box_pack_start (GTK_BOX (MOO_WINDOW(window)->vbox), GTK_WIDGET (paned), TRUE, TRUE, 0); window->paned = paned; for (i = 0; i < 4; ++i) { int size; char *key = g_strdup_printf (MOO_EDIT_PREFS_PREFIX "/window/panes/%s", PANE_POSITIONS[i]); moo_prefs_new_key_int (key, -1); size = moo_prefs_get_int (key); if (size > 0) moo_paned_set_pane_size (MOO_PANED (paned->paned[i]), size); g_free (key); } g_signal_connect_swapped (paned, "pane-params-changed", G_CALLBACK (pane_params_changed), window); g_signal_connect_swapped (paned, "set-pane-size", G_CALLBACK (pane_size_changed), window); } gboolean moo_edit_window_add_pane (MooEditWindow *window, const char *user_id, GtkWidget *widget, MooPaneLabel *label, MooPanePosition position) { int result; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), FALSE); g_return_val_if_fail (user_id != NULL, FALSE); g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (label != NULL, FALSE); g_return_val_if_fail (moo_edit_window_get_pane (window, user_id) == NULL, FALSE); gtk_object_sink (g_object_ref (widget)); result = moo_big_paned_insert_pane (window->paned, widget, label, position, -1); if (result >= 0) { MooPaneParams *params; g_hash_table_insert (window->priv->panes, g_strdup (user_id), widget); g_object_set_data_full (G_OBJECT (widget), "moo-edit-window-pane-user-id", g_strdup (user_id), g_free); params = load_pane_params (user_id); if (params) { moo_big_paned_set_pane_params (window->paned, position, result, params); moo_pane_params_free (params); } } g_object_unref (widget); return result >= 0; } gboolean moo_edit_window_remove_pane (MooEditWindow *window, const char *user_id) { GtkWidget *widget; gboolean result; g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), FALSE); g_return_val_if_fail (user_id != NULL, FALSE); widget = g_hash_table_lookup (window->priv->panes, user_id); if (!widget) return FALSE; g_hash_table_remove (window->priv->panes, user_id); result = moo_big_paned_remove_pane (window->paned, widget); g_return_val_if_fail (result, FALSE); return TRUE; } GtkWidget* moo_edit_window_get_pane (MooEditWindow *window, const char *user_id) { g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL); g_return_val_if_fail (user_id != NULL, NULL); return g_hash_table_lookup (window->priv->panes, user_id); } #define PANE_PREFS_ROOT MOO_EDIT_PREFS_PREFIX "/panes" #define ELEMENT_PANE "pane" #define PROP_PANE_ID "id" #define PROP_PANE_WINDOW_X "x" #define PROP_PANE_WINDOW_Y "y" #define PROP_PANE_WINDOW_WIDTH "width" #define PROP_PANE_WINDOW_HEIGHT "height" #define PROP_PANE_WINDOW_DETACHED "detached" #define PROP_PANE_WINDOW_MAXIMIZED "maximized" #define PROP_PANE_WINDOW_KEEP_ON_TOP "keep-on-top" static MooMarkupNode* get_pane_element (const char *pane_id, gboolean create) { MooMarkupDoc *xml; MooMarkupNode *root, *node; xml = moo_prefs_get_markup (); root = moo_markup_get_element (MOO_MARKUP_NODE (xml), PANE_PREFS_ROOT); if (!root) { if (create) { node = moo_markup_create_element (MOO_MARKUP_NODE (xml), PANE_PREFS_ROOT "/" ELEMENT_PANE); moo_markup_set_prop (node, PROP_PANE_ID, pane_id); return node; } else { return NULL; } } for (node = root->children; node != NULL; node = node->next) { const char *id; if (!MOO_MARKUP_IS_ELEMENT (node)) continue; if (strcmp (node->name, ELEMENT_PANE)) { g_warning ("%s: invalid element '%s'", G_STRLOC, node->name); continue; } id = moo_markup_get_prop (node, PROP_PANE_ID); if (!id || !id[0]) { g_warning ("%s: id missing", G_STRLOC); continue; } if (strcmp (id, pane_id)) continue; return node; } if (create) { node = moo_markup_create_element (MOO_MARKUP_NODE (xml), PANE_PREFS_ROOT "/" ELEMENT_PANE); moo_markup_set_prop (node, PROP_PANE_ID, pane_id); return node; } return NULL; } static MooPaneParams* load_pane_params (const char *pane_id) { MooMarkupNode *node; MooPaneParams *params; node = get_pane_element (pane_id, FALSE); if (!node) return NULL; params = moo_pane_params_new (); params->window_position.x = moo_markup_get_int_prop (node, PROP_PANE_WINDOW_X, 0); params->window_position.y = moo_markup_get_int_prop (node, PROP_PANE_WINDOW_Y, 0); params->window_position.width = moo_markup_get_int_prop (node, PROP_PANE_WINDOW_WIDTH, 0); params->window_position.height = moo_markup_get_int_prop (node, PROP_PANE_WINDOW_HEIGHT, 0); params->detached = moo_markup_get_bool_prop (node, PROP_PANE_WINDOW_DETACHED, FALSE); params->maximized = moo_markup_get_bool_prop (node, PROP_PANE_WINDOW_MAXIMIZED, FALSE); params->keep_on_top = moo_markup_get_bool_prop (node, PROP_PANE_WINDOW_KEEP_ON_TOP, FALSE); return params; } static void set_if_not_zero (MooMarkupNode *node, const char *attr, int val) { if (val) moo_markup_set_int_prop (node, attr, val); else moo_markup_set_prop (node, attr, NULL); } static void set_if_not_false (MooMarkupNode *node, const char *attr, gboolean val) { if (val) moo_markup_set_bool_prop (node, attr, val); else moo_markup_set_prop (node, attr, NULL); } static gboolean save_pane_params (const char *pane_id, MooPaneParams *params) { MooMarkupNode *node; if (!params) { node = get_pane_element (pane_id, FALSE); if (node) moo_markup_delete_node (node); return TRUE; } node = get_pane_element (pane_id, TRUE); g_return_val_if_fail (node != NULL, TRUE); set_if_not_zero (node, PROP_PANE_WINDOW_X, params->window_position.x); set_if_not_zero (node, PROP_PANE_WINDOW_Y, params->window_position.y); set_if_not_zero (node, PROP_PANE_WINDOW_WIDTH, params->window_position.width); set_if_not_zero (node, PROP_PANE_WINDOW_HEIGHT, params->window_position.height); set_if_not_false (node, PROP_PANE_WINDOW_DETACHED, params->detached); set_if_not_false (node, PROP_PANE_WINDOW_MAXIMIZED, params->maximized); set_if_not_false (node, PROP_PANE_WINDOW_KEEP_ON_TOP, params->keep_on_top); return TRUE; } static gboolean do_save_panes (MooEditWindow *window) { g_hash_table_foreach_remove (window->priv->panes_to_save, (GHRFunc) save_pane_params, NULL); window->priv->save_params_idle = 0; return FALSE; } static void pane_params_changed (MooEditWindow *window, MooPanePosition position, guint index) { GtkWidget *widget; const char *id; MooPaneParams *params; widget = moo_big_paned_get_pane (window->paned, position, index); g_return_if_fail (widget != NULL); id = g_object_get_data (G_OBJECT (widget), "moo-edit-window-pane-user-id"); if (id) { params = moo_big_paned_get_pane_params (window->paned, position, index); g_hash_table_insert (window->priv->panes_to_save, g_strdup (id), params); if (!window->priv->save_params_idle) window->priv->save_params_idle = g_idle_add ((GSourceFunc) do_save_panes, window); } } static void pane_size_changed (MooEditWindow *window, MooPanePosition pos) { GtkWidget *paned = window->paned->paned[pos]; char *key; g_return_if_fail (MOO_IS_PANED (paned)); g_return_if_fail (pos < 4); key = g_strdup_printf (MOO_EDIT_PREFS_PREFIX "/window/panes/%s", PANE_POSITIONS[pos]); moo_prefs_set_int (key, moo_paned_get_pane_size (MOO_PANED (paned))); g_free (key); } /****************************************************************************/ /* Statusbar */ static void set_statusbar_numbers (MooEditWindow *window, int line, int column) { char *text = g_strdup_printf ("Line: %d Col: %d", line, column); gtk_statusbar_pop (window->priv->statusbar, window->priv->statusbar_context_id); gtk_statusbar_push (window->priv->statusbar, window->priv->statusbar_context_id, text); g_free (text); } /* XXX */ static void update_statusbar (MooEditWindow *window) { MooEdit *edit; int line, column; GtkTextIter iter; GtkTextBuffer *buffer; edit = ACTIVE_DOC (window); if (!edit) { gtk_statusbar_pop (window->priv->statusbar, window->priv->statusbar_context_id); return; } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit)); gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer)); line = gtk_text_iter_get_line (&iter) + 1; column = gtk_text_iter_get_line_offset (&iter) + 1; set_statusbar_numbers (window, line, column); } /* XXX */ static void edit_cursor_moved (MooEditWindow *window, GtkTextIter *iter, MooEdit *edit) { if (edit == ACTIVE_DOC (window)) { int line = gtk_text_iter_get_line (iter) + 1; int column = gtk_text_iter_get_line_offset (iter) + 1; set_statusbar_numbers (window, line, column); } } /*****************************************************************************/ /* Language menu */ #define NONE_LANGUAGE_ID "MOO_LANG_NONE" static int cmp_langs (MooLang *lang1, MooLang *lang2) { int result; result = strcmp (lang1->section, lang2->section); if (result) return result; else return strcmp (lang1->display_name, lang2->display_name); } static void lang_item_activated (MooEditWindow *window, const char *lang_name) { MooEdit *doc = ACTIVE_DOC (window); const char *old_val; gboolean do_set = FALSE; g_return_if_fail (doc != NULL); g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); old_val = moo_edit_get_var (doc, MOO_EDIT_VAR_LANG); if (old_val) do_set = !lang_name || strcmp (old_val, lang_name); else do_set = !!lang_name; if (do_set) moo_edit_set_var_full (doc, MOO_EDIT_VAR_LANG, lang_name, MOO_EDIT_VAR_DEP_NONE); } static MooAction* create_lang_action (MooEditWindow *window) { MooAction *action; MooMenuMgr *menu_mgr; MooLangMgr *lang_mgr; GSList *langs, *sections, *l; lang_mgr = moo_editor_get_lang_mgr (window->priv->editor); /* TODO display names, etc. */ sections = moo_lang_mgr_get_sections (lang_mgr); sections = g_slist_sort (sections, (GCompareFunc) strcmp); langs = moo_lang_mgr_get_available_langs (lang_mgr); langs = g_slist_sort (langs, (GCompareFunc) cmp_langs); action = moo_menu_action_new (LANG_ACTION_ID); g_object_set (action, "no-accel", TRUE, NULL); menu_mgr = moo_menu_action_get_mgr (MOO_MENU_ACTION (action)); moo_menu_mgr_append (menu_mgr, NULL, LANG_ACTION_ID, "Language", 0, NULL, NULL); moo_menu_mgr_append (menu_mgr, LANG_ACTION_ID, NONE_LANGUAGE_ID, "None", MOO_MENU_ITEM_RADIO, NULL, NULL); for (l = sections; l != NULL; l = l->next) moo_menu_mgr_append (menu_mgr, LANG_ACTION_ID, l->data, l->data, 0, NULL, NULL); for (l = langs; l != NULL; l = l->next) { MooLang *lang = l->data; moo_menu_mgr_append (menu_mgr, lang->section, lang->id, lang->display_name, MOO_MENU_ITEM_RADIO, g_strdup (lang->id), g_free); } g_signal_connect_swapped (menu_mgr, "radio-set-active", G_CALLBACK (lang_item_activated), window); g_slist_free (langs); g_slist_foreach (sections, (GFunc) g_free, NULL); g_slist_free (sections); moo_bind_bool_property (action, "sensitive", window, "has-open-document", FALSE); return action; } static void update_lang_menu (MooEditWindow *window) { MooEdit *doc; MooAction *action; MooLang *lang; doc = ACTIVE_DOC (window); if (!doc) return; lang = moo_text_view_get_lang (MOO_TEXT_VIEW (doc)); action = moo_window_get_action_by_id (MOO_WINDOW (window), LANG_ACTION_ID); g_return_if_fail (action != NULL); moo_menu_mgr_set_active (moo_menu_action_get_mgr (MOO_MENU_ACTION (action)), lang ? lang->id : NONE_LANGUAGE_ID, TRUE); } static void edit_lang_changed (MooEditWindow *window, G_GNUC_UNUSED GParamSpec *pspec, MooEdit *doc) { if (doc == ACTIVE_DOC (window)) update_lang_menu (window); } /*****************************************************************************/ /* Stop button */ typedef struct { gpointer job; MooAbortJobFunc abort; } Job; static void client_died (MooEditWindow *window, gpointer client) { window->priv->stop_clients = g_slist_remove (window->priv->stop_clients, client); moo_edit_window_job_finished (window, client); } static void abort_client_job (gpointer client) { gboolean ret; g_signal_emit_by_name (client, "abort", &ret); } static void client_job_started (gpointer client, const char *job_name, MooEditWindow *window) { moo_edit_window_job_started (window, job_name, abort_client_job, client); } static void client_job_finished (gpointer client, MooEditWindow *window) { moo_edit_window_job_finished (window, client); } void moo_edit_window_add_stop_client (MooEditWindow *window, gpointer client) { GType type, return_type; guint signal_abort, signal_started, signal_finished; GSignalQuery query; gboolean had_clients; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (G_IS_OBJECT (client)); g_return_if_fail (!g_slist_find (window->priv->stop_clients, client)); type = G_OBJECT_TYPE (client); signal_abort = g_signal_lookup ("abort", type); signal_started = g_signal_lookup ("job-started", type); signal_finished = g_signal_lookup ("job-finished", type); g_return_if_fail (signal_abort && signal_started && signal_finished); #define REAL_TYPE(t__) ((t__) & ~(G_SIGNAL_TYPE_STATIC_SCOPE)) g_signal_query (signal_abort, &query); return_type = REAL_TYPE (query.return_type); g_return_if_fail (return_type == G_TYPE_NONE || return_type == G_TYPE_BOOLEAN); g_return_if_fail (query.n_params == 0); g_signal_query (signal_started, &query); g_return_if_fail (REAL_TYPE (query.return_type) == G_TYPE_NONE); g_return_if_fail (query.n_params == 1); g_return_if_fail (REAL_TYPE (query.param_types[0]) == G_TYPE_STRING); g_signal_query (signal_finished, &query); g_return_if_fail (REAL_TYPE (query.return_type) == G_TYPE_NONE); g_return_if_fail (query.n_params == 0); #undef REAL_TYPE had_clients = window->priv->stop_clients != NULL; window->priv->stop_clients = g_slist_prepend (window->priv->stop_clients, client); g_object_weak_ref (client, (GWeakNotify) client_died, window); g_signal_connect (client, "job-started", G_CALLBACK (client_job_started), window); g_signal_connect (client, "job-finished", G_CALLBACK (client_job_finished), window); if (!had_clients) g_object_notify (G_OBJECT (window), "has-stop-clients"); } void moo_edit_window_remove_stop_client (MooEditWindow *window, gpointer client) { g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (g_slist_find (window->priv->stop_clients, client)); window->priv->stop_clients = g_slist_remove (window->priv->stop_clients, client); if (G_IS_OBJECT (client)) { g_object_weak_unref (client, (GWeakNotify) client_died, window); g_signal_handlers_disconnect_by_func (client, (gpointer)client_job_started, window); g_signal_handlers_disconnect_by_func (client, (gpointer)client_job_finished, window); } if (!window->priv->stop_clients) g_object_notify (G_OBJECT (window), "has-stop-clients"); } void moo_edit_window_abort_jobs (MooEditWindow *window) { GSList *l, *jobs; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); jobs = g_slist_copy (window->priv->jobs); for (l = jobs; l != NULL; l = l->next) { Job *j = l->data; j->abort (j->job); } g_slist_free (jobs); } void moo_edit_window_job_started (MooEditWindow *window, G_GNUC_UNUSED const char *name, MooAbortJobFunc func, gpointer job) { Job *j; gboolean had_jobs; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (func != NULL); g_return_if_fail (job != NULL); j = g_new0 (Job, 1); j->abort = func; j->job = job; had_jobs = window->priv->jobs != NULL; window->priv->jobs = g_slist_prepend (window->priv->jobs, j); if (!had_jobs) g_object_notify (G_OBJECT (window), "has-jobs-running"); } void moo_edit_window_job_finished (MooEditWindow *window, gpointer job) { GSList *l; Job *j = NULL; g_return_if_fail (MOO_IS_EDIT_WINDOW (window)); g_return_if_fail (job != NULL); for (l = window->priv->jobs; l != NULL; l = l->next) { j = l->data; if (j->job == job) break; else j = NULL; } if (j) { window->priv->jobs = g_slist_remove (window->priv->jobs, j); if (!window->priv->jobs) g_object_notify (G_OBJECT (window), "has-jobs-running"); g_free (j); } } /* kate: space-indent: on; indent-width: 4; strip on; */