Memory-managed wrapper type.

Type class for types which can be safely cast to Notebook, for instance with toNotebook.

Cast to Notebook, for types for which this is known to be safe. For general casts, use castTo.

A convenience alias for Nothing :: Maybe Notebook.

Appends a page to notebook.

Appends a page to notebook, specifying the widget to use as the label in the popup menu.

Removes the child from the notebook.

This function is very similar to containerRemove, but additionally informs the notebook that the removal is happening as part of a tab DND operation, which should not be cancelled.

Since: 3.16

Gets one of the action widgets. See notebookSetActionWidget.

Since: 2.20

Returns the page number of the current page.

Gets the current group name for notebook.

Since: 2.24

Retrieves the menu label widget of the page containing child.

Retrieves the text of the menu label for the page containing child.

Gets the number of pages in a notebook.

Since: 2.2

Returns the child widget contained in page number pageNum.

Returns whether the tab label area has arrows for scrolling. See notebookSetScrollable.

Returns whether a bevel will be drawn around the notebook pages. See notebookSetShowBorder.

Returns whether the tabs of the notebook are shown. See notebookSetShowTabs.

Returns whether the tab contents can be detached from notebook.

Since: 2.10

Returns the horizontal width of a tab border.

Since: 2.22

Returns the tab label widget for the page child. Nothing is returned if child is not in notebook or if no tab label has specifically been set for child.

Retrieves the text of the tab label for the page containing child.

Gets the edge at which the tabs for switching pages in the notebook are drawn.

Gets whether the tab can be reordered via drag and drop or not.

Since: 2.10

Returns the vertical width of a tab border.

Since: 2.22

Insert a page into notebook at the given position.

Insert a page into notebook at the given position, specifying the widget to use as the label in the popup menu.

Creates a new Notebook widget with no pages.

Switches to the next page. Nothing happens if the current page is the last page.

Finds the index of the page which contains the given child widget.

Disables the popup menu.

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.

Prepends a page to notebook.

Prepends a page to notebook, specifying the widget to use as the label in the popup menu.

Switches to the previous page. Nothing happens if the current page is the first page.

Removes a page from the notebook given its index in the notebook.

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.

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 Box 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 containerForeach.

Since: 2.20

Switches to the page number pageNum.

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.

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 Nothing group name will not be able to exchange tabs with any other notebook.

Since: 2.24

Changes the menu label for the page containing child.

Creates a new label and sets it as the menu label of child.

Sets whether the tab label area will have arrows for scrolling if there are too many tabs to fit in the area.

Sets whether a bevel will be drawn around the notebook pages. This only has a visual effect when the tabs are not shown. See notebookSetShowTabs.

Sets whether to show the tabs for the notebook 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 notebookSetGroupName) 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 notebookDetachTab instead of containerRemove 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.

C code

static void
on_drag_data_received (GtkWidget        *widget,
                       GdkDragContext   *context,
                       gint              x,
                       gint              y,
                       GtkSelectionData *data,
                       guint             info,
                       guint             time,
                       gpointer          user_data)
{
  GtkWidget *notebook;
  GtkWidget **child;

  notebook = gtk_drag_get_source_widget (context);
  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.

Since: 2.10

Changes the tab label for child. If Nothing is specified for tabLabel, then the page will have the label “page N”.

Creates a new label and sets it as the tab label for the page containing child.

Sets the edge at which the tabs for switching pages in the notebook are drawn.

Sets whether the notebook tab can be reordered via drag and drop or not.

Since: 2.10

Construct a GValueConstruct with valid value for the “enable-popup” property. This is rarely needed directly, but it is used by new.

Get the value of the “enable-popup” property. When overloading is enabled, this is equivalent to

get notebook #enablePopup

Set the value of the “enable-popup” property. When overloading is enabled, this is equivalent to

set notebook [ #enablePopup := value ]

Set the value of the “group-name” property to Nothing. When overloading is enabled, this is equivalent to

clear #groupName

Construct a GValueConstruct with valid value for the “group-name” property. This is rarely needed directly, but it is used by new.

Get the value of the “group-name” property. When overloading is enabled, this is equivalent to

get notebook #groupName

Set the value of the “group-name” property. When overloading is enabled, this is equivalent to

set notebook [ #groupName := value ]

Construct a GValueConstruct with valid value for the “page” property. This is rarely needed directly, but it is used by new.

Get the value of the “page” property. When overloading is enabled, this is equivalent to

get notebook #page

Set the value of the “page” property. When overloading is enabled, this is equivalent to

set notebook [ #page := value ]

Construct a GValueConstruct with valid value for the “scrollable” property. This is rarely needed directly, but it is used by new.

Get the value of the “scrollable” property. When overloading is enabled, this is equivalent to

get notebook #scrollable

Set the value of the “scrollable” property. When overloading is enabled, this is equivalent to

set notebook [ #scrollable := value ]

Construct a GValueConstruct with valid value for the “show-border” property. This is rarely needed directly, but it is used by new.

Get the value of the “show-border” property. When overloading is enabled, this is equivalent to

get notebook #showBorder

Set the value of the “show-border” property. When overloading is enabled, this is equivalent to

set notebook [ #showBorder := value ]

Construct a GValueConstruct with valid value for the “show-tabs” property. This is rarely needed directly, but it is used by new.

Get the value of the “show-tabs” property. When overloading is enabled, this is equivalent to

get notebook #showTabs

Set the value of the “show-tabs” property. When overloading is enabled, this is equivalent to

set notebook [ #showTabs := value ]

Construct a GValueConstruct with valid value for the “tab-pos” property. This is rarely needed directly, but it is used by new.

Get the value of the “tab-pos” property. When overloading is enabled, this is equivalent to

get notebook #tabPos

Set the value of the “tab-pos” property. When overloading is enabled, this is equivalent to

set notebook [ #tabPos := value ]

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “change-current-page” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #changeCurrentPage callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookChangeCurrentPageCallback.

A convenience synonym for Nothing :: Maybe NotebookChangeCurrentPageCallback.

Connect a signal handler for the “change-current-page” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #changeCurrentPage callback

Wrap a NotebookChangeCurrentPageCallback into a C_NotebookChangeCurrentPageCallback.

Type for the callback on the (unwrapped) C side.

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 Notebook:group-name ).

Since: 2.12

Connect a signal handler for the “create-window” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #createWindow callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookCreateWindowCallback.

A convenience synonym for Nothing :: Maybe NotebookCreateWindowCallback.

Connect a signal handler for the “create-window” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #createWindow callback

Wrap a NotebookCreateWindowCallback into a C_NotebookCreateWindowCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “focus-tab” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #focusTab callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookFocusTabCallback.

A convenience synonym for Nothing :: Maybe NotebookFocusTabCallback.

Connect a signal handler for the “focus-tab” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #focusTab callback

Wrap a NotebookFocusTabCallback into a C_NotebookFocusTabCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “move-focus-out” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #moveFocusOut callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookMoveFocusOutCallback.

A convenience synonym for Nothing :: Maybe NotebookMoveFocusOutCallback.

Connect a signal handler for the “move-focus-out” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #moveFocusOut callback

Wrap a NotebookMoveFocusOutCallback into a C_NotebookMoveFocusOutCallback.

Type for the callback on the (unwrapped) C side.

the ::page-added signal is emitted in the notebook right after a page is added to the notebook.

Since: 2.10

Connect a signal handler for the “page-added” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #pageAdded callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookPageAddedCallback.

A convenience synonym for Nothing :: Maybe NotebookPageAddedCallback.

Connect a signal handler for the “page-added” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #pageAdded callback

Wrap a NotebookPageAddedCallback into a C_NotebookPageAddedCallback.

Type for the callback on the (unwrapped) C side.

the ::page-removed signal is emitted in the notebook right after a page is removed from the notebook.

Since: 2.10

Connect a signal handler for the “page-removed” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #pageRemoved callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookPageRemovedCallback.

A convenience synonym for Nothing :: Maybe NotebookPageRemovedCallback.

Connect a signal handler for the “page-removed” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #pageRemoved callback

Wrap a NotebookPageRemovedCallback into a C_NotebookPageRemovedCallback.

Type for the callback on the (unwrapped) C side.

the ::page-reordered signal is emitted in the notebook right after a page has been reordered.

Since: 2.10

Connect a signal handler for the “page-reordered” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #pageReordered callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookPageReorderedCallback.

A convenience synonym for Nothing :: Maybe NotebookPageReorderedCallback.

Connect a signal handler for the “page-reordered” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #pageReordered callback

Wrap a NotebookPageReorderedCallback into a C_NotebookPageReorderedCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “reorder-tab” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #reorderTab callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookReorderTabCallback.

A convenience synonym for Nothing :: Maybe NotebookReorderTabCallback.

Connect a signal handler for the “reorder-tab” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #reorderTab callback

Wrap a NotebookReorderTabCallback into a C_NotebookReorderTabCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “select-page” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #selectPage callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookSelectPageCallback.

A convenience synonym for Nothing :: Maybe NotebookSelectPageCallback.

Connect a signal handler for the “select-page” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #selectPage callback

Wrap a NotebookSelectPageCallback into a C_NotebookSelectPageCallback.

Type for the callback on the (unwrapped) C side.

Emitted when the user or a function changes the current page.

Connect a signal handler for the “switch-page” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after notebook #switchPage callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_NotebookSwitchPageCallback.

A convenience synonym for Nothing :: Maybe NotebookSwitchPageCallback.

Connect a signal handler for the “switch-page” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on notebook #switchPage callback

Wrap a NotebookSwitchPageCallback into a C_NotebookSwitchPageCallback.