/* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */ /* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp:ftp.gtk.org/pub/gtk/. */ #include "config.h" #include "gtknotebook.h" #include "gtkbox.h" #include "gtkboxlayout.h" #include "gtkbuildable.h" #include "gtkbutton.h" #include "gtkcssstylepropertyprivate.h" #include "gtkdroptarget.h" #include "gtkdragicon.h" #include "gtkdropcontrollermotion.h" #include "gtkeventcontrollermotion.h" #include "gtkgestureclick.h" #include "gtkgizmoprivate.h" #include "gtkbuiltiniconprivate.h" #include "gtkintl.h" #include "gtklabel.h" #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtkpopovermenuprivate.h" #include "gtkorientable.h" #include "gtksizerequest.h" #include "gtkstylecontextprivate.h" #include "gtkprivate.h" #include "gtkstack.h" #include "gtktypebuiltins.h" #include "gtkwidgetprivate.h" #include "gtkdragsource.h" #include "gtkwidgetpaintable.h" #include "gtknative.h" #include "a11y/gtknotebookaccessibleprivate.h" #include #include #include /** * SECTION:gtknotebook * @Short_description: A tabbed notebook container * @Title: GtkNotebook * @See_also: #GtkContainer * * The #GtkNotebook widget is a #GtkContainer whose children are pages that * can be switched between using tab labels along one edge. * * There are many configuration options for GtkNotebook. Among other * things, you can choose on which edge the tabs appear * (see gtk_notebook_set_tab_pos()), whether, if there are too many * tabs to fit the notebook should be made bigger or scrolling * arrows added (see gtk_notebook_set_scrollable()), and whether there * will be a popup menu allowing the users to switch pages. * (see gtk_notebook_popup_enable(), gtk_notebook_popup_disable()) * * # GtkNotebook as GtkBuildable * * The GtkNotebook implementation of the #GtkBuildable interface * supports placing children into tabs by specifying “tab” as the * “type” attribute of a element. Note that the content * of the tab must be created before the tab can be filled. * A tab child can be specified without specifying a * type attribute. * * To add a child widget in the notebooks action area, specify * "action-start" or “action-end” as the “type” attribute of the * element. * * An example of a UI definition fragment with GtkNotebook: * |[ * * * * Content * * * * * Tab * * * * ]| * * # CSS nodes * * |[ * notebook * ├── header.top * │ ├── [] * │ ├── tabs * │ │ ├── [arrow] * │ │ ├── tab * │ │ │ ╰── * ┊ ┊ ┊ * │ │ ├── tab[.reorderable-page] * │ │ │ ╰── * │ │ ╰── [arrow] * │ ╰── [] * │ * ╰── stack * ├── * ┊ * ╰── * ]| * * GtkNotebook has a main CSS node with name notebook, a subnode * with name header and below that a subnode with name tabs which * contains one subnode per tab with name tab. * * If action widgets are present, their CSS nodes are placed next * to the tabs node. If the notebook is scrollable, CSS nodes with * name arrow are placed as first and last child of the tabs node. * * The main node gets the .frame style class when the notebook * has a border (see gtk_notebook_set_show_border()). * * The header node gets one of the style class .top, .bottom, * .left or .right, depending on where the tabs are placed. For * reorderable pages, the tab node gets the .reorderable-page class. * * A tab node gets the .dnd style class while it is moved with drag-and-drop. * * The nodes are always arranged from left-to-right, regardless of text direction. */ #define SCROLL_DELAY_FACTOR 5 #define SCROLL_THRESHOLD 12 #define DND_THRESHOLD_MULTIPLIER 4 #define TIMEOUT_INITIAL 500 #define TIMEOUT_REPEAT 50 #define TIMEOUT_EXPAND 500 typedef struct _GtkNotebookPage GtkNotebookPage; typedef enum { DRAG_OPERATION_NONE, DRAG_OPERATION_REORDER, DRAG_OPERATION_DETACH } GtkNotebookDragOperation; enum { ACTION_WIDGET_START, ACTION_WIDGET_END, N_ACTION_WIDGETS }; #define GTK_NOTEBOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK, GtkNotebookClass)) #define GTK_NOTEBOOK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK, GtkNotebookClass)) typedef struct _GtkNotebookClass GtkNotebookClass; struct _GtkNotebookClass { GtkWidgetClass parent_class; void (* switch_page) (GtkNotebook *notebook, GtkWidget *page, guint page_num); /* Action signals for keybindings */ gboolean (* select_page) (GtkNotebook *notebook, gboolean move_focus); gboolean (* focus_tab) (GtkNotebook *notebook, GtkNotebookTab type); gboolean (* change_current_page) (GtkNotebook *notebook, gint offset); void (* move_focus_out) (GtkNotebook *notebook, GtkDirectionType direction); gboolean (* reorder_tab) (GtkNotebook *notebook, GtkDirectionType direction, gboolean move_to_last); /* More vfuncs */ gint (* insert_page) (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label, gint position); GtkNotebook * (* create_window) (GtkNotebook *notebook, GtkWidget *page); void (* page_reordered) (GtkNotebook *notebook, GtkWidget *child, guint page_num); void (* page_removed) (GtkNotebook *notebook, GtkWidget *child, guint page_num); void (* page_added) (GtkNotebook *notebook, GtkWidget *child, guint page_num); }; struct _GtkNotebook { GtkWidget container; GtkNotebookDragOperation operation; GtkNotebookPage *cur_page; GtkNotebookPage *detached_tab; GtkWidget *action_widget[N_ACTION_WIDGETS]; GtkWidget *menu; GtkWidget *menu_box; GtkWidget *stack_widget; GtkWidget *header_widget; GtkWidget *tabs_widget; GtkWidget *arrow_widget[4]; GListModel *pages; GList *children; GList *first_tab; /* The first tab visible (for scrolling notebooks) */ GList *focus_tab; gint drag_begin_x; gint drag_begin_y; gint drag_offset_x; gint drag_offset_y; gint drag_surface_x; gint drag_surface_y; gint mouse_x; gint mouse_y; gint pressed_button; GQuark group; guint dnd_timer; guint switch_page_timer; GtkNotebookPage *switch_page; guint32 timer; guint child_has_focus : 1; guint click_child : 3; guint remove_in_detach : 1; guint focus_out : 1; /* Flag used by ::move-focus-out implementation */ guint has_scrolled : 1; guint need_timer : 1; guint show_border : 1; guint show_tabs : 1; guint scrollable : 1; guint tab_pos : 2; guint rootwindow_drop : 1; }; enum { SWITCH_PAGE, FOCUS_TAB, SELECT_PAGE, CHANGE_CURRENT_PAGE, MOVE_FOCUS_OUT, REORDER_TAB, PAGE_REORDERED, PAGE_REMOVED, PAGE_ADDED, CREATE_WINDOW, LAST_SIGNAL }; enum { STEP_PREV, STEP_NEXT }; typedef enum { ARROW_LEFT_BEFORE, ARROW_RIGHT_BEFORE, ARROW_LEFT_AFTER, ARROW_RIGHT_AFTER, ARROW_NONE } GtkNotebookArrow; typedef enum { POINTER_BEFORE, POINTER_AFTER, POINTER_BETWEEN } GtkNotebookPointerPosition; #define ARROW_IS_LEFT(arrow) ((arrow) == ARROW_LEFT_BEFORE || (arrow) == ARROW_LEFT_AFTER) #define ARROW_IS_BEFORE(arrow) ((arrow) == ARROW_LEFT_BEFORE || (arrow) == ARROW_RIGHT_BEFORE) enum { PROP_0, PROP_TAB_POS, PROP_SHOW_TABS, PROP_SHOW_BORDER, PROP_SCROLLABLE, PROP_PAGE, PROP_ENABLE_POPUP, PROP_GROUP_NAME, PROP_PAGES, LAST_PROP }; static GParamSpec *properties[LAST_PROP]; enum { CHILD_PROP_0, CHILD_PROP_TAB_LABEL, CHILD_PROP_MENU_LABEL, CHILD_PROP_POSITION, CHILD_PROP_TAB_EXPAND, CHILD_PROP_TAB_FILL, CHILD_PROP_REORDERABLE, CHILD_PROP_DETACHABLE, CHILD_PROP_CHILD, CHILD_PROP_TAB, CHILD_PROP_MENU, }; #define GTK_NOTEBOOK_PAGE_FROM_LIST(_glist_) ((GtkNotebookPage *)(_glist_)->data) #define NOTEBOOK_IS_TAB_LABEL_PARENT(_notebook_,_page_) \ (g_object_get_data (G_OBJECT ((_page_)->tab_label), "notebook") == _notebook_) struct _GtkNotebookPage { GObject instance; GtkWidget *child; GtkWidget *tab_label; GtkWidget *menu_label; GtkWidget *last_focus_child; /* Last descendant of the page that had focus */ GtkWidget *tab_widget; /* widget used for the tab itself */ char *tab_text; char *menu_text; guint default_menu : 1; /* If true, we create the menu label ourself */ guint default_tab : 1; /* If true, we create the tab label ourself */ guint expand : 1; guint fill : 1; guint reorderable : 1; guint detachable : 1; GtkRequisition requisition; gulong mnemonic_activate_signal; gulong notify_visible_handler; }; typedef struct _GtkNotebookPageClass GtkNotebookPageClass; struct _GtkNotebookPageClass { GObjectClass parent_class; }; G_DEFINE_TYPE (GtkNotebookPage, gtk_notebook_page, G_TYPE_OBJECT) static void gtk_notebook_page_init (GtkNotebookPage *page) { page->default_tab = TRUE; page->default_menu = TRUE; page->fill = TRUE; } static void gtk_notebook_page_finalize (GObject *object) { GtkNotebookPage *page = GTK_NOTEBOOK_PAGE (object); g_clear_object (&page->child); g_clear_object (&page->tab_label); g_clear_object (&page->menu_label); g_free (page->tab_text); g_free (page->menu_text); G_OBJECT_CLASS (gtk_notebook_page_parent_class)->finalize (object); } static void gtk_notebook_page_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GtkNotebookPage *page = GTK_NOTEBOOK_PAGE (object); switch (property_id) { case CHILD_PROP_CHILD: g_set_object (&page->child, g_value_get_object (value)); break; case CHILD_PROP_TAB: g_set_object (&page->tab_label, g_value_get_object (value)); page->default_tab = page->tab_label == NULL; break; case CHILD_PROP_MENU: g_set_object (&page->menu_label, g_value_get_object (value)); page->default_menu = page->menu_label == NULL; break; case CHILD_PROP_TAB_LABEL: g_free (page->tab_text); page->tab_text = g_value_dup_string (value); if (page->default_tab && GTK_IS_LABEL (page->tab_label)) gtk_label_set_label (GTK_LABEL (page->tab_label), page->tab_text); break; case CHILD_PROP_MENU_LABEL: g_free (page->menu_text); page->menu_text = g_value_dup_string (value); if (page->default_menu && GTK_IS_LABEL (page->menu_label)) gtk_label_set_label (GTK_LABEL (page->menu_label), page->menu_text); break; case CHILD_PROP_POSITION: { GtkNotebook *notebook = NULL; if (page->tab_widget) notebook = GTK_NOTEBOOK (g_object_get_data (G_OBJECT (page->tab_widget), "notebook")); if (notebook) gtk_notebook_reorder_child (notebook, page->child, g_value_get_int (value)); } break; case CHILD_PROP_TAB_EXPAND: if (page->expand != g_value_get_boolean (value)) { page->expand = g_value_get_boolean (value); g_object_notify_by_pspec (object, pspec); } break; case CHILD_PROP_TAB_FILL: if (page->fill != g_value_get_boolean (value)) { page->fill = g_value_get_boolean (value); g_object_notify_by_pspec (object, pspec); } break; case CHILD_PROP_REORDERABLE: if (page->reorderable != g_value_get_boolean (value)) { page->reorderable = g_value_get_boolean (value); g_object_notify_by_pspec (object, pspec); } break; case CHILD_PROP_DETACHABLE: if (page->detachable != g_value_get_boolean (value)) { page->detachable = g_value_get_boolean (value); g_object_notify_by_pspec (object, pspec); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gtk_notebook_page_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GtkNotebookPage *page = GTK_NOTEBOOK_PAGE (object); switch (property_id) { case CHILD_PROP_CHILD: g_value_set_object (value, page->child); break; case CHILD_PROP_TAB: g_value_set_object (value, page->tab_label); break; case CHILD_PROP_MENU: g_value_set_object (value, page->menu_label); break; case CHILD_PROP_TAB_LABEL: g_value_set_string (value, page->tab_text); break; case CHILD_PROP_MENU_LABEL: g_value_set_string (value, page->menu_text); break; case CHILD_PROP_POSITION: { GtkNotebook *notebook = NULL; if (page->tab_widget) notebook = GTK_NOTEBOOK (g_object_get_data (G_OBJECT (page->tab_widget), "notebook")); if (notebook) g_value_set_int (value, g_list_index (notebook->children, page)); } break; case CHILD_PROP_TAB_EXPAND: g_value_set_boolean (value, page->expand); break; case CHILD_PROP_TAB_FILL: g_value_set_boolean (value, page->fill); break; case CHILD_PROP_REORDERABLE: g_value_set_boolean (value, page->reorderable); break; case CHILD_PROP_DETACHABLE: g_value_set_boolean (value, page->detachable); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gtk_notebook_page_class_init (GtkNotebookPageClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = gtk_notebook_page_finalize; object_class->get_property = gtk_notebook_page_get_property; object_class->set_property = gtk_notebook_page_set_property; g_object_class_install_property (object_class, CHILD_PROP_CHILD, g_param_spec_object ("child", P_("Child"), P_("The child for this page"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, CHILD_PROP_TAB, g_param_spec_object ("tab", P_("Tab"), P_("The tab widget for this page"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, CHILD_PROP_MENU, g_param_spec_object ("menu", P_("Menu"), P_("The label widget displayed in the child’s menu entry"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, CHILD_PROP_TAB_LABEL, g_param_spec_string ("tab-label", P_("Tab label"), P_("The text of the tab widget"), NULL, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, CHILD_PROP_MENU_LABEL, g_param_spec_string ("menu-label", P_("Menu label"), P_("The text of the menu widget"), NULL, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, CHILD_PROP_POSITION, g_param_spec_int ("position", P_("Position"), P_("The index of the child in the parent"), -1, G_MAXINT, 0, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, CHILD_PROP_TAB_EXPAND, g_param_spec_boolean ("tab-expand", P_("Tab expand"), P_("Whether to expand the child’s tab"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, CHILD_PROP_TAB_FILL, g_param_spec_boolean ("tab-fill", P_("Tab fill"), P_("Whether the child’s tab should fill the allocated area"), TRUE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, CHILD_PROP_REORDERABLE, g_param_spec_boolean ("reorderable", P_("Tab reorderable"), P_("Whether the tab is reorderable by user action"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, CHILD_PROP_DETACHABLE, g_param_spec_boolean ("detachable", P_("Tab detachable"), P_("Whether the tab is detachable"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); } #define GTK_TYPE_NOTEBOOK_ROOT_CONTENT (gtk_notebook_root_content_get_type ()) #define GTK_NOTEBOOK_ROOT_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_ROOT_CONTENT, GtkNotebookRootContent)) #define GTK_IS_NOTEBOOK_ROOT_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_ROOT_CONTENT)) typedef struct _GtkNotebookRootContent GtkNotebookRootContent; typedef struct _GtkNotebookRootContentClass GtkNotebookRootContentClass; struct _GtkNotebookRootContent { GdkContentProvider parent_instance; GtkNotebook *notebook; }; struct _GtkNotebookRootContentClass { GdkContentProviderClass parent_class; }; static GdkContentFormats * gtk_notebook_root_content_ref_formats (GdkContentProvider *provider) { return gdk_content_formats_new ((const char *[1]) { "application/x-rootwindow-drop" }, 1); } GType gtk_notebook_root_content_get_type (void); G_DEFINE_TYPE (GtkNotebookRootContent, gtk_notebook_root_content, GDK_TYPE_CONTENT_PROVIDER) static void gtk_notebook_root_content_write_mime_type_async (GdkContentProvider *provider, const char *mime_type, GOutputStream *stream, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GtkNotebookRootContent *self = GTK_NOTEBOOK_ROOT_CONTENT (provider); GTask *task; self->notebook->rootwindow_drop = TRUE; task = g_task_new (self, cancellable, callback, user_data); g_task_set_priority (task, io_priority); g_task_set_source_tag (task, gtk_notebook_root_content_write_mime_type_async); g_task_return_boolean (task, TRUE); g_object_unref (task); } static gboolean gtk_notebook_root_content_write_mime_type_finish (GdkContentProvider *provider, GAsyncResult *result, GError **error) { return g_task_propagate_boolean (G_TASK (result), error); } static void gtk_notebook_root_content_finalize (GObject *object) { GtkNotebookRootContent *self = GTK_NOTEBOOK_ROOT_CONTENT (object); g_object_unref (self->notebook); G_OBJECT_CLASS (gtk_notebook_root_content_parent_class)->finalize (object); } static void gtk_notebook_root_content_class_init (GtkNotebookRootContentClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); GdkContentProviderClass *provider_class = GDK_CONTENT_PROVIDER_CLASS (class); object_class->finalize = gtk_notebook_root_content_finalize; provider_class->ref_formats = gtk_notebook_root_content_ref_formats; provider_class->write_mime_type_async = gtk_notebook_root_content_write_mime_type_async; provider_class->write_mime_type_finish = gtk_notebook_root_content_write_mime_type_finish; } static void gtk_notebook_root_content_init (GtkNotebookRootContent *self) { } static GdkContentProvider * gtk_notebook_root_content_new (GtkNotebook *notebook) { GtkNotebookRootContent *result; result = g_object_new (GTK_TYPE_NOTEBOOK_ROOT_CONTENT, NULL); result->notebook = g_object_ref (notebook); return GDK_CONTENT_PROVIDER (result); } /*** GtkNotebook Methods ***/ static gboolean gtk_notebook_select_page (GtkNotebook *notebook, gboolean move_focus); static gboolean gtk_notebook_focus_tab (GtkNotebook *notebook, GtkNotebookTab type); static gboolean gtk_notebook_change_current_page (GtkNotebook *notebook, gint offset); static void gtk_notebook_move_focus_out (GtkNotebook *notebook, GtkDirectionType direction_type); static gboolean gtk_notebook_reorder_tab (GtkNotebook *notebook, GtkDirectionType direction_type, gboolean move_to_last); static void gtk_notebook_remove_tab_label (GtkNotebook *notebook, GtkNotebookPage *page); /*** GObject Methods ***/ static void gtk_notebook_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void gtk_notebook_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void gtk_notebook_finalize (GObject *object); static void gtk_notebook_dispose (GObject *object); /*** GtkWidget Methods ***/ static void gtk_notebook_unmap (GtkWidget *widget); static void gtk_notebook_popup_menu (GtkWidget *widget, const char *action_name, GVariant *parameters); static void gtk_notebook_motion (GtkEventController *controller, double x, double y, gpointer user_data); static void gtk_notebook_state_flags_changed (GtkWidget *widget, GtkStateFlags previous_state); static void gtk_notebook_direction_changed (GtkWidget *widget, GtkTextDirection previous_direction); static gboolean gtk_notebook_focus (GtkWidget *widget, GtkDirectionType direction); static gboolean gtk_notebook_grab_focus (GtkWidget *widget); static void gtk_notebook_set_focus_child (GtkWidget *widget, GtkWidget *child); /*** Drag and drop Methods ***/ static void gtk_notebook_dnd_finished_cb (GdkDrag *drag, GtkWidget *widget); static void gtk_notebook_drag_cancel_cb (GdkDrag *drag, GdkDragCancelReason reason, GtkWidget *widget); static GdkDragAction gtk_notebook_drag_motion(GtkDropTarget *dest, double x, double y, GtkNotebook *notebook); static gboolean gtk_notebook_drag_drop (GtkDropTarget *dest, const GValue *value, double x, double y, GtkNotebook *notebook); static void gtk_notebook_remove (GtkNotebook *notebook, GtkWidget *widget); /*** GtkNotebook Methods ***/ static gint gtk_notebook_real_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label, gint position); static GtkNotebook *gtk_notebook_create_window (GtkNotebook *notebook, GtkWidget *page); static void gtk_notebook_measure_tabs (GtkGizmo *gizmo, GtkOrientation orientation, gint for_size, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline); static void gtk_notebook_allocate_tabs (GtkGizmo *gizmo, int width, int height, int baseline); static void gtk_notebook_snapshot_tabs (GtkGizmo *gizmo, GtkSnapshot *snapshot); /*** GtkNotebook Private Functions ***/ static void gtk_notebook_real_remove (GtkNotebook *notebook, GList *list); static void gtk_notebook_update_labels (GtkNotebook *notebook); static gint gtk_notebook_timer (GtkNotebook *notebook); static void gtk_notebook_set_scroll_timer (GtkNotebook *notebook); static gint gtk_notebook_page_compare (gconstpointer a, gconstpointer b); static GList* gtk_notebook_find_child (GtkNotebook *notebook, GtkWidget *child); static GList * gtk_notebook_search_page (GtkNotebook *notebook, GList *list, gint direction, gboolean find_visible); static void gtk_notebook_child_reordered (GtkNotebook *notebook, GtkNotebookPage *page); static gint gtk_notebook_insert_notebook_page (GtkNotebook *notebook, GtkNotebookPage *page, int position); /*** GtkNotebook Size Allocate Functions ***/ static void gtk_notebook_pages_allocate (GtkNotebook *notebook, int width, int height); static void gtk_notebook_calc_tabs (GtkNotebook *notebook, GList *start, GList **end, gint *tab_space, guint direction); /*** GtkNotebook Page Switch Methods ***/ static void gtk_notebook_real_switch_page (GtkNotebook *notebook, GtkWidget *child, guint page_num); /*** GtkNotebook Page Switch Functions ***/ static void gtk_notebook_switch_page (GtkNotebook *notebook, GtkNotebookPage *page); static gint gtk_notebook_page_select (GtkNotebook *notebook, gboolean move_focus); static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook, GList *new_child); static void gtk_notebook_menu_switch_page (GtkWidget *widget, GtkNotebookPage *page); /*** GtkNotebook Menu Functions ***/ static void gtk_notebook_menu_item_create (GtkNotebook *notebook, GtkNotebookPage *page); static void gtk_notebook_menu_item_recreate (GtkNotebook *notebook, GList *list); static void gtk_notebook_menu_label_unparent (GtkWidget *widget); static void gtk_notebook_update_tab_pos (GtkNotebook *notebook); /*** GtkNotebook Private Setters ***/ static gboolean gtk_notebook_mnemonic_activate_switch_page (GtkWidget *child, gboolean overload, gpointer data); static gboolean focus_tabs_in (GtkNotebook *notebook); static gboolean focus_child_in (GtkNotebook *notebook, GtkDirectionType direction); static void stop_scrolling (GtkNotebook *notebook); static void do_detach_tab (GtkNotebook *from, GtkNotebook *to, GtkWidget *child); /* GtkBuildable */ static void gtk_notebook_buildable_init (GtkBuildableIface *iface); static void gtk_notebook_buildable_add_child (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *type); static void gtk_notebook_gesture_pressed (GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data); static void gtk_notebook_gesture_released (GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data); static void gtk_notebook_gesture_cancel (GtkGestureClick *gesture, GdkEventSequence *sequence, GtkNotebook *notebook); static guint notebook_signals[LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE_WITH_CODE (GtkNotebook, gtk_notebook, GTK_TYPE_WIDGET, G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, gtk_notebook_buildable_init)) static void add_tab_bindings (GtkWidgetClass *widget_class, GdkModifierType modifiers, GtkDirectionType direction) { gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Tab, modifiers, "move_focus_out", "(i)", direction); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Tab, modifiers, "move_focus_out", "(i)", direction); } static void add_arrow_bindings (GtkWidgetClass *widget_class, guint keysym, GtkDirectionType direction) { guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left; gtk_widget_class_add_binding_signal (widget_class, keysym, GDK_CONTROL_MASK, "move_focus_out", "(i)", direction); gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, GDK_CONTROL_MASK, "move_focus_out", "(i)", direction); } static void add_reorder_bindings (GtkWidgetClass *widget_class, guint keysym, GtkDirectionType direction, gboolean move_to_last) { guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left; gtk_widget_class_add_binding_signal (widget_class, keysym, GDK_ALT_MASK, "reorder_tab", "(ib)", direction, move_to_last); gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, GDK_ALT_MASK, "reorder_tab", "(ib)", direction, move_to_last); } static gboolean gtk_object_handled_accumulator (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer dummy) { gboolean continue_emission; GObject *object; object = g_value_get_object (handler_return); g_value_set_object (return_accu, object); continue_emission = !object; return continue_emission; } static void gtk_notebook_compute_expand (GtkWidget *widget, gboolean *hexpand_p, gboolean *vexpand_p) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); gboolean hexpand; gboolean vexpand; GList *list; GtkNotebookPage *page; hexpand = FALSE; vexpand = FALSE; for (list = notebook->children; list; list = list->next) { page = list->data; hexpand = hexpand || gtk_widget_compute_expand (page->child, GTK_ORIENTATION_HORIZONTAL); vexpand = vexpand || gtk_widget_compute_expand (page->child, GTK_ORIENTATION_VERTICAL); if (hexpand & vexpand) break; } *hexpand_p = hexpand; *vexpand_p = vexpand; } static void gtk_notebook_class_init (GtkNotebookClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); gobject_class->set_property = gtk_notebook_set_property; gobject_class->get_property = gtk_notebook_get_property; gobject_class->finalize = gtk_notebook_finalize; gobject_class->dispose = gtk_notebook_dispose; widget_class->unmap = gtk_notebook_unmap; widget_class->state_flags_changed = gtk_notebook_state_flags_changed; widget_class->direction_changed = gtk_notebook_direction_changed; widget_class->focus = gtk_notebook_focus; widget_class->grab_focus = gtk_notebook_grab_focus; widget_class->set_focus_child = gtk_notebook_set_focus_child; widget_class->compute_expand = gtk_notebook_compute_expand; class->switch_page = gtk_notebook_real_switch_page; class->insert_page = gtk_notebook_real_insert_page; class->focus_tab = gtk_notebook_focus_tab; class->select_page = gtk_notebook_select_page; class->change_current_page = gtk_notebook_change_current_page; class->move_focus_out = gtk_notebook_move_focus_out; class->reorder_tab = gtk_notebook_reorder_tab; class->create_window = gtk_notebook_create_window; properties[PROP_PAGE] = g_param_spec_int ("page", P_("Page"), P_("The index of the current page"), -1, G_MAXINT, -1, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_TAB_POS] = g_param_spec_enum ("tab-pos", P_("Tab Position"), P_("Which side of the notebook holds the tabs"), GTK_TYPE_POSITION_TYPE, GTK_POS_TOP, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_SHOW_TABS] = g_param_spec_boolean ("show-tabs", P_("Show Tabs"), P_("Whether tabs should be shown"), TRUE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_SHOW_BORDER] = g_param_spec_boolean ("show-border", P_("Show Border"), P_("Whether the border should be shown"), TRUE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_SCROLLABLE] = g_param_spec_boolean ("scrollable", P_("Scrollable"), P_("If TRUE, scroll arrows are added if there are too many tabs to fit"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_ENABLE_POPUP] = g_param_spec_boolean ("enable-popup", P_("Enable Popup"), P_("If TRUE, pressing the right mouse button on the notebook pops up a menu that you can use to go to a page"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); /** * GtkNotebook:group-name: * * Group name for tab drag and drop. */ properties[PROP_GROUP_NAME] = g_param_spec_string ("group-name", P_("Group Name"), P_("Group name for tab drag and drop"), NULL, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); properties[PROP_PAGES] = g_param_spec_object ("pages", P_("Pages"), P_("The pages of the notebook."), G_TYPE_LIST_MODEL, GTK_PARAM_READABLE); g_object_class_install_properties (gobject_class, LAST_PROP, properties); /** * GtkNotebook::switch-page: * @notebook: the object which received the signal. * @page: the new current page * @page_num: the index of the page * * Emitted when the user or a function changes the current page. */ notebook_signals[SWITCH_PAGE] = g_signal_new (I_("switch-page"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkNotebookClass, switch_page), NULL, NULL, _gtk_marshal_VOID__OBJECT_UINT, G_TYPE_NONE, 2, GTK_TYPE_WIDGET, G_TYPE_UINT); g_signal_set_va_marshaller (notebook_signals[SWITCH_PAGE], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_VOID__OBJECT_UINTv); notebook_signals[FOCUS_TAB] = g_signal_new (I_("focus-tab"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkNotebookClass, focus_tab), NULL, NULL, _gtk_marshal_BOOLEAN__ENUM, G_TYPE_BOOLEAN, 1, GTK_TYPE_NOTEBOOK_TAB); g_signal_set_va_marshaller (notebook_signals[FOCUS_TAB], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_BOOLEAN__ENUMv); notebook_signals[SELECT_PAGE] = g_signal_new (I_("select-page"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkNotebookClass, select_page), NULL, NULL, _gtk_marshal_BOOLEAN__BOOLEAN, G_TYPE_BOOLEAN, 1, G_TYPE_BOOLEAN); g_signal_set_va_marshaller (notebook_signals[SELECT_PAGE], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_BOOLEAN__BOOLEANv); notebook_signals[CHANGE_CURRENT_PAGE] = g_signal_new (I_("change-current-page"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkNotebookClass, change_current_page), NULL, NULL, _gtk_marshal_BOOLEAN__INT, G_TYPE_BOOLEAN, 1, G_TYPE_INT); g_signal_set_va_marshaller (notebook_signals[CHANGE_CURRENT_PAGE], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_BOOLEAN__INTv); notebook_signals[MOVE_FOCUS_OUT] = g_signal_new (I_("move-focus-out"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkNotebookClass, move_focus_out), NULL, NULL, NULL, G_TYPE_NONE, 1, GTK_TYPE_DIRECTION_TYPE); notebook_signals[REORDER_TAB] = g_signal_new (I_("reorder-tab"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkNotebookClass, reorder_tab), NULL, NULL, _gtk_marshal_BOOLEAN__ENUM_BOOLEAN, G_TYPE_BOOLEAN, 2, GTK_TYPE_DIRECTION_TYPE, G_TYPE_BOOLEAN); g_signal_set_va_marshaller (notebook_signals[REORDER_TAB], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_BOOLEAN__ENUM_BOOLEANv); /** * GtkNotebook::page-reordered: * @notebook: the #GtkNotebook * @child: the child #GtkWidget affected * @page_num: the new page number for @child * * the ::page-reordered signal is emitted in the notebook * right after a page has been reordered. */ notebook_signals[PAGE_REORDERED] = g_signal_new (I_("page-reordered"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkNotebookClass, page_reordered), NULL, NULL, _gtk_marshal_VOID__OBJECT_UINT, G_TYPE_NONE, 2, GTK_TYPE_WIDGET, G_TYPE_UINT); g_signal_set_va_marshaller (notebook_signals[PAGE_REORDERED], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_VOID__OBJECT_UINTv); /** * GtkNotebook::page-removed: * @notebook: the #GtkNotebook * @child: the child #GtkWidget affected * @page_num: the @child page number * * the ::page-removed signal is emitted in the notebook * right after a page is removed from the notebook. */ notebook_signals[PAGE_REMOVED] = g_signal_new (I_("page-removed"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkNotebookClass, page_removed), NULL, NULL, _gtk_marshal_VOID__OBJECT_UINT, G_TYPE_NONE, 2, GTK_TYPE_WIDGET, G_TYPE_UINT); g_signal_set_va_marshaller (notebook_signals[PAGE_REMOVED], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_VOID__OBJECT_UINTv); /** * GtkNotebook::page-added: * @notebook: the #GtkNotebook * @child: the child #GtkWidget affected * @page_num: the new page number for @child * * the ::page-added signal is emitted in the notebook * right after a page is added to the notebook. */ notebook_signals[PAGE_ADDED] = g_signal_new (I_("page-added"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkNotebookClass, page_added), NULL, NULL, _gtk_marshal_VOID__OBJECT_UINT, G_TYPE_NONE, 2, GTK_TYPE_WIDGET, G_TYPE_UINT); g_signal_set_va_marshaller (notebook_signals[PAGE_ADDED], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_VOID__OBJECT_UINTv); /** * GtkNotebook::create-window: * @notebook: the #GtkNotebook emitting the signal * @page: the tab of @notebook that is being detached * * The ::create-window signal is emitted when a detachable * tab is dropped on the root window. * * A handler for this signal can create a window containing * a notebook where the tab will be attached. It is also * responsible for moving/resizing the window and adding the * necessary properties to the notebook (e.g. the * #GtkNotebook:group-name ). * * Returns: (transfer none): a #GtkNotebook that @page should be * added to, or %NULL. */ notebook_signals[CREATE_WINDOW] = g_signal_new (I_("create-window"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkNotebookClass, create_window), gtk_object_handled_accumulator, NULL, _gtk_marshal_OBJECT__OBJECT, GTK_TYPE_NOTEBOOK, 1, GTK_TYPE_WIDGET); g_signal_set_va_marshaller (notebook_signals[CREATE_WINDOW], G_TYPE_FROM_CLASS (gobject_class), _gtk_marshal_OBJECT__OBJECTv); /** * GtkNotebook|menu.popup: * * Opens the context menu. */ gtk_widget_class_install_action (widget_class, "menu.popup", NULL, gtk_notebook_popup_menu); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_space, 0, "select-page", "(b)", FALSE); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Space, 0, "select-page", "(b)", FALSE); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Home, 0, "focus-tab", "(i)", GTK_NOTEBOOK_TAB_FIRST); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Home, 0, "focus-tab", "(i)", GTK_NOTEBOOK_TAB_FIRST); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_End, 0, "focus-tab", "(i)", GTK_NOTEBOOK_TAB_LAST); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_End, 0, "focus-tab", "(i)", GTK_NOTEBOOK_TAB_LAST); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_F10, GDK_SHIFT_MASK, "menu.popup", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Menu, 0, "menu.popup", NULL); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Page_Up, GDK_CONTROL_MASK, "change-current-page", "(i)", -1); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Page_Down, GDK_CONTROL_MASK, "change-current-page", "(i)", 1); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Page_Up, GDK_CONTROL_MASK | GDK_ALT_MASK, "change-current-page", "(i)", -1); gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Page_Down, GDK_CONTROL_MASK | GDK_ALT_MASK, "change-current-page", "(i)", 1); add_arrow_bindings (widget_class, GDK_KEY_Up, GTK_DIR_UP); add_arrow_bindings (widget_class, GDK_KEY_Down, GTK_DIR_DOWN); add_arrow_bindings (widget_class, GDK_KEY_Left, GTK_DIR_LEFT); add_arrow_bindings (widget_class, GDK_KEY_Right, GTK_DIR_RIGHT); add_reorder_bindings (widget_class, GDK_KEY_Up, GTK_DIR_UP, FALSE); add_reorder_bindings (widget_class, GDK_KEY_Down, GTK_DIR_DOWN, FALSE); add_reorder_bindings (widget_class, GDK_KEY_Left, GTK_DIR_LEFT, FALSE); add_reorder_bindings (widget_class, GDK_KEY_Right, GTK_DIR_RIGHT, FALSE); add_reorder_bindings (widget_class, GDK_KEY_Home, GTK_DIR_LEFT, TRUE); add_reorder_bindings (widget_class, GDK_KEY_Home, GTK_DIR_UP, TRUE); add_reorder_bindings (widget_class, GDK_KEY_End, GTK_DIR_RIGHT, TRUE); add_reorder_bindings (widget_class, GDK_KEY_End, GTK_DIR_DOWN, TRUE); add_tab_bindings (widget_class, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD); add_tab_bindings (widget_class, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD); gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_NOTEBOOK_ACCESSIBLE); gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT); gtk_widget_class_set_css_name (widget_class, I_("notebook")); } static void gtk_notebook_init (GtkNotebook *notebook) { GtkEventController *controller; GtkGesture *gesture; GtkLayoutManager *layout; GtkDropTarget *dest; notebook->cur_page = NULL; notebook->children = NULL; notebook->first_tab = NULL; notebook->focus_tab = NULL; notebook->menu = NULL; notebook->show_tabs = TRUE; notebook->show_border = TRUE; notebook->tab_pos = GTK_POS_TOP; notebook->scrollable = FALSE; notebook->click_child = ARROW_NONE; notebook->need_timer = 0; notebook->child_has_focus = FALSE; notebook->focus_out = FALSE; notebook->group = 0; notebook->pressed_button = 0; notebook->dnd_timer = 0; notebook->operation = DRAG_OPERATION_NONE; notebook->detached_tab = NULL; notebook->has_scrolled = FALSE; gtk_widget_set_focusable (GTK_WIDGET (notebook), TRUE); notebook->header_widget = g_object_new (GTK_TYPE_BOX, "css-name", "header", NULL); gtk_widget_add_css_class (notebook->header_widget, GTK_STYLE_CLASS_TOP); gtk_widget_hide (notebook->header_widget); gtk_widget_set_parent (notebook->header_widget, GTK_WIDGET (notebook)); notebook->tabs_widget = gtk_gizmo_new ("tabs", gtk_notebook_measure_tabs, gtk_notebook_allocate_tabs, gtk_notebook_snapshot_tabs, NULL, (GtkGizmoFocusFunc)gtk_widget_focus_self, (GtkGizmoGrabFocusFunc)gtk_widget_grab_focus_self); gtk_widget_set_hexpand (notebook->tabs_widget, TRUE); gtk_box_append (GTK_BOX (notebook->header_widget), notebook->tabs_widget); notebook->stack_widget = gtk_stack_new (); gtk_widget_set_hexpand (notebook->stack_widget, TRUE); gtk_widget_set_vexpand (notebook->stack_widget, TRUE); gtk_widget_set_parent (notebook->stack_widget, GTK_WIDGET (notebook)); dest = gtk_drop_target_new (GTK_TYPE_NOTEBOOK_PAGE, GDK_ACTION_MOVE); gtk_drop_target_set_preload (dest, TRUE); g_signal_connect (dest, "motion", G_CALLBACK (gtk_notebook_drag_motion), notebook); g_signal_connect (dest, "drop", G_CALLBACK (gtk_notebook_drag_drop), notebook); gtk_widget_add_controller (GTK_WIDGET (notebook->tabs_widget), GTK_EVENT_CONTROLLER (dest)); gesture = gtk_gesture_click_new (); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0); gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_CAPTURE); g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_notebook_gesture_pressed), notebook); g_signal_connect (gesture, "released", G_CALLBACK (gtk_notebook_gesture_released), notebook); g_signal_connect (gesture, "cancel", G_CALLBACK (gtk_notebook_gesture_cancel), notebook); gtk_widget_add_controller (GTK_WIDGET (notebook), GTK_EVENT_CONTROLLER (gesture)); controller = gtk_event_controller_motion_new (); g_signal_connect (controller, "motion", G_CALLBACK (gtk_notebook_motion), notebook); gtk_widget_add_controller (GTK_WIDGET (notebook), controller); gtk_widget_add_css_class (GTK_WIDGET (notebook), GTK_STYLE_CLASS_FRAME); layout = gtk_widget_get_layout_manager (GTK_WIDGET (notebook)); gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_VERTICAL); } static GtkBuildableIface *parent_buildable_iface; static void gtk_notebook_buildable_init (GtkBuildableIface *iface) { parent_buildable_iface = g_type_interface_peek_parent (iface); iface->add_child = gtk_notebook_buildable_add_child; } static void gtk_notebook_buildable_add_child (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, const gchar *type) { GtkNotebook *notebook = GTK_NOTEBOOK (buildable); if (GTK_IS_NOTEBOOK_PAGE (child)) { gtk_notebook_insert_notebook_page (notebook, GTK_NOTEBOOK_PAGE (child), -1); } else if (GTK_IS_WIDGET (child)) { if (type && strcmp (type, "tab") == 0) { GtkWidget * page; page = gtk_notebook_get_nth_page (notebook, -1); /* To set the tab label widget, we must have already a child * inside the tab container. */ g_assert (page != NULL); /* warn when Glade tries to overwrite label */ if (gtk_notebook_get_tab_label (notebook, page)) g_warning ("Overriding tab label for notebook"); gtk_notebook_set_tab_label (notebook, page, GTK_WIDGET (child)); } else if (type && strcmp (type, "action-start") == 0) { gtk_notebook_set_action_widget (notebook, GTK_WIDGET (child), GTK_PACK_START); } else if (type && strcmp (type, "action-end") == 0) { gtk_notebook_set_action_widget (notebook, GTK_WIDGET (child), GTK_PACK_END); } else if (!type) gtk_notebook_append_page (notebook, GTK_WIDGET (child), NULL); else GTK_BUILDER_WARN_INVALID_CHILD_TYPE (notebook, type); } else { parent_buildable_iface->add_child (buildable, builder, child, type); } } static gboolean gtk_notebook_has_current_page (GtkNotebook *notebook) { return notebook->cur_page && gtk_widget_get_visible (notebook->cur_page->child); } static gboolean gtk_notebook_select_page (GtkNotebook *notebook, gboolean move_focus) { if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && notebook->show_tabs) { gtk_notebook_page_select (notebook, move_focus); return TRUE; } else return FALSE; } static gboolean gtk_notebook_focus_tab (GtkNotebook *notebook, GtkNotebookTab type) { GList *list; if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && notebook->show_tabs) { switch (type) { case GTK_NOTEBOOK_TAB_FIRST: list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE); if (list) gtk_notebook_switch_focus_tab (notebook, list); break; case GTK_NOTEBOOK_TAB_LAST: list = gtk_notebook_search_page (notebook, NULL, STEP_PREV, TRUE); if (list) gtk_notebook_switch_focus_tab (notebook, list); break; default: break; } return TRUE; } else return FALSE; } static gboolean gtk_notebook_change_current_page (GtkNotebook *notebook, gint offset) { GList *current = NULL; if (!notebook->show_tabs) return FALSE; if (notebook->cur_page) current = g_list_find (notebook->children, notebook->cur_page); while (offset != 0) { current = gtk_notebook_search_page (notebook, current, offset < 0 ? STEP_PREV : STEP_NEXT, TRUE); if (!current) { current = gtk_notebook_search_page (notebook, NULL, offset < 0 ? STEP_PREV : STEP_NEXT, TRUE); } offset += offset < 0 ? 1 : -1; } if (current) gtk_notebook_switch_page (notebook, current->data); else gtk_widget_error_bell (GTK_WIDGET (notebook)); return TRUE; } static GtkDirectionType get_effective_direction (GtkNotebook *notebook, GtkDirectionType direction) { /* Remap the directions into the effective direction it would be for a * GTK_POS_TOP notebook */ #define D(rest) GTK_DIR_##rest static const GtkDirectionType translate_direction[2][4][6] = { /* LEFT */ {{ D(TAB_FORWARD), D(TAB_BACKWARD), D(LEFT), D(RIGHT), D(UP), D(DOWN) }, /* RIGHT */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(LEFT), D(RIGHT), D(DOWN), D(UP) }, /* TOP */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(UP), D(DOWN), D(LEFT), D(RIGHT) }, /* BOTTOM */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(DOWN), D(UP), D(LEFT), D(RIGHT) }}, /* LEFT */ {{ D(TAB_BACKWARD), D(TAB_FORWARD), D(LEFT), D(RIGHT), D(DOWN), D(UP) }, /* RIGHT */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(LEFT), D(RIGHT), D(UP), D(DOWN) }, /* TOP */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(UP), D(DOWN), D(RIGHT), D(LEFT) }, /* BOTTOM */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(DOWN), D(UP), D(RIGHT), D(LEFT) }}, }; #undef D int text_dir = gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL ? 1 : 0; return translate_direction[text_dir][notebook->tab_pos][direction]; } static GtkPositionType get_effective_tab_pos (GtkNotebook *notebook) { if (gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL) { switch (notebook->tab_pos) { case GTK_POS_LEFT: return GTK_POS_RIGHT; case GTK_POS_RIGHT: return GTK_POS_LEFT; default: ; } } return notebook->tab_pos; } static void gtk_notebook_move_focus_out (GtkNotebook *notebook, GtkDirectionType direction_type) { GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type); GtkWidget *toplevel; if (gtk_widget_get_focus_child (GTK_WIDGET (notebook)) && effective_direction == GTK_DIR_UP) if (focus_tabs_in (notebook)) return; if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && effective_direction == GTK_DIR_DOWN) if (focus_child_in (notebook, GTK_DIR_TAB_FORWARD)) return; /* At this point, we know we should be focusing out of the notebook entirely. We * do this by setting a flag, then propagating the focus motion to the notebook. */ toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (notebook))); if (!GTK_IS_ROOT (toplevel)) return; g_object_ref (notebook); notebook->focus_out = TRUE; g_signal_emit_by_name (toplevel, "move-focus", direction_type); notebook->focus_out = FALSE; g_object_unref (notebook); } static gint reorder_tab (GtkNotebook *notebook, GList *position, GList *tab) { GList *elem; if (position == tab) return g_list_position (notebook->children, tab); /* check that we aren't inserting the tab in the * same relative position, taking packing into account */ elem = (position) ? position->prev : g_list_last (notebook->children); if (elem == tab) return g_list_position (notebook->children, tab); /* now actually reorder the tab */ if (notebook->first_tab == tab) notebook->first_tab = gtk_notebook_search_page (notebook, notebook->first_tab, STEP_NEXT, TRUE); notebook->children = g_list_remove_link (notebook->children, tab); if (!position) elem = g_list_last (notebook->children); else { elem = position->prev; position->prev = tab; } if (elem) elem->next = tab; else notebook->children = tab; tab->prev = elem; tab->next = position; return g_list_position (notebook->children, tab); } static gboolean gtk_notebook_reorder_tab (GtkNotebook *notebook, GtkDirectionType direction_type, gboolean move_to_last) { GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type); GList *last, *child, *element; gint page_num, old_page_num, i; if (!gtk_widget_is_focus (GTK_WIDGET (notebook)) || !notebook->show_tabs) return FALSE; if (!gtk_notebook_has_current_page (notebook) || !notebook->cur_page->reorderable) return FALSE; if (effective_direction != GTK_DIR_LEFT && effective_direction != GTK_DIR_RIGHT) return FALSE; if (move_to_last) { child = notebook->focus_tab; do { last = child; child = gtk_notebook_search_page (notebook, last, (effective_direction == GTK_DIR_RIGHT) ? STEP_NEXT : STEP_PREV, TRUE); } while (child); child = last; } else child = gtk_notebook_search_page (notebook, notebook->focus_tab, (effective_direction == GTK_DIR_RIGHT) ? STEP_NEXT : STEP_PREV, TRUE); if (!child || child->data == notebook->cur_page) return FALSE; old_page_num = g_list_position (notebook->children, notebook->focus_tab); if (effective_direction == GTK_DIR_RIGHT) page_num = reorder_tab (notebook, child->next, notebook->focus_tab); else page_num = reorder_tab (notebook, child, notebook->focus_tab); gtk_notebook_child_reordered (notebook, notebook->focus_tab->data); for (element = notebook->children, i = 0; element; element = element->next, i++) { if (MIN (old_page_num, page_num) <= i && i <= MAX (old_page_num, page_num)) g_object_notify (G_OBJECT (element->data), "position"); } g_signal_emit (notebook, notebook_signals[PAGE_REORDERED], 0, ((GtkNotebookPage *) notebook->focus_tab->data)->child, page_num); return TRUE; } /** * gtk_notebook_new: * * Creates a new #GtkNotebook widget with no pages. * Returns: the newly created #GtkNotebook */ GtkWidget* gtk_notebook_new (void) { return g_object_new (GTK_TYPE_NOTEBOOK, NULL); } /* Private GObject Methods : * * gtk_notebook_set_property * gtk_notebook_get_property */ static void gtk_notebook_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkNotebook *notebook; notebook = GTK_NOTEBOOK (object); switch (prop_id) { case PROP_SHOW_TABS: gtk_notebook_set_show_tabs (notebook, g_value_get_boolean (value)); break; case PROP_SHOW_BORDER: gtk_notebook_set_show_border (notebook, g_value_get_boolean (value)); break; case PROP_SCROLLABLE: gtk_notebook_set_scrollable (notebook, g_value_get_boolean (value)); break; case PROP_ENABLE_POPUP: if (g_value_get_boolean (value)) gtk_notebook_popup_enable (notebook); else gtk_notebook_popup_disable (notebook); break; case PROP_PAGE: gtk_notebook_set_current_page (notebook, g_value_get_int (value)); break; case PROP_TAB_POS: gtk_notebook_set_tab_pos (notebook, g_value_get_enum (value)); break; case PROP_GROUP_NAME: gtk_notebook_set_group_name (notebook, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gtk_notebook_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GtkNotebook *notebook = GTK_NOTEBOOK (object); switch (prop_id) { case PROP_SHOW_TABS: g_value_set_boolean (value, notebook->show_tabs); break; case PROP_SHOW_BORDER: g_value_set_boolean (value, notebook->show_border); break; case PROP_SCROLLABLE: g_value_set_boolean (value, notebook->scrollable); break; case PROP_ENABLE_POPUP: g_value_set_boolean (value, notebook->menu != NULL); break; case PROP_PAGE: g_value_set_int (value, gtk_notebook_get_current_page (notebook)); break; case PROP_TAB_POS: g_value_set_enum (value, notebook->tab_pos); break; case PROP_GROUP_NAME: g_value_set_string (value, gtk_notebook_get_group_name (notebook)); break; case PROP_PAGES: g_value_set_object (value, gtk_notebook_get_pages (notebook)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } /* Private GtkWidget Methods : * * gtk_notebook_map * gtk_notebook_unmap * gtk_notebook_snapshot * gtk_notebook_popup_menu * gtk_notebook_drag_begin * gtk_notebook_drag_end * gtk_notebook_drag_failed * gtk_notebook_drag_motion * gtk_notebook_drag_drop * gtk_notebook_drag_data_get */ static void gtk_notebook_finalize (GObject *object) { GtkNotebook *notebook = GTK_NOTEBOOK (object); gtk_widget_unparent (notebook->header_widget); gtk_widget_unparent (notebook->stack_widget); G_OBJECT_CLASS (gtk_notebook_parent_class)->finalize (object); } static void gtk_notebook_dispose (GObject *object) { GtkNotebook *notebook = GTK_NOTEBOOK (object); GList *l = notebook->children; if (notebook->pages) g_list_model_items_changed (G_LIST_MODEL (notebook->pages), 0, g_list_length (notebook->children), 0); while (l != NULL) { GtkNotebookPage *page = l->data; l = l->next; gtk_notebook_remove (notebook, page->child); } G_OBJECT_CLASS (gtk_notebook_parent_class)->dispose (object); } static gboolean gtk_notebook_get_tab_area_position (GtkNotebook *notebook, graphene_rect_t *rectangle) { if (notebook->show_tabs && gtk_notebook_has_current_page (notebook)) { return gtk_widget_compute_bounds (notebook->header_widget, GTK_WIDGET (notebook), rectangle); } else { graphene_rect_init_from_rect (rectangle, graphene_rect_zero ()); } return FALSE; } static void gtk_notebook_unmap (GtkWidget *widget) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); stop_scrolling (notebook); GTK_WIDGET_CLASS (gtk_notebook_parent_class)->unmap (widget); } static void gtk_notebook_distribute_arrow_width (GtkNotebook *notebook, GtkPackType type, gint size, gint *out_left, gint *out_right) { GtkRequestedSize sizes[2]; if (notebook->arrow_widget[2 * type + 1] == NULL) { if (notebook->arrow_widget[2 * type] == NULL) *out_left = 0; else *out_left = size; *out_right = 0; } else if (notebook->arrow_widget[2 * type] == NULL) { *out_left = 0; *out_right = size; } else { gtk_widget_measure (notebook->arrow_widget[2 * type], GTK_ORIENTATION_HORIZONTAL, -1, &sizes[0].minimum_size, &sizes[0].natural_size, NULL, NULL); gtk_widget_measure (notebook->arrow_widget[2 * type + 1], GTK_ORIENTATION_HORIZONTAL, -1, &sizes[1].minimum_size, &sizes[1].natural_size, NULL, NULL); size -= sizes[0].minimum_size + sizes[1].minimum_size; size = gtk_distribute_natural_allocation (size, G_N_ELEMENTS (sizes), sizes); *out_left = sizes[0].minimum_size + size / 2; *out_right = sizes[1].minimum_size + (size + 1) / 2; } } static void gtk_notebook_measure_arrows (GtkNotebook *notebook, GtkPackType type, GtkOrientation orientation, gint for_size, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline) { gint child1_min, child1_nat; gint child2_min, child2_nat; if (orientation == GTK_ORIENTATION_HORIZONTAL) { if (notebook->arrow_widget[2 * type]) { gtk_widget_measure (notebook->arrow_widget[2 * type], orientation, for_size, &child1_min, &child1_nat, NULL, NULL); } else { child1_min = child1_nat = 0; } if (notebook->arrow_widget[2 * type + 1]) { gtk_widget_measure (notebook->arrow_widget[2 * type + 1], orientation, for_size, &child2_min, &child2_nat, NULL, NULL); } else { child2_min = child2_nat = 0; } *minimum = child1_min + child2_min; *natural = child1_nat + child2_nat; if (minimum_baseline) *minimum_baseline = -1; if (natural_baseline) *natural_baseline = -1; } else { gint child1_size, child2_size; if (for_size > -1) gtk_notebook_distribute_arrow_width (notebook, type, for_size, &child1_size, &child2_size); else child1_size = child2_size = for_size; if (notebook->arrow_widget[2 * type]) { gtk_widget_measure (notebook->arrow_widget[2 * type], orientation, child1_size, &child1_min, &child1_nat, NULL, NULL); } else { child1_min = child1_nat = 0; } if (notebook->arrow_widget[2 * type + 1]) { gtk_widget_measure (notebook->arrow_widget[2 * type + 1], orientation, child2_size, &child2_min, &child2_nat, NULL, NULL); } else { child2_min = child2_nat = 0; } *minimum = MAX (child1_min, child2_min); *natural = MAX (child1_nat, child2_nat); if (minimum_baseline) *minimum_baseline = -1; if (natural_baseline) *natural_baseline = -1; } } static void gtk_notebook_get_preferred_tabs_size (GtkNotebook *notebook, GtkRequisition *requisition) { gint tab_width = 0; gint tab_height = 0; gint tab_max = 0; guint vis_pages = 0; GList *children; GtkNotebookPage *page; for (children = notebook->children; children; children = children->next) { page = children->data; if (gtk_widget_get_visible (page->child)) { vis_pages++; if (!gtk_widget_get_visible (page->tab_label)) gtk_widget_show (page->tab_label); gtk_widget_measure (page->tab_widget, GTK_ORIENTATION_HORIZONTAL, -1, &page->requisition.width, NULL, NULL, NULL); gtk_widget_measure (page->tab_widget, GTK_ORIENTATION_VERTICAL, page->requisition.width, &page->requisition.height, NULL, NULL, NULL); switch (notebook->tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: tab_height = MAX (tab_height, page->requisition.height); tab_max = MAX (tab_max, page->requisition.width); break; case GTK_POS_LEFT: case GTK_POS_RIGHT: tab_width = MAX (tab_width, page->requisition.width); tab_max = MAX (tab_max, page->requisition.height); break; default: g_assert_not_reached (); break; } } else if (gtk_widget_get_visible (page->tab_label)) gtk_widget_hide (page->tab_label); } children = notebook->children; if (vis_pages) { switch (notebook->tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (tab_height == 0) break; if (notebook->scrollable) { gint arrow_height, unused; gtk_notebook_measure_arrows (notebook, GTK_PACK_START, GTK_ORIENTATION_VERTICAL, -1, &arrow_height, &unused, NULL, NULL); tab_height = MAX (tab_height, arrow_height); gtk_notebook_measure_arrows (notebook, GTK_PACK_END, GTK_ORIENTATION_VERTICAL, -1, &arrow_height, &unused, NULL, NULL); tab_height = MAX (tab_height, arrow_height); } while (children) { page = children->data; children = children->next; if (!gtk_widget_get_visible (page->child)) continue; tab_width += page->requisition.width; page->requisition.height = tab_height; } if (notebook->scrollable) { gint start_arrow_width, end_arrow_width, unused; gtk_notebook_measure_arrows (notebook, GTK_PACK_START, GTK_ORIENTATION_HORIZONTAL, tab_height, &start_arrow_width, &unused, NULL, NULL); gtk_notebook_measure_arrows (notebook, GTK_PACK_END, GTK_ORIENTATION_HORIZONTAL, tab_height, &end_arrow_width, &unused, NULL, NULL); tab_width = MIN (tab_width, tab_max + start_arrow_width + end_arrow_width); } requisition->width = tab_width; requisition->height = tab_height; break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (tab_width == 0) break; if (notebook->scrollable) { gint arrow_width, unused; gtk_notebook_measure_arrows (notebook, GTK_PACK_START, GTK_ORIENTATION_HORIZONTAL, -1, &arrow_width, &unused, NULL, NULL); tab_width = MAX (tab_width, arrow_width); gtk_notebook_measure_arrows (notebook, GTK_PACK_END, GTK_ORIENTATION_HORIZONTAL, -1, &arrow_width, &unused, NULL, NULL); tab_width = MAX (tab_width, arrow_width); } while (children) { page = children->data; children = children->next; if (!gtk_widget_get_visible (page->child)) continue; page->requisition.width = tab_width; tab_height += page->requisition.height; } if (notebook->scrollable) { gint start_arrow_height, end_arrow_height, unused; gtk_notebook_measure_arrows (notebook, GTK_PACK_START, GTK_ORIENTATION_VERTICAL, tab_width, &start_arrow_height, &unused, NULL, NULL); gtk_notebook_measure_arrows (notebook, GTK_PACK_END, GTK_ORIENTATION_VERTICAL, tab_width, &end_arrow_height, &unused, NULL, NULL); tab_height = MIN (tab_height, tab_max + start_arrow_height + end_arrow_height); } requisition->height = tab_height; requisition->height = MAX (requisition->height, tab_max); requisition->width = tab_width; break; default: g_assert_not_reached (); requisition->width = 0; requisition->height = 0; } } else { requisition->width = 0; requisition->height = 0; } } static void gtk_notebook_measure_tabs (GtkGizmo *gizmo, GtkOrientation orientation, gint size, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline) { GtkWidget *widget = gtk_widget_get_parent (GTK_WIDGET (gizmo)); GtkNotebook *notebook = GTK_NOTEBOOK (gtk_widget_get_parent (widget)); GtkRequisition tabs_requisition = { 0 }; gtk_notebook_get_preferred_tabs_size (notebook, &tabs_requisition); if (orientation == GTK_ORIENTATION_HORIZONTAL) { *minimum = tabs_requisition.width; *natural = tabs_requisition.width; } else { *minimum = tabs_requisition.height; *natural = tabs_requisition.height; } } static void gtk_notebook_allocate_tabs (GtkGizmo *gizmo, int width, int height, int baseline) { GtkWidget *widget = gtk_widget_get_parent (GTK_WIDGET (gizmo)); GtkNotebook *notebook = GTK_NOTEBOOK (gtk_widget_get_parent (widget)); gtk_notebook_pages_allocate (notebook, width, height); } static gboolean gtk_notebook_show_arrows (GtkNotebook *notebook) { GList *children; if (!notebook->scrollable) return FALSE; children = notebook->children; while (children) { GtkNotebookPage *page = children->data; if (!gtk_widget_get_child_visible (page->tab_widget)) return TRUE; children = children->next; } return FALSE; } static GtkNotebookArrow gtk_notebook_get_arrow (GtkNotebook *notebook, gint x, gint y) { gint i; if (gtk_notebook_show_arrows (notebook)) { for (i = 0; i < 4; i++) { graphene_rect_t arrow_bounds; if (notebook->arrow_widget[i] == NULL) continue; if (!gtk_widget_compute_bounds (notebook->arrow_widget[i], GTK_WIDGET (notebook), &arrow_bounds)) continue; if (graphene_rect_contains_point (&arrow_bounds, &(graphene_point_t){x, y})) return i; } } return ARROW_NONE; } static void gtk_notebook_do_arrow (GtkNotebook *notebook, GtkNotebookArrow arrow) { GtkWidget *widget = GTK_WIDGET (notebook); gboolean is_rtl, left; is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; left = (ARROW_IS_LEFT (arrow) && !is_rtl) || (!ARROW_IS_LEFT (arrow) && is_rtl); if (!notebook->focus_tab || gtk_notebook_search_page (notebook, notebook->focus_tab, left ? STEP_PREV : STEP_NEXT, TRUE)) { gtk_notebook_change_current_page (notebook, left ? -1 : 1); gtk_widget_grab_focus (widget); } } static gboolean gtk_notebook_arrow_button_press (GtkNotebook *notebook, GtkNotebookArrow arrow, gint button) { GtkWidget *widget = GTK_WIDGET (notebook); gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; gboolean left = (ARROW_IS_LEFT (arrow) && !is_rtl) || (!ARROW_IS_LEFT (arrow) && is_rtl); if (notebook->pressed_button) return FALSE; if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); notebook->pressed_button = button; notebook->click_child = arrow; if (button == GDK_BUTTON_PRIMARY) { gtk_notebook_do_arrow (notebook, arrow); gtk_notebook_set_scroll_timer (notebook); } else if (button == GDK_BUTTON_MIDDLE) gtk_notebook_page_select (notebook, TRUE); else if (button == GDK_BUTTON_SECONDARY) gtk_notebook_switch_focus_tab (notebook, gtk_notebook_search_page (notebook, NULL, left ? STEP_NEXT : STEP_PREV, TRUE)); return TRUE; } static gboolean gtk_notebook_page_tab_label_is_visible (GtkNotebookPage *page) { return page->tab_label && gtk_widget_get_visible (page->tab_widget) && gtk_widget_get_child_visible (page->tab_widget) && gtk_widget_get_visible (page->tab_label) && gtk_widget_get_child_visible (page->tab_label); } static gboolean in_tabs (GtkNotebook *notebook, gdouble x, gdouble y) { graphene_rect_t tabs_bounds; if (!gtk_widget_compute_bounds (notebook->tabs_widget, GTK_WIDGET (notebook), &tabs_bounds)) return FALSE; return graphene_rect_contains_point (&tabs_bounds, &(graphene_point_t){x, y}); } static GList* get_tab_at_pos (GtkNotebook *notebook, gdouble x, gdouble y) { GtkNotebookPage *page; GList *children; for (children = notebook->children; children; children = children->next) { graphene_rect_t bounds; page = children->data; if (!gtk_notebook_page_tab_label_is_visible (page)) continue; if (!gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &bounds)) continue; if (graphene_rect_contains_point (&bounds, &(graphene_point_t){x, y})) return children; } return NULL; } static void gtk_notebook_gesture_pressed (GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data) { GtkNotebook *notebook = user_data; GtkWidget *widget = user_data; GdkEventSequence *sequence; GtkNotebookArrow arrow; GtkNotebookPage *page; GdkEvent *event; guint button; GList *tab; sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)); button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)); event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence); if (!notebook->children) return; arrow = gtk_notebook_get_arrow (notebook, x, y); if (arrow != ARROW_NONE) { gtk_notebook_arrow_button_press (notebook, arrow, button); return; } if (in_tabs (notebook, x, y) && notebook->menu && gdk_event_triggers_context_menu (event)) { GdkRectangle rect; rect.x = x; rect.y = y; rect.width = 1; rect.height = 1; gtk_popover_set_pointing_to (GTK_POPOVER (notebook->menu), &rect); gtk_popover_popup (GTK_POPOVER (notebook->menu)); return; } if (button != GDK_BUTTON_PRIMARY) return; if ((tab = get_tab_at_pos (notebook, x, y)) != NULL) { gboolean page_changed, was_focus; page = tab->data; page_changed = page != notebook->cur_page; was_focus = gtk_widget_is_focus (widget); gtk_notebook_switch_focus_tab (notebook, tab); gtk_widget_grab_focus (widget); if (page_changed && !was_focus) gtk_widget_child_focus (page->child, GTK_DIR_TAB_FORWARD); /* save press to possibly begin a drag */ if (page->reorderable || page->detachable) { graphene_rect_t tab_bounds; notebook->pressed_button = button; notebook->mouse_x = x; notebook->mouse_y = y; notebook->drag_begin_x = notebook->mouse_x; notebook->drag_begin_y = notebook->mouse_y; /* tab bounds get set to empty, which is fine */ notebook->drag_offset_x = notebook->drag_begin_x; notebook->drag_offset_y = notebook->drag_begin_y; if (gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds)) { notebook->drag_offset_x -= tab_bounds.origin.x; notebook->drag_offset_y -= tab_bounds.origin.y; } } } } static void gtk_notebook_popup_menu (GtkWidget *widget, const char *action_name, GVariant *parameters) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); if (notebook->menu) gtk_popover_popup (GTK_POPOVER (notebook->menu)); } static void stop_scrolling (GtkNotebook *notebook) { if (notebook->timer) { g_source_remove (notebook->timer); notebook->timer = 0; notebook->need_timer = FALSE; } notebook->click_child = ARROW_NONE; notebook->pressed_button = 0; } static GList* get_drop_position (GtkNotebook *notebook) { GList *children, *last_child; GtkNotebookPage *page; gboolean is_rtl; gint x, y; x = notebook->mouse_x; y = notebook->mouse_y; is_rtl = gtk_widget_get_direction ((GtkWidget *) notebook) == GTK_TEXT_DIR_RTL; last_child = NULL; for (children = notebook->children; children; children = children->next) { page = children->data; if ((notebook->operation != DRAG_OPERATION_REORDER || page != notebook->cur_page) && gtk_widget_get_visible (page->child) && page->tab_label && gtk_widget_get_mapped (page->tab_label)) { graphene_rect_t tab_bounds; if (!gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds)) continue; switch (notebook->tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (!is_rtl) { if (tab_bounds.origin.x + tab_bounds.size.width / 2 > x) return children; } else { if (tab_bounds.origin.x + tab_bounds.size.width / 2 < x) return children; } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (tab_bounds.origin.y + tab_bounds.size.height / 2 > y) return children; break; default: g_assert_not_reached (); break; } last_child = children->next; } } return last_child; } static void tab_drag_begin (GtkNotebook *notebook, GtkNotebookPage *page) { gtk_widget_add_css_class (page->tab_widget, GTK_STYLE_CLASS_DND); } /* This function undoes the reparenting that happens both when drag_surface * is shown for reordering and when the DnD icon is shown for detaching */ static void tab_drag_end (GtkNotebook *notebook, GtkNotebookPage *page) { if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)) { g_object_ref (page->tab_label); gtk_box_remove (GTK_BOX (gtk_widget_get_parent (page->tab_label)), page->tab_label); gtk_widget_set_parent (page->tab_label, page->tab_widget); g_object_unref (page->tab_label); } gtk_widget_remove_css_class (page->tab_widget, GTK_STYLE_CLASS_DND); } static void gtk_notebook_stop_reorder (GtkNotebook *notebook) { GtkNotebookPage *page; if (notebook->operation == DRAG_OPERATION_DETACH) page = notebook->detached_tab; else page = notebook->cur_page; if (!page || !page->tab_label) return; notebook->pressed_button = 0; if (page->reorderable || page->detachable) { if (notebook->operation == DRAG_OPERATION_REORDER) { gint old_page_num, page_num, i; GList *element; element = get_drop_position (notebook); old_page_num = g_list_position (notebook->children, notebook->focus_tab); page_num = reorder_tab (notebook, element, notebook->focus_tab); gtk_notebook_child_reordered (notebook, page); if (notebook->has_scrolled || old_page_num != page_num) { for (element = notebook->children, i = 0; element; element = element->next, i++) { if (MIN (old_page_num, page_num) <= i && i <= MAX (old_page_num, page_num)) g_object_notify (G_OBJECT (element->data), "position"); } g_signal_emit (notebook, notebook_signals[PAGE_REORDERED], 0, page->child, page_num); } } notebook->has_scrolled = FALSE; tab_drag_end (notebook, page); notebook->operation = DRAG_OPERATION_NONE; if (notebook->dnd_timer) { g_source_remove (notebook->dnd_timer); notebook->dnd_timer = 0; } gtk_widget_queue_allocate (GTK_WIDGET (notebook)); } } static void gtk_notebook_gesture_released (GtkGestureClick *gesture, int n_press, double x, double y, gpointer user_data) { GtkNotebook *notebook = user_data; GdkEventSequence *sequence; GdkEvent *event; guint button; sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)); button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)); event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence); if (!event) return; if (notebook->pressed_button != button) return; if (notebook->operation == DRAG_OPERATION_REORDER && notebook->cur_page && notebook->cur_page->reorderable) gtk_notebook_stop_reorder (notebook); stop_scrolling (notebook); } static void gtk_notebook_gesture_cancel (GtkGestureClick *gesture, GdkEventSequence *sequence, GtkNotebook *notebook) { gtk_notebook_stop_reorder (notebook); stop_scrolling (notebook); } static GtkNotebookPointerPosition get_pointer_position (GtkNotebook *notebook) { GtkWidget *widget = GTK_WIDGET (notebook); graphene_rect_t area; gint width, height; gboolean is_rtl; if (!notebook->scrollable) return POINTER_BETWEEN; gtk_notebook_get_tab_area_position (notebook, &area); width = area.size.width; height = area.size.height; if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_BOTTOM) { gint x = notebook->mouse_x; is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; if (x > width - SCROLL_THRESHOLD) return (is_rtl) ? POINTER_BEFORE : POINTER_AFTER; else if (x < SCROLL_THRESHOLD) return (is_rtl) ? POINTER_AFTER : POINTER_BEFORE; else return POINTER_BETWEEN; } else { gint y = notebook->mouse_y; if (y > height - SCROLL_THRESHOLD) return POINTER_AFTER; else if (y < SCROLL_THRESHOLD) return POINTER_BEFORE; else return POINTER_BETWEEN; } } static gboolean scroll_notebook_timer (gpointer data) { GtkNotebook *notebook = GTK_NOTEBOOK (data); GtkNotebookPointerPosition pointer_position; GList *element, *first_tab; pointer_position = get_pointer_position (notebook); element = get_drop_position (notebook); reorder_tab (notebook, element, notebook->focus_tab); first_tab = gtk_notebook_search_page (notebook, notebook->first_tab, (pointer_position == POINTER_BEFORE) ? STEP_PREV : STEP_NEXT, TRUE); if (first_tab && notebook->cur_page) { notebook->first_tab = first_tab; gtk_widget_queue_allocate (notebook->tabs_widget); } return TRUE; } static gboolean check_threshold (GtkNotebook *notebook, gint current_x, gint current_y) { gint dnd_threshold; graphene_rect_t rectangle; GtkSettings *settings; settings = gtk_widget_get_settings (GTK_WIDGET (notebook)); g_object_get (G_OBJECT (settings), "gtk-dnd-drag-threshold", &dnd_threshold, NULL); /* we want a large threshold */ dnd_threshold *= DND_THRESHOLD_MULTIPLIER; gtk_notebook_get_tab_area_position (notebook, &rectangle); graphene_rect_inset (&rectangle, -dnd_threshold, -dnd_threshold); /* The negation here is important! */ return !graphene_rect_contains_point (&rectangle, &(graphene_point_t){current_x, current_y}); } static void gtk_notebook_motion (GtkEventController *controller, double x, double y, gpointer user_data) { GtkWidget *widget = GTK_WIDGET (user_data); GtkNotebook *notebook = GTK_NOTEBOOK (widget); GtkNotebookPage *page; guint state; page = notebook->cur_page; if (!page) return; state = gtk_event_controller_get_current_event_state (controller); if (!(state & GDK_BUTTON1_MASK) && notebook->pressed_button != 0) { gtk_notebook_stop_reorder (notebook); stop_scrolling (notebook); } notebook->mouse_x = x; notebook->mouse_y = y; if (notebook->pressed_button == 0) return; if (page->detachable && check_threshold (notebook, notebook->mouse_x, notebook->mouse_y)) { GdkSurface *surface; GdkDevice *device; GdkContentProvider *content; GdkDrag *drag; GdkPaintable *paintable; notebook->detached_tab = notebook->cur_page; surface = gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (notebook))); device = gtk_event_controller_get_current_event_device (controller); content = gdk_content_provider_new_union ((GdkContentProvider *[2]) { gtk_notebook_root_content_new (notebook), gdk_content_provider_new_typed (GTK_TYPE_NOTEBOOK_PAGE, notebook->cur_page) }, 2); drag = gdk_drag_begin (surface, device, content, GDK_ACTION_MOVE, notebook->drag_begin_x, notebook->drag_begin_y); g_object_unref (content); g_signal_connect (drag, "dnd-finished", G_CALLBACK (gtk_notebook_dnd_finished_cb), notebook); g_signal_connect (drag, "cancel", G_CALLBACK (gtk_notebook_drag_cancel_cb), notebook); paintable = gtk_widget_paintable_new (notebook->detached_tab->tab_widget); gtk_drag_icon_set_from_paintable (drag, paintable, -2, -2); g_object_unref (paintable); if (notebook->dnd_timer) { g_source_remove (notebook->dnd_timer); notebook->dnd_timer = 0; } notebook->operation = DRAG_OPERATION_DETACH; tab_drag_end (notebook, notebook->cur_page); g_object_set_data (G_OBJECT (drag), "gtk-notebook-drag-origin", notebook); g_object_unref (drag); return; } if (page->reorderable && (notebook->operation == DRAG_OPERATION_REORDER || gtk_drag_check_threshold (widget, notebook->drag_begin_x, notebook->drag_begin_y, notebook->mouse_x, notebook->mouse_y))) { GtkNotebookPointerPosition pointer_position = get_pointer_position (notebook); if (pointer_position != POINTER_BETWEEN && gtk_notebook_show_arrows (notebook)) { /* scroll tabs */ if (!notebook->dnd_timer) { notebook->has_scrolled = TRUE; notebook->dnd_timer = g_timeout_add (TIMEOUT_REPEAT * SCROLL_DELAY_FACTOR, scroll_notebook_timer, notebook); g_source_set_name_by_id (notebook->dnd_timer, "[gtk] scroll_notebook_timer"); } } else { if (notebook->dnd_timer) { g_source_remove (notebook->dnd_timer); notebook->dnd_timer = 0; } } if (notebook->operation != DRAG_OPERATION_REORDER) { notebook->operation = DRAG_OPERATION_REORDER; tab_drag_begin (notebook, page); } } if (notebook->operation == DRAG_OPERATION_REORDER) gtk_widget_queue_allocate (notebook->tabs_widget); } static void update_arrow_state (GtkNotebook *notebook) { gint i; gboolean is_rtl, left; is_rtl = gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL; for (i = 0; i < 4; i++) { gboolean sensitive = TRUE; if (notebook->arrow_widget[i] == NULL) continue; left = (ARROW_IS_LEFT (i) && !is_rtl) || (!ARROW_IS_LEFT (i) && is_rtl); if (notebook->focus_tab && !gtk_notebook_search_page (notebook, notebook->focus_tab, left ? STEP_PREV : STEP_NEXT, TRUE)) { sensitive = FALSE; } gtk_widget_set_sensitive (notebook->arrow_widget[i], sensitive); } } static void gtk_notebook_state_flags_changed (GtkWidget *widget, GtkStateFlags previous_state) { if (!gtk_widget_is_sensitive (widget)) stop_scrolling (GTK_NOTEBOOK (widget)); } static void gtk_notebook_arrow_drag_enter (GtkDropControllerMotion *motion, double x, double y, GtkNotebook *notebook) { GtkWidget *arrow_widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (motion)); guint arrow; for (arrow = 0; arrow < 4; arrow++) { if (notebook->arrow_widget[arrow] == arrow_widget) break; } g_assert (arrow != ARROW_NONE); notebook->click_child = arrow; gtk_notebook_set_scroll_timer (notebook); } static void gtk_notebook_arrow_drag_leave (GtkDropTarget *target, GdkDrop *drop, GtkNotebook *notebook) { stop_scrolling (notebook); } static void update_arrow_nodes (GtkNotebook *notebook) { gboolean arrow[4]; const char *up_icon_name; const char *down_icon_name; gint i; if (notebook->tab_pos == GTK_POS_LEFT || notebook->tab_pos == GTK_POS_RIGHT) { up_icon_name = "pan-down-symbolic"; down_icon_name = "pan-up-symbolic"; } else if (gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_LTR) { up_icon_name = "pan-end-symbolic"; down_icon_name = "pan-start-symbolic"; } else { up_icon_name = "pan-start-symbolic"; down_icon_name = "pan-end-symbolic"; } arrow[0] = TRUE; arrow[1] = FALSE; arrow[2] = FALSE; arrow[3] = TRUE; for (i = 0; i < 4; i++) { if (notebook->scrollable && arrow[i]) { if (notebook->arrow_widget[i] == NULL) { GtkWidget *next_widget; GtkEventController *controller; switch (i) { case 0: if (notebook->arrow_widget[1]) { next_widget = notebook->arrow_widget[1]; break; } G_GNUC_FALLTHROUGH; case 1: if (notebook->children) { GtkNotebookPage *page = notebook->children->data; next_widget = page->tab_widget; break; } if (notebook->arrow_widget[2]) { next_widget = notebook->arrow_widget[2]; break; } G_GNUC_FALLTHROUGH; case 2: if (notebook->arrow_widget[3]) { next_widget = notebook->arrow_widget[3]; break; } G_GNUC_FALLTHROUGH; case 3: next_widget = NULL; break; default: g_assert_not_reached (); next_widget = NULL; break; } notebook->arrow_widget[i] = g_object_new (GTK_TYPE_BUTTON, "css-name", "arrow", NULL); controller = gtk_drop_controller_motion_new (); g_signal_connect (controller, "enter", G_CALLBACK (gtk_notebook_arrow_drag_enter), notebook); g_signal_connect (controller, "leave", G_CALLBACK (gtk_notebook_arrow_drag_leave), notebook); gtk_widget_add_controller (notebook->arrow_widget[i], controller); if (i == ARROW_LEFT_BEFORE || i == ARROW_LEFT_AFTER) { gtk_widget_add_css_class (notebook->arrow_widget[i], "down"); gtk_widget_insert_after (notebook->arrow_widget[i], notebook->tabs_widget, next_widget); } else { gtk_widget_add_css_class (notebook->arrow_widget[i], "up"); gtk_widget_insert_before (notebook->arrow_widget[i], notebook->tabs_widget, next_widget); } } if (i == ARROW_LEFT_BEFORE || i == ARROW_LEFT_AFTER) gtk_button_set_icon_name (GTK_BUTTON (notebook->arrow_widget[i]), down_icon_name); else gtk_button_set_icon_name (GTK_BUTTON (notebook->arrow_widget[i]), up_icon_name); } else { g_clear_pointer (¬ebook->arrow_widget[i], gtk_widget_unparent); } } } static void gtk_notebook_direction_changed (GtkWidget *widget, GtkTextDirection previous_direction) { update_arrow_nodes (GTK_NOTEBOOK (widget)); } static void gtk_notebook_dnd_finished_cb (GdkDrag *drag, GtkWidget *widget) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); gtk_notebook_stop_reorder (notebook); if (notebook->rootwindow_drop) { GtkNotebook *dest_notebook = NULL; g_signal_emit (notebook, notebook_signals[CREATE_WINDOW], 0, notebook->detached_tab->child, &dest_notebook); if (dest_notebook) do_detach_tab (notebook, dest_notebook, notebook->detached_tab->child); notebook->rootwindow_drop = FALSE; } else if (notebook->detached_tab) { gtk_notebook_switch_page (notebook, notebook->detached_tab); } notebook->operation = DRAG_OPERATION_NONE; } static GtkNotebook * gtk_notebook_create_window (GtkNotebook *notebook, GtkWidget *page) { return NULL; } static void gtk_notebook_drag_cancel_cb (GdkDrag *drag, GdkDragCancelReason reason, GtkWidget *widget) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); notebook->rootwindow_drop = FALSE; if (reason == GDK_DRAG_CANCEL_NO_TARGET) { GtkNotebook *dest_notebook = NULL; g_signal_emit (notebook, notebook_signals[CREATE_WINDOW], 0, notebook->detached_tab->child, &dest_notebook); if (dest_notebook) do_detach_tab (notebook, dest_notebook, notebook->detached_tab->child); } } static gboolean gtk_notebook_switch_page_timeout (gpointer data) { GtkNotebook *notebook = GTK_NOTEBOOK (data); GtkNotebookPage *switch_page; notebook->switch_page_timer = 0; switch_page = notebook->switch_page; notebook->switch_page = NULL; if (switch_page) { /* FIXME: hack, we don't want the * focus to move fom the source widget */ notebook->child_has_focus = FALSE; gtk_notebook_switch_focus_tab (notebook, g_list_find (notebook->children, switch_page)); } return FALSE; } static gboolean gtk_notebook_can_drag_from (GtkNotebook *self, GtkNotebook *other, GtkNotebookPage *page) { /* always allow dragging inside self */ if (self == other) return TRUE; /* if the groups don't match, fail */ if (self->group == 0 || self->group != other->group) return FALSE; /* Check that the dragged page is not a parent of the notebook * being dragged into */ if (GTK_WIDGET (self) == page->child || gtk_widget_is_ancestor (GTK_WIDGET (self), GTK_WIDGET (page->child)) || GTK_WIDGET (self) == page->tab_label || gtk_widget_is_ancestor (GTK_WIDGET (self), GTK_WIDGET (page->tab_label))) return FALSE; return TRUE; } static GdkDragAction gtk_notebook_drag_motion (GtkDropTarget *dest, double x, double y, GtkNotebook *notebook) { GdkDrag *drag = gdk_drop_get_drag (gtk_drop_target_get_drop (dest)); GtkNotebook *source; notebook->mouse_x = x; notebook->mouse_y = y; if (!drag) return 0; source = GTK_NOTEBOOK (g_object_get_data (G_OBJECT (drag), "gtk-notebook-drag-origin")); g_assert (source->cur_page != NULL); if (!gtk_notebook_can_drag_from (notebook, source, source->cur_page)) return 0; return GDK_ACTION_MOVE; } static gboolean gtk_notebook_drag_drop (GtkDropTarget *dest, const GValue *value, double x, double y, GtkNotebook *self) { GdkDrag *drag = gdk_drop_get_drag (gtk_drop_target_get_drop (dest)); GtkNotebook *source; GtkNotebookPage *page = g_value_get_object (value); source = drag ? g_object_get_data (G_OBJECT (drag), "gtk-notebook-drag-origin") : NULL; if (!source || !gtk_notebook_can_drag_from (self, source, source->cur_page)) return FALSE; self->mouse_x = x; self->mouse_y = y; do_detach_tab (source, self, page->child); return TRUE; } /** * gtk_notebook_detach_tab: * @notebook: a #GtkNotebook * @child: a child * * Removes the child from the notebook. * * This function is very similar to gtk_container_remove(), * but additionally informs the notebook that the removal * is happening as part of a tab DND operation, which should * not be cancelled. */ void gtk_notebook_detach_tab (GtkNotebook *notebook, GtkWidget *child) { notebook->remove_in_detach = TRUE; gtk_notebook_remove (notebook, child); notebook->remove_in_detach = FALSE; } static void do_detach_tab (GtkNotebook *from, GtkNotebook *to, GtkWidget *child) { GtkWidget *tab_label, *menu_label; gboolean tab_expand, tab_fill, reorderable, detachable; GList *element; gint page_num; GtkNotebookPage *page; menu_label = gtk_notebook_get_menu_label (from, child); if (menu_label) g_object_ref (menu_label); tab_label = gtk_notebook_get_tab_label (from, child); if (tab_label) g_object_ref (tab_label); g_object_ref (child); page = gtk_notebook_get_page (from, child); g_object_get (page, "tab-expand", &tab_expand, "tab-fill", &tab_fill, "reorderable", &reorderable, "detachable", &detachable, NULL); gtk_notebook_detach_tab (from, child); element = get_drop_position (to); page_num = g_list_position (to->children, element); gtk_notebook_insert_page_menu (to, child, tab_label, menu_label, page_num); page = gtk_notebook_get_page (to, child); g_object_set (page, "tab-expand", tab_expand, "tab-fill", tab_fill, "reorderable", reorderable, "detachable", detachable, NULL); if (child) g_object_unref (child); if (tab_label) g_object_unref (tab_label); if (menu_label) g_object_unref (menu_label); gtk_notebook_set_current_page (to, page_num); } /* Private GtkContainer Methods : * * gtk_notebook_remove * gtk_notebook_focus * gtk_notebook_set_focus_child */ static void gtk_notebook_remove (GtkNotebook *notebook, GtkWidget *widget) { GtkNotebookPage *page; GList *children, *list; gint page_num = 0; children = notebook->children; while (children) { page = children->data; if (page->child == widget) break; page_num++; children = children->next; } if (children == NULL) return; g_object_ref (widget); list = children->next; gtk_notebook_real_remove (notebook, children); while (list) { g_object_notify (G_OBJECT (list->data), "position"); list = list->next; } g_signal_emit (notebook, notebook_signals[PAGE_REMOVED], 0, widget, page_num); g_object_unref (widget); } static gboolean focus_tabs_in (GtkNotebook *notebook) { if (notebook->show_tabs && gtk_notebook_has_current_page (notebook)) { gtk_widget_grab_focus (GTK_WIDGET (notebook)); gtk_notebook_set_focus_child (GTK_WIDGET (notebook), NULL); gtk_notebook_switch_focus_tab (notebook, g_list_find (notebook->children, notebook->cur_page)); return TRUE; } else return FALSE; } static gboolean focus_tabs_move (GtkNotebook *notebook, GtkDirectionType direction, gint search_direction) { GList *new_page; new_page = gtk_notebook_search_page (notebook, notebook->focus_tab, search_direction, TRUE); if (!new_page) { new_page = gtk_notebook_search_page (notebook, NULL, search_direction, TRUE); } if (new_page) gtk_notebook_switch_focus_tab (notebook, new_page); else gtk_widget_error_bell (GTK_WIDGET (notebook)); return TRUE; } static gboolean focus_child_in (GtkNotebook *notebook, GtkDirectionType direction) { if (notebook->cur_page) return gtk_widget_child_focus (notebook->cur_page->child, direction); else return FALSE; } static gboolean focus_action_in (GtkNotebook *notebook, gint action, GtkDirectionType direction) { if (notebook->action_widget[action] && gtk_widget_get_visible (notebook->action_widget[action])) return gtk_widget_child_focus (notebook->action_widget[action], direction); else return FALSE; } /* Focus in the notebook can either be on the pages, or on * the tabs or on the action_widgets. */ static gboolean gtk_notebook_focus (GtkWidget *widget, GtkDirectionType direction) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); GtkWidget *old_focus_child; GtkDirectionType effective_direction; gint first_action; gint last_action; gboolean widget_is_focus; if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_LEFT) { first_action = ACTION_WIDGET_START; last_action = ACTION_WIDGET_END; } else { first_action = ACTION_WIDGET_END; last_action = ACTION_WIDGET_START; } if (notebook->focus_out) { notebook->focus_out = FALSE; /* Clear this to catch the wrap-around case */ return FALSE; } widget_is_focus = gtk_widget_is_focus (widget); old_focus_child = gtk_widget_get_focus_child (widget); if (old_focus_child) old_focus_child = gtk_widget_get_focus_child (old_focus_child); effective_direction = get_effective_direction (notebook, direction); if (old_focus_child) /* Focus on page child or action widget */ { if (gtk_widget_child_focus (old_focus_child, direction)) return TRUE; if (old_focus_child == notebook->action_widget[ACTION_WIDGET_START]) { switch ((guint) effective_direction) { case GTK_DIR_DOWN: return focus_child_in (notebook, GTK_DIR_TAB_FORWARD); case GTK_DIR_RIGHT: return focus_tabs_in (notebook); case GTK_DIR_LEFT: return FALSE; case GTK_DIR_UP: return FALSE; default: switch ((guint) direction) { case GTK_DIR_TAB_FORWARD: if ((notebook->tab_pos == GTK_POS_RIGHT || notebook->tab_pos == GTK_POS_BOTTOM) && focus_child_in (notebook, direction)) return TRUE; return focus_tabs_in (notebook); case GTK_DIR_TAB_BACKWARD: return FALSE; default: g_assert_not_reached (); break; } } } else if (old_focus_child == notebook->action_widget[ACTION_WIDGET_END]) { switch ((guint) effective_direction) { case GTK_DIR_DOWN: return focus_child_in (notebook, GTK_DIR_TAB_FORWARD); case GTK_DIR_RIGHT: return FALSE; case GTK_DIR_LEFT: return focus_tabs_in (notebook); case GTK_DIR_UP: return FALSE; default: switch ((guint) direction) { case GTK_DIR_TAB_FORWARD: return FALSE; case GTK_DIR_TAB_BACKWARD: if ((notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_LEFT) && focus_child_in (notebook, direction)) return TRUE; return focus_tabs_in (notebook); default: g_assert_not_reached (); break; } } } else { switch ((guint) effective_direction) { case GTK_DIR_TAB_BACKWARD: case GTK_DIR_UP: /* Focus onto the tabs */ return focus_tabs_in (notebook); case GTK_DIR_DOWN: case GTK_DIR_LEFT: case GTK_DIR_RIGHT: return FALSE; case GTK_DIR_TAB_FORWARD: return focus_action_in (notebook, last_action, direction); default: break; } } } else if (widget_is_focus) /* Focus was on tabs */ { switch ((guint) effective_direction) { case GTK_DIR_TAB_BACKWARD: return focus_action_in (notebook, first_action, direction); case GTK_DIR_UP: return FALSE; case GTK_DIR_TAB_FORWARD: if (focus_child_in (notebook, GTK_DIR_TAB_FORWARD)) return TRUE; return focus_action_in (notebook, last_action, direction); case GTK_DIR_DOWN: /* We use TAB_FORWARD rather than direction so that we focus a more * predictable widget for the user; users may be using arrow focusing * in this situation even if they don't usually use arrow focusing. */ return focus_child_in (notebook, GTK_DIR_TAB_FORWARD); case GTK_DIR_LEFT: return focus_tabs_move (notebook, direction, STEP_PREV); case GTK_DIR_RIGHT: return focus_tabs_move (notebook, direction, STEP_NEXT); default: break; } } else /* Focus was not on widget */ { switch ((guint) effective_direction) { case GTK_DIR_TAB_FORWARD: case GTK_DIR_DOWN: if (focus_action_in (notebook, first_action, direction)) return TRUE; if (focus_tabs_in (notebook)) return TRUE; if (focus_action_in (notebook, last_action, direction)) return TRUE; if (focus_child_in (notebook, direction)) return TRUE; return FALSE; case GTK_DIR_TAB_BACKWARD: if (focus_action_in (notebook, last_action, direction)) return TRUE; if (focus_child_in (notebook, direction)) return TRUE; if (focus_tabs_in (notebook)) return TRUE; if (focus_action_in (notebook, first_action, direction)) return TRUE; return FALSE; case GTK_DIR_UP: case GTK_DIR_LEFT: case GTK_DIR_RIGHT: return focus_child_in (notebook, direction); default: break; } } g_assert_not_reached (); return FALSE; } static gboolean gtk_notebook_grab_focus (GtkWidget *widget) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); if (notebook->show_tabs) return gtk_widget_grab_focus_self (widget); else return gtk_widget_grab_focus_child (widget); } static void gtk_notebook_set_focus_child (GtkWidget *widget, GtkWidget *child) { GtkNotebook *notebook = GTK_NOTEBOOK (widget); GtkWidget *page_child; GtkWidget *toplevel; /* If the old focus widget was within a page of the notebook, * (child may either be NULL or not in this case), record it * for future use if we switch to the page with a mnemonic. */ toplevel = GTK_WIDGET (gtk_widget_get_root (widget)); if (GTK_IS_WINDOW (toplevel)) { page_child = gtk_window_get_focus (GTK_WINDOW (toplevel)); while (page_child) { if (gtk_widget_get_parent (page_child) == widget) { GList *list = gtk_notebook_find_child (notebook, page_child); if (list != NULL) { GtkNotebookPage *page = list->data; if (page->last_focus_child) g_object_remove_weak_pointer (G_OBJECT (page->last_focus_child), (gpointer *)&page->last_focus_child); page->last_focus_child = gtk_window_get_focus (GTK_WINDOW (toplevel)); g_object_add_weak_pointer (G_OBJECT (page->last_focus_child), (gpointer *)&page->last_focus_child); break; } } page_child = gtk_widget_get_parent (page_child); } } if (child) { g_return_if_fail (GTK_IS_WIDGET (child)); notebook->child_has_focus = TRUE; if (!notebook->focus_tab) { GList *children; GtkNotebookPage *page; children = notebook->children; while (children) { page = children->data; if (page->child == child || page->tab_label == child) gtk_notebook_switch_focus_tab (notebook, children); children = children->next; } } } else notebook->child_has_focus = FALSE; GTK_WIDGET_CLASS (gtk_notebook_parent_class)->set_focus_child (widget, child); } /* Private GtkNotebook Methods: * * gtk_notebook_real_insert_page */ static void page_visible_cb (GtkWidget *child, GParamSpec *arg, gpointer data) { GtkNotebook *notebook = GTK_NOTEBOOK (data); GList *list = gtk_notebook_find_child (notebook, GTK_WIDGET (child)); GtkNotebookPage *page = list->data; GList *next = NULL; if (notebook->menu && page->menu_label) { GtkWidget *parent = gtk_widget_get_parent (page->menu_label); if (parent) gtk_widget_set_visible (parent, gtk_widget_get_visible (child)); } gtk_widget_set_visible (page->tab_widget, gtk_widget_get_visible (child)); if (notebook->cur_page == page) { if (!gtk_widget_get_visible (child)) { list = g_list_find (notebook->children, notebook->cur_page); if (list) { next = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE); if (!next) next = gtk_notebook_search_page (notebook, list, STEP_PREV, TRUE); } if (next) gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE_FROM_LIST (next)); } gtk_widget_set_visible (notebook->header_widget, notebook->show_tabs && gtk_notebook_has_current_page (notebook)); } if (!gtk_notebook_has_current_page (notebook) && gtk_widget_get_visible (child)) { gtk_notebook_switch_page (notebook, page); /* focus_tab is set in the switch_page method */ gtk_notebook_switch_focus_tab (notebook, notebook->focus_tab); } } static void measure_tab (GtkGizmo *gizmo, GtkOrientation orientation, gint for_size, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline) { GtkNotebook *notebook = g_object_get_data (G_OBJECT (gizmo), "notebook"); GList *l; GtkNotebookPage *page = NULL; for (l = notebook->children; l; l = l->next) { GtkNotebookPage *p = GTK_NOTEBOOK_PAGE_FROM_LIST (l); if (p->tab_widget == GTK_WIDGET (gizmo)) { page = p; break; } } g_assert (page != NULL); gtk_widget_measure (page->tab_label, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline); } static void allocate_tab (GtkGizmo *gizmo, int width, int height, int baseline) { GtkNotebook *notebook = g_object_get_data (G_OBJECT (gizmo), "notebook"); GList *l; GtkNotebookPage *page = NULL; GtkAllocation child_allocation; for (l = notebook->children; l; l = l->next) { GtkNotebookPage *p = GTK_NOTEBOOK_PAGE_FROM_LIST (l); if (p->tab_widget == GTK_WIDGET (gizmo)) { page = p; break; } } g_assert (page != NULL); child_allocation = (GtkAllocation) {0, 0, width, height}; if (!page->fill) { if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_BOTTOM) { gtk_widget_measure (page->tab_label, GTK_ORIENTATION_HORIZONTAL, height, NULL, &child_allocation.width, NULL, NULL); if (child_allocation.width > width) child_allocation.width = width; else child_allocation.x += (width - child_allocation.width) / 2; } else { gtk_widget_measure (page->tab_label, GTK_ORIENTATION_VERTICAL, width, NULL, &child_allocation.height, NULL, NULL); if (child_allocation.height > height) child_allocation.height = height; else child_allocation.y += (height - child_allocation.height) / 2; } } gtk_widget_size_allocate (page->tab_label, &child_allocation, baseline); } static void gtk_notebook_tab_drop_enter (GtkEventController *controller, double x, double y, GtkNotebookPage *page) { GtkWidget *widget = gtk_event_controller_get_widget (controller); GtkNotebook *notebook = g_object_get_data (G_OBJECT (widget), "notebook"); g_assert (!notebook->switch_page_timer); notebook->switch_page = page; notebook->switch_page_timer = g_timeout_add (TIMEOUT_EXPAND, gtk_notebook_switch_page_timeout, notebook); g_source_set_name_by_id (notebook->switch_page_timer, "[gtk] gtk_notebook_switch_page_timeout"); } static void gtk_notebook_tab_drop_leave (GtkEventController *controller, GtkNotebookPage *page) { GtkWidget *widget = gtk_event_controller_get_widget (controller); GtkNotebook *notebook = g_object_get_data (G_OBJECT (widget), "notebook"); g_clear_handle_id (¬ebook->switch_page_timer, g_source_remove); } static gint gtk_notebook_insert_notebook_page (GtkNotebook *notebook, GtkNotebookPage *page, int position) { gint nchildren; GList *list; GtkWidget *sibling; GtkEventController *controller; nchildren = g_list_length (notebook->children); if ((position < 0) || (position > nchildren)) position = nchildren; notebook->children = g_list_insert (notebook->children, g_object_ref (page), position); if (position < nchildren) sibling = GTK_NOTEBOOK_PAGE_FROM_LIST (g_list_nth (notebook->children, position))->tab_widget; else if (notebook->arrow_widget[ARROW_LEFT_AFTER]) sibling = notebook->arrow_widget[ARROW_LEFT_AFTER]; else sibling = notebook->arrow_widget[ARROW_RIGHT_AFTER]; page->tab_widget = gtk_gizmo_new ("tab", measure_tab, allocate_tab, NULL, NULL, NULL, NULL); g_object_set_data (G_OBJECT (page->tab_widget), "notebook", notebook); gtk_widget_insert_before (page->tab_widget, notebook->tabs_widget, sibling); controller = gtk_drop_controller_motion_new (); g_signal_connect (controller, "enter", G_CALLBACK (gtk_notebook_tab_drop_enter), page); g_signal_connect (controller, "leave", G_CALLBACK (gtk_notebook_tab_drop_leave), page); gtk_widget_add_controller (page->tab_widget, controller); page->expand = FALSE; page->fill = TRUE; if (notebook->menu) gtk_notebook_menu_item_create (notebook, page); gtk_stack_add_named (GTK_STACK (notebook->stack_widget), page->child, NULL); if (page->tab_label) { gtk_widget_set_parent (page->tab_label, page->tab_widget); g_object_set_data (G_OBJECT (page->tab_label), "notebook", notebook); } gtk_notebook_update_labels (notebook); if (!notebook->first_tab) notebook->first_tab = notebook->children; if (page->tab_label) { if (notebook->show_tabs && gtk_widget_get_visible (page->child)) gtk_widget_show (page->tab_label); else gtk_widget_hide (page->tab_label); page->mnemonic_activate_signal = g_signal_connect (page->tab_label, "mnemonic-activate", G_CALLBACK (gtk_notebook_mnemonic_activate_switch_page), notebook); } page->notify_visible_handler = g_signal_connect (page->child, "notify::visible", G_CALLBACK (page_visible_cb), notebook); g_signal_emit (notebook, notebook_signals[PAGE_ADDED], 0, page->child, position); if (!gtk_notebook_has_current_page (notebook)) { gtk_notebook_switch_page (notebook, page); /* focus_tab is set in the switch_page method */ gtk_notebook_switch_focus_tab (notebook, notebook->focus_tab); } g_object_notify (G_OBJECT (page), "tab-expand"); g_object_notify (G_OBJECT (page), "tab-fill"); g_object_notify (G_OBJECT (page), "tab-label"); g_object_notify (G_OBJECT (page), "menu-label"); list = g_list_nth (notebook->children, position); while (list) { g_object_notify (G_OBJECT (list->data), "position"); list = list->next; } update_arrow_state (notebook); if (notebook->pages) g_list_model_items_changed (notebook->pages, position, 0, 1); /* The page-added handler might have reordered the pages, re-get the position */ return gtk_notebook_page_num (notebook, page->child); } static gint gtk_notebook_real_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label, gint position) { GtkNotebookPage *page; int ret; page = g_object_new (GTK_TYPE_NOTEBOOK_PAGE, "child", child, "tab", tab_label, "menu", menu_label, NULL); ret = gtk_notebook_insert_notebook_page (notebook, page, position); g_object_unref (page); return ret; } static gboolean gtk_notebook_timer (GtkNotebook *notebook) { gboolean retval = FALSE; if (notebook->timer) { gtk_notebook_do_arrow (notebook, notebook->click_child); if (notebook->need_timer) { notebook->need_timer = FALSE; notebook->timer = g_timeout_add (TIMEOUT_REPEAT * SCROLL_DELAY_FACTOR, (GSourceFunc) gtk_notebook_timer, notebook); g_source_set_name_by_id (notebook->timer, "[gtk] gtk_notebook_timer"); } else retval = TRUE; } return retval; } static void gtk_notebook_set_scroll_timer (GtkNotebook *notebook) { if (!notebook->timer) { notebook->timer = g_timeout_add (TIMEOUT_INITIAL, (GSourceFunc) gtk_notebook_timer, notebook); g_source_set_name_by_id (notebook->timer, "[gtk] gtk_notebook_timer"); notebook->need_timer = TRUE; } } static gint gtk_notebook_page_compare (gconstpointer a, gconstpointer b) { return (((GtkNotebookPage *) a)->child != b); } static GList* gtk_notebook_find_child (GtkNotebook *notebook, GtkWidget *child) { return g_list_find_custom (notebook->children, child, gtk_notebook_page_compare); } static void gtk_notebook_remove_tab_label (GtkNotebook *notebook, GtkNotebookPage *page) { if (page->tab_label) { if (page->mnemonic_activate_signal) g_signal_handler_disconnect (page->tab_label, page->mnemonic_activate_signal); page->mnemonic_activate_signal = 0; if (gtk_widget_get_native (page->tab_label) != gtk_widget_get_native (GTK_WIDGET (notebook)) || !NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)) { GtkWidget *parent; /* we hit this condition during dnd of a detached tab */ parent = gtk_widget_get_parent (page->tab_label); if (GTK_IS_WINDOW (parent)) gtk_box_remove (GTK_BOX (parent), page->tab_label); else gtk_widget_unparent (page->tab_label); } else { gtk_widget_unparent (page->tab_label); } page->tab_label = NULL; } } static void gtk_notebook_real_remove (GtkNotebook *notebook, GList *list) { GtkNotebookPage *page; GList * next_list; gint need_resize = FALSE; GtkWidget *tab_label; gboolean destroying; int position; page = list->data; destroying = gtk_widget_in_destruction (GTK_WIDGET (notebook)); next_list = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE); if (!next_list) next_list = gtk_notebook_search_page (notebook, list, STEP_PREV, TRUE); notebook->children = g_list_remove_link (notebook->children, list); if (notebook->cur_page == list->data) { notebook->cur_page = NULL; if (next_list && !destroying) gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE_FROM_LIST (next_list)); if (notebook->operation == DRAG_OPERATION_REORDER && !notebook->remove_in_detach) gtk_notebook_stop_reorder (notebook); } if (notebook->detached_tab == list->data) notebook->detached_tab = NULL; if (notebook->switch_page == page) notebook->switch_page = NULL; if (list == notebook->first_tab) notebook->first_tab = next_list; if (list == notebook->focus_tab && !destroying) gtk_notebook_switch_focus_tab (notebook, next_list); position = g_list_index (notebook->children, page); g_signal_handler_disconnect (page->child, page->notify_visible_handler); if (gtk_widget_get_visible (page->child) && gtk_widget_get_visible (GTK_WIDGET (notebook))) need_resize = TRUE; gtk_stack_remove (GTK_STACK (notebook->stack_widget), page->child); tab_label = page->tab_label; if (tab_label) { g_object_ref (tab_label); gtk_notebook_remove_tab_label (notebook, page); if (destroying) gtk_widget_unparent (tab_label); g_object_unref (tab_label); } if (notebook->menu) { GtkWidget *parent = gtk_widget_get_parent (page->menu_label); if (parent) gtk_notebook_menu_label_unparent (parent); gtk_popover_set_child (GTK_POPOVER (notebook->menu), NULL); gtk_widget_queue_resize (notebook->menu); } g_list_free (list); if (page->last_focus_child) { g_object_remove_weak_pointer (G_OBJECT (page->last_focus_child), (gpointer *)&page->last_focus_child); page->last_focus_child = NULL; } gtk_widget_unparent (page->tab_widget); g_object_unref (page); gtk_notebook_update_labels (notebook); if (need_resize) gtk_widget_queue_resize (GTK_WIDGET (notebook)); if (notebook->pages) g_list_model_items_changed (notebook->pages, position, 1, 0); } static void gtk_notebook_update_labels (GtkNotebook *notebook) { GtkNotebookPage *page; GList *list; char string[32]; gint page_num = 1; if (!notebook->show_tabs && !notebook->menu) return; for (list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, FALSE); list; list = gtk_notebook_search_page (notebook, list, STEP_NEXT, FALSE)) { const char *text; page = list->data; g_snprintf (string, sizeof (string), _("Page %u"), page_num++); if (page->tab_text) text = page->tab_text; else text = string; if (notebook->show_tabs) { if (page->default_tab) { if (!page->tab_label) { page->tab_label = gtk_label_new (""); g_object_ref_sink (page->tab_label); g_object_set_data (G_OBJECT (page->tab_label), "notebook", notebook); gtk_widget_set_parent (page->tab_label, page->tab_widget); } gtk_label_set_text (GTK_LABEL (page->tab_label), text); } if (page->child && page->tab_label) gtk_widget_set_visible (page->tab_label, gtk_widget_get_visible (page->child)); } if (notebook->menu && page->default_menu) { if (page->menu_text) text = page->menu_text; else if (GTK_IS_LABEL (page->tab_label)) text = gtk_label_get_text (GTK_LABEL (page->tab_label)); else text = string; gtk_label_set_text (GTK_LABEL (page->menu_label), text); } } } static GList * gtk_notebook_search_page (GtkNotebook *notebook, GList *list, gint direction, gboolean find_visible) { GtkNotebookPage *page = NULL; GList *old_list = NULL; if (list) page = list->data; if (!page || direction == STEP_NEXT) { if (list) { old_list = list; list = list->next; } else list = notebook->children; while (list) { page = list->data; if (direction == STEP_NEXT && (!find_visible || (gtk_widget_get_visible (page->child) && (!page->tab_label || NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))))) return list; old_list = list; list = list->next; } list = old_list; } else { list = list->prev; } while (list) { page = list->data; if (direction == STEP_PREV && (!find_visible || (gtk_widget_get_visible (page->child) && (!page->tab_label || NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))))) return list; list = list->prev; } return NULL; } static void gtk_notebook_snapshot_tabs (GtkGizmo *gizmo, GtkSnapshot *snapshot) { GtkWidget *widget = gtk_widget_get_parent (GTK_WIDGET (gizmo)); GtkNotebook *notebook = GTK_NOTEBOOK (gtk_widget_get_parent (widget)); GtkNotebookPage *page; GList *children; gboolean showarrow; gint step = STEP_PREV; gboolean is_rtl; GtkPositionType tab_pos; guint i; is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; tab_pos = get_effective_tab_pos (notebook); showarrow = FALSE; if (!gtk_notebook_has_current_page (notebook)) return; if (!notebook->first_tab) notebook->first_tab = notebook->children; if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, notebook->cur_page) || !gtk_widget_get_mapped (notebook->cur_page->tab_label)) { step = STEP_PREV; } else { switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: step = is_rtl ? STEP_PREV : STEP_NEXT; break; case GTK_POS_LEFT: case GTK_POS_RIGHT: step = STEP_PREV; break; default: g_assert_not_reached (); break; } } for (children = notebook->children; children; children = children->next) { page = children->data; if (!gtk_widget_get_visible (page->child) || page == notebook->detached_tab) continue; if (!gtk_widget_get_mapped (page->tab_label)) showarrow = TRUE; /* No point in keeping searching */ if (showarrow) break; } for (children = gtk_notebook_search_page (notebook, NULL, step, TRUE); children; children = gtk_notebook_search_page (notebook, children, step, TRUE)) { page = children->data; if (page == notebook->cur_page) break; if (!gtk_notebook_page_tab_label_is_visible (page)) continue; gtk_widget_snapshot_child (GTK_WIDGET (gizmo), page->tab_widget, snapshot); } if (children != NULL) { GList *other_order = NULL; for (children = gtk_notebook_search_page (notebook, children, step, TRUE); children; children = gtk_notebook_search_page (notebook, children, step, TRUE)) { page = children->data; if (!gtk_notebook_page_tab_label_is_visible (page)) continue; other_order = g_list_prepend (other_order, page); } /* draw them with the opposite order */ for (children = other_order; children; children = children->next) { page = children->data; gtk_widget_snapshot_child (GTK_WIDGET (gizmo), page->tab_widget, snapshot); } g_list_free (other_order); } if (showarrow && notebook->scrollable) { for (i = 0; i < 4; i++) { if (notebook->arrow_widget[i] == NULL) continue; gtk_widget_snapshot_child (GTK_WIDGET (gizmo), notebook->arrow_widget[i], snapshot); } } if (notebook->operation != DRAG_OPERATION_DETACH) gtk_widget_snapshot_child (GTK_WIDGET (gizmo), notebook->cur_page->tab_widget, snapshot); } /* Private GtkNotebook Size Allocate Functions: * * gtk_notebook_calculate_shown_tabs * gtk_notebook_calculate_tabs_allocation * gtk_notebook_calc_tabs */ static void gtk_notebook_allocate_arrows (GtkNotebook *notebook, GtkAllocation *allocation) { GtkAllocation arrow_allocation; gint size1, size2, min, nat; guint i, ii; switch (notebook->tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: arrow_allocation.y = allocation->y; arrow_allocation.height = allocation->height; for (i = 0; i < 4; i++) { ii = i < 2 ? i : i ^ 1; if (notebook->arrow_widget[ii] == NULL) continue; gtk_widget_measure (notebook->arrow_widget[ii], GTK_ORIENTATION_HORIZONTAL, allocation->height, &min, &nat, NULL, NULL); if (i < 2) { arrow_allocation.x = allocation->x; arrow_allocation.width = min; gtk_widget_size_allocate (notebook->arrow_widget[ii], &arrow_allocation, -1); allocation->x += min; allocation->width -= min; } else { arrow_allocation.x = allocation->x + allocation->width - min; arrow_allocation.width = min; gtk_widget_size_allocate (notebook->arrow_widget[ii], &arrow_allocation, -1); allocation->width -= min; } } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (notebook->arrow_widget[0] || notebook->arrow_widget[1]) { gtk_notebook_measure_arrows (notebook, GTK_PACK_START, GTK_ORIENTATION_VERTICAL, allocation->width, &min, &nat, NULL, NULL); gtk_notebook_distribute_arrow_width (notebook, GTK_PACK_START, allocation->width, &size1, &size2); arrow_allocation.x = allocation->x; arrow_allocation.y = allocation->y; arrow_allocation.width = size1; arrow_allocation.height = min; if (notebook->arrow_widget[0]) gtk_widget_size_allocate (notebook->arrow_widget[0], &arrow_allocation, -1); arrow_allocation.x += size1; arrow_allocation.width = size2; if (notebook->arrow_widget[1]) gtk_widget_size_allocate (notebook->arrow_widget[1], &arrow_allocation, -1); allocation->y += min; allocation->height -= min; } if (notebook->arrow_widget[2] || notebook->arrow_widget[3]) { gtk_notebook_measure_arrows (notebook, GTK_PACK_END, GTK_ORIENTATION_VERTICAL, allocation->width, &min, &nat, NULL, NULL); gtk_notebook_distribute_arrow_width (notebook, GTK_PACK_END, allocation->width, &size1, &size2); arrow_allocation.x = allocation->x; arrow_allocation.y = allocation->y + allocation->height - min; arrow_allocation.width = size1; arrow_allocation.height = min; if (notebook->arrow_widget[2]) gtk_widget_size_allocate (notebook->arrow_widget[2], &arrow_allocation, -1); arrow_allocation.x += size1; arrow_allocation.width = size2; if (notebook->arrow_widget[3]) gtk_widget_size_allocate (notebook->arrow_widget[3], &arrow_allocation, -1); allocation->height -= min; } break; default: g_assert_not_reached (); break; } } static void gtk_notebook_tab_space (GtkNotebook *notebook, int notebook_width, int notebook_height, gboolean *show_arrows, GtkAllocation *tabs_allocation, gint *tab_space) { GList *children; GtkPositionType tab_pos = get_effective_tab_pos (notebook); children = notebook->children; *tabs_allocation = (GtkAllocation) {0, 0, notebook_width, notebook_height}; switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: while (children) { GtkNotebookPage *page; page = children->data; children = children->next; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) && gtk_widget_get_visible (page->child)) *tab_space += page->requisition.width; } break; case GTK_POS_RIGHT: case GTK_POS_LEFT: while (children) { GtkNotebookPage *page; page = children->data; children = children->next; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) && gtk_widget_get_visible (page->child)) *tab_space += page->requisition.height; } break; default: g_assert_not_reached (); break; } if (!notebook->scrollable) *show_arrows = FALSE; else { switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (*tab_space > tabs_allocation->width) { *show_arrows = TRUE; gtk_notebook_allocate_arrows (notebook, tabs_allocation); *tab_space = tabs_allocation->width; } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (*tab_space > tabs_allocation->height) { *show_arrows = TRUE; gtk_notebook_allocate_arrows (notebook, tabs_allocation); *tab_space = tabs_allocation->height; } break; default: g_assert_not_reached (); break; } } } static void gtk_notebook_calculate_shown_tabs (GtkNotebook *notebook, gboolean show_arrows, const GtkAllocation *tabs_allocation, gint tab_space, GList **last_child, gint *n, gint *remaining_space) { GList *children; GtkNotebookPage *page; if (show_arrows) /* first_tab <- focus_tab */ { *remaining_space = tab_space; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, notebook->cur_page) && gtk_widget_get_visible (notebook->cur_page->child)) { gtk_notebook_calc_tabs (notebook, notebook->focus_tab, &(notebook->focus_tab), remaining_space, STEP_NEXT); } if (tab_space <= 0 || *remaining_space <= 0) { /* show 1 tab */ notebook->first_tab = notebook->focus_tab; *last_child = gtk_notebook_search_page (notebook, notebook->focus_tab, STEP_NEXT, TRUE); *n = 1; } else { children = NULL; if (notebook->first_tab && notebook->first_tab != notebook->focus_tab) { /* Is first_tab really predecessor of focus_tab? */ page = notebook->first_tab->data; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) && gtk_widget_get_visible (page->child)) for (children = notebook->focus_tab; children && children != notebook->first_tab; children = gtk_notebook_search_page (notebook, children, STEP_PREV, TRUE)); } if (!children) { if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, notebook->cur_page)) notebook->first_tab = notebook->focus_tab; else notebook->first_tab = gtk_notebook_search_page (notebook, notebook->focus_tab, STEP_NEXT, TRUE); } else /* calculate shown tabs counting backwards from the focus tab */ gtk_notebook_calc_tabs (notebook, gtk_notebook_search_page (notebook, notebook->focus_tab, STEP_PREV, TRUE), &(notebook->first_tab), remaining_space, STEP_PREV); if (*remaining_space < 0) { notebook->first_tab = gtk_notebook_search_page (notebook, notebook->first_tab, STEP_NEXT, TRUE); if (!notebook->first_tab) notebook->first_tab = notebook->focus_tab; *last_child = gtk_notebook_search_page (notebook, notebook->focus_tab, STEP_NEXT, TRUE); } else /* focus_tab -> end */ { if (!notebook->first_tab) notebook->first_tab = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE); children = NULL; gtk_notebook_calc_tabs (notebook, gtk_notebook_search_page (notebook, notebook->focus_tab, STEP_NEXT, TRUE), &children, remaining_space, STEP_NEXT); if (*remaining_space <= 0) *last_child = children; else /* start <- first_tab */ { *last_child = NULL; children = NULL; gtk_notebook_calc_tabs (notebook, gtk_notebook_search_page (notebook, notebook->first_tab, STEP_PREV, TRUE), &children, remaining_space, STEP_PREV); if (*remaining_space == 0) notebook->first_tab = children; else notebook->first_tab = gtk_notebook_search_page(notebook, children, STEP_NEXT, TRUE); } } if (*remaining_space < 0) { /* calculate number of tabs */ *remaining_space = - (*remaining_space); *n = 0; for (children = notebook->first_tab; children && children != *last_child; children = gtk_notebook_search_page (notebook, children, STEP_NEXT, TRUE)) (*n)++; } else *remaining_space = 0; } /* unmap all non-visible tabs */ for (children = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE); children && children != notebook->first_tab; children = gtk_notebook_search_page (notebook, children, STEP_NEXT, TRUE)) { page = children->data; if (page->tab_label && NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)) gtk_widget_set_child_visible (page->tab_widget, FALSE); } for (children = *last_child; children; children = gtk_notebook_search_page (notebook, children, STEP_NEXT, TRUE)) { page = children->data; if (page->tab_label && NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)) gtk_widget_set_child_visible (page->tab_widget, FALSE); } } else /* !show_arrows */ { GtkOrientation tab_expand_orientation; gint c = 0; *n = 0; if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_BOTTOM) { tab_expand_orientation = GTK_ORIENTATION_HORIZONTAL; *remaining_space = tabs_allocation->width - tab_space; } else { tab_expand_orientation = GTK_ORIENTATION_VERTICAL; *remaining_space = tabs_allocation->height - tab_space; } children = notebook->children; notebook->first_tab = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE); while (children) { page = children->data; children = children->next; if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) || !gtk_widget_get_visible (page->child)) continue; c++; if (page->expand || (gtk_widget_compute_expand (page->tab_label, tab_expand_orientation))) (*n)++; } } } static gboolean get_allocate_at_bottom (GtkWidget *widget, gint search_direction) { gboolean is_rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); GtkPositionType tab_pos = get_effective_tab_pos (GTK_NOTEBOOK (widget)); switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (!is_rtl) return (search_direction == STEP_PREV); else return (search_direction == STEP_NEXT); case GTK_POS_RIGHT: case GTK_POS_LEFT: return (search_direction == STEP_PREV); default: g_assert_not_reached (); return FALSE; } } static void gtk_notebook_calculate_tabs_allocation (GtkNotebook *notebook, GList **children, GList *last_child, gboolean showarrow, gint direction, gint *remaining_space, gint *expanded_tabs, const GtkAllocation *allocation) { GtkWidget *widget; GtkNotebookPage *page; gboolean allocate_at_bottom; gint tab_extra_space; GtkPositionType tab_pos; gint left_x, right_x, top_y, bottom_y, anchor; gboolean gap_left, packing_changed; GtkAllocation child_allocation; GtkOrientation tab_expand_orientation; graphene_rect_t drag_bounds; g_assert (notebook->cur_page != NULL); widget = GTK_WIDGET (notebook); tab_pos = get_effective_tab_pos (notebook); allocate_at_bottom = get_allocate_at_bottom (widget, direction); child_allocation = *allocation; switch (tab_pos) { case GTK_POS_BOTTOM: case GTK_POS_TOP: if (allocate_at_bottom) child_allocation.x += allocation->width; anchor = child_allocation.x; break; case GTK_POS_RIGHT: case GTK_POS_LEFT: if (allocate_at_bottom) child_allocation.y += allocation->height; anchor = child_allocation.y; break; default: g_assert_not_reached (); anchor = 0; break; } if (!gtk_widget_compute_bounds (notebook->cur_page->tab_widget, notebook->cur_page->tab_widget, &drag_bounds)) graphene_rect_init_from_rect (&drag_bounds, graphene_rect_zero ()); left_x = CLAMP (notebook->mouse_x - notebook->drag_offset_x, allocation->x, allocation->x + allocation->width - drag_bounds.size.width); top_y = CLAMP (notebook->mouse_y - notebook->drag_offset_y, allocation->y, allocation->y + allocation->height - drag_bounds.size.height); right_x = left_x + drag_bounds.size.width; bottom_y = top_y + drag_bounds.size.height; gap_left = packing_changed = FALSE; if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_BOTTOM) tab_expand_orientation = GTK_ORIENTATION_HORIZONTAL; else tab_expand_orientation = GTK_ORIENTATION_VERTICAL; while (*children && *children != last_child) { page = (*children)->data; if (direction == STEP_NEXT) *children = gtk_notebook_search_page (notebook, *children, direction, TRUE); else { *children = (*children)->next; continue; } if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page)) continue; tab_extra_space = 0; if (*expanded_tabs && (showarrow || page->expand || gtk_widget_compute_expand (page->tab_label, tab_expand_orientation))) { tab_extra_space = *remaining_space / *expanded_tabs; *remaining_space -= tab_extra_space; (*expanded_tabs)--; } switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: child_allocation.width = MAX (1, page->requisition.width + tab_extra_space); /* make sure that the reordered tab doesn't go past the last position */ if (notebook->operation == DRAG_OPERATION_REORDER && !gap_left && packing_changed) { if (!allocate_at_bottom) { if (left_x >= anchor) { left_x = notebook->drag_surface_x = anchor; anchor += drag_bounds.size.width; } } else { if (right_x <= anchor) { anchor -= drag_bounds.size.width; left_x = notebook->drag_surface_x = anchor; } } gap_left = TRUE; } if (notebook->operation == DRAG_OPERATION_REORDER && page == notebook->cur_page) { notebook->drag_surface_x = left_x; notebook->drag_surface_y = child_allocation.y; } else { if (allocate_at_bottom) anchor -= child_allocation.width; if (notebook->operation == DRAG_OPERATION_REORDER) { if (!allocate_at_bottom && left_x >= anchor && left_x <= anchor + child_allocation.width / 2) anchor += drag_bounds.size.width; else if (allocate_at_bottom && right_x >= anchor + child_allocation.width / 2 && right_x <= anchor + child_allocation.width) anchor -= drag_bounds.size.width; } child_allocation.x = anchor; } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: child_allocation.height = MAX (1, page->requisition.height + tab_extra_space); /* make sure that the reordered tab doesn't go past the last position */ if (notebook->operation == DRAG_OPERATION_REORDER && !gap_left && packing_changed) { if (!allocate_at_bottom && top_y >= anchor) { top_y = notebook->drag_surface_y = anchor; anchor += drag_bounds.size.height; } gap_left = TRUE; } if (notebook->operation == DRAG_OPERATION_REORDER && page == notebook->cur_page) { notebook->drag_surface_x = child_allocation.x; notebook->drag_surface_y = top_y; } else { if (allocate_at_bottom) anchor -= child_allocation.height; if (notebook->operation == DRAG_OPERATION_REORDER) { if (!allocate_at_bottom && top_y >= anchor && top_y <= anchor + child_allocation.height / 2) anchor += drag_bounds.size.height; else if (allocate_at_bottom && bottom_y >= anchor + child_allocation.height / 2 && bottom_y <= anchor + child_allocation.height) anchor -= drag_bounds.size.height; } child_allocation.y = anchor; } break; default: g_assert_not_reached (); break; } /* set child visible */ if (page->tab_label) gtk_widget_set_child_visible (page->tab_widget, TRUE); if (page == notebook->cur_page && notebook->operation == DRAG_OPERATION_REORDER) { GtkAllocation fixed_allocation = { notebook->drag_surface_x, notebook->drag_surface_y, child_allocation.width, child_allocation.height }; gtk_widget_size_allocate (page->tab_widget, &fixed_allocation, -1); } else if (page == notebook->detached_tab && notebook->operation == DRAG_OPERATION_DETACH) { /* needs to be allocated at 0,0 * to be shown in the drag window */ GtkAllocation fixed_allocation = { 0, 0, child_allocation.width, child_allocation.height }; gtk_widget_size_allocate (page->tab_widget, &fixed_allocation, -1); } else if (gtk_notebook_page_tab_label_is_visible (page)) { gtk_widget_size_allocate (page->tab_widget, &child_allocation, -1); } /* calculate whether to leave a gap based on reorder operation or not */ switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (notebook->operation != DRAG_OPERATION_REORDER || page != notebook->cur_page) { if (notebook->operation == DRAG_OPERATION_REORDER) { if (!allocate_at_bottom && left_x > anchor + child_allocation.width / 2 && left_x <= anchor + child_allocation.width) anchor += drag_bounds.size.width; else if (allocate_at_bottom && right_x >= anchor && right_x <= anchor + child_allocation.width / 2) anchor -= drag_bounds.size.width; } if (!allocate_at_bottom) anchor += child_allocation.width; } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (notebook->operation != DRAG_OPERATION_REORDER || page != notebook->cur_page) { if (notebook->operation == DRAG_OPERATION_REORDER) { if (!allocate_at_bottom && top_y >= anchor + child_allocation.height / 2 && top_y <= anchor + child_allocation.height) anchor += drag_bounds.size.height; else if (allocate_at_bottom && bottom_y >= anchor && bottom_y <= anchor + child_allocation.height / 2) anchor -= drag_bounds.size.height; } if (!allocate_at_bottom) anchor += child_allocation.height; } break; default: g_assert_not_reached (); break; } } /* Don't move the current tab past the last position during tabs reordering */ if (notebook->operation == DRAG_OPERATION_REORDER && direction == STEP_NEXT) { switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: if (allocate_at_bottom) anchor -= drag_bounds.size.width; if ((!allocate_at_bottom && notebook->drag_surface_x > anchor) || (allocate_at_bottom && notebook->drag_surface_x < anchor)) notebook->drag_surface_x = anchor; break; case GTK_POS_LEFT: case GTK_POS_RIGHT: if (allocate_at_bottom) anchor -= drag_bounds.size.height; if ((!allocate_at_bottom && notebook->drag_surface_y > anchor) || (allocate_at_bottom && notebook->drag_surface_y < anchor)) notebook->drag_surface_y = anchor; break; default: g_assert_not_reached (); break; } } } static void gtk_notebook_pages_allocate (GtkNotebook *notebook, int width, int height) { GList *children = NULL; GList *last_child = NULL; gboolean showarrow = FALSE; GtkAllocation tabs_allocation; gint tab_space, remaining_space; gint expanded_tabs; if (!notebook->show_tabs || !gtk_notebook_has_current_page (notebook)) return; tab_space = remaining_space = 0; expanded_tabs = 1; gtk_notebook_tab_space (notebook, width, height, &showarrow, &tabs_allocation, &tab_space); gtk_notebook_calculate_shown_tabs (notebook, showarrow, &tabs_allocation, tab_space, &last_child, &expanded_tabs, &remaining_space); children = notebook->first_tab; gtk_notebook_calculate_tabs_allocation (notebook, &children, last_child, showarrow, STEP_NEXT, &remaining_space, &expanded_tabs, &tabs_allocation); if (children && children != last_child) { children = notebook->children; gtk_notebook_calculate_tabs_allocation (notebook, &children, last_child, showarrow, STEP_PREV, &remaining_space, &expanded_tabs, &tabs_allocation); } if (!notebook->first_tab) notebook->first_tab = notebook->children; } static void gtk_notebook_calc_tabs (GtkNotebook *notebook, GList *start, GList **end, gint *tab_space, guint direction) { GtkNotebookPage *page = NULL; GList *children; GList *last_calculated_child = NULL; GtkPositionType tab_pos = get_effective_tab_pos (notebook); if (!start) return; children = start; switch (tab_pos) { case GTK_POS_TOP: case GTK_POS_BOTTOM: while (children) { page = children->data; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) && gtk_widget_get_visible (page->child)) { *tab_space -= page->requisition.width; if (*tab_space < 0 || children == *end) { if (*tab_space < 0) { *tab_space = - (*tab_space + page->requisition.width); if (*tab_space == 0 && direction == STEP_PREV) children = last_calculated_child; *end = children; } return; } last_calculated_child = children; } if (direction == STEP_NEXT) children = children->next; else children = children->prev; } break; case GTK_POS_LEFT: case GTK_POS_RIGHT: while (children) { page = children->data; if (NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page) && gtk_widget_get_visible (page->child)) { *tab_space -= page->requisition.height; if (*tab_space < 0 || children == *end) { if (*tab_space < 0) { *tab_space = - (*tab_space + page->requisition.height); if (*tab_space == 0 && direction == STEP_PREV) children = last_calculated_child; *end = children; } return; } last_calculated_child = children; } if (direction == STEP_NEXT) children = children->next; else children = children->prev; } break; default: g_assert_not_reached (); break; } } /* Private GtkNotebook Page Switch Methods: * * gtk_notebook_real_switch_page */ static void gtk_notebook_real_switch_page (GtkNotebook *notebook, GtkWidget* child, guint page_num) { GList *list = gtk_notebook_find_child (notebook, GTK_WIDGET (child)); GtkNotebookPage *page = GTK_NOTEBOOK_PAGE_FROM_LIST (list); AtkObject *accessible; gboolean child_has_focus; if (notebook->cur_page == page || !gtk_widget_get_visible (GTK_WIDGET (child))) return; /* save the value here, changing visibility changes focus */ child_has_focus = notebook->child_has_focus; if (notebook->cur_page) { GtkRoot *root = gtk_widget_get_root (GTK_WIDGET (notebook)); GtkWidget *focus = gtk_root_get_focus (root); if (focus) child_has_focus = gtk_widget_is_ancestor (focus, notebook->cur_page->child); gtk_widget_unset_state_flags (notebook->cur_page->tab_widget, GTK_STATE_FLAG_CHECKED); } notebook->cur_page = page; gtk_widget_set_state_flags (page->tab_widget, GTK_STATE_FLAG_CHECKED, FALSE); gtk_widget_set_visible (notebook->header_widget, notebook->show_tabs); if (!notebook->focus_tab || notebook->focus_tab->data != (gpointer) notebook->cur_page) notebook->focus_tab = g_list_find (notebook->children, notebook->cur_page); gtk_stack_set_visible_child (GTK_STACK (notebook->stack_widget), notebook->cur_page->child); gtk_widget_set_child_visible (notebook->cur_page->tab_widget, TRUE); /* If the focus was on the previous page, move it to the first * element on the new page, if possible, or if not, to the * notebook itself. */ if (child_has_focus) { if (notebook->cur_page->last_focus_child && gtk_widget_is_ancestor (notebook->cur_page->last_focus_child, notebook->cur_page->child)) gtk_widget_grab_focus (notebook->cur_page->last_focus_child); else if (!gtk_widget_child_focus (notebook->cur_page->child, GTK_DIR_TAB_FORWARD)) gtk_widget_grab_focus (GTK_WIDGET (notebook)); } update_arrow_state (notebook); accessible = _gtk_widget_peek_accessible (GTK_WIDGET (notebook)); if (accessible != NULL) gtk_notebook_accessible_update_page (GTK_NOTEBOOK_ACCESSIBLE (accessible), gtk_notebook_get_current_page (notebook)); gtk_widget_queue_resize (GTK_WIDGET (notebook)); gtk_widget_queue_resize (notebook->tabs_widget); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_PAGE]); } /* Private GtkNotebook Page Switch Functions: * * gtk_notebook_switch_page * gtk_notebook_page_select * gtk_notebook_switch_focus_tab * gtk_notebook_menu_switch_page */ static void gtk_notebook_switch_page (GtkNotebook *notebook, GtkNotebookPage *page) { guint page_num; if (notebook->cur_page == page) return; page_num = g_list_index (notebook->children, page); g_signal_emit (notebook, notebook_signals[SWITCH_PAGE], 0, page->child, page_num); } static gint gtk_notebook_page_select (GtkNotebook *notebook, gboolean move_focus) { GtkNotebookPage *page; GtkDirectionType dir; GtkPositionType tab_pos = get_effective_tab_pos (notebook); if (!notebook->focus_tab) return FALSE; page = notebook->focus_tab->data; gtk_notebook_switch_page (notebook, page); if (move_focus) { switch (tab_pos) { case GTK_POS_TOP: dir = GTK_DIR_DOWN; break; case GTK_POS_BOTTOM: dir = GTK_DIR_UP; break; case GTK_POS_LEFT: dir = GTK_DIR_RIGHT; break; case GTK_POS_RIGHT: dir = GTK_DIR_LEFT; break; default: g_assert_not_reached (); dir = GTK_DIR_DOWN; break; } if (gtk_widget_child_focus (page->child, dir)) return TRUE; } return FALSE; } static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook, GList *new_child) { GtkNotebookPage *page; if (notebook->focus_tab == new_child) return; notebook->focus_tab = new_child; if (!notebook->show_tabs || !notebook->focus_tab) return; page = notebook->focus_tab->data; gtk_notebook_switch_page (notebook, page); } static void gtk_notebook_menu_switch_page (GtkWidget *widget, GtkNotebookPage *page) { GtkNotebook *notebook; GList *children; guint page_num; notebook = GTK_NOTEBOOK (gtk_widget_get_ancestor (widget, GTK_TYPE_NOTEBOOK)); gtk_popover_popdown (GTK_POPOVER (notebook->menu)); if (notebook->cur_page == page) return; page_num = 0; children = notebook->children; while (children && children->data != page) { children = children->next; page_num++; } g_signal_emit (notebook, notebook_signals[SWITCH_PAGE], 0, page->child, page_num); } /* Private GtkNotebook Menu Functions: * * gtk_notebook_menu_item_create * gtk_notebook_menu_item_recreate * gtk_notebook_menu_label_unparent */ static void gtk_notebook_menu_item_create (GtkNotebook *notebook, GtkNotebookPage *page) { GtkWidget *menu_item; if (page->default_menu) { if (GTK_IS_LABEL (page->tab_label)) page->menu_label = gtk_label_new (gtk_label_get_text (GTK_LABEL (page->tab_label))); else page->menu_label = gtk_label_new (""); g_object_ref_sink (page->menu_label); gtk_widget_set_halign (page->menu_label, GTK_ALIGN_START); gtk_widget_set_valign (page->menu_label, GTK_ALIGN_CENTER); } menu_item = gtk_button_new (); gtk_button_set_has_frame (GTK_BUTTON (menu_item), FALSE); gtk_button_set_child (GTK_BUTTON (menu_item), page->menu_label); gtk_box_append (GTK_BOX (notebook->menu_box), menu_item); g_signal_connect (menu_item, "clicked", G_CALLBACK (gtk_notebook_menu_switch_page), page); if (!gtk_widget_get_visible (page->child)) gtk_widget_hide (menu_item); } static void gtk_notebook_menu_item_recreate (GtkNotebook *notebook, GList *list) { GtkNotebookPage *page = list->data; GtkWidget *menu_item = gtk_widget_get_parent (page->menu_label); gtk_box_remove (GTK_BOX (menu_item), page->menu_label); gtk_widget_unparent (menu_item); gtk_notebook_menu_item_create (notebook, page); } static void gtk_notebook_menu_label_unparent (GtkWidget *widget) { gtk_button_set_child (GTK_BUTTON (widget), NULL); } /* Public GtkNotebook Page Insert/Remove Methods : * * gtk_notebook_append_page * gtk_notebook_append_page_menu * gtk_notebook_prepend_page * gtk_notebook_prepend_page_menu * gtk_notebook_insert_page * gtk_notebook_insert_page_menu * gtk_notebook_remove_page */ /** * gtk_notebook_append_page: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * * Appends a page to @notebook. * * Returns: the index (starting from 0) of the appended * page in the notebook, or -1 if function fails */ gint gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); return gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, -1); } /** * gtk_notebook_append_page_menu: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * @menu_label: (allow-none): the widget to use as a label for the * page-switch menu, if that is enabled. If %NULL, and @tab_label * is a #GtkLabel or %NULL, then the menu label will be a newly * created label with the same text as @tab_label; if @tab_label * is not a #GtkLabel, @menu_label must be specified if the * page-switch menu is to be used. * * Appends a page to @notebook, specifying the widget to use as the * label in the popup menu. * * Returns: the index (starting from 0) of the appended * page in the notebook, or -1 if function fails */ gint gtk_notebook_append_page_menu (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); g_return_val_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label), -1); return gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, -1); } /** * gtk_notebook_prepend_page: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * * Prepends a page to @notebook. * * Returns: the index (starting from 0) of the prepended * page in the notebook, or -1 if function fails */ gint gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); return gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, 0); } /** * gtk_notebook_prepend_page_menu: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * @menu_label: (allow-none): the widget to use as a label for the * page-switch menu, if that is enabled. If %NULL, and @tab_label * is a #GtkLabel or %NULL, then the menu label will be a newly * created label with the same text as @tab_label; if @tab_label * is not a #GtkLabel, @menu_label must be specified if the * page-switch menu is to be used. * * Prepends a page to @notebook, specifying the widget to use as the * label in the popup menu. * * Returns: the index (starting from 0) of the prepended * page in the notebook, or -1 if function fails */ gint gtk_notebook_prepend_page_menu (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); g_return_val_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label), -1); return gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, 0); } /** * gtk_notebook_insert_page: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * @position: the index (starting at 0) at which to insert the page, * or -1 to append the page after all other pages * * Insert a page into @notebook at the given position. * * Returns: the index (starting from 0) of the inserted * page in the notebook, or -1 if function fails */ gint gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, gint position) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); return gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, position); } static gint gtk_notebook_page_compare_tab (gconstpointer a, gconstpointer b) { return (((GtkNotebookPage *) a)->tab_label != b); } static gboolean gtk_notebook_mnemonic_activate_switch_page (GtkWidget *child, gboolean overload, gpointer data) { GtkNotebook *notebook = GTK_NOTEBOOK (data); GList *list; list = g_list_find_custom (notebook->children, child, gtk_notebook_page_compare_tab); if (list) { GtkNotebookPage *page = list->data; gtk_widget_grab_focus (GTK_WIDGET (notebook)); /* Do this first to avoid focusing new page */ gtk_notebook_switch_page (notebook, page); focus_tabs_in (notebook); } return TRUE; } /** * gtk_notebook_insert_page_menu: * @notebook: a #GtkNotebook * @child: the #GtkWidget to use as the contents of the page * @tab_label: (allow-none): the #GtkWidget to be used as the label * for the page, or %NULL to use the default label, “page N” * @menu_label: (allow-none): the widget to use as a label for the * page-switch menu, if that is enabled. If %NULL, and @tab_label * is a #GtkLabel or %NULL, then the menu label will be a newly * created label with the same text as @tab_label; if @tab_label * is not a #GtkLabel, @menu_label must be specified if the * page-switch menu is to be used. * @position: the index (starting at 0) at which to insert the page, * or -1 to append the page after all other pages. * * Insert a page into @notebook at the given position, specifying * the widget to use as the label in the popup menu. * * Returns: the index (starting from 0) of the inserted * page in the notebook */ gint gtk_notebook_insert_page_menu (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label, gint position) { GtkNotebookClass *class; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); g_return_val_if_fail (GTK_IS_WIDGET (child), -1); g_return_val_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label), -1); g_return_val_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label), -1); class = GTK_NOTEBOOK_GET_CLASS (notebook); return (class->insert_page) (notebook, child, tab_label, menu_label, position); } /** * gtk_notebook_remove_page: * @notebook: a #GtkNotebook * @page_num: the index of a notebook page, starting * from 0. If -1, the last page will be removed. * * Removes a page from the notebook given its index * in the notebook. */ void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num) { GList *list = NULL; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (page_num >= 0) list = g_list_nth (notebook->children, page_num); else list = g_list_last (notebook->children); if (list) gtk_notebook_remove (notebook, ((GtkNotebookPage *) list->data)->child); } /* Public GtkNotebook Page Switch Methods : * gtk_notebook_get_current_page * gtk_notebook_page_num * gtk_notebook_set_current_page * gtk_notebook_next_page * gtk_notebook_prev_page */ /** * gtk_notebook_get_current_page: * @notebook: a #GtkNotebook * * Returns the page number of the current page. * * Returns: the index (starting from 0) of the current * page in the notebook. If the notebook has no pages, * then -1 will be returned. */ gint gtk_notebook_get_current_page (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); if (!notebook->cur_page) return -1; return g_list_index (notebook->children, notebook->cur_page); } /** * gtk_notebook_get_nth_page: * @notebook: a #GtkNotebook * @page_num: the index of a page in the notebook, or -1 * to get the last page * * Returns the child widget contained in page number @page_num. * * Returns: (nullable) (transfer none): the child widget, or %NULL if @page_num * is out of bounds */ GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook, gint page_num) { GtkNotebookPage *page; GList *list; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); if (page_num >= 0) list = g_list_nth (notebook->children, page_num); else list = g_list_last (notebook->children); if (list) { page = list->data; return page->child; } return NULL; } /** * gtk_notebook_get_n_pages: * @notebook: a #GtkNotebook * * Gets the number of pages in a notebook. * * Returns: the number of pages in the notebook */ gint gtk_notebook_get_n_pages (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), 0); return g_list_length (notebook->children); } /** * gtk_notebook_page_num: * @notebook: a #GtkNotebook * @child: a #GtkWidget * * Finds the index of the page which contains the given child * widget. * * Returns: the index of the page containing @child, or * -1 if @child is not in the notebook */ gint gtk_notebook_page_num (GtkNotebook *notebook, GtkWidget *child) { GList *children; gint num; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1); num = 0; children = notebook->children; while (children) { GtkNotebookPage *page = children->data; if (page->child == child) return num; children = children->next; num++; } return -1; } /** * gtk_notebook_set_current_page: * @notebook: a #GtkNotebook * @page_num: index of the page to switch to, starting from 0. * If negative, the last page will be used. If greater * than the number of pages in the notebook, nothing * will be done. * * Switches to the page number @page_num. * * Note that due to historical reasons, GtkNotebook refuses * to switch to a page unless the child widget is visible. * Therefore, it is recommended to show child widgets before * adding them to a notebook. */ void gtk_notebook_set_current_page (GtkNotebook *notebook, gint page_num) { GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (page_num < 0) page_num = g_list_length (notebook->children) - 1; list = g_list_nth (notebook->children, page_num); if (list) gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE_FROM_LIST (list)); } /** * gtk_notebook_next_page: * @notebook: a #GtkNotebook * * Switches to the next page. Nothing happens if the current page is * the last page. */ void gtk_notebook_next_page (GtkNotebook *notebook) { GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); list = g_list_find (notebook->children, notebook->cur_page); if (!list) return; list = gtk_notebook_search_page (notebook, list, STEP_NEXT, TRUE); if (!list) return; gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE_FROM_LIST (list)); } /** * gtk_notebook_prev_page: * @notebook: a #GtkNotebook * * Switches to the previous page. Nothing happens if the current page * is the first page. */ void gtk_notebook_prev_page (GtkNotebook *notebook) { GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); list = g_list_find (notebook->children, notebook->cur_page); if (!list) return; list = gtk_notebook_search_page (notebook, list, STEP_PREV, TRUE); if (!list) return; gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE_FROM_LIST (list)); } /* Public GtkNotebook/Tab Style Functions * * gtk_notebook_set_show_border * gtk_notebook_get_show_border * gtk_notebook_set_show_tabs * gtk_notebook_get_show_tabs * gtk_notebook_set_tab_pos * gtk_notebook_get_tab_pos * gtk_notebook_set_scrollable * gtk_notebook_get_scrollable */ /** * gtk_notebook_set_show_border: * @notebook: a #GtkNotebook * @show_border: %TRUE if a bevel should be drawn around the notebook * * Sets whether a bevel will be drawn around the notebook pages. * This only has a visual effect when the tabs are not shown. * See gtk_notebook_set_show_tabs(). */ void gtk_notebook_set_show_border (GtkNotebook *notebook, gboolean show_border) { g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (notebook->show_border != show_border) { notebook->show_border = show_border; if (show_border) gtk_widget_add_css_class (GTK_WIDGET (notebook), GTK_STYLE_CLASS_FRAME); else gtk_widget_remove_css_class (GTK_WIDGET (notebook), GTK_STYLE_CLASS_FRAME); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_SHOW_BORDER]); } } /** * gtk_notebook_get_show_border: * @notebook: a #GtkNotebook * * Returns whether a bevel will be drawn around the notebook pages. * See gtk_notebook_set_show_border(). * * Returns: %TRUE if the bevel is drawn */ gboolean gtk_notebook_get_show_border (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE); return notebook->show_border; } /** * gtk_notebook_set_show_tabs: * @notebook: a #GtkNotebook * @show_tabs: %TRUE if the tabs should be shown * * Sets whether to show the tabs for the notebook or not. */ void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gboolean show_tabs) { GtkNotebookPage *page; GList *children; gint i; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); show_tabs = show_tabs != FALSE; if (notebook->show_tabs == show_tabs) return; notebook->show_tabs = show_tabs; children = notebook->children; if (!show_tabs) { while (children) { page = children->data; children = children->next; if (page->default_tab) { gtk_widget_unparent (page->tab_label); page->tab_label = NULL; } else gtk_widget_hide (page->tab_label); } gtk_widget_hide (notebook->header_widget); } else { gtk_notebook_update_labels (notebook); gtk_widget_show (notebook->header_widget); } for (i = 0; i < N_ACTION_WIDGETS; i++) { if (notebook->action_widget[i]) gtk_widget_set_child_visible (notebook->action_widget[i], show_tabs); } gtk_notebook_update_tab_pos (notebook); gtk_widget_queue_resize (GTK_WIDGET (notebook)); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_SHOW_TABS]); } /** * gtk_notebook_get_show_tabs: * @notebook: a #GtkNotebook * * Returns whether the tabs of the notebook are shown. * See gtk_notebook_set_show_tabs(). * * Returns: %TRUE if the tabs are shown */ gboolean gtk_notebook_get_show_tabs (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE); return notebook->show_tabs; } static void gtk_notebook_update_tab_pos (GtkNotebook *notebook) { GtkLayoutManager *layout; GtkPositionType tab_pos; const char *tab_pos_names[] = { GTK_STYLE_CLASS_LEFT, GTK_STYLE_CLASS_RIGHT, GTK_STYLE_CLASS_TOP, GTK_STYLE_CLASS_BOTTOM }; gint i; tab_pos = get_effective_tab_pos (notebook); for (i = 0; i < G_N_ELEMENTS (tab_pos_names); i++) { if (tab_pos == i) gtk_widget_add_css_class (notebook->header_widget, tab_pos_names[i]); else gtk_widget_remove_css_class (notebook->header_widget, tab_pos_names[i]); } layout = gtk_widget_get_layout_manager (GTK_WIDGET (notebook)); switch (tab_pos) { case GTK_POS_TOP: gtk_widget_set_hexpand (notebook->tabs_widget, TRUE); gtk_widget_set_vexpand (notebook->tabs_widget, FALSE); gtk_widget_set_hexpand (notebook->header_widget, TRUE); gtk_widget_set_vexpand (notebook->header_widget, FALSE); if (notebook->show_tabs) { gtk_widget_insert_before (notebook->header_widget, GTK_WIDGET (notebook), notebook->stack_widget); gtk_css_node_insert_before (gtk_widget_get_css_node (GTK_WIDGET (notebook)), gtk_widget_get_css_node (notebook->header_widget), gtk_widget_get_css_node (notebook->stack_widget)); } gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_VERTICAL); gtk_orientable_set_orientation (GTK_ORIENTABLE (notebook->header_widget), GTK_ORIENTATION_HORIZONTAL); break; case GTK_POS_BOTTOM: gtk_widget_set_hexpand (notebook->tabs_widget, TRUE); gtk_widget_set_vexpand (notebook->tabs_widget, FALSE); gtk_widget_set_hexpand (notebook->header_widget, TRUE); gtk_widget_set_vexpand (notebook->header_widget, FALSE); if (notebook->show_tabs) { gtk_widget_insert_after (notebook->header_widget, GTK_WIDGET (notebook), notebook->stack_widget); gtk_css_node_insert_after (gtk_widget_get_css_node (GTK_WIDGET (notebook)), gtk_widget_get_css_node (notebook->header_widget), gtk_widget_get_css_node (notebook->stack_widget)); } gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_VERTICAL); gtk_orientable_set_orientation (GTK_ORIENTABLE (notebook->header_widget), GTK_ORIENTATION_HORIZONTAL); break; case GTK_POS_LEFT: gtk_widget_set_hexpand (notebook->tabs_widget, FALSE); gtk_widget_set_vexpand (notebook->tabs_widget, TRUE); gtk_widget_set_hexpand (notebook->header_widget, FALSE); gtk_widget_set_vexpand (notebook->header_widget, TRUE); if (notebook->show_tabs) { gtk_widget_insert_before (notebook->header_widget, GTK_WIDGET (notebook), notebook->stack_widget); gtk_css_node_insert_before (gtk_widget_get_css_node (GTK_WIDGET (notebook)), gtk_widget_get_css_node (notebook->header_widget), gtk_widget_get_css_node (notebook->stack_widget)); } gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_HORIZONTAL); gtk_orientable_set_orientation (GTK_ORIENTABLE (notebook->header_widget), GTK_ORIENTATION_VERTICAL); break; case GTK_POS_RIGHT: gtk_widget_set_hexpand (notebook->tabs_widget, FALSE); gtk_widget_set_vexpand (notebook->tabs_widget, TRUE); gtk_widget_set_hexpand (notebook->header_widget, FALSE); gtk_widget_set_vexpand (notebook->header_widget, TRUE); if (notebook->show_tabs) { gtk_widget_insert_after (notebook->header_widget, GTK_WIDGET (notebook), notebook->stack_widget); gtk_css_node_insert_after (gtk_widget_get_css_node (GTK_WIDGET (notebook)), gtk_widget_get_css_node (notebook->header_widget), gtk_widget_get_css_node (notebook->stack_widget)); } gtk_orientable_set_orientation (GTK_ORIENTABLE (layout), GTK_ORIENTATION_HORIZONTAL); gtk_orientable_set_orientation (GTK_ORIENTABLE (notebook->header_widget), GTK_ORIENTATION_VERTICAL); break; default: g_assert_not_reached (); break; } } /** * gtk_notebook_set_tab_pos: * @notebook: a #GtkNotebook. * @pos: the edge to draw the tabs at * * Sets the edge at which the tabs for switching pages in the * notebook are drawn. */ void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos) { g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (notebook->tab_pos != pos) { notebook->tab_pos = pos; gtk_widget_queue_resize (GTK_WIDGET (notebook)); gtk_notebook_update_tab_pos (notebook); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_TAB_POS]); } } /** * gtk_notebook_get_tab_pos: * @notebook: a #GtkNotebook * * Gets the edge at which the tabs for switching pages in the * notebook are drawn. * * Returns: the edge at which the tabs are drawn */ GtkPositionType gtk_notebook_get_tab_pos (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), GTK_POS_TOP); return notebook->tab_pos; } /** * gtk_notebook_set_scrollable: * @notebook: a #GtkNotebook * @scrollable: %TRUE if scroll arrows should be added * * Sets whether the tab label area will have arrows for * scrolling if there are too many tabs to fit in the area. */ void gtk_notebook_set_scrollable (GtkNotebook *notebook, gboolean scrollable) { g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); scrollable = (scrollable != FALSE); if (notebook->scrollable == scrollable) return; notebook->scrollable = scrollable; update_arrow_nodes (notebook); update_arrow_state (notebook); gtk_widget_queue_resize (GTK_WIDGET (notebook)); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_SCROLLABLE]); } /** * gtk_notebook_get_scrollable: * @notebook: a #GtkNotebook * * Returns whether the tab label area has arrows for scrolling. * See gtk_notebook_set_scrollable(). * * Returns: %TRUE if arrows for scrolling are present */ gboolean gtk_notebook_get_scrollable (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE); return notebook->scrollable; } /* Public GtkNotebook Popup Menu Methods: * * gtk_notebook_popup_enable * gtk_notebook_popup_disable */ /** * gtk_notebook_popup_enable: * @notebook: a #GtkNotebook * * Enables the popup menu: if the user clicks with the right * mouse button on the tab labels, a menu with all the pages * will be popped up. */ void gtk_notebook_popup_enable (GtkNotebook *notebook) { GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (notebook->menu) return; notebook->menu = gtk_popover_menu_new (); gtk_widget_set_parent (notebook->menu, notebook->tabs_widget); notebook->menu_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); g_object_ref_sink (notebook->menu_box); gtk_popover_menu_add_submenu (GTK_POPOVER_MENU (notebook->menu), notebook->menu_box, "main"); for (list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, FALSE); list; list = gtk_notebook_search_page (notebook, list, STEP_NEXT, FALSE)) gtk_notebook_menu_item_create (notebook, list->data); gtk_notebook_update_labels (notebook); g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_ENABLE_POPUP]); } /** * gtk_notebook_popup_disable: * @notebook: a #GtkNotebook * * Disables the popup menu. */ void gtk_notebook_popup_disable (GtkNotebook *notebook) { GtkWidget *child; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (!notebook->menu) return; for (child = gtk_widget_get_first_child (notebook->menu_box); child != NULL; child = gtk_widget_get_next_sibling (child)) gtk_notebook_menu_label_unparent (child); notebook->menu = NULL; notebook->menu_box = NULL; g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_ENABLE_POPUP]); } /* Public GtkNotebook Page Properties Functions: * * gtk_notebook_get_tab_label * gtk_notebook_set_tab_label * gtk_notebook_set_tab_label_text * gtk_notebook_get_menu_label * gtk_notebook_set_menu_label * gtk_notebook_set_menu_label_text * gtk_notebook_get_tab_reorderable * gtk_notebook_set_tab_reorderable * gtk_notebook_get_tab_detachable * gtk_notebook_set_tab_detachable */ /** * gtk_notebook_get_tab_label: * @notebook: a #GtkNotebook * @child: the page * * Returns the tab label widget for the page @child. * %NULL is returned if @child is not in @notebook or * if no tab label has specifically been set for @child. * * Returns: (transfer none) (nullable): the tab label */ GtkWidget * gtk_notebook_get_tab_label (GtkNotebook *notebook, GtkWidget *child) { GList *list; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); g_return_val_if_fail (GTK_IS_WIDGET (child), NULL); list = gtk_notebook_find_child (notebook, child); if (list == NULL) return NULL; if (GTK_NOTEBOOK_PAGE_FROM_LIST (list)->default_tab) return NULL; return GTK_NOTEBOOK_PAGE_FROM_LIST (list)->tab_label; } /** * gtk_notebook_set_tab_label: * @notebook: a #GtkNotebook * @child: the page * @tab_label: (allow-none): the tab label widget to use, or %NULL * for default tab label * * Changes the tab label for @child. * If %NULL is specified for @tab_label, then the page will * have the label “page N”. */ void gtk_notebook_set_tab_label (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label) { GtkNotebookPage *page; GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (GTK_IS_WIDGET (child)); list = gtk_notebook_find_child (notebook, child); g_return_if_fail (list != NULL); /* a NULL pointer indicates a default_tab setting, otherwise * we need to set the associated label */ page = list->data; if (page->tab_label == tab_label) return; gtk_notebook_remove_tab_label (notebook, page); if (tab_label) { page->default_tab = FALSE; page->tab_label = tab_label; g_object_set_data (G_OBJECT (page->tab_label), "notebook", notebook); gtk_widget_set_parent (page->tab_label, page->tab_widget); } else { page->default_tab = TRUE; page->tab_label = NULL; if (notebook->show_tabs) { gchar string[32]; g_snprintf (string, sizeof(string), _("Page %u"), g_list_position (notebook->children, list)); page->tab_label = gtk_label_new (string); gtk_widget_set_parent (page->tab_label, page->tab_widget); g_object_set_data (G_OBJECT (page->tab_label), "notebook", notebook); } } if (page->tab_label) page->mnemonic_activate_signal = g_signal_connect (page->tab_label, "mnemonic-activate", G_CALLBACK (gtk_notebook_mnemonic_activate_switch_page), notebook); if (notebook->show_tabs && gtk_widget_get_visible (child)) { gtk_widget_show (page->tab_label); gtk_widget_queue_resize (GTK_WIDGET (notebook)); } if (notebook->menu) gtk_notebook_menu_item_recreate (notebook, list); g_object_notify (G_OBJECT (page), "tab-label"); } /** * gtk_notebook_set_tab_label_text: * @notebook: a #GtkNotebook * @child: the page * @tab_text: the label text * * Creates a new label and sets it as the tab label for the page * containing @child. */ void gtk_notebook_set_tab_label_text (GtkNotebook *notebook, GtkWidget *child, const gchar *tab_text) { GtkWidget *tab_label = NULL; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (tab_text) tab_label = gtk_label_new (tab_text); gtk_notebook_set_tab_label (notebook, child, tab_label); } /** * gtk_notebook_get_tab_label_text: * @notebook: a #GtkNotebook * @child: a widget contained in a page of @notebook * * Retrieves the text of the tab label for the page containing * @child. * * Returns: (nullable): the text of the tab label, or %NULL if the tab label * widget is not a #GtkLabel. The string is owned by the widget and must not be * freed. */ const gchar * gtk_notebook_get_tab_label_text (GtkNotebook *notebook, GtkWidget *child) { GtkWidget *tab_label; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); g_return_val_if_fail (GTK_IS_WIDGET (child), NULL); tab_label = gtk_notebook_get_tab_label (notebook, child); if (GTK_IS_LABEL (tab_label)) return gtk_label_get_text (GTK_LABEL (tab_label)); else return NULL; } /** * gtk_notebook_get_menu_label: * @notebook: a #GtkNotebook * @child: a widget contained in a page of @notebook * * Retrieves the menu label widget of the page containing @child. * * Returns: (nullable) (transfer none): the menu label, or %NULL if the * notebook page does not have a menu label other than the default (the tab * label). */ GtkWidget* gtk_notebook_get_menu_label (GtkNotebook *notebook, GtkWidget *child) { GList *list; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); g_return_val_if_fail (GTK_IS_WIDGET (child), NULL); list = gtk_notebook_find_child (notebook, child); g_return_val_if_fail (list != NULL, NULL); if (GTK_NOTEBOOK_PAGE_FROM_LIST (list)->default_menu) return NULL; return GTK_NOTEBOOK_PAGE_FROM_LIST (list)->menu_label; } /** * gtk_notebook_set_menu_label: * @notebook: a #GtkNotebook * @child: the child widget * @menu_label: (allow-none): the menu label, or %NULL for default * * Changes the menu label for the page containing @child. */ void gtk_notebook_set_menu_label (GtkNotebook *notebook, GtkWidget *child, GtkWidget *menu_label) { GtkNotebookPage *page; GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (GTK_IS_WIDGET (child)); list = gtk_notebook_find_child (notebook, child); g_return_if_fail (list != NULL); page = list->data; if (page->menu_label) { if (notebook->menu) gtk_widget_unparent (gtk_widget_get_parent (page->menu_label)); g_clear_object (&page->menu_label); } if (menu_label) { page->menu_label = menu_label; g_object_ref_sink (page->menu_label); page->default_menu = FALSE; } else page->default_menu = TRUE; if (notebook->menu) gtk_notebook_menu_item_create (notebook, page); g_object_notify (G_OBJECT (page), "menu-label"); } /** * gtk_notebook_set_menu_label_text: * @notebook: a #GtkNotebook * @child: the child widget * @menu_text: the label text * * Creates a new label and sets it as the menu label of @child. */ void gtk_notebook_set_menu_label_text (GtkNotebook *notebook, GtkWidget *child, const gchar *menu_text) { GtkWidget *menu_label = NULL; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); if (menu_text) { menu_label = gtk_label_new (menu_text); gtk_widget_set_halign (menu_label, GTK_ALIGN_START); gtk_widget_set_valign (menu_label, GTK_ALIGN_CENTER); } gtk_notebook_set_menu_label (notebook, child, menu_label); } /** * gtk_notebook_get_menu_label_text: * @notebook: a #GtkNotebook * @child: the child widget of a page of the notebook. * * Retrieves the text of the menu label for the page containing * @child. * * Returns: (nullable): the text of the tab label, or %NULL if the widget does * not have a menu label other than the default menu label, or the menu label * widget is not a #GtkLabel. The string is owned by the widget and must not be * freed. */ const gchar * gtk_notebook_get_menu_label_text (GtkNotebook *notebook, GtkWidget *child) { GtkWidget *menu_label; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); g_return_val_if_fail (GTK_IS_WIDGET (child), NULL); menu_label = gtk_notebook_get_menu_label (notebook, child); if (GTK_IS_LABEL (menu_label)) return gtk_label_get_text (GTK_LABEL (menu_label)); else return NULL; } /* Helper function called when pages are reordered */ static void gtk_notebook_child_reordered (GtkNotebook *notebook, GtkNotebookPage *page) { GList *list; GtkCssNode *sibling; list = g_list_find (notebook->children, page); if (notebook->menu) gtk_notebook_menu_item_recreate (notebook, list); if (list->prev) sibling = gtk_widget_get_css_node (GTK_NOTEBOOK_PAGE_FROM_LIST (list->prev)->tab_widget); else if (notebook->arrow_widget[ARROW_RIGHT_BEFORE]) sibling = gtk_widget_get_css_node (notebook->arrow_widget[ARROW_RIGHT_BEFORE]); else if (notebook->arrow_widget[ARROW_LEFT_BEFORE]) sibling = gtk_widget_get_css_node (notebook->arrow_widget[ARROW_LEFT_BEFORE]); else sibling = NULL; gtk_css_node_insert_after (gtk_widget_get_css_node (notebook->tabs_widget), gtk_widget_get_css_node (page->tab_widget), sibling); gtk_notebook_update_labels (notebook); gtk_widget_queue_allocate (notebook->tabs_widget); } /** * gtk_notebook_reorder_child: * @notebook: a #GtkNotebook * @child: the child to move * @position: the new position, or -1 to move to the end * * Reorders the page containing @child, so that it appears in position * @position. If @position is greater than or equal to the number of * children in the list or negative, @child will be moved to the end * of the list. */ void gtk_notebook_reorder_child (GtkNotebook *notebook, GtkWidget *child, gint position) { GList *list, *new_list; GtkNotebookPage *page; gint old_pos; gint max_pos; gint i; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (GTK_IS_WIDGET (child)); list = gtk_notebook_find_child (notebook, child); g_return_if_fail (list != NULL); max_pos = g_list_length (notebook->children) - 1; if (position < 0 || position > max_pos) position = max_pos; old_pos = g_list_position (notebook->children, list); if (old_pos == position) return; page = list->data; notebook->children = g_list_delete_link (notebook->children, list); notebook->children = g_list_insert (notebook->children, page, position); new_list = g_list_nth (notebook->children, position); /* Fix up GList references in GtkNotebook structure */ if (notebook->first_tab == list) notebook->first_tab = new_list; if (notebook->focus_tab == list) notebook->focus_tab = new_list; /* Move around the menu items if necessary */ gtk_notebook_child_reordered (notebook, page); for (list = notebook->children, i = 0; list; list = list->next, i++) { if (MIN (old_pos, position) <= i && i <= MAX (old_pos, position)) g_object_notify (G_OBJECT (list->data), "position"); } g_signal_emit (notebook, notebook_signals[PAGE_REORDERED], 0, child, position); } /** * gtk_notebook_set_group_name: * @notebook: a #GtkNotebook * @group_name: (allow-none): the name of the notebook group, * or %NULL to unset it * * Sets a group name for @notebook. * * Notebooks with the same name will be able to exchange tabs * via drag and drop. A notebook with a %NULL group name will * not be able to exchange tabs with any other notebook. */ void gtk_notebook_set_group_name (GtkNotebook *notebook, const gchar *group_name) { GQuark group; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); group = g_quark_from_string (group_name); if (notebook->group != group) { notebook->group = group; g_object_notify_by_pspec (G_OBJECT (notebook), properties[PROP_GROUP_NAME]); } } /** * gtk_notebook_get_group_name: * @notebook: a #GtkNotebook * * Gets the current group name for @notebook. * * Returns: (nullable) (transfer none): the group name, or %NULL if none is set */ const gchar * gtk_notebook_get_group_name (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); return g_quark_to_string (notebook->group); } /** * gtk_notebook_get_tab_reorderable: * @notebook: a #GtkNotebook * @child: a child #GtkWidget * * Gets whether the tab can be reordered via drag and drop or not. * * Returns: %TRUE if the tab is reorderable. */ gboolean gtk_notebook_get_tab_reorderable (GtkNotebook *notebook, GtkWidget *child) { GList *list; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE); g_return_val_if_fail (GTK_IS_WIDGET (child), FALSE); list = gtk_notebook_find_child (notebook, child); g_return_val_if_fail (list != NULL, FALSE); return GTK_NOTEBOOK_PAGE_FROM_LIST (list)->reorderable; } /** * gtk_notebook_set_tab_reorderable: * @notebook: a #GtkNotebook * @child: a child #GtkWidget * @reorderable: whether the tab is reorderable or not * * Sets whether the notebook tab can be reordered * via drag and drop or not. */ void gtk_notebook_set_tab_reorderable (GtkNotebook *notebook, GtkWidget *child, gboolean reorderable) { GtkNotebookPage *page; GList *list; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (GTK_IS_WIDGET (child)); list = gtk_notebook_find_child (notebook, child); g_return_if_fail (list != NULL); page = GTK_NOTEBOOK_PAGE_FROM_LIST (list); reorderable = reorderable != FALSE; if (page->reorderable != reorderable) { page->reorderable = reorderable; if (reorderable) gtk_widget_add_css_class (page->tab_widget, "reorderable-page"); else gtk_widget_remove_css_class (page->tab_widget, "reorderable-page"); g_object_notify (G_OBJECT (page), "reorderable"); } } /** * gtk_notebook_get_tab_detachable: * @notebook: a #GtkNotebook * @child: a child #GtkWidget * * Returns whether the tab contents can be detached from @notebook. * * Returns: %TRUE if the tab is detachable. */ gboolean gtk_notebook_get_tab_detachable (GtkNotebook *notebook, GtkWidget *child) { GList *list; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE); g_return_val_if_fail (GTK_IS_WIDGET (child), FALSE); list = gtk_notebook_find_child (notebook, child); g_return_val_if_fail (list != NULL, FALSE); return GTK_NOTEBOOK_PAGE_FROM_LIST (list)->detachable; } /** * gtk_notebook_set_tab_detachable: * @notebook: a #GtkNotebook * @child: a child #GtkWidget * @detachable: whether the tab is detachable or not * * Sets whether the tab can be detached from @notebook to another * notebook or widget. * * Note that 2 notebooks must share a common group identificator * (see gtk_notebook_set_group_name()) to allow automatic tabs * interchange between them. * * If you want a widget to interact with a notebook through DnD * (i.e.: accept dragged tabs from it) it must be set as a drop * destination and accept the target “GTK_NOTEBOOK_TAB”. The notebook * will fill the selection with a GtkWidget** pointing to the child * widget that corresponds to the dropped tab. * * Note that you should use gtk_notebook_detach_tab() instead * of gtk_container_remove() if you want to remove the tab from * the source notebook as part of accepting a drop. Otherwise, * the source notebook will think that the dragged tab was * removed from underneath the ongoing drag operation, and * will initiate a drag cancel animation. * * |[ * static void * on_drag_data_received (GtkWidget *widget, * GdkDrop *drop, * GtkSelectionData *data, * guint time, * gpointer user_data) * { * GtkDrag *drag; * GtkWidget *notebook; * GtkWidget **child; * * drag = gtk_drop_get_drag (drop); * notebook = g_object_get_data (drag, "gtk-notebook-drag-origin"); * child = (void*) gtk_selection_data_get_data (data); * * // process_widget (*child); * * gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child); * } * ]| * * If you want a notebook to accept drags from other widgets, * you will have to set your own DnD code to do it. */ void gtk_notebook_set_tab_detachable (GtkNotebook *notebook, GtkWidget *child, gboolean detachable) { GList *list; GtkNotebookPage *page; g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (GTK_IS_WIDGET (child)); list = gtk_notebook_find_child (notebook, child); g_return_if_fail (list != NULL); page = GTK_NOTEBOOK_PAGE_FROM_LIST (list); detachable = detachable != FALSE; if (page->detachable != detachable) { page->detachable = detachable; g_object_notify (G_OBJECT (page), "detachable"); } } /** * gtk_notebook_get_action_widget: * @notebook: a #GtkNotebook * @pack_type: pack type of the action widget to receive * * Gets one of the action widgets. See gtk_notebook_set_action_widget(). * * Returns: (nullable) (transfer none): The action widget with the given * @pack_type or %NULL when this action widget has not been set */ GtkWidget* gtk_notebook_get_action_widget (GtkNotebook *notebook, GtkPackType pack_type) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); return notebook->action_widget[pack_type]; } /** * gtk_notebook_set_action_widget: * @notebook: a #GtkNotebook * @widget: a #GtkWidget * @pack_type: pack type of the action widget * * Sets @widget as one of the action widgets. Depending on the pack type * the widget will be placed before or after the tabs. You can use * a #GtkBox if you need to pack more than one widget on the same side. * * Note that action widgets are “internal” children of the notebook and thus * not included in the list returned from gtk_container_foreach(). */ void gtk_notebook_set_action_widget (GtkNotebook *notebook, GtkWidget *widget, GtkPackType pack_type) { g_return_if_fail (GTK_IS_NOTEBOOK (notebook)); g_return_if_fail (!widget || GTK_IS_WIDGET (widget)); g_return_if_fail (!widget || gtk_widget_get_parent (widget) == NULL); if (notebook->action_widget[pack_type]) gtk_box_remove (GTK_BOX (notebook->header_widget), notebook->action_widget[pack_type]); notebook->action_widget[pack_type] = widget; if (widget) { gtk_box_append (GTK_BOX (notebook->header_widget), widget); if (pack_type == GTK_PACK_START) gtk_box_reorder_child_after (GTK_BOX (notebook->header_widget), widget, NULL); else gtk_box_reorder_child_after (GTK_BOX (notebook->header_widget), widget, gtk_widget_get_last_child (notebook->header_widget)); gtk_widget_set_child_visible (widget, notebook->show_tabs); } gtk_widget_queue_resize (GTK_WIDGET (notebook)); } /** * gtk_notebook_get_page: * @notebook: a #GtkNotebook * @child: a child of @notebook * * Returns the #GtkNotebookPage for @child. * * Returns: (transfer none): the #GtkNotebookPage for @child */ GtkNotebookPage * gtk_notebook_get_page (GtkNotebook *notebook, GtkWidget *child) { GList *list; GtkNotebookPage *page = NULL; g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); g_return_val_if_fail (GTK_IS_WIDGET (child), NULL); list = gtk_notebook_find_child (notebook, child); if (list != NULL) page = list->data; return page; } /** * gtk_notebook_page_get_child: * @page: a #GtkNotebookPage * * Returns the notebook child to which @page belongs. * * Returns: (transfer none): the child to which @page belongs */ GtkWidget * gtk_notebook_page_get_child (GtkNotebookPage *page) { return page->child; } #define GTK_TYPE_NOTEBOOK_PAGES (gtk_notebook_pages_get_type ()) G_DECLARE_FINAL_TYPE (GtkNotebookPages, gtk_notebook_pages, GTK, NOTEBOOK_PAGES, GObject) struct _GtkNotebookPages { GObject parent_instance; GtkNotebook *notebook; }; struct _GtkNotebookPagesClass { GObjectClass parent_class; }; static GType gtk_notebook_pages_get_item_type (GListModel *model) { return GTK_TYPE_NOTEBOOK_PAGE; } static guint gtk_notebook_pages_get_n_items (GListModel *model) { GtkNotebookPages *pages = GTK_NOTEBOOK_PAGES (model); return g_list_length (pages->notebook->children); } static gpointer gtk_notebook_pages_get_item (GListModel *model, guint position) { GtkNotebookPages *pages = GTK_NOTEBOOK_PAGES (model); GtkNotebookPage *page; page = g_list_nth_data (pages->notebook->children, position); return g_object_ref (page); } static void gtk_notebook_pages_list_model_init (GListModelInterface *iface) { iface->get_item_type = gtk_notebook_pages_get_item_type; iface->get_n_items = gtk_notebook_pages_get_n_items; iface->get_item = gtk_notebook_pages_get_item; } G_DEFINE_TYPE_WITH_CODE (GtkNotebookPages, gtk_notebook_pages, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, gtk_notebook_pages_list_model_init)) static void gtk_notebook_pages_init (GtkNotebookPages *pages) { } static void gtk_notebook_pages_class_init (GtkNotebookPagesClass *class) { } static GtkNotebookPages * gtk_notebook_pages_new (GtkNotebook *notebook) { GtkNotebookPages *pages; pages = g_object_new (GTK_TYPE_NOTEBOOK_PAGES, NULL); pages->notebook = notebook; return pages; } /** * gtk_notebook_get_pages: * @notebook: a #GtkNotebook * * Returns a #GListModel that contains the pages of the notebook, * and can be used to keep an up-to-date view. * * Returns: (transfer full) (attributes element-type=GtkNotebookPage): a * #GListModel for the notebook's children */ GListModel * gtk_notebook_get_pages (GtkNotebook *notebook) { g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL); if (notebook->pages) return g_object_ref (notebook->pages); notebook->pages = G_LIST_MODEL (gtk_notebook_pages_new (notebook)); g_object_add_weak_pointer (G_OBJECT (notebook->pages), (gpointer *)¬ebook->pages); return notebook->pages; }