/* * Copyright (C) 2002 Christophe Fergeau * Copyright (C) 2003, 2004 Marco Pesenti Gritti * Copyright (C) 2003, 2004, 2005 Christian Persch * * 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, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Id$ */ #include "config.h" #include "ephy-notebook.h" #include "ephy-stock-icons.h" #include "eel-gconf-extensions.h" #include "ephy-prefs.h" #include "ephy-marshal.h" #include "ephy-file-helpers.h" #include "ephy-dnd.h" #include "ephy-embed.h" #include "ephy-window.h" #include "ephy-shell.h" #include "ephy-spinner.h" #include "ephy-link.h" #include "ephy-debug.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define TAB_WIDTH_N_CHARS 15 #define AFTER_ALL_TABS -1 #define NOT_IN_APP_WINDOWS -2 #define INSANE_NUMBER_OF_URLS 20 /* Until https://bugzilla.mozilla.org/show_bug.cgi?id=296002 is fixed */ #define KEEP_TAB_IN_SAME_TOPLEVEL #define EPHY_NOTEBOOK_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_NOTEBOOK, EphyNotebookPrivate)) struct _EphyNotebookPrivate { GList *focused_pages; GtkTooltips *title_tips; guint tabs_vis_notifier_id; gulong motion_notify_handler_id; gulong grab_notify_handler_id; gulong toplevel_grab_broken_handler_id; gulong toplevel_motion_notify_handler_id; gulong toplevel_button_release_handler_id; int x_start; int y_start; guint drag_in_progress : 1; guint show_tabs : 1; guint dnd_enabled : 1; }; static void ephy_notebook_init (EphyNotebook *notebook); static void ephy_notebook_class_init (EphyNotebookClass *klass); static void ephy_notebook_finalize (GObject *object); static void move_tab_to_another_notebook (EphyNotebook *src, EphyNotebook *dest, GdkEventMotion *event, int dest_position); static void move_tab (EphyNotebook *notebook, int dest_position); /* Local variables */ static GdkCursor *cursor = NULL; static const GtkTargetEntry url_drag_types [] = { { EPHY_DND_URI_LIST_TYPE, 0, 0 }, { EPHY_DND_URL_TYPE, 0, 1 } }; enum { PROP_0, PROP_DND_ENABLED, PROP_SHOW_TABS }; enum { TAB_ADDED, TAB_REMOVED, TABS_REORDERED, TAB_DETACHED, TAB_CLOSE_REQUEST, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0 }; static GObjectClass *parent_class = NULL; GType ephy_notebook_get_type (void) { static GType type = 0; if (G_UNLIKELY (type == 0)) { static const GTypeInfo our_info = { sizeof (EphyNotebookClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc) ephy_notebook_class_init, NULL, NULL, /* class_data */ sizeof (EphyNotebook), 0, /* n_preallocs */ (GInstanceInitFunc) ephy_notebook_init }; static const GInterfaceInfo link_info = { NULL, NULL, NULL }; type = g_type_register_static (GTK_TYPE_NOTEBOOK, "EphyNotebook", &our_info, 0); g_type_add_interface_static (type, EPHY_TYPE_LINK, &link_info); } return type; } void ephy_notebook_set_dnd_enabled (EphyNotebook *notebook, gboolean enabled) { EphyNotebookPrivate *priv = notebook->priv; priv->dnd_enabled = enabled; /* FIXME abort any DNDs in progress */ g_object_notify (G_OBJECT (notebook), "dnd-enabled"); } static void ephy_notebook_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { EphyNotebook *notebook = EPHY_NOTEBOOK (object); EphyNotebookPrivate *priv = notebook->priv; switch (prop_id) { case PROP_DND_ENABLED: g_value_set_boolean (value, priv->dnd_enabled); break; case PROP_SHOW_TABS: g_value_set_boolean (value, priv->show_tabs); break; } } static void ephy_notebook_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { EphyNotebook *notebook = EPHY_NOTEBOOK (object); switch (prop_id) { case PROP_DND_ENABLED: ephy_notebook_set_dnd_enabled (notebook, g_value_get_boolean (value)); break; case PROP_SHOW_TABS: ephy_notebook_set_show_tabs (notebook, g_value_get_boolean (value)); break; } } static void ephy_notebook_class_init (EphyNotebookClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); parent_class = g_type_class_peek_parent (klass); object_class->finalize = ephy_notebook_finalize; object_class->get_property = ephy_notebook_get_property; object_class->set_property = ephy_notebook_set_property; signals[TAB_ADDED] = g_signal_new ("tab_added", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (EphyNotebookClass, tab_added), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EPHY_TYPE_TAB); signals[TAB_REMOVED] = g_signal_new ("tab_removed", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (EphyNotebookClass, tab_removed), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EPHY_TYPE_TAB); signals[TAB_DETACHED] = g_signal_new ("tab_detached", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (EphyNotebookClass, tab_detached), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EPHY_TYPE_TAB); signals[TABS_REORDERED] = g_signal_new ("tabs_reordered", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (EphyNotebookClass, tabs_reordered), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[TAB_CLOSE_REQUEST] = g_signal_new ("tab-close-request", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (EphyNotebookClass, tab_close_req), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EPHY_TYPE_TAB); g_object_class_install_property (object_class, PROP_DND_ENABLED, g_param_spec_boolean ("dnd-enabled", "DND enabled", "Whether the notebook allows tab reordering by DND", TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); g_object_class_install_property (object_class, PROP_SHOW_TABS, g_param_spec_boolean ("show-tabs", "Show tabs", "Whether the notebook shows the tabs bar", TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); g_type_class_add_private (object_class, sizeof (EphyNotebookPrivate)); } static EphyNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ win_at_pointer = gdk_window_at_pointer (&x, &y); if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an EphyWindow */ if (toplevel != NULL && EPHY_IS_WINDOW (toplevel)) { return EPHY_NOTEBOOK (ephy_window_get_notebook (EPHY_WINDOW (toplevel))); } return NULL; } static gboolean is_in_notebook_window (EphyNotebook *notebook, gint abs_x, gint abs_y) { EphyNotebook *nb_at_pointer; nb_at_pointer = find_notebook_at_pointer (abs_x, abs_y); return nb_at_pointer == notebook; } static gint find_tab_num_at_pos (EphyNotebook *notebook, gint abs_x, gint abs_y) { GtkPositionType tab_pos; int page_num = 0; GtkNotebook *nb = GTK_NOTEBOOK (notebook); GtkWidget *page; tab_pos = gtk_notebook_get_tab_pos (GTK_NOTEBOOK (notebook)); if (GTK_NOTEBOOK (notebook)->first_tab == NULL) { return AFTER_ALL_TABS; } /* For some reason unfullscreen + quick click can cause a wrong click event to be reported to the tab */ if (!is_in_notebook_window(notebook, abs_x, abs_y)) { return NOT_IN_APP_WINDOWS; } while ((page = gtk_notebook_get_nth_page (nb, page_num))) { GtkWidget *tab; gint max_x, max_y; gint x_root, y_root; tab = gtk_notebook_get_tab_label (nb, page); g_return_val_if_fail (tab != NULL, -1); if (!GTK_WIDGET_MAPPED (GTK_WIDGET (tab))) { page_num++; continue; } gdk_window_get_origin (GDK_WINDOW (tab->window), &x_root, &y_root); max_x = x_root + tab->allocation.x + tab->allocation.width; max_y = y_root + tab->allocation.y + tab->allocation.height; if (((tab_pos == GTK_POS_TOP) || (tab_pos == GTK_POS_BOTTOM)) &&(abs_x<=max_x)) { return page_num; } else if (((tab_pos == GTK_POS_LEFT) || (tab_pos == GTK_POS_RIGHT)) && (abs_y<=max_y)) { return page_num; } page_num++; } return AFTER_ALL_TABS; } static gint find_notebook_and_tab_at_pos (gint abs_x, gint abs_y, EphyNotebook **notebook, gint *page_num) { *notebook = find_notebook_at_pointer (abs_x, abs_y); if (*notebook == NULL) { return NOT_IN_APP_WINDOWS; } *page_num = find_tab_num_at_pos (*notebook, abs_x, abs_y); if (*page_num < 0) { return *page_num; } else { return 0; } } void ephy_notebook_move_tab (EphyNotebook *src, EphyNotebook *dest, EphyTab *tab, int dest_position) { if (dest == NULL || src == dest) { gtk_notebook_reorder_child (GTK_NOTEBOOK (src), GTK_WIDGET (tab), dest_position); if (src->priv->drag_in_progress == FALSE) { g_signal_emit (G_OBJECT (src), signals[TABS_REORDERED], 0); } } #ifndef KEEP_TAB_IN_SAME_TOPLEVEL else { /* make sure the tab isn't destroyed while we move it */ g_object_ref (tab); ephy_notebook_remove_tab (src, tab); ephy_notebook_add_tab (dest, tab, dest_position, TRUE); g_object_unref (tab); } #endif } static void drag_stop (EphyNotebook *notebook, guint32 time) { EphyNotebookPrivate *priv = notebook->priv; GtkWidget *widget = GTK_WIDGET (notebook); GtkWidget *toplevel, *child; if (priv->drag_in_progress) { LOG ("Drag Stop"); toplevel = gtk_widget_get_toplevel (widget); g_return_if_fail (GTK_WIDGET_TOPLEVEL (toplevel)); child = gtk_bin_get_child (GTK_BIN (toplevel)); g_return_if_fail (child != NULL); /* disconnect the signals before ungrabbing! */ if (priv->toplevel_grab_broken_handler_id != 0) { g_signal_handler_disconnect (toplevel, priv->toplevel_grab_broken_handler_id); priv->toplevel_grab_broken_handler_id = 0; } if (priv->grab_notify_handler_id != 0) { g_signal_handler_disconnect (notebook, priv->grab_notify_handler_id); priv->grab_notify_handler_id = 0; } if (priv->toplevel_motion_notify_handler_id != 0) { g_signal_handler_disconnect (toplevel, priv->toplevel_motion_notify_handler_id); priv->toplevel_motion_notify_handler_id = 0; } if (priv->toplevel_button_release_handler_id != 0) { g_signal_handler_disconnect (toplevel, priv->toplevel_button_release_handler_id); priv->toplevel_button_release_handler_id = 0; } /* ungrab the pointer if it's grabbed */ /* FIXME multihead */ if (gdk_pointer_is_grabbed ()) { gdk_pointer_ungrab (time); } gtk_grab_remove (toplevel); g_signal_emit (G_OBJECT (notebook), signals[TABS_REORDERED], 0); } if (priv->motion_notify_handler_id != 0) { g_signal_handler_disconnect (notebook, priv->motion_notify_handler_id); priv->motion_notify_handler_id = 0; } priv->drag_in_progress = FALSE; } static gboolean grab_broken_event_cb (GtkWidget *widget, GdkEventGrabBroken *event, EphyNotebook *notebook) { LOG ("Grab Broken [%p]", notebook); drag_stop (notebook, GDK_CURRENT_TIME /* FIXME? */); return FALSE; } static void grab_notify_cb (GtkWidget *widget, gboolean was_grabbed, EphyNotebook *notebook) { LOG ("Grab Notify [%p, was-grabbed:%s]", notebook, was_grabbed ? "t" : "f"); drag_stop (notebook, GDK_CURRENT_TIME /* FIXME? */); } static gboolean toplevel_motion_notify_cb (GtkWidget *toplevel, GdkEventMotion *event, EphyNotebook *notebook) { EphyNotebook *dest = NULL; int page_num, result; result = find_notebook_and_tab_at_pos ((gint)event->x_root, (gint)event->y_root, &dest, &page_num); if (result != NOT_IN_APP_WINDOWS) { if (dest != notebook) { move_tab_to_another_notebook (notebook, dest, event, page_num); } else { g_assert (page_num >= -1); move_tab (notebook, page_num); } } return FALSE; } static gboolean toplevel_button_release_cb (GtkWidget *toplevel, GdkEventButton *event, EphyNotebook *notebook) { #ifndef KEEP_TAB_IN_SAME_TOPLEVEL EphyNotebookPrivate *priv = notebook->priv; if (priv->drag_in_progress) { gint cur_page_num; GtkWidget *cur_page; cur_page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); cur_page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), cur_page_num); if (!is_in_notebook_window (notebook, event->x_root, event->y_root) && gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook)) > 1) { /* Tab was detached */ g_signal_emit (G_OBJECT (notebook), signals[TAB_DETACHED], 0, cur_page); } } #endif /* This must be called even if a drag isn't happening */ drag_stop (notebook, event->time); return FALSE; } static gboolean drag_start (EphyNotebook *notebook, guint32 time) { EphyNotebookPrivate *priv = notebook->priv; GtkWidget *widget = GTK_WIDGET (notebook); GtkWidget *toplevel, *child; /* FIXME multihead */ if (priv->drag_in_progress || gdk_pointer_is_grabbed ()) return FALSE; LOG ("Drag Start"); priv->drag_in_progress = TRUE; /* get a new cursor, if necessary */ /* FIXME multi-head */ if (!cursor) cursor = gdk_cursor_new (GDK_FLEUR); toplevel = gtk_widget_get_toplevel (widget); g_return_val_if_fail (GTK_WIDGET_TOPLEVEL (toplevel), FALSE); child = gtk_bin_get_child (GTK_BIN (toplevel)); g_return_val_if_fail (child != NULL, FALSE); /* grab the pointer */ gtk_grab_add (toplevel); /* FIXME multi-head */ if (gdk_pointer_grab (toplevel->window, FALSE, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, NULL, cursor, time) != GDK_GRAB_SUCCESS) { drag_stop (notebook, time); return FALSE; } g_return_val_if_fail (priv->toplevel_grab_broken_handler_id == 0, FALSE); g_return_val_if_fail (priv->toplevel_motion_notify_handler_id == 0, FALSE); g_return_val_if_fail (priv->toplevel_button_release_handler_id == 0, FALSE); g_return_val_if_fail (priv->grab_notify_handler_id == 0, FALSE); priv->toplevel_grab_broken_handler_id = g_signal_connect (toplevel, "grab-broken-event", G_CALLBACK (grab_broken_event_cb), notebook); priv->toplevel_motion_notify_handler_id = g_signal_connect (toplevel, "motion-notify-event", G_CALLBACK (toplevel_motion_notify_cb), notebook); priv->toplevel_button_release_handler_id = g_signal_connect (toplevel, "button-release-event", G_CALLBACK (toplevel_button_release_cb), notebook); priv->grab_notify_handler_id = g_signal_connect (notebook, "grab-notify", G_CALLBACK (grab_notify_cb), notebook); return TRUE; } /* this function is only called during dnd, we don't need to emit TABS_REORDERED * here, instead we do it on drag_stop */ static void move_tab (EphyNotebook *notebook, int dest_position) { gint cur_page_num; cur_page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); if (dest_position != cur_page_num) { GtkWidget *cur_tab; cur_tab = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), cur_page_num); ephy_notebook_move_tab (EPHY_NOTEBOOK (notebook), NULL, EPHY_TAB (cur_tab), dest_position); } } static gboolean motion_notify_cb (EphyNotebook *notebook, GdkEventMotion *event, gpointer data) { EphyNotebookPrivate *priv = notebook->priv; if (priv->drag_in_progress == FALSE) { if (gtk_drag_check_threshold (GTK_WIDGET (notebook), notebook->priv->x_start, notebook->priv->y_start, event->x_root, event->y_root)) { return drag_start (notebook, event->time); } return FALSE; } return FALSE; } static void move_tab_to_another_notebook (EphyNotebook *src, EphyNotebook *dest, GdkEventMotion *event, int dest_position) { #ifndef KEEP_TAB_IN_SAME_TOPLEVEL EphyTab *tab; int cur_page; /* This is getting tricky, the tab was dragged in a notebook * in another window of the same app, we move the tab * to that new notebook, and let this notebook handle the * drag */ g_assert (EPHY_IS_NOTEBOOK (dest)); g_assert (dest != src); /* Check if the dest notebook can accept the drag */ if (!dest->priv->dnd_enabled) return; cur_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (src)); tab = EPHY_TAB (gtk_notebook_get_nth_page (GTK_NOTEBOOK (src), cur_page)); /* stop drag in origin window */ drag_stop (src, event->time); ephy_notebook_move_tab (src, dest, tab, dest_position); /* start drag handling in dest notebook */ dest->priv->motion_notify_handler_id = g_signal_connect (G_OBJECT (dest), "motion-notify-event", G_CALLBACK (motion_notify_cb), NULL); drag_start (dest, event->time); #endif /* KEEP_TAB_IN_SAME_TOPLEVEL */ } static gboolean button_release_cb (EphyNotebook *notebook, GdkEventButton *event, gpointer data) { /* This must be called even if a drag isn't happening */ drag_stop (notebook, event->time); return FALSE; } static gboolean button_press_cb (EphyNotebook *notebook, GdkEventButton *event, gpointer data) { EphyNotebookPrivate *priv = notebook->priv; int tab_clicked; if (!notebook->priv->dnd_enabled) return FALSE; tab_clicked = find_tab_num_at_pos (notebook, event->x_root, event->y_root); /* FIXME: how could there be a drag in progress!? */ if (notebook->priv->drag_in_progress) { return TRUE; } if ((event->button == 1) && (event->type == GDK_BUTTON_PRESS) && (tab_clicked >= 0)) { priv->x_start = event->x_root; priv->y_start = event->y_root; priv->motion_notify_handler_id = g_signal_connect (notebook, "motion-notify-event", G_CALLBACK (motion_notify_cb), NULL); } else if (GDK_BUTTON_PRESS == event->type && 3 == event->button) { if (tab_clicked == -1) { /* consume event, so that we don't pop up the context menu when * the mouse if not over a tab label */ return TRUE; } else { /* switch to the page the mouse is over, but don't consume the event */ gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), tab_clicked); } } return FALSE; } GtkWidget * ephy_notebook_new (void) { return GTK_WIDGET (g_object_new (EPHY_TYPE_NOTEBOOK, NULL)); } static void ephy_notebook_switch_page_cb (GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer data) { EphyNotebook *nb = EPHY_NOTEBOOK (notebook); GtkWidget *child; child = gtk_notebook_get_nth_page (notebook, page_num); /* Remove the old page, we dont want to grow unnecessarily * the list */ if (nb->priv->focused_pages) { nb->priv->focused_pages = g_list_remove (nb->priv->focused_pages, child); } nb->priv->focused_pages = g_list_append (nb->priv->focused_pages, child); } static void notebook_drag_data_received_cb (GtkWidget* widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time, EphyTab *tab) { EphyWindow *window; GtkWidget *notebook; g_signal_stop_emission_by_name (widget, "drag_data_received"); if (eel_gconf_get_boolean (CONF_LOCKDOWN_DISABLE_ARBITRARY_URL)) return; if (selection_data->length <= 0 || selection_data->data == NULL) return; window = EPHY_WINDOW (gtk_widget_get_toplevel (widget)); notebook = ephy_window_get_notebook (window); if (selection_data->target == gdk_atom_intern (EPHY_DND_URL_TYPE, FALSE)) { char **split; /* URL_TYPE has format: url \n title */ split = g_strsplit ((const gchar *)selection_data->data, "\n", 2); if (split != NULL && split[0] != NULL && split[0][0] != '\0') { ephy_link_open (EPHY_LINK (notebook), split[0], tab, tab ? 0 : EPHY_LINK_NEW_TAB); } g_strfreev (split); } else if (selection_data->target == gdk_atom_intern (EPHY_DND_URI_LIST_TYPE, FALSE)) { char **uris; int i; uris = gtk_selection_data_get_uris (selection_data); if (uris == NULL) return; for (i = 0; uris[i] != NULL && i < INSANE_NUMBER_OF_URLS; i++) { tab = ephy_link_open (EPHY_LINK (notebook), uris[i], tab, i == 0 ? 0 : EPHY_LINK_NEW_TAB); } g_strfreev (uris); } else { g_return_if_reached (); } } /* * update_tabs_visibility: Hide tabs if there is only one tab * and the pref is not set. */ static void update_tabs_visibility (EphyNotebook *nb, gboolean before_inserting) { gboolean show_tabs; guint num; num = gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb)); if (before_inserting) num++; show_tabs = (eel_gconf_get_boolean (CONF_ALWAYS_SHOW_TABS_BAR) || num > 1) && nb->priv->show_tabs == TRUE; gtk_notebook_set_show_tabs (GTK_NOTEBOOK (nb), show_tabs); } static void tabs_visibility_notifier (GConfClient *client, guint cnxn_id, GConfEntry *entry, EphyNotebook *nb) { update_tabs_visibility (nb, FALSE); } static void ephy_notebook_init (EphyNotebook *notebook) { notebook->priv = EPHY_NOTEBOOK_GET_PRIVATE (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->priv->title_tips = gtk_tooltips_new (); g_object_ref (G_OBJECT (notebook->priv->title_tips)); gtk_object_sink (GTK_OBJECT (notebook->priv->title_tips)); notebook->priv->show_tabs = TRUE; notebook->priv->dnd_enabled = TRUE; g_signal_connect (notebook, "button-press-event", (GCallback)button_press_cb, NULL); g_signal_connect (notebook, "button-release-event", (GCallback)button_release_cb, NULL); gtk_widget_add_events (GTK_WIDGET (notebook), GDK_BUTTON1_MOTION_MASK); g_signal_connect_after (G_OBJECT (notebook), "switch_page", G_CALLBACK (ephy_notebook_switch_page_cb), NULL); /* Set up drag-and-drop target */ g_signal_connect (G_OBJECT(notebook), "drag_data_received", G_CALLBACK(notebook_drag_data_received_cb), NULL); gtk_drag_dest_set (GTK_WIDGET(notebook), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, url_drag_types, G_N_ELEMENTS (url_drag_types), GDK_ACTION_MOVE | GDK_ACTION_COPY); notebook->priv->tabs_vis_notifier_id = eel_gconf_notification_add (CONF_ALWAYS_SHOW_TABS_BAR, (GConfClientNotifyFunc)tabs_visibility_notifier, notebook); } static void ephy_notebook_finalize (GObject *object) { EphyNotebook *notebook = EPHY_NOTEBOOK (object); eel_gconf_notification_remove (notebook->priv->tabs_vis_notifier_id); if (notebook->priv->focused_pages) { g_list_free (notebook->priv->focused_pages); } g_object_unref (notebook->priv->title_tips); G_OBJECT_CLASS (parent_class)->finalize (object); } static void sync_load_status (EphyTab *tab, GParamSpec *pspec, GtkWidget *proxy) { GtkWidget *spinner, *icon; spinner = GTK_WIDGET (g_object_get_data (G_OBJECT (proxy), "spinner")); icon = GTK_WIDGET (g_object_get_data (G_OBJECT (proxy), "icon")); g_return_if_fail (spinner != NULL && icon != NULL); if (ephy_tab_get_load_status (tab)) { gtk_widget_hide (icon); gtk_widget_show (spinner); ephy_spinner_start (EPHY_SPINNER (spinner)); } else { ephy_spinner_stop (EPHY_SPINNER (spinner)); gtk_widget_hide (spinner); gtk_widget_show (icon); } } static void sync_icon (EphyTab *tab, GParamSpec *pspec, GtkWidget *proxy) { GtkImage *icon; icon = GTK_IMAGE (g_object_get_data (G_OBJECT (proxy), "icon")); g_return_if_fail (icon != NULL); gtk_image_set_from_pixbuf (icon, ephy_tab_get_icon (tab)); } static void sync_label (EphyTab *tab, GParamSpec *pspec, GtkWidget *proxy) { GtkWidget *label, *ebox; GtkTooltips *tips; const char *title; ebox = GTK_WIDGET (g_object_get_data (G_OBJECT (proxy), "label-ebox")); tips = GTK_TOOLTIPS (g_object_get_data (G_OBJECT (proxy), "tooltips")); label = GTK_WIDGET (g_object_get_data (G_OBJECT (proxy), "label")); g_return_if_fail (ebox != NULL && tips != NULL && label != NULL); title = ephy_tab_get_title_composite (tab); if (title) { gtk_label_set_text (GTK_LABEL (label), title); gtk_tooltips_set_tip (tips, ebox, title, NULL); } } static void close_button_clicked_cb (GtkWidget *widget, GtkWidget *tab) { GtkWidget *notebook; notebook = gtk_widget_get_parent (tab); g_signal_emit (notebook, signals[TAB_CLOSE_REQUEST], 0, tab); } static void tab_label_style_set_cb (GtkWidget *hbox, GtkStyle *previous_style, gpointer user_data) { PangoFontMetrics *metrics; PangoContext *context; int char_width, h, w; context = gtk_widget_get_pango_context (hbox); metrics = pango_context_get_metrics (context, hbox->style->font_desc, pango_context_get_language (context)); char_width = pango_font_metrics_get_approximate_digit_width (metrics); pango_font_metrics_unref (metrics); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (hbox), GTK_ICON_SIZE_MENU, &w, &h); gtk_widget_set_size_request (hbox, TAB_WIDTH_N_CHARS * PANGO_PIXELS(char_width) + 2 * w, -1); } static GtkWidget * build_tab_label (EphyNotebook *nb, EphyTab *tab) { GtkWidget *hbox, *label_hbox, *label_ebox; GtkWidget *label, *close_button, *image, *spinner, *icon; GtkIconSize close_icon_size; /* set hbox spacing and label padding (see below) so that there's an * equal amount of space around the label */ hbox = gtk_hbox_new (FALSE, 4); label_ebox = gtk_event_box_new (); gtk_event_box_set_visible_window (GTK_EVENT_BOX (label_ebox), FALSE); gtk_box_pack_start (GTK_BOX (hbox), label_ebox, TRUE, TRUE, 0); label_hbox = gtk_hbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (label_ebox), label_hbox); /* setup 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_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE); close_icon_size = gtk_icon_size_from_name (EPHY_ICON_SIZE_TAB_BUTTON); image = gtk_image_new_from_stock (EPHY_STOCK_CLOSE_TAB, close_icon_size); gtk_container_add (GTK_CONTAINER (close_button), image); gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 0); gtk_tooltips_set_tip (nb->priv->title_tips, close_button, _("Close tab"), NULL); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (close_button_clicked_cb), tab); /* setup load feedback */ spinner = ephy_spinner_new (); ephy_spinner_set_size (EPHY_SPINNER (spinner), GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (label_hbox), spinner, FALSE, FALSE, 0); /* setup site icon, empty by default */ icon = gtk_image_new (); gtk_box_pack_start (GTK_BOX (label_hbox), icon, FALSE, FALSE, 0); /* setup label */ label = gtk_label_new (""); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_misc_set_padding (GTK_MISC (label), 0, 0); gtk_box_pack_start (GTK_BOX (label_hbox), label, TRUE, TRUE, 0); /* Set minimal size */ g_signal_connect (hbox, "style-set", G_CALLBACK (tab_label_style_set_cb), NULL); gtk_widget_show (hbox); gtk_widget_show (label_ebox); gtk_widget_show (label_hbox); gtk_widget_show (label); gtk_widget_show (image); gtk_widget_show (close_button); g_object_set_data (G_OBJECT (hbox), "label", label); g_object_set_data (G_OBJECT (hbox), "label-ebox", label_ebox); g_object_set_data (G_OBJECT (hbox), "spinner", spinner); g_object_set_data (G_OBJECT (hbox), "icon", icon); g_object_set_data (G_OBJECT (hbox), "close-button", close_button); g_object_set_data (G_OBJECT (hbox), "tooltips", nb->priv->title_tips); return hbox; } void ephy_notebook_set_show_tabs (EphyNotebook *nb, gboolean show_tabs) { nb->priv->show_tabs = show_tabs; update_tabs_visibility (nb, FALSE); } void ephy_notebook_add_tab (EphyNotebook *nb, EphyTab *tab, int position, gboolean jump_to) { GtkWidget *label; g_return_if_fail (EPHY_IS_TAB (tab)); label = build_tab_label (nb, tab); update_tabs_visibility (nb, TRUE); gtk_notebook_insert_page (GTK_NOTEBOOK (nb), GTK_WIDGET (tab), label, position); /* Set up drag-and-drop target */ g_signal_connect (G_OBJECT(label), "drag_data_received", G_CALLBACK(notebook_drag_data_received_cb), tab); gtk_drag_dest_set (label, GTK_DEST_DEFAULT_ALL, url_drag_types, G_N_ELEMENTS (url_drag_types), GDK_ACTION_MOVE | GDK_ACTION_COPY); sync_icon (tab, NULL, label); sync_label (tab, NULL, label); sync_load_status (tab, NULL, label); g_signal_connect_object (tab, "notify::icon", G_CALLBACK (sync_icon), label, 0); g_signal_connect_object (tab, "notify::title", G_CALLBACK (sync_label), label, 0); g_signal_connect_object (tab, "notify::load-status", G_CALLBACK (sync_load_status), label, 0); g_signal_emit (G_OBJECT (nb), signals[TAB_ADDED], 0, tab); /* The signal handler may have reordered the tabs */ position = gtk_notebook_page_num (GTK_NOTEBOOK (nb), GTK_WIDGET (tab)); if (jump_to) { gtk_notebook_set_current_page (GTK_NOTEBOOK (nb), position); g_object_set_data (G_OBJECT (tab), "jump_to", GINT_TO_POINTER (jump_to)); } } static void smart_tab_switching_on_closure (EphyNotebook *nb, EphyTab *tab) { gboolean jump_to; jump_to = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tab), "jump_to")); if (!jump_to || !nb->priv->focused_pages) { gtk_notebook_next_page (GTK_NOTEBOOK (nb)); } else { GList *l; GtkWidget *child; int page_num; /* activate the last focused tab */ l = g_list_last (nb->priv->focused_pages); child = GTK_WIDGET (l->data); page_num = gtk_notebook_page_num (GTK_NOTEBOOK (nb), child); gtk_notebook_set_current_page (GTK_NOTEBOOK (nb), page_num); } } void ephy_notebook_remove_tab (EphyNotebook *nb, EphyTab *tab) { int position, curr; GtkWidget *label, *ebox; g_return_if_fail (EPHY_IS_NOTEBOOK (nb)); g_return_if_fail (EPHY_IS_TAB (tab)); /* Remove the page from the focused pages list */ nb->priv->focused_pages = g_list_remove (nb->priv->focused_pages, tab); position = gtk_notebook_page_num (GTK_NOTEBOOK (nb), GTK_WIDGET (tab)); curr = gtk_notebook_get_current_page (GTK_NOTEBOOK (nb)); if (position == curr) { smart_tab_switching_on_closure (nb, tab); } label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (nb), GTK_WIDGET (tab)); ebox = GTK_WIDGET (g_object_get_data (G_OBJECT (label), "label-ebox")); gtk_tooltips_set_tip (GTK_TOOLTIPS (nb->priv->title_tips), ebox, NULL, NULL); g_signal_handlers_disconnect_by_func (tab, G_CALLBACK (sync_icon), label); g_signal_handlers_disconnect_by_func (tab, G_CALLBACK (sync_label), label); g_signal_handlers_disconnect_by_func (tab, G_CALLBACK (sync_load_status), label); /** * we ref the tab so that it's still alive while the tabs_removed * signal is processed. */ g_object_ref (tab); gtk_notebook_remove_page (GTK_NOTEBOOK (nb), position); update_tabs_visibility (nb, FALSE); g_signal_emit (G_OBJECT (nb), signals[TAB_REMOVED], 0, tab); g_object_unref (tab); /* if that was the last tab, destroy the window */ if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb)) == 0) { gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (nb))); } }