Notebook

Object Hierarchy:

Description:

[ CCode ( type_id = "gtk_notebook_get_type ()" ) ]
public sealed class Notebook : Widget, Accessible, Buildable, ConstraintTarget

Switches between children using tabs.

There are many configuration options for `GtkNotebook`. Among other things, you can choose on which edge the tabs appear (see [ method@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 [method@Gtk.Notebook.set_scrollable]), and whether there will be a popup menu allowing the users to switch pages. (see [ method@Gtk.Notebook.popup_enable]).

GtkNotebook as GtkBuildable

The `GtkNotebook` implementation of the `GtkBuildable` interface supports placing children into tabs by specifying “tab” as the “type” attribute of a `<child>` 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 `<child>` type attribute.

To add a child widget in the notebooks action area, specify "action-start" or “action-end” as the “type” attribute of the `<child >` element.

An example of a UI definition fragment with `GtkNotebook`:

```xml <object class="GtkNotebook"> <child> <object class="GtkLabel" id="notebook-content"> <property name="label"> Content</property> </object> </child> <child type="tab"> <object class="GtkLabel" id="notebook-tab"> < property name="label">Tab</property> </object> </child> </object> ```

Shortcuts and Gestures

`GtkNotebook` supports the following keyboard shortcuts:

<kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
<kbd>Home</kbd> moves the focus to the first tab.
<kbd>End</kbd> moves the focus to the last tab.

Additionally, the following signals have default keybindings:

[signal@Gtk.Notebook:GtkNotebook:change-current-page]
[signal@Gtk.Notebook:GtkNotebook:focus-tab]
[signal@Gtk.Notebook:GtkNotebook:move-focus-out]
[signal@Gtk.Notebook:GtkNotebook:reorder-tab]
[signal@Gtk.Notebook:GtkNotebook:select-page]

Tabs support drag-and-drop between notebooks sharing the same `group-name`, or to new windows by handling the ` create_window` signal.

Actions

`GtkNotebook` defines a set of built-in actions:

`menu.popup` opens the tabs context menu.

CSS nodes

``` notebook ├── header.top │ ├── [<action widget>] │ ├── tabs │ │ ├── [arrow] │ │ ├── tab │ │ │ ╰── <tab label> ┊ ┊ ┊ │ │ ├── tab[.reorderable-page] │ │ │ ╰── <tab label> │ │ ╰── [arrow] │ ╰── [<action widget>] │ ╰── stack ├── <child> ┊ ╰── <child> ```

`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 [method@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.

Accessibility

`GtkNotebook` uses the following roles:

[enum@Gtk.AccessibleRole.group] for the notebook widget
[enum@Gtk.AccessibleRole.tab_list] for the list of tabs
[enum@Gtk.AccessibleRole.tab] role for each tab
[enum@Gtk.AccessibleRole.tab_panel] for each page

Namespace: Gtk

Package: gtk4

Content:

Properties:

public bool enable_popup { get; set; }
If true, pressing the right mouse button on the notebook shows a page switching menu.
public string group_name { get; set; }
Group name for tab drag and drop.
public int page { get; set; }
The index of the current page.
public ListModel pages { owned get; }
A selection model with the pages.
public bool scrollable { get; set; }
If true, scroll arrows are added if there are too many pages to fit.
public bool show_border { get; set; }
Whether the border should be shown.
public bool show_tabs { get; set; }
Whether tabs should be shown.
public PositionType tab_pos { get; set; }
Which side of the notebook holds the tabs.

Creation methods:

public Notebook ()
Creates a new `GtkNotebook` widget with no pages.

Methods:

public int append_page (Widget child, Widget? tab_label = null)
Appends a page to this.
public int append_page_menu (Widget child, Widget? tab_label, Widget? menu_label)
Appends a page to this, specifying the widget to use as the label in the popup menu.
public void detach_tab (Widget child)
Removes the child from the notebook.
public unowned Widget? get_action_widget (PackType pack_type)
Gets one of the action widgets.
public int get_current_page ()
Returns the page number of the current page.
public unowned string? get_group_name ()
Gets the current group name for this.
public unowned Widget? get_menu_label (Widget child)
Retrieves the menu label widget of the page containing child.
public unowned string? get_menu_label_text (Widget child)
Retrieves the text of the menu label for the page containing child.
public int get_n_pages ()
Gets the number of pages in a notebook.
public unowned Widget? get_nth_page (int page_num)
Returns the child widget contained in page number page_num.
public unowned NotebookPage get_page (Widget child)
Returns the `GtkNotebookPage` for child.
public ListModel get_pages ()
Returns a `GListModel` that contains the pages of the notebook.
public bool get_scrollable ()
Returns whether the tab label area has arrows for scrolling.
public bool get_show_border ()
Returns whether a bevel will be drawn around the notebook pages.
public bool get_show_tabs ()
Returns whether the tabs of the notebook are shown.
public bool get_tab_detachable (Widget child)
Returns whether the tab contents can be detached from this.
public unowned Widget? get_tab_label (Widget child)
Returns the tab label widget for the page child.
public unowned string? get_tab_label_text (Widget child)
Retrieves the text of the tab label for the page containing child.
public PositionType get_tab_pos ()
Gets the edge at which the tabs are drawn.
public bool get_tab_reorderable (Widget child)
Gets whether the tab can be reordered via drag and drop or not.
public int insert_page (Widget child, Widget? tab_label, int position)
Insert a page into this at the given position.
public int insert_page_menu (Widget child, Widget? tab_label, Widget? menu_label, int position)
Insert a page into this at the given position, specifying the widget to use as the label in the popup menu.
public void next_page ()
Switches to the next page.
public int page_num (Widget child)
Finds the index of the page which contains the given child widget.
public void popup_disable ()
Disables the popup menu.
public void popup_enable ()
Enables the popup menu.
public int prepend_page (Widget child, Widget? tab_label = null)
Prepends a page to this.
public int prepend_page_menu (Widget child, Widget? tab_label, Widget? menu_label)
Prepends a page to this, specifying the widget to use as the label in the popup menu.
public void prev_page ()
Switches to the previous page.
public void remove_page (int page_num)
Removes a page from the notebook given its index in the notebook.
public void reorder_child (Widget child, int position)
Reorders the page containing child, so that it appears in position position.
public void set_action_widget (Widget widget, PackType pack_type)
Sets widget as one of the action widgets.
public void set_current_page (int page_num)
Switches to the page number page_num.
public void set_group_name (string? group_name)
Sets a group name for this.
public void set_menu_label (Widget child, Widget? menu_label)
Changes the menu label for the page containing child.
public void set_menu_label_text (Widget child, string menu_text)
Creates a new label and sets it as the menu label of child.
public void set_scrollable (bool scrollable)
Sets whether the tab label area will have arrows for scrolling if there are too many tabs to fit in the area.
public void set_show_border (bool show_border)
Sets whether a bevel will be drawn around the notebook pages.
public void set_show_tabs (bool show_tabs)
Sets whether to show the tabs for the notebook or not.
public void set_tab_detachable (Widget child, bool detachable)
Sets whether the tab can be detached from this to another notebook or widget.
public void set_tab_label (Widget child, Widget? tab_label)
Changes the tab label for child.
public void set_tab_label_text (Widget child, string tab_text)
Creates a new label and sets it as the tab label for the page containing child.
public void set_tab_pos (PositionType pos)
Sets the edge at which the tabs are drawn.
public void set_tab_reorderable (Widget child, bool reorderable)
Sets whether the notebook tab can be reordered via drag and drop or not.

Signals:

public signal bool change_current_page (int page)
Emitted when the current page should be changed.
public signal unowned Notebook? create_window (Widget page)
The create_window signal is emitted when a detachable tab is dropped on the root window.
public signal bool focus_tab (NotebookTab tab)
Emitted when a tab should be focused.
public signal void move_focus_out (DirectionType direction)
Emitted when focus was moved out.
public signal void page_added (Widget child, uint page_num)
the page_added signal is emitted in the notebook right after a page is added to the notebook.
public signal void page_removed (Widget child, uint page_num)
the page_removed signal is emitted in the notebook right after a page is removed from the notebook.
public signal void page_reordered (Widget child, uint page_num)
the page_reordered signal is emitted in the notebook right after a page has been reordered.
public signal bool reorder_tab (DirectionType direction, bool move_to_last)
Emitted when the tab should be reordered.
public signal bool select_page (bool move_focus)
Emitted when a page should be selected.
public signal void switch_page (Widget page, uint page_num)
Emitted when the user or a function changes the current page.

Inherited Members:

All known members inherited from class Gtk.Widget

All known members inherited from class GLib.Object

All known members inherited from interface Gtk.Accessible

All known members inherited from interface Gtk.Buildable