diff options
Diffstat (limited to 'src/nautilus-notebook.c')
| -rw-r--r-- | src/nautilus-notebook.c | 572 |
1 files changed, 572 insertions, 0 deletions
diff --git a/src/nautilus-notebook.c b/src/nautilus-notebook.c new file mode 100644 index 0000000..9d2fb1d --- /dev/null +++ b/src/nautilus-notebook.c @@ -0,0 +1,572 @@ +/* + * Copyright © 2002 Christophe Fergeau + * Copyright © 2003, 2004 Marco Pesenti Gritti + * Copyright © 2003, 2004, 2005 Christian Persch + * (ephy-notebook.c) + * + * Copyright © 2008 Free Software Foundation, Inc. + * (nautilus-notebook.c) + * + * 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, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "config.h" + +#include "nautilus-notebook.h" + +#include "nautilus-window.h" +#include "nautilus-window-slot.h" +#include "nautilus-window-slot-dnd.h" + +#include <eel/eel-vfs-extensions.h> +#include <glib/gi18n.h> +#include <gio/gio.h> +#include <gtk/gtk.h> + +#define AFTER_ALL_TABS -1 + +static int nautilus_notebook_insert_page (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label, + GtkWidget *menu_label, + int position); +static void nautilus_notebook_remove (GtkContainer *container, + GtkWidget *tab_widget); + +enum +{ + TAB_CLOSE_REQUEST, + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL]; + +struct _NautilusNotebook +{ + GtkNotebook parent_instance; + + GtkGesture *multi_press_gesture; +}; + +G_DEFINE_TYPE (NautilusNotebook, nautilus_notebook, GTK_TYPE_NOTEBOOK); + +static void +nautilus_notebook_dispose (GObject *object) +{ + NautilusNotebook *notebook; + + notebook = NAUTILUS_NOTEBOOK (object); + + g_clear_object (¬ebook->multi_press_gesture); + + G_OBJECT_CLASS (nautilus_notebook_parent_class)->dispose (object); +} + +static void +nautilus_notebook_class_init (NautilusNotebookClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); + GtkNotebookClass *notebook_class = GTK_NOTEBOOK_CLASS (klass); + + object_class->dispose = nautilus_notebook_dispose; + + container_class->remove = nautilus_notebook_remove; + + notebook_class->insert_page = nautilus_notebook_insert_page; + + signals[TAB_CLOSE_REQUEST] = + g_signal_new ("tab-close-request", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + NAUTILUS_TYPE_WINDOW_SLOT); +} + +static gint +find_tab_num_at_pos (NautilusNotebook *notebook, + gint abs_x, + gint abs_y) +{ + int page_num = 0; + GtkNotebook *nb = GTK_NOTEBOOK (notebook); + GtkWidget *page; + GtkAllocation allocation; + + while ((page = gtk_notebook_get_nth_page (nb, page_num))) + { + GtkWidget *tab; + gint max_x, max_y; + + tab = gtk_notebook_get_tab_label (nb, page); + g_return_val_if_fail (tab != NULL, -1); + + if (!gtk_widget_get_mapped (GTK_WIDGET (tab))) + { + page_num++; + continue; + } + + gtk_widget_get_allocation (tab, &allocation); + + max_x = allocation.x + allocation.width; + max_y = allocation.y + allocation.height; + + if (abs_x <= max_x && abs_y <= max_y) + { + return page_num; + } + + page_num++; + } + return AFTER_ALL_TABS; +} + +static void +button_press_cb (GtkGestureMultiPress *gesture, + gint n_press, + gdouble x, + gdouble y, + gpointer user_data) +{ + guint button; + GdkEventSequence *sequence; + const GdkEvent *event; + GtkWidget *widget; + NautilusNotebook *notebook; + int tab_clicked; + GdkModifierType state; + + button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)); + sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)); + event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence); + widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)); + notebook = NAUTILUS_NOTEBOOK (widget); + tab_clicked = find_tab_num_at_pos (notebook, x, y); + + gdk_event_get_state (event, &state); + + if (n_press != 1) + { + return; + } + + if (tab_clicked == -1) + { + return; + } + + if (button == GDK_BUTTON_SECONDARY && + (state & gtk_accelerator_get_default_mod_mask ()) == 0) + { + /* switch to the page the mouse is over, but don't consume the event */ + gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), tab_clicked); + } + else if (button == GDK_BUTTON_MIDDLE) + { + GtkWidget *slot; + + slot = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), tab_clicked); + g_signal_emit (notebook, signals[TAB_CLOSE_REQUEST], 0, slot); + } +} + +static void +nautilus_notebook_init (NautilusNotebook *notebook) +{ + gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); + + notebook->multi_press_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (notebook)); + + gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (notebook->multi_press_gesture), + GTK_PHASE_CAPTURE); + gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (notebook->multi_press_gesture), 0); + + g_signal_connect (notebook->multi_press_gesture, "pressed", G_CALLBACK (button_press_cb), NULL); +} + +gboolean +nautilus_notebook_contains_slot (NautilusNotebook *notebook, + NautilusWindowSlot *slot) +{ + GList *children; + GList *l; + gboolean found = FALSE; + + children = gtk_container_get_children (GTK_CONTAINER (notebook)); + for (l = children; l != NULL && !found; l = l->next) + { + found = l->data == slot; + } + + g_list_free (children); + + return found; +} + +gboolean +nautilus_notebook_content_area_hit (NautilusNotebook *notebook, + gint x, + gint y) +{ + return find_tab_num_at_pos (notebook, x, y) == -1; +} + +void +nautilus_notebook_sync_loading (NautilusNotebook *notebook, + NautilusWindowSlot *slot) +{ + GtkWidget *tab_label, *spinner, *icon; + gboolean active, allow_stop; + + g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); + g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot)); + + tab_label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (notebook), + GTK_WIDGET (slot)); + g_return_if_fail (GTK_IS_WIDGET (tab_label)); + + spinner = GTK_WIDGET (g_object_get_data (G_OBJECT (tab_label), "spinner")); + icon = GTK_WIDGET (g_object_get_data (G_OBJECT (tab_label), "icon")); + g_return_if_fail (spinner != NULL && icon != NULL); + + active = FALSE; + g_object_get (spinner, "active", &active, NULL); + allow_stop = nautilus_window_slot_get_allow_stop (slot); + + if (active == allow_stop) + { + return; + } + + if (allow_stop) + { + gtk_widget_hide (icon); + gtk_widget_show (spinner); + gtk_spinner_start (GTK_SPINNER (spinner)); + } + else + { + gtk_spinner_stop (GTK_SPINNER (spinner)); + gtk_widget_hide (spinner); + gtk_widget_show (icon); + } +} + +void +nautilus_notebook_sync_tab_label (NautilusNotebook *notebook, + NautilusWindowSlot *slot) +{ + GtkWidget *hbox, *label; + char *location_name; + GFile *location; + const gchar *title_name; + + g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); + g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot)); + + hbox = gtk_notebook_get_tab_label (GTK_NOTEBOOK (notebook), GTK_WIDGET (slot)); + g_return_if_fail (GTK_IS_WIDGET (hbox)); + + label = GTK_WIDGET (g_object_get_data (G_OBJECT (hbox), "label")); + g_return_if_fail (GTK_IS_WIDGET (label)); + + gtk_label_set_text (GTK_LABEL (label), nautilus_window_slot_get_title (slot)); + location = nautilus_window_slot_get_location (slot); + + if (location != NULL) + { + /* Set the tooltip on the label's parent (the tab label hbox), + * so it covers all of the tab label. + */ + location_name = g_file_get_parse_name (location); + title_name = nautilus_window_slot_get_title (slot); + if (eel_uri_is_search (location_name)) + { + gtk_widget_set_tooltip_text (gtk_widget_get_parent (label), title_name); + } + else + { + gtk_widget_set_tooltip_text (gtk_widget_get_parent (label), location_name); + } + g_free (location_name); + } + else + { + gtk_widget_set_tooltip_text (gtk_widget_get_parent (label), NULL); + } +} + +static void +close_button_clicked_cb (GtkWidget *widget, + NautilusWindowSlot *slot) +{ + GtkWidget *notebook; + + notebook = gtk_widget_get_ancestor (GTK_WIDGET (slot), NAUTILUS_TYPE_NOTEBOOK); + if (notebook != NULL) + { + g_signal_emit (notebook, signals[TAB_CLOSE_REQUEST], 0, slot); + } +} + +static GtkWidget * +build_tab_label (NautilusNotebook *notebook, + NautilusWindowSlot *slot) +{ + GtkWidget *box; + GtkWidget *label; + GtkWidget *close_button; + GtkWidget *image; + GtkWidget *spinner; + GtkWidget *icon; + + /* When porting to Gtk+4, use GtkCenterBox instead */ + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + gtk_widget_show (box); + + /* Spinner to be shown as load feedback */ + spinner = gtk_spinner_new (); + gtk_box_pack_start (GTK_BOX (box), spinner, FALSE, FALSE, 0); + + /* Dummy icon to allocate space for spinner */ + icon = gtk_image_new (); + gtk_box_pack_start (GTK_BOX (box), icon, FALSE, FALSE, 0); + /* don't show the icon */ + + /* Tab title */ + label = gtk_label_new (NULL); + gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); + gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE); + gtk_label_set_width_chars (GTK_LABEL (label), 6); + gtk_box_set_center_widget (GTK_BOX (box), label); + gtk_widget_show (label); + + /* Tab close button */ + close_button = gtk_button_new (); + gtk_button_set_relief (GTK_BUTTON (close_button), + GTK_RELIEF_NONE); + /* don't allow focus on the close button */ + gtk_widget_set_focus_on_click (close_button, FALSE); + + gtk_widget_set_name (close_button, "nautilus-tab-close-button"); + + image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU); + gtk_widget_set_tooltip_text (close_button, _("Close tab")); + g_signal_connect_object (close_button, "clicked", + G_CALLBACK (close_button_clicked_cb), slot, 0); + + gtk_container_add (GTK_CONTAINER (close_button), image); + gtk_widget_show (image); + + gtk_box_pack_end (GTK_BOX (box), close_button, FALSE, FALSE, 0); + gtk_widget_show (close_button); + + g_object_set_data (G_OBJECT (box), "nautilus-notebook-tab", GINT_TO_POINTER (1)); + nautilus_drag_slot_proxy_init (box, NULL, slot); + + g_object_set_data (G_OBJECT (box), "label", label); + g_object_set_data (G_OBJECT (box), "spinner", spinner); + g_object_set_data (G_OBJECT (box), "icon", icon); + g_object_set_data (G_OBJECT (box), "close-button", close_button); + + return box; +} + +static int +nautilus_notebook_insert_page (GtkNotebook *gnotebook, + GtkWidget *tab_widget, + GtkWidget *tab_label, + GtkWidget *menu_label, + int position) +{ + g_assert (GTK_IS_WIDGET (tab_widget)); + + position = GTK_NOTEBOOK_CLASS (nautilus_notebook_parent_class)->insert_page (gnotebook, + tab_widget, + tab_label, + menu_label, + position); + + gtk_notebook_set_show_tabs (gnotebook, + gtk_notebook_get_n_pages (gnotebook) > 1); + gtk_notebook_set_tab_reorderable (gnotebook, tab_widget, TRUE); + gtk_notebook_set_tab_detachable (gnotebook, tab_widget, TRUE); + + return position; +} + +int +nautilus_notebook_add_tab (NautilusNotebook *notebook, + NautilusWindowSlot *slot, + int position, + gboolean jump_to) +{ + GtkNotebook *gnotebook = GTK_NOTEBOOK (notebook); + GtkWidget *tab_label; + + g_return_val_if_fail (NAUTILUS_IS_NOTEBOOK (notebook), -1); + g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), -1); + + tab_label = build_tab_label (notebook, slot); + + position = gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), + GTK_WIDGET (slot), + tab_label, + position); + + gtk_container_child_set (GTK_CONTAINER (notebook), + GTK_WIDGET (slot), + "tab-expand", TRUE, + "detachable", FALSE, + NULL); + + nautilus_notebook_sync_tab_label (notebook, slot); + nautilus_notebook_sync_loading (notebook, slot); + + if (jump_to) + { + gtk_notebook_set_current_page (gnotebook, position); + } + + return position; +} + +static void +nautilus_notebook_remove (GtkContainer *container, + GtkWidget *tab_widget) +{ + GtkNotebook *gnotebook = GTK_NOTEBOOK (container); + GTK_CONTAINER_CLASS (nautilus_notebook_parent_class)->remove (container, tab_widget); + + gtk_notebook_set_show_tabs (gnotebook, + gtk_notebook_get_n_pages (gnotebook) > 1); +} + +void +nautilus_notebook_reorder_current_child_relative (NautilusNotebook *notebook, + int offset) +{ + GtkNotebook *gnotebook; + GtkWidget *child; + int page; + + g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); + + if (!nautilus_notebook_can_reorder_current_child_relative (notebook, offset)) + { + return; + } + + gnotebook = GTK_NOTEBOOK (notebook); + + page = gtk_notebook_get_current_page (gnotebook); + child = gtk_notebook_get_nth_page (gnotebook, page); + gtk_notebook_reorder_child (gnotebook, child, page + offset); +} + +static gboolean +nautilus_notebook_is_valid_relative_position (NautilusNotebook *notebook, + int offset) +{ + GtkNotebook *gnotebook; + int page; + int n_pages; + + gnotebook = GTK_NOTEBOOK (notebook); + + page = gtk_notebook_get_current_page (gnotebook); + n_pages = gtk_notebook_get_n_pages (gnotebook) - 1; + if (page < 0 || + (offset < 0 && page < -offset) || + (offset > 0 && page > n_pages - offset)) + { + return FALSE; + } + + return TRUE; +} + +gboolean +nautilus_notebook_can_reorder_current_child_relative (NautilusNotebook *notebook, + int offset) +{ + g_return_val_if_fail (NAUTILUS_IS_NOTEBOOK (notebook), FALSE); + + return nautilus_notebook_is_valid_relative_position (notebook, offset); +} + +void +nautilus_notebook_next_page (NautilusNotebook *notebook) +{ + gint current_page, n_pages; + + g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); + + current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); + n_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook)); + + if (current_page < n_pages - 1) + { + gtk_notebook_next_page (GTK_NOTEBOOK (notebook)); + } + else + { + gboolean wrap_around; + + g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)), + "gtk-keynav-wrap-around", &wrap_around, + NULL); + + if (wrap_around) + { + gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0); + } + } +} + +void +nautilus_notebook_prev_page (NautilusNotebook *notebook) +{ + gint current_page; + + g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); + + current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); + + if (current_page > 0) + { + gtk_notebook_prev_page (GTK_NOTEBOOK (notebook)); + } + else + { + gboolean wrap_around; + + g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)), + "gtk-keynav-wrap-around", &wrap_around, + NULL); + + if (wrap_around) + { + gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), -1); + } + } +} |