/*
* Copyright © 2001 Havoc Pennington
* Copyright © 2002 Red Hat, Inc.
* Copyright © 2008, 2010, 2011, 2012 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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include "terminal-notebook.h"
#include <gtk/gtk.h>
#include "terminal-debug.h"
#include "terminal-app.h"
#include "terminal-intl.h"
#include "terminal-mdi-container.h"
#include "terminal-screen-container.h"
#include "terminal-tab-label.h"
#include "terminal-schemas.h"
#include "terminal-libgsystem.h"
#define TERMINAL_NOTEBOOK_GET_PRIVATE(notebook)(G_TYPE_INSTANCE_GET_PRIVATE ((notebook), TERMINAL_TYPE_NOTEBOOK, TerminalNotebookPrivate))
struct _TerminalNotebookPrivate
{
TerminalScreen *active_screen;
GtkPolicyType policy;
};
enum
{
PROP_0,
PROP_ACTIVE_SCREEN,
PROP_TAB_POLICY
};
#define ACTION_AREA_BORDER_WIDTH (2)
#define ACTION_BUTTON_SPACING (6)
/* helper functions */
static void
update_tab_visibility (TerminalNotebook *notebook,
int change)
{
TerminalNotebookPrivate *priv = notebook->priv;
GtkNotebook *gtk_notebook = GTK_NOTEBOOK (notebook);
int new_n_pages;
gboolean show_tabs;
if (gtk_widget_in_destruction (GTK_WIDGET (notebook)))
return;
new_n_pages = gtk_notebook_get_n_pages (gtk_notebook) + change;
/* Don't do anything if we're going to have zero pages (and thus close the window) */
if (new_n_pages == 0)
return;
switch (priv->policy) {
case GTK_POLICY_ALWAYS:
show_tabs = TRUE;
break;
case GTK_POLICY_AUTOMATIC:
show_tabs = new_n_pages > 1;
break;
case GTK_POLICY_NEVER:
#if GTK_CHECK_VERSION (3, 16, 0)
case GTK_POLICY_EXTERNAL:
#endif
default:
show_tabs = FALSE;
break;
}
gtk_notebook_set_show_tabs (gtk_notebook, show_tabs);
}
static void
close_button_clicked_cb (TerminalTabLabel *tab_label,
gpointer user_data)
{
TerminalScreen *screen;
TerminalNotebook *notebook;
screen = terminal_tab_label_get_screen (tab_label);
/* notebook is not passed as user_data because it can change during DND
* and the close button is not notified about that, see bug 731998.
*/
notebook = TERMINAL_NOTEBOOK (gtk_widget_get_ancestor (GTK_WIDGET (screen),
TERMINAL_TYPE_NOTEBOOK));
if (notebook != NULL)
g_signal_emit_by_name (notebook, "screen-close-request", screen);
}
static void
remove_reorder_bindings (GtkBindingSet *binding_set,
guint keysym)
{
guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
gtk_binding_entry_skip (binding_set, keysym, GDK_MOD1_MASK);
gtk_binding_entry_skip (binding_set, keypad_keysym, GDK_MOD1_MASK);
}
/* TerminalMdiContainer impl */
static void
terminal_notebook_add_screen (TerminalMdiContainer *container,
TerminalScreen *screen)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (container);
GtkNotebook *gtk_notebook = GTK_NOTEBOOK (notebook);
GtkWidget *screen_container, *tab_label;
const int position = -1;
g_warn_if_fail (gtk_widget_get_parent (GTK_WIDGET (screen)) == NULL);
screen_container = terminal_screen_container_new (screen);
gtk_widget_show (screen_container);
update_tab_visibility (notebook, +1);
tab_label = terminal_tab_label_new (screen);
g_signal_connect (tab_label, "close-button-clicked",
G_CALLBACK (close_button_clicked_cb), NULL);
gtk_notebook_insert_page (gtk_notebook,
screen_container,
tab_label,
position);
gtk_container_child_set (GTK_CONTAINER (notebook),
screen_container,
"tab-expand", TRUE,
"tab-fill", TRUE,
NULL);
gtk_notebook_set_tab_reorderable (gtk_notebook, screen_container, TRUE);
#if 0
gtk_notebook_set_tab_detachable (gtk_notebook, screen_container, TRUE);
#endif
}
static void
terminal_notebook_remove_screen (TerminalMdiContainer *container,
TerminalScreen *screen)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (container);
TerminalScreenContainer *screen_container;
g_warn_if_fail (gtk_widget_is_ancestor (GTK_WIDGET (screen), GTK_WIDGET (notebook)));
update_tab_visibility (notebook, -1);
screen_container = terminal_screen_container_get_from_screen (screen);
gtk_container_remove (GTK_CONTAINER (notebook),
GTK_WIDGET (screen_container));
}
static TerminalScreen *
terminal_notebook_get_active_screen (TerminalMdiContainer *container)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (container);
GtkNotebook *gtk_notebook = GTK_NOTEBOOK (notebook);
GtkWidget *widget;
widget = gtk_notebook_get_nth_page (gtk_notebook, gtk_notebook_get_current_page (gtk_notebook));
return terminal_screen_container_get_screen (TERMINAL_SCREEN_CONTAINER (widget));
}
static void
terminal_notebook_set_active_screen (TerminalMdiContainer *container,
TerminalScreen *screen)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (container);
GtkNotebook *gtk_notebook = GTK_NOTEBOOK (notebook);
TerminalScreenContainer *screen_container;
GtkWidget *widget;
screen_container = terminal_screen_container_get_from_screen (screen);
widget = GTK_WIDGET (screen_container);
gtk_notebook_set_current_page (gtk_notebook,
gtk_notebook_page_num (gtk_notebook, widget));
}
static GList *
terminal_notebook_list_screen_containers (TerminalMdiContainer *container)
{
/* We are trusting that GtkNotebook will return pages in order */
return gtk_container_get_children (GTK_CONTAINER (container));
}
static GList *
terminal_notebook_list_screens (TerminalMdiContainer *container)
{
GList *list, *l;
list = terminal_notebook_list_screen_containers (container);
for (l = list; l != NULL; l = l->next)
l->data = terminal_screen_container_get_screen ((TerminalScreenContainer *) l->data);
return list;
}
static int
terminal_notebook_get_n_screens (TerminalMdiContainer *container)
{
return gtk_notebook_get_n_pages (GTK_NOTEBOOK (container));
}
static int
terminal_notebook_get_active_screen_num (TerminalMdiContainer *container)
{
return gtk_notebook_get_current_page (GTK_NOTEBOOK (container));
}
static void
terminal_notebook_set_active_screen_num (TerminalMdiContainer *container,
int position)
{
GtkNotebook *gtk_notebook = GTK_NOTEBOOK (container);
gtk_notebook_set_current_page (gtk_notebook, position);
}
static void
terminal_notebook_reorder_screen (TerminalMdiContainer *container,
TerminalScreen *screen,
int new_position)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
GtkWidget *child;
int n, pos;
g_return_if_fail (new_position == 1 || new_position == -1);
child = GTK_WIDGET (terminal_screen_container_get_from_screen (screen));
n = gtk_notebook_get_n_pages (notebook);
pos = gtk_notebook_page_num (notebook, child);
pos += new_position;
gtk_notebook_reorder_child (notebook, child,
pos < 0 ? n - 1 : pos < n ? pos : 0);
}
static void
terminal_notebook_mdi_iface_init (TerminalMdiContainerInterface *iface)
{
iface->add_screen = terminal_notebook_add_screen;
iface->remove_screen = terminal_notebook_remove_screen;
iface->get_active_screen = terminal_notebook_get_active_screen;
iface->set_active_screen = terminal_notebook_set_active_screen;
iface->list_screens = terminal_notebook_list_screens;
iface->list_screen_containers = terminal_notebook_list_screen_containers;
iface->get_n_screens = terminal_notebook_get_n_screens;
iface->get_active_screen_num = terminal_notebook_get_active_screen_num;
iface->set_active_screen_num = terminal_notebook_set_active_screen_num;
iface->reorder_screen = terminal_notebook_reorder_screen;
}
G_DEFINE_TYPE_WITH_CODE (TerminalNotebook, terminal_notebook, GTK_TYPE_NOTEBOOK,
G_IMPLEMENT_INTERFACE (TERMINAL_TYPE_MDI_CONTAINER, terminal_notebook_mdi_iface_init))
/* GtkNotebookClass impl */
static void
terminal_notebook_switch_page (GtkNotebook *gtk_notebook,
GtkWidget *child,
guint page_num)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (gtk_notebook);
TerminalNotebookPrivate *priv = notebook->priv;
TerminalScreen *screen, *old_active_screen;
GTK_NOTEBOOK_CLASS (terminal_notebook_parent_class)->switch_page (gtk_notebook, child, page_num);
screen = terminal_screen_container_get_screen (TERMINAL_SCREEN_CONTAINER (child));
old_active_screen = priv->active_screen;
if (screen == old_active_screen)
return;
/* Workaround to remove gtknotebook's feature of computing its size based on
* all pages. When the widget is hidden, its size will not be taken into
* account.
* FIXME!
*/
// if (old_active_screen)
// gtk_widget_hide (GTK_WIDGET (terminal_screen_container_get_from_screen (old_active_screen)));
/* Make sure that the widget is no longer hidden due to the workaround */
// if (child)
// gtk_widget_show (child);
if (old_active_screen)
gtk_widget_hide (GTK_WIDGET (old_active_screen));
if (screen)
gtk_widget_show (GTK_WIDGET (screen));
priv->active_screen = screen;
g_signal_emit_by_name (notebook, "screen-switched", old_active_screen, screen);
g_object_notify (G_OBJECT (notebook), "active-screen");
}
static void
terminal_notebook_page_added (GtkNotebook *gtk_notebook,
GtkWidget *child,
guint page_num)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (gtk_notebook);
void (* page_added) (GtkNotebook *, GtkWidget *, guint) =
GTK_NOTEBOOK_CLASS (terminal_notebook_parent_class)->page_added;
if (page_added)
page_added (gtk_notebook, child, page_num);
update_tab_visibility (notebook, 0);
g_signal_emit_by_name (gtk_notebook, "screen-added",
terminal_screen_container_get_screen (TERMINAL_SCREEN_CONTAINER (child)));
}
static void
terminal_notebook_page_removed (GtkNotebook *gtk_notebook,
GtkWidget *child,
guint page_num)
{
TerminalNotebook *notebook = TERMINAL_NOTEBOOK (gtk_notebook);
void (* page_removed) (GtkNotebook *, GtkWidget *, guint) =
GTK_NOTEBOOK_CLASS (terminal_notebook_parent_class)->page_removed;
if (page_removed)
page_removed (gtk_notebook, child, page_num);
update_tab_visibility (notebook, 0);
g_signal_emit_by_name (gtk_notebook, "screen-removed",
terminal_screen_container_get_screen (TERMINAL_SCREEN_CONTAINER (child)));
}
static void
terminal_notebook_page_reordered (GtkNotebook *notebook,
GtkWidget *child,
guint page_num)
{
void (* page_reordered) (GtkNotebook *, GtkWidget *, guint) =
GTK_NOTEBOOK_CLASS (terminal_notebook_parent_class)->page_reordered;
if (page_reordered)
page_reordered (notebook, child, page_num);
g_signal_emit_by_name (notebook, "screens-reordered");
}
static GtkNotebook *
terminal_notebook_create_window (GtkNotebook *notebook,
GtkWidget *page,
gint x,
gint y)
{
return GTK_NOTEBOOK_CLASS (terminal_notebook_parent_class)->create_window (notebook, page, x, y);
}
/* GtkWidgetClass impl */
static void
terminal_notebook_grab_focus (GtkWidget *widget)
{
TerminalScreen *screen;
screen = terminal_mdi_container_get_active_screen (TERMINAL_MDI_CONTAINER (widget));
gtk_widget_grab_focus (GTK_WIDGET (screen));
}
/* Tab scrolling was removed from GtkNotebook in gtk 3, so reimplement it here */
static gboolean
terminal_notebook_scroll_event (GtkWidget *widget,
GdkEventScroll *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
gboolean (* scroll_event) (GtkWidget *, GdkEventScroll *) =
GTK_WIDGET_CLASS (terminal_notebook_parent_class)->scroll_event;
GtkWidget *child, *event_widget, *action_widget;
if ((event->state & gtk_accelerator_get_default_mod_mask ()) != 0)
goto chain_up;
child = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
if (child == NULL)
goto chain_up;
event_widget = gtk_get_event_widget ((GdkEvent *) event);
/* Ignore scroll events from the content of the page */
if (event_widget == NULL ||
event_widget == child ||
gtk_widget_is_ancestor (event_widget, child))
goto chain_up;
/* And also from the action widgets */
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_START);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
goto chain_up;
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_END);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
goto chain_up;
switch (event->direction) {
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_DOWN:
gtk_notebook_next_page (notebook);
return TRUE;
case GDK_SCROLL_LEFT:
case GDK_SCROLL_UP:
gtk_notebook_prev_page (notebook);
return TRUE;
case GDK_SCROLL_SMOOTH:
switch (gtk_notebook_get_tab_pos (notebook)) {
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
if (event->delta_y > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_y < 0)
gtk_notebook_prev_page (notebook);
break;
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
if (event->delta_x > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_x < 0)
gtk_notebook_prev_page (notebook);
break;
}
return TRUE;
}
chain_up:
if (scroll_event)
return scroll_event (widget, event);
return FALSE;
}
/* GObjectClass impl */
static void
terminal_notebook_init (TerminalNotebook *notebook)
{
TerminalNotebookPrivate *priv;
priv = notebook->priv = TERMINAL_NOTEBOOK_GET_PRIVATE (notebook);
priv->active_screen = NULL;
priv->policy = GTK_POLICY_AUTOMATIC;
}
static void
terminal_notebook_constructed (GObject *object)
{
GSettings *settings;
GtkWidget *widget = GTK_WIDGET (object);
GtkNotebook *notebook = GTK_NOTEBOOK (object);
G_OBJECT_CLASS (terminal_notebook_parent_class)->constructed (object);
settings = terminal_app_get_global_settings (terminal_app_get ());
update_tab_visibility (TERMINAL_NOTEBOOK (notebook), 0);
g_settings_bind (settings,
TERMINAL_SETTING_TAB_POLICY_KEY,
object,
"tab-policy",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (settings,
TERMINAL_SETTING_TAB_POSITION_KEY,
object,
"tab-pos",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
gtk_notebook_set_scrollable (notebook, TRUE);
gtk_notebook_set_show_border (notebook, FALSE);
gtk_notebook_set_group_name (notebook, I_("gnome-terminal-window"));
/* Necessary for scroll events */
gtk_widget_add_events (widget, GDK_SCROLL_MASK);
}
static void
terminal_notebook_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
TerminalMdiContainer *mdi_container = TERMINAL_MDI_CONTAINER (object);
switch (prop_id) {
case PROP_ACTIVE_SCREEN:
g_value_set_object (value, terminal_notebook_get_active_screen (mdi_container));
break;
case PROP_TAB_POLICY:
g_value_set_enum (value, terminal_notebook_get_tab_policy (TERMINAL_NOTEBOOK (mdi_container)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
terminal_notebook_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
TerminalMdiContainer *mdi_container = TERMINAL_MDI_CONTAINER (object);
switch (prop_id) {
case PROP_ACTIVE_SCREEN:
terminal_notebook_set_active_screen (mdi_container, g_value_get_object (value));
break;
case PROP_TAB_POLICY:
terminal_notebook_set_tab_policy (TERMINAL_NOTEBOOK (mdi_container), g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
terminal_notebook_class_init (TerminalNotebookClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkNotebookClass *notebook_class = GTK_NOTEBOOK_CLASS (klass);
g_type_class_add_private (gobject_class, sizeof (TerminalNotebookPrivate));
gobject_class->constructed = terminal_notebook_constructed;
gobject_class->get_property = terminal_notebook_get_property;
gobject_class->set_property = terminal_notebook_set_property;
g_object_class_override_property (gobject_class, PROP_ACTIVE_SCREEN, "active-screen");
widget_class->grab_focus = terminal_notebook_grab_focus;
widget_class->scroll_event = terminal_notebook_scroll_event;
notebook_class->switch_page = terminal_notebook_switch_page;
notebook_class->create_window = terminal_notebook_create_window;
notebook_class->page_added = terminal_notebook_page_added;
notebook_class->page_removed = terminal_notebook_page_removed;
notebook_class->page_reordered = terminal_notebook_page_reordered;
g_object_class_install_property
(gobject_class,
PROP_TAB_POLICY,
g_param_spec_enum ("tab-policy", NULL, NULL,
GTK_TYPE_POLICY_TYPE,
GTK_POLICY_AUTOMATIC,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/* Remove unwanted and interfering keybindings */
GtkBindingSet *binding_set = gtk_binding_set_by_class (terminal_notebook_parent_class);
gtk_binding_entry_skip (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK);
gtk_binding_entry_skip (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK | GDK_MOD1_MASK);
gtk_binding_entry_skip (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK);
gtk_binding_entry_skip (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK | GDK_MOD1_MASK);
remove_reorder_bindings (binding_set, GDK_KEY_Up);
remove_reorder_bindings (binding_set, GDK_KEY_Down);
remove_reorder_bindings (binding_set, GDK_KEY_Left);
remove_reorder_bindings (binding_set, GDK_KEY_Right);
remove_reorder_bindings (binding_set, GDK_KEY_Home);
remove_reorder_bindings (binding_set, GDK_KEY_Home);
remove_reorder_bindings (binding_set, GDK_KEY_End);
remove_reorder_bindings (binding_set, GDK_KEY_End);
}
/* public API */
/**
* terminal_notebook_new:
*
* Returns: (transfer full): a new #TerminalNotebook
*/
GtkWidget *
terminal_notebook_new (void)
{
return g_object_new (TERMINAL_TYPE_NOTEBOOK, NULL);
}
void
terminal_notebook_set_tab_policy (TerminalNotebook *notebook,
GtkPolicyType policy)
{
TerminalNotebookPrivate *priv = notebook->priv;
if (priv->policy == policy)
return;
priv->policy = policy;
update_tab_visibility (notebook, 0);
g_object_notify (G_OBJECT (notebook), "tab-policy");
}
GtkPolicyType
terminal_notebook_get_tab_policy (TerminalNotebook *notebook)
{
return notebook->priv->policy;
}
GtkWidget *
terminal_notebook_get_action_box (TerminalNotebook *notebook,
GtkPackType pack_type)
{
GtkNotebook *gtk_notebook;
GtkWidget *box, *inner_box;
g_return_val_if_fail (TERMINAL_IS_NOTEBOOK (notebook), NULL);
gtk_notebook = GTK_NOTEBOOK (notebook);
box = gtk_notebook_get_action_widget (gtk_notebook, pack_type);
if (box != NULL) {
gs_free_list GList *list;
list = gtk_container_get_children (GTK_CONTAINER (box));
g_assert (list->data != NULL);
return list->data;
}
/* Create container for the buttons */
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), ACTION_AREA_BORDER_WIDTH);
inner_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, ACTION_BUTTON_SPACING);
gtk_box_pack_start (GTK_BOX (box), inner_box, TRUE, FALSE, 0);
gtk_widget_show (inner_box);
gtk_notebook_set_action_widget (gtk_notebook, box, pack_type);
gtk_widget_show (box);
/* FIXME: this appears to be necessary to make the icon buttons contained
* in the action area render the same way as buttons in the tab labels (e.g.
* the close button). gtk+ bug?
*/
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_style_context_add_region (gtk_widget_get_style_context (box),
GTK_STYLE_REGION_TAB,
pack_type == GTK_PACK_START ? GTK_REGION_FIRST : GTK_REGION_LAST);
G_GNUC_END_IGNORE_DEPRECATIONS
return inner_box;
}