GI.Gtk.Objects.Notebook

The Notebook widget is a Container 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 notebookSetTabPos), whether, if there are too many tabs to fit the notebook should be made bigger or scrolling arrows added (see notebookSetScrollable), and whether there will be a popup menu allowing the users to switch pages. (see notebookPopupEnable, notebookPopupDisable)

GtkNotebook as GtkBuildable

The GtkNotebook implementation of the Buildable 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: > >class="GtkNotebook" > child > class="GtkLabel" id="notebook-content" > name="label"Content/property > /object > /child > type="tab" > class="GtkLabel" id="notebook-tab" > name="label"Tab/property > /object > /child >/object

CSS nodes

plain code

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 notebookSetShowBorder).

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, regarldess of text direction.

Exported types

newtype Notebook

Constructors

Notebook (ManagedPtr Notebook)

Instances

GObject Notebook

Methods

gobjectType :: Notebook -> IO GType

IsImplementorIface Notebook

IsObject Notebook

IsWidget Notebook

IsContainer Notebook

IsBuildable Notebook

IsNotebook Notebook

class GObject o => IsNotebook o

Instances

(GObject a, UnknownAncestorError Constraint Notebook a) => IsNotebook a

IsNotebook Notebook

toNotebook :: (MonadIO m, IsNotebook o) => o -> m Notebook

noNotebook :: Maybe Notebook

Methods

appendPage

notebookAppendPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> m Int32

Returns: the index (starting from 0) of the appended page in the notebook, or -1 if function fails

Appends a page to notebook.

appendPageMenu

notebookAppendPageMenu

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> Maybe d

menuLabel: the widget to use as a label for the page-switch menu, if that is enabled. If Nothing, and tabLabel is a Label or Nothing, then the menu label will be a newly created label with the same text as tabLabel; if tabLabel is not a Label, menuLabel must be specified if the page-switch menu is to be used.

-> m Int32

Returns: the index (starting from 0) of the appended page in the notebook, or -1 if function fails

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

detachTab

notebookDetachTab

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a child

-> m ()

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

getActionWidget

notebookGetActionWidget

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> PackType

packType: pack type of the action widget to receive

-> m (Maybe Widget)

Returns: The action widget with the given packType or Nothing when this action widget has not been set

Gets one of the action widgets. See notebookSetActionWidget.

Since: 2.20

getCurrentPage

notebookGetCurrentPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Int32

Returns: the index (starting from 0) of the current page in the notebook. If the notebook has no pages, then -1 will be returned.

Returns the page number of the current page.

getGroupName

notebookGetGroupName

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m (Maybe Text)

Returns: the group name, or Nothing if none is set

Gets the current group name for notebook.

Since: 2.24

getMenuLabel

notebookGetMenuLabel

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a widget contained in a page of notebook

-> m (Maybe Widget)

Returns: the menu label, or Nothing if the notebook page does not have a menu label other than the default (the tab label).

Retrieves the menu label widget of the page containing child.

getMenuLabelText

notebookGetMenuLabelText

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: the child widget of a page of the notebook.

-> m (Maybe Text)

Returns: the text of the tab label, or Nothing if the widget does not have a menu label other than the default menu label, or the menu label widget is not a Label. The string is owned by the widget and must not be freed.

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

getNPages

notebookGetNPages

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Int32

Returns: the number of pages in the notebook

Gets the number of pages in a notebook.

Since: 2.2

getNthPage

notebookGetNthPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Int32

pageNum: the index of a page in the notebook, or -1 to get the last page

-> m (Maybe Widget)

Returns: the child widget, or Nothing if pageNum is out of bounds

Returns the child widget contained in page number pageNum.

getScrollable

notebookGetScrollable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Bool

Returns: True if arrows for scrolling are present

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

getShowBorder

notebookGetShowBorder

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Bool

Returns: True if the bevel is drawn

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

getShowTabs

notebookGetShowTabs

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Bool

Returns: True if the tabs are shown

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

getTabDetachable

notebookGetTabDetachable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a child Widget

-> m Bool

Returns: True if the tab is detachable.

Returns whether the tab contents can be detached from notebook.

Since: 2.10

getTabHborder

notebookGetTabHborder

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Word16

Returns: horizontal width of a tab border

Deprecated: (Since version 3.4)this function returns zero

Returns the horizontal width of a tab border.

Since: 2.22

getTabLabel

notebookGetTabLabel

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: the page

-> m (Maybe Widget)

Returns: the tab label

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.

getTabLabelText

notebookGetTabLabelText

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a widget contained in a page of notebook

-> m (Maybe Text)

Returns: the text of the tab label, or Nothing if the tab label widget is not a Label. The string is owned by the widget and must not be freed.

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

getTabPos

notebookGetTabPos

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m PositionType

Returns: the edge at which the tabs are drawn

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

getTabReorderable

notebookGetTabReorderable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a child Widget

-> m Bool

Returns: True if the tab is reorderable.

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

Since: 2.10

getTabVborder

notebookGetTabVborder

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m Word16

Returns: vertical width of a tab border

Deprecated: (Since version 3.4)this function returns zero

Returns the vertical width of a tab border.

Since: 2.22

insertPage

notebookInsertPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> Int32

position: the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages

-> m Int32

Returns: the index (starting from 0) of the inserted page in the notebook, or -1 if function fails

Insert a page into notebook at the given position.

insertPageMenu

notebookInsertPageMenu

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> Maybe d

menuLabel: the widget to use as a label for the page-switch menu, if that is enabled. If Nothing, and tabLabel is a Label or Nothing, then the menu label will be a newly created label with the same text as tabLabel; if tabLabel is not a Label, menuLabel must be specified if the page-switch menu is to be used.

-> Int32

position: the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages.

-> m Int32

Returns: the index (starting from 0) of the inserted page in the notebook

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

new

notebookNew

Arguments

:: (HasCallStack, MonadIO m)

=> m Notebook

Returns: the newly created Notebook

Creates a new Notebook widget with no pages.

nextPage

notebookNextPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m ()

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

pageNum

notebookPageNum

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a Widget

-> m Int32

Returns: the index of the page containing child, or -1 if child is not in the notebook

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

popupDisable

notebookPopupDisable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m ()

Disables the popup menu.

popupEnable

notebookPopupEnable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m ()

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.

prependPage

notebookPrependPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> m Int32

Returns: the index (starting from 0) of the prepended page in the notebook, or -1 if function fails

Prepends a page to notebook.

prependPageMenu

notebookPrependPageMenu

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d)

=> a

notebook: a Notebook

-> b

child: the Widget to use as the contents of the page

-> Maybe c

tabLabel: the Widget to be used as the label for the page, or Nothing to use the default label, “page N”

-> Maybe d

menuLabel: the widget to use as a label for the page-switch menu, if that is enabled. If Nothing, and tabLabel is a Label or Nothing, then the menu label will be a newly created label with the same text as tabLabel; if tabLabel is not a Label, menuLabel must be specified if the page-switch menu is to be used.

-> m Int32

Returns: the index (starting from 0) of the prepended page in the notebook, or -1 if function fails

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

prevPage

notebookPrevPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> m ()

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

removePage

notebookRemovePage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Int32

pageNum: the index of a notebook page, starting from 0. If -1, the last page will be removed.

-> m ()

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

reorderChild

notebookReorderChild

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: the child to move

-> Int32

position: the new position, or -1 to move to the end

-> m ()

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.

setActionWidget

notebookSetActionWidget

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

widget: a Widget

-> PackType

packType: pack type of the action widget

-> m ()

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

setCurrentPage

notebookSetCurrentPage

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Int32

pageNum: 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.

-> m ()

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.

setGroupName

notebookSetGroupName

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Maybe Text

groupName: the name of the notebook group, or Nothing to unset it

-> m ()

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

setMenuLabel

notebookSetMenuLabel

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c)

=> a

notebook: a Notebook

-> b

child: the child widget

-> Maybe c

menuLabel: the menu label, or Nothing for default

-> m ()

Changes the menu label for the page containing child.

setMenuLabelText

notebookSetMenuLabelText

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: the child widget

-> Text

menuText: the label text

-> m ()

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

setScrollable

notebookSetScrollable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Bool

scrollable: True if scroll arrows should be added

-> m ()

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

setShowBorder

notebookSetShowBorder

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Bool

showBorder: True if a bevel should be drawn around the notebook

-> m ()

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.

setShowTabs

notebookSetShowTabs

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook

-> Bool

showTabs: True if the tabs should be shown

-> m ()

Sets whether to show the tabs for the notebook or not.

setTabDetachable

notebookSetTabDetachable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a child Widget

-> Bool

detachable: whether the tab is detachable or not

-> m ()

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

setTabLabel

notebookSetTabLabel

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c)

=> a

notebook: a Notebook

-> b

child: the page

-> Maybe c

tabLabel: the tab label widget to use, or Nothing for default tab label

-> m ()

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

setTabLabelText

notebookSetTabLabelText

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: the page

-> Text

tabText: the label text

-> m ()

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

setTabPos

notebookSetTabPos

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a)

=> a

notebook: a Notebook.

-> PositionType

pos: the edge to draw the tabs at

-> m ()

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

setTabReorderable

notebookSetTabReorderable

Arguments

:: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b)

=> a

notebook: a Notebook

-> b

child: a child Widget

-> Bool

reorderable: whether the tab is reorderable or not

-> m ()

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

Since: 2.10

Properties

enablePopup

constructNotebookEnablePopup :: IsNotebook o => Bool -> IO (GValueConstruct o)

getNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> m Bool

setNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

groupName

clearNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m ()

constructNotebookGroupName :: IsNotebook o => Text -> IO (GValueConstruct o)

getNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m (Maybe Text)

setNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> Text -> m ()

page

constructNotebookPage :: IsNotebook o => Int32 -> IO (GValueConstruct o)

getNotebookPage :: (MonadIO m, IsNotebook o) => o -> m Int32

setNotebookPage :: (MonadIO m, IsNotebook o) => o -> Int32 -> m ()

scrollable

constructNotebookScrollable :: IsNotebook o => Bool -> IO (GValueConstruct o)

getNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> m Bool

setNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

showBorder

constructNotebookShowBorder :: IsNotebook o => Bool -> IO (GValueConstruct o)

getNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> m Bool

setNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

showTabs

constructNotebookShowTabs :: IsNotebook o => Bool -> IO (GValueConstruct o)

getNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> m Bool

setNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

tabPos

constructNotebookTabPos :: IsNotebook o => PositionType -> IO (GValueConstruct o)

getNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> m PositionType

setNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> PositionType -> m ()

Signals

changeCurrentPage

type C_NotebookChangeCurrentPageCallback = Ptr () -> Int32 -> Ptr () -> IO CInt

type NotebookChangeCurrentPageCallback = Int32 -> IO Bool

afterNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> NotebookChangeCurrentPageCallback -> m SignalHandlerId

genClosure_NotebookChangeCurrentPage :: NotebookChangeCurrentPageCallback -> IO Closure

mk_NotebookChangeCurrentPageCallback :: C_NotebookChangeCurrentPageCallback -> IO (FunPtr C_NotebookChangeCurrentPageCallback)

noNotebookChangeCurrentPageCallback :: Maybe NotebookChangeCurrentPageCallback

onNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> NotebookChangeCurrentPageCallback -> m SignalHandlerId

wrap_NotebookChangeCurrentPageCallback :: NotebookChangeCurrentPageCallback -> Ptr () -> Int32 -> Ptr () -> IO CInt

createWindow

type C_NotebookCreateWindowCallback = Ptr () -> Ptr Widget -> Int32 -> Int32 -> Ptr () -> IO (Ptr Notebook)

type NotebookCreateWindowCallback = Widget -> Int32 -> Int32 -> IO Notebook

afterNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> NotebookCreateWindowCallback -> m SignalHandlerId

genClosure_NotebookCreateWindow :: NotebookCreateWindowCallback -> IO Closure

mk_NotebookCreateWindowCallback :: C_NotebookCreateWindowCallback -> IO (FunPtr C_NotebookCreateWindowCallback)

noNotebookCreateWindowCallback :: Maybe NotebookCreateWindowCallback

onNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> NotebookCreateWindowCallback -> m SignalHandlerId

wrap_NotebookCreateWindowCallback :: NotebookCreateWindowCallback -> Ptr () -> Ptr Widget -> Int32 -> Int32 -> Ptr () -> IO (Ptr Notebook)

focusTab

type C_NotebookFocusTabCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

type NotebookFocusTabCallback = NotebookTab -> IO Bool

afterNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> NotebookFocusTabCallback -> m SignalHandlerId

genClosure_NotebookFocusTab :: NotebookFocusTabCallback -> IO Closure

mk_NotebookFocusTabCallback :: C_NotebookFocusTabCallback -> IO (FunPtr C_NotebookFocusTabCallback)

noNotebookFocusTabCallback :: Maybe NotebookFocusTabCallback

onNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> NotebookFocusTabCallback -> m SignalHandlerId

wrap_NotebookFocusTabCallback :: NotebookFocusTabCallback -> Ptr () -> CUInt -> Ptr () -> IO CInt

moveFocusOut

type C_NotebookMoveFocusOutCallback = Ptr () -> CUInt -> Ptr () -> IO ()

type NotebookMoveFocusOutCallback = DirectionType -> IO ()

afterNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> NotebookMoveFocusOutCallback -> m SignalHandlerId

genClosure_NotebookMoveFocusOut :: NotebookMoveFocusOutCallback -> IO Closure

mk_NotebookMoveFocusOutCallback :: C_NotebookMoveFocusOutCallback -> IO (FunPtr C_NotebookMoveFocusOutCallback)

noNotebookMoveFocusOutCallback :: Maybe NotebookMoveFocusOutCallback

onNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> NotebookMoveFocusOutCallback -> m SignalHandlerId

wrap_NotebookMoveFocusOutCallback :: NotebookMoveFocusOutCallback -> Ptr () -> CUInt -> Ptr () -> IO ()

pageAdded

type C_NotebookPageAddedCallback = Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

type NotebookPageAddedCallback = Widget -> Word32 -> IO ()

afterNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> NotebookPageAddedCallback -> m SignalHandlerId

genClosure_NotebookPageAdded :: NotebookPageAddedCallback -> IO Closure

mk_NotebookPageAddedCallback :: C_NotebookPageAddedCallback -> IO (FunPtr C_NotebookPageAddedCallback)

noNotebookPageAddedCallback :: Maybe NotebookPageAddedCallback

onNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> NotebookPageAddedCallback -> m SignalHandlerId

wrap_NotebookPageAddedCallback :: NotebookPageAddedCallback -> Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

pageRemoved

type C_NotebookPageRemovedCallback = Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

type NotebookPageRemovedCallback = Widget -> Word32 -> IO ()

afterNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> NotebookPageRemovedCallback -> m SignalHandlerId

genClosure_NotebookPageRemoved :: NotebookPageRemovedCallback -> IO Closure

mk_NotebookPageRemovedCallback :: C_NotebookPageRemovedCallback -> IO (FunPtr C_NotebookPageRemovedCallback)

noNotebookPageRemovedCallback :: Maybe NotebookPageRemovedCallback

onNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> NotebookPageRemovedCallback -> m SignalHandlerId

wrap_NotebookPageRemovedCallback :: NotebookPageRemovedCallback -> Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

pageReordered

type C_NotebookPageReorderedCallback = Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

type NotebookPageReorderedCallback = Widget -> Word32 -> IO ()

afterNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> NotebookPageReorderedCallback -> m SignalHandlerId

genClosure_NotebookPageReordered :: NotebookPageReorderedCallback -> IO Closure

mk_NotebookPageReorderedCallback :: C_NotebookPageReorderedCallback -> IO (FunPtr C_NotebookPageReorderedCallback)

noNotebookPageReorderedCallback :: Maybe NotebookPageReorderedCallback

onNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> NotebookPageReorderedCallback -> m SignalHandlerId

wrap_NotebookPageReorderedCallback :: NotebookPageReorderedCallback -> Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

reorderTab

type C_NotebookReorderTabCallback = Ptr () -> CUInt -> CInt -> Ptr () -> IO CInt

type NotebookReorderTabCallback = DirectionType -> Bool -> IO Bool

afterNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> NotebookReorderTabCallback -> m SignalHandlerId

genClosure_NotebookReorderTab :: NotebookReorderTabCallback -> IO Closure

mk_NotebookReorderTabCallback :: C_NotebookReorderTabCallback -> IO (FunPtr C_NotebookReorderTabCallback)

noNotebookReorderTabCallback :: Maybe NotebookReorderTabCallback

onNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> NotebookReorderTabCallback -> m SignalHandlerId

wrap_NotebookReorderTabCallback :: NotebookReorderTabCallback -> Ptr () -> CUInt -> CInt -> Ptr () -> IO CInt

selectPage

type C_NotebookSelectPageCallback = Ptr () -> CInt -> Ptr () -> IO CInt

type NotebookSelectPageCallback = Bool -> IO Bool

afterNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> NotebookSelectPageCallback -> m SignalHandlerId

genClosure_NotebookSelectPage :: NotebookSelectPageCallback -> IO Closure

mk_NotebookSelectPageCallback :: C_NotebookSelectPageCallback -> IO (FunPtr C_NotebookSelectPageCallback)

noNotebookSelectPageCallback :: Maybe NotebookSelectPageCallback

onNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> NotebookSelectPageCallback -> m SignalHandlerId

wrap_NotebookSelectPageCallback :: NotebookSelectPageCallback -> Ptr () -> CInt -> Ptr () -> IO CInt

switchPage

type C_NotebookSwitchPageCallback = Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()

type NotebookSwitchPageCallback = Widget -> Word32 -> IO ()

afterNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> NotebookSwitchPageCallback -> m SignalHandlerId

genClosure_NotebookSwitchPage :: NotebookSwitchPageCallback -> IO Closure

mk_NotebookSwitchPageCallback :: C_NotebookSwitchPageCallback -> IO (FunPtr C_NotebookSwitchPageCallback)

noNotebookSwitchPageCallback :: Maybe NotebookSwitchPageCallback

onNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> NotebookSwitchPageCallback -> m SignalHandlerId

wrap_NotebookSwitchPageCallback :: NotebookSwitchPageCallback -> Ptr () -> Ptr Widget -> Word32 -> Ptr () -> IO ()