gtk.Notebook
Prev | The gtk Class Reference | Next

## gtk.Notebook

gtk.Notebook — a tabbed notebook container.

## Synopsis

    class gtk.Notebook(gtk.Container):
        gtk.Notebook()
        def append_page(child, tab_label=None)
        def append_page_menu(child, tab_label=None, menu_label=None)
        def prepend_page(child, tab_label=None)
        def prepend_page_menu(child, tab_label=None, menu_label=None)
        def insert_page(child, tab_label=None, position=-1)
        def insert_page_menu(child, tab_label=None, menu_label=None, position=-1)
        def remove_page(page_num)
        def get_current_page()
        def get_nth_page(page_num)
        def get_n_pages()
        def page_num(child)
        def set_current_page(page_num)
        def next_page()
        def prev_page()
        def set_show_border(show_border)
        def get_show_border()
        def set_show_tabs(show_tabs)
        def get_show_tabs()
        def set_tab_pos(pos)
        def get_tab_pos()
        def set_scrollable(scrollable)
        def get_scrollable()
        def popup_enable()
        def popup_disable()
        def get_tab_label(child)
        def set_tab_label(child, tab_label=None)
        def set_tab_label_text(child, tab_text)
        def get_tab_label_text(child)
        def get_menu_label(child)
        def set_menu_label(child, menu_label=None)
        def set_menu_label_text(child, menu_text)
        def get_menu_label_text(child)
        def query_tab_label_packing(child)
        def set_tab_label_packing(child, expand, fill, pack_type)
        def reorder_child(child, position)
        def set_group_id(group_id)
        def get_group_id()
        def get_tab_reorderable(child)
        def set_tab_reorderable(child, reorderable)
        def get_tab_detachable(child)
        def set_tab_detachable(child, detachable)

    Functions

        def gtk.notebook_set_window_creation_hook(func, data)

## Ancestry

    +-- gobject.GObject
      +-- gtk.Object
        +-- gtk.Widget
          +-- gtk.Container
            +-- gtk.Notebook

## Implemented Interfaces

`gtk.Notebook` implements `gtk.Buildable`

## gtk.Notebook Properties

gtk.Object Properties

gtk.Widget Properties

gtk.Container Properties

"enable-popup" | Read-Write | If `True`, pressing the right mouse button on the notebook pops up a menu that you can use to go to a page. Default value: `False`.
"group-id" | Read-Write | Group ID for tabs drag and drop. Allowed values: >= -1. Default value: -1.
"homogeneous" | Read-Write | If `True`, tabs should have homogeneous sizes. Default value: `False`.
"page" | Read-Write | The index of the current page. Allowed values: >= 0. Default value: 0.
"scrollable" | Read-Write | If `True`, scroll arrows are added if there are too many tabs to fit. Default value: `False`.
"show-border" | Read-Write | If `True`, the border should be shown. Default value: `True`.
"show-tabs" | Read-Write | If `True`, tabs should be shown. Default value: `True`.
"tab-border" | Write | The width of the border around the tab labels. Default value: 2.
"tab-hborder" | Read-Write | The width of the horizontal border of tab labels. Default value: 2.
"tab-pos" | Read-Write | The side of the notebook that holds the tabs - one of the GTK Position Type Constants: `gtk.POS_LEFT`, `gtk.POS_RIGHT`, `gtk.POS_TOP` or `gtk.POS_BOTTOM`. Default value: `gtk.POS_TOP`.
"tab-vborder" | Read-Write | The width of the vertical border of tab labels. Default value: 2,

## gtk.Notebook Style Properties

gtk.Widget Style Properties

"arrow-spacing" | Read-Write | The "arrow-size" property defines the spacing between the scroll arrows and the tabs. Allowed values: >= 0. Default value: 0. Available in GTK+ 2.10.
"has-backward-stepper" | Read-Write | If `True` the standard backward arrow button is displayed. Default value: `True`. Available in GTK+ 2.4 and above.
"has-forward-stepper" | Read-Write | If `True` the standard forward arrow button is displayed. Default value: `True`. Available in GTK+ 2.4 and above.
"has-secondary-backward-stepper" | Read-Write | If `True` a second backward arrow button is displayed on the opposite end of the tab area. Default value: `False`. Available in GTK+ 2.4 and above.
"has-secondary-forward-stepper" | Read-Write | If `True` a second forward arrow button is displayed on the opposite end of the tab area. Default value: `False`. Available in GTK+ 2.4 and above.
"tab-curvature" | Read-Write | The "tab-curvature" property defines size of tab curvature. Allowed values: >= 0. Default value: 1. Available in GTK+ 2.10.
"tab-overlap" | Read-Write | The "tab-overlap" property defines size of tab overlap area. Default value: 2. Available in GTK+ 2.10.

## gtk.Notebook Child Properties

"detachable" | Read-Write | if `True` the tab is detachable. Default value: `False`.
"menu-label" | Read-Write | The string displayed in the child's menu entry. Default value: `None`
"position" | Read-Write | The index of the child in the parent. Allowed values: >= -1 Default value: 0.
"tab-expand" | Read-Write | If `True`, expand the child's tabs. Default value: `False`.
"tab-fill" | Read-Write | If `True`, the child's tab should fill the allocated area. Default value: `True`.
"tab-label" | Read-Write | The string displayed on the child's tab label. Default value: `None`.
tab-pack"" | Read-Write | A pack type indicating whether the child is packed with reference to the start or end of the parent - one of the GTK Pack Type Constants: `gtk.PACK_START` or `gtk.PACK_END`. Default value: `gtk.PACK_START`.

## Attributes

"tab_pos" | Read | The side of the notebook that holds the tabs: `gtk.POS_LEFT`, `gtk.POS_RIGHT`, `gtk.POS_TOP` or `gtk.POS_BOTTOM`

## gtk.Notebook Signal Prototypes

gobject.GObject Signal Prototypes

gtk.Object Signal Prototypes

gtk.Widget Signal Prototypes

gtk.Container Signal Prototypes

"change-current-page" | `def callback(`notebook`, `offset`, `user_param1`, `...`)`
"create-window" | `def callback(`notebook`, `page`, `x`, `y`, `user_param1`, `...`)`
"focus-tab" | `def callback(`notebook`, `type`, `user_param1`, `...`)`
"move-focus-out" | `def callback(`notebook`, `direction_type`, `user_param1`, `...`)`
"page-added" | `def callback(`notebook`, `child`, `page_num`, `user_param1`, `...`)`
"page-removed" | `def callback(`notebook`, `child`, `page_num`, `user_param1`, `...`)`
"page-reordered" | `def callback(`notebook`, `child`, `page_num`, `user_param1`, `...`)`
"select-page" | `def callback(`notebook`, `move_focus`, `user_param1`, `...`)`
"switch-page" | `def callback(`notebook`, `page`, `page_num`, `user_param1`, `...`)`

## Description

The `gtk.Notebook` widget is a `gtk.Container` whose children are overlapping pages that can be switched between by using tab labels along one edge. There are many configuration options for the `gtk.Notebook`. You can choose on which edge the tabs appear (see `set_tab_pos`()); whether the notebook should be made bigger or scrolling arrows added if there are too many tabs to fit (see `set_scrollable`()); and, whether there will be a popup menu allowing the users to switch pages. (see `popup_enable`(), `popup_disable`()).

The `gtk.Notebook` is particularly useful for displaying a large number of application controls that can be grouped into several functional areas. The typical example is the user preferences dialog in some applications. For example, a notebook page can be setup for each of font selection, color selection, formating, etc.

The `gtk.Notebook` implementation of the `gtk.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.

### A UI definition fragment with gtk.Notebook

    <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>

Beyond this general structure, several object classes define their own XML DTD fragments for filling in the ANY placeholders in the DTD above. Note that a custom element in a <child> element gets parsed by the custom tag handler of the parent object, while a custom element in an <object> element gets parsed by the custom tag handler of the object.

## Constructor

        gtk.Notebook()

Returns : | the newly created `gtk.Notebook`

Creates a new `gtk.Notebook` widget with no pages.

## Methods

### gtk.Notebook.append_page

        def append_page(child, tab_label=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `append_page`() method appends a page to the notebook using the widget specified by `child` and the widget specified by `tab_label` as the label on the tab.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. Also if `tab_label` is not specified it will default to `None`.

### gtk.Notebook.append_page_menu

        def append_page_menu(child, tab_label=None, menu_label=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
`menu_label` : | the widget to use as a label for the page-switch menu, if that is enabled.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `append_page_menu`() method appends a page to the notebook and specifying the widget to use as the label in the popup menu. `child` specifies the widget to use as the contents of the page; `tab_label` specifies the widget to be used as the tab label; and, `menu_label` specifies the widget to use in the popup menu.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. If `tab_label` is a `gtk.Label` or `None` and `menu_label` is `None` then the menu label will have the same text as the tab label. Otherwise, `menu_label` must be specified and not `None`. These parameters will default to `None` in PyGTK 2.4 as well.

### gtk.Notebook.prepend_page

        def prepend_page(child, tab_label=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `prepend_page`() method prepends a page to the notebook. `child` specifies the widget to use as the contents of the page and `tab_label` specifies the widget to be used as the tab label.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. Also if `tab_label` is not specified it will default to `None`.

### gtk.Notebook.prepend_page_menu

        def prepend_page_menu(child, tab_label=None, menu_label=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
`menu_label` : | the widget to use as a label for the page-switch menu, if that is enabled.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `prepend_page_menu`() method prepends a page to the notebook specifying the widget to use as the label in the popup menu. `child` specifies the widget to use as the contents of the page; `tab_label` specifies the widget to use as the tab label; and, `menu_label` specifies the widget to use in the popup menu.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. If `tab_label` is a `gtk.Label` or `None` and `menu_label` is `None` then the menu label will have the same text as the tab label. Otherwise, `menu_label` must be specified and not `None`. These parameters will default to `None` in PyGTK 2.4 as well.

### gtk.Notebook.insert_page

        def insert_page(child, tab_label=None, position=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
`position` : | the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `insert_page`() method inserts a page into the notebook at the location specified by `position` (0 is the first page). `child` is the widget to use as the contents of the page and `tab_label` specifies the widget to be used as the tab label. If `position` is -1 the page is appended to the notebook. In PyGTK 2.4 and above if `tab_label` is `None` a default label if "page N" is used.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. Also if `tab_label` is not specified it will default to `None`.

In Pygtk 2.4 and above `position` will default to -1 if not specified.

### gtk.Notebook.insert_page_menu

        def insert_page_menu(child, tab_label=None, menu_label=None, position=None)

`child` : | the `gtk.Widget` to use as the contents of the page.
`tab_label` : | the `gtk.Widget` to be used as the label for the page.
`menu_label` : | the widget to use as a label for the page-switch menu, if that is enabled.
`position` : | the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages.
Returns : | in PyGTK 2.0 and 2.2 returns `None`. In PyGTK 2.4 and above returns the index number of the page in the notebook

The `insert_page_menu`() method inserts a page into the notebook at the location specified by `position`. `child` specifies the widget to use as the contents of the page; `tab_label` specifies the widget to use as the tab label; and `menu_label` specifies the widget to use as the label in the popup menu.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. If `tab_label` is a `gtk.Label` or `None` and `menu_label` is `None` then the menu label will have the same text as the tab label. Otherwise, `menu_label` must be specified and not `None`. These parameters will default to `None` in PyGTK 2.4 as well.

In Pygtk 2.4 and above `position` will default to -1 if not specified.

### gtk.Notebook.remove_page

        def remove_page(page_num)

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

The `remove_page`() method removes from the notebook the page at the location specified by `index`. The value of `index` starts from 0. If `index` is -1 the last page of the notebook will be removed.

### gtk.Notebook.get_current_page

        def get_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.

The `get_current_page`() method returns the page index of the current page numbered from 0.

### gtk.Notebook.get_nth_page

        def get_nth_page(page_num)

`page_num` : | the index of a page in the notebook
Returns : | the child widget, or `None` if `page_num` is out of bounds.

The `get_nth_page`() method returns the child widget contained in the page with the index specified by `page_num`. If `page_num` is out of bounds for the page range of the notebook this method returns `None`.

### gtk.Notebook.get_n_pages

        def get_n_pages()

Returns : | the number of pages in the notebook.

### Note

This method is available in PyGTK 2.4 and above.

The `get_n_pages`() method returns the number of pages in a notebook.

### gtk.Notebook.page_num

        def page_num(child)

`child` : | a `gtk.Widget`
Returns : | the index of the page containing `child`, or -1 if `child` is not in the notebook.

The `page_num`() method returns the index of the page which contains the widget specified by `child` or `None` if no page contains `child`.

### gtk.Notebook.set_current_page

        def set_current_page(page_num)

`page_num` : | the 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.

The `set_current_page`() method switches to the page number specified by `page_num`. If `page_num` is negative the last page is selected.

### gtk.Notebook.next_page

        def next_page()

The `next_page`() method switches to the next page. Nothing happens if the current page is the last page.

### gtk.Notebook.prev_page

        def prev_page()

The `prev_page`() method switches to the previous page. Nothing happens if the current page is the first page.

### gtk.Notebook.set_show_border

        def set_show_border(show_border)

`show_border` : | if `True` a bevel should be drawn around the notebook.

The `show_border`() method sets the "show-border" property to the value of `show_border`. If `show_border` is `True` a bevel will be drawn around the notebook pages. This only has a visual effect when the tabs are not shown. See `set_show_tabs`().

### gtk.Notebook.get_show_border

        def get_show_border()

Returns : | `True` if the bevel should be drawn

The `get_show_border`() method returns the value of the "show-border" property. If "show-border" is `True` a bevel will be drawn around the notebook pages when tabs are not shown. See `set_show_border`().

### gtk.Notebook.set_show_tabs

        def set_show_tabs(show_tabs)

`show_tabs` : | if `True` the tabs should be shown.

The `set_show_tabs`() method sets the "show-tabs" property to the value of `show_tabs`. If `show_tabs` is `True` the notebook tabs will be displayed.

### gtk.Notebook.get_show_tabs

        def get_show_tabs()

Returns : | `True` if the tabs are shown

The `get_show_tabs`() method returns the value of the "show-tabs" property. If "show-tabs" is `True` the tabs of the notebook are shown. See `set_show_tabs`().

### gtk.Notebook.set_tab_pos

        def set_tab_pos(pos)

`pos` : | the edge to draw the tabs at: `gtk.POS_LEFT`, `gtk.POS_RIGHT`, `gtk.POS_TOP` or `gtk.POS_BOTTOM`.

The `set_tab_pos`() method sets the edge at which the tabs for switching pages in the notebook are drawn as specified by `pos`. The value of `pos` can be one of: `gtk.POS_LEFT`, `gtk.POS_RIGHT`, `gtk.POS_TOP` or `gtk.POS_BOTTOM`.

### gtk.Notebook.get_tab_pos

        def get_tab_pos()

Returns : | the edge at which the tabs are drawn

The `get_tab_pos`() method returns the edge at which the tabs for switching pages in the notebook are drawn. The return value is one of: `gtk.POS_LEFT`, `gtk.POS_RIGHT`, `gtk.POS_TOP` or `gtk.POS_BOTTOM`.

### gtk.Notebook.set_scrollable

        def set_scrollable(scrollable)

`scrollable` : | if `True` scroll arrows should be added

The `set_scrollable`() method sets the "scrollable" property to the value specified by `scrollable`. If `scrollable` is `True` the tab label area will have arrows for scrolling if there are too many tabs to fit in the area.

### gtk.Notebook.get_scrollable

        def get_scrollable()

Returns : | `True` if arrows for scrolling are enabled

The `get_scrollable`() method returns the value of the "scrollable" property. If "scrollable" is `True` the tab label area has scrolling arrows enabled and displayed if there are too many tabs to fit in the display area. See `set_scrollable`().

### gtk.Notebook.popup_enable

        def popup_enable()

The `popup_enable`() method enables the popup menu: if the user clicks with the right mouse button on the tabs, a menu with all the pages will be popped up.

### gtk.Notebook.popup_disable

        def popup_disable()

The `popup_disable`() method disables the popup menu.

### gtk.Notebook.get_tab_label

        def get_tab_label(child)

`child` : | a widget contained in a notebook page
Returns : | the tab label widget for the page containing `child`

The `get_tab_label`() method returns the tab label widget for the page containing the widget `child`. `None` is returned if `child` is not in the notebook.

### gtk.Notebook.set_tab_label

        def set_tab_label(child, tab_label=None)

`child` : | a widget contained in a notebook page
`tab_label` : | the tab label widget to use or `None`.

The `set_tab_label`() method replaces the tab label for the notebook page containing `child` with the widget specified by `tab_label`.

In PyGTK 2.4 and above `tab_label` can be `None` to use a default label. Also if `tab_label` is not specified it will default to `None`.

### gtk.Notebook.set_tab_label_text

        def set_tab_label_text(child, tab_text)

`child` : | a widget contained in a notebook page
`tab_text` : | the new label text

The `set_tab_label_text`() method creates a new label with the text specified by `tab_text` and sets it as the tab label for the page containing `child`.

### gtk.Notebook.get_tab_label_text

        def get_tab_label_text(child)

`child` : | a widget contained in a notebook page
Returns : | value: the text of the tab label, or `None` if the tab label widget is not a `gtk.Label` or `child` is not in a notebook page.

The `get_tab_label_text`() retrieves the text of the tab label for the page containing `child`. This method returns `None` if `child` is not in a notebook page or the page tab label is not a `gtk.Label` widget.

### gtk.Notebook.get_menu_label

        def get_menu_label(child)

`child` : | a widget contained in a notebook page
Returns : | the menu label, or `None` if the notebook page does not have a menu label other than the default (the tab label) or if child is not in a notebook page.

The `get_menu_label`() method retrieves the menu label widget of the page containing `child`. If `child` is not in a notebook page or the menu label has not been set (it defaults to the tab label), this method returns `None`.

### gtk.Notebook.set_menu_label

        def set_menu_label(child, menu_label=None)

`child` : | a widget contained in a notebook page
`menu_label` : | a widget to be used as the new menu label

The `set_menu_label`() replaces the menu label for the page containing `child` with the widget specified by `menu_label`.

In PyGTK 2.4 and above `menu_label` can be `None` to use a default label. Also if `menu_label` is not specified it will default to `None`. See the `append_page_menu`() method for more information.

### gtk.Notebook.set_menu_label_text

        def set_menu_label_text(child, menu_text)

`child` : | a widget contained in a notebook page
`menu_text` : | the new menu label text

The `set_menu_label_text`() method creates a new label widget and replaces the menu label of the page containing`child`.

### gtk.Notebook.get_menu_label_text

        def get_menu_label_text(child)

`child` : | a child widget of a notebook page.
Returns : | value: the text of the tab label, or `None` if the widget does not have a menu label other than the default menu label, or the menu label widget is not a `gtk.Label` or `child` is not contained in a notebook page.

The `get_menu_label_text`() method retrieves the text of the menu label for the page containing `child`. If `child` is not in a notebook page or the menu label is not a `gtk.Label` widget or the menu label has not been set (it default to the tab label), the return value is `None`.

### gtk.Notebook.query_tab_label_packing

        def query_tab_label_packing(child)

`child` : | the page
Returns : | a tuple containing: the expand value, the fill value and the pack type

The `query_tab_label_packing`() method returns a tuple containing the packing attributes (expand, fill, pack type) for the tab label of the page containing `child`. If the expand attribute is `True` the tab can expand to take up the free space in the tab area. If fill is `True` the label widget in the tab can use up all the space in the tab. The pack type can be one of `gtk.PACK_START` or `gtk.PACK_END` to specify whether the tab is packed to the left or right if tabs are on the top or bottom edge (top or bottom if the tabs are on the left or right edge).

### gtk.Notebook.set_tab_label_packing

        def set_tab_label_packing(child, expand, fill, pack_type)

`child` : | a widget contained in a notebook page
`expand` : | if `True` the tab can expand to fill the free space in the tab area
`fill` : | if `True` the label widget can fill the space in the tab
`pack_type` : | the position of the tab: `gtk.PACK_START` or `gtk.PACK_END`

The `set_tab_label_packing`() method sets the packing parameters for the tab label of the page containing `child`. If `expand` is `True` the tab can expand to take up the free space in the tab area. If `fill` is `True` the label widget in the tab can use up all the space in the tab. The `pack_type` can be one of `gtk.PACK_START` or `gtk.PACK_END` to specify whether the tab is packed to the left or right if tabs are on the top or bottom edge (top or bottom if the tabs are on the left or right edge).See `gtk.Box.pack_start`() for the exact meaning of the parameters.

### gtk.Notebook.reorder_child

        def reorder_child(child, position)

`child` : | the child widget to move
`position` : | the index of the page that `child` is to move to, or -1 to move to the end

The `reorder_child`() method reorders the notebook pages so that `child` appears in the page whose index is specified by `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.

### gtk.Notebook.set_group_id

        def set_group_id(group_id)

`group_id` : | a group identifier, or -1 to unset it

### Note

This method is available in PyGTK 2.10 and above.

The `set_group_id`() method sets the group identifier for the notebook to the value specified by `group_id`. Notebooks sharing the same group identifier will be able to exchange tabs via drag and drop. A notebook with group identifier -1 will not be able to exchange tabs with any other notebook.

### gtk.Notebook.get_group_id

        def get_group_id()

Returns : | the group identifier, or -1 if none is set.

### Note

This method is available in PyGTK 2.10 and above.

The `get_group_id`() method returns the current group identifier for the notebook.

### gtk.Notebook.get_tab_reorderable

        def get_tab_reorderable(child)

`child` : | a child `gtk.Widget`
Returns : | `True` if the tab is reorderable.

### Note

This method is available in PyGTK 2.10 and above.

The `get_tab_reorderable`() method returns `True` if the tab can be reordered via drag and drop.

### gtk.Notebook.set_tab_reorderable

        def set_tab_reorderable(child, reorderable)

`child` : | a child `gtk.Widget`
`reorderable` : | if `True` the tab is reorderable.

### Note

This method is available in PyGTK 2.10 and above.

The `set_tab_reorderable`() method sets the "reorderable" property of `child` to the value of `reorderable`. If `reorderable` is `True`, the notebook tab can be reordered via drag and drop.

### gtk.Notebook.get_tab_detachable

        def get_tab_detachable(child)

`child` : | a child `gtk.Widget`
Returns : | if `True` the tab is detachable.

### Note

This method is available in PyGTK 2.10 and above.

The `get_tab_detachable`() method returns the value of the "detachable" property of `child`. The method returns `True` if the tab contents can be detached from `notebook`.

### gtk.Notebook.set_tab_detachable

        def set_tab_detachable(child, detachable)

`child` : | a child `gtk.Widget`
`detachable` : | if `True` the tab is detachable or not

### Note

This method is available in PyGTK 2.10 and above.

The `set_tab_detachable`() method sets the "detachable" property of `child` to the value specified by `detachable`. If `detachable` is `True`, `child` can be moved from this notebook to another notebook or widget.

Note that two notebooks must share a common group identifier (see the `set_group_id`() method) 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 reference to the child widget that corresponds to the dropped tab.

If you want a notebook to accept drags from other widgets, you will have to set your own DnD code to do it.

## Functions

### gtk.notebook_set_window_creation_hook

        def gtk.notebook_set_window_creation_hook(func, data)

`func` : | a function to call when a tab is dropped in an empty area.
`data` : | data to pass to `func`

### Note

This function is available in PyGTK 2.10 and above.

The `gtk.notebook_set_window_creation_hook` function installs a global function (specified by `func`) used to create a window when a detached tab is dropped in an empty area.

The signature of the callback function `func` is:

    def func(source, page, x, y, user_data)

where `source` is the `gtk.Notebook` of the drag operation, `page` is the child `gtk.Widget` affected, `x` is the X coordinate where the drop happens, `y` is the Y coordinate where the drop happens, `user_data` is the user data to pass to `func`.

This function is used by `gtk.Notebook` when a detachable tab is dropped in the root window, it's used to create a window containing a notebook where the tab will be attached. This function will also be responsible of moving/resizing the window and adding the necessary properties to the notebook (i.e.: group-id). If the function returns `None`, the drag will be cancelled.

## Signals

### The "change-current-page" gtk.Notebook Signal

        def callback(notebook, offset, user_param1, ...)

`notebook` : | the notebook that received the signal
`offset` : | the count of pages to move (negative count is backward)
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

The "change-current-page" signal is emitted when the page forward or page backward request is issued.

### The "create-window" gtk.Notebook Signal

        def callback(notebook, page, x, y, user_param1, ...)

`notebook` : | the notebook that received the signal
`page` : | the tab of notebook that is being detached
`x` : | the X coordinate where the drop happens
`y` : | the Y coordinate where the drop happens
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

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

### The "focus-tab" gtk.Notebook Signal

        def callback(notebook, type, user_param1, ...)

`notebook` : | the notebook that received the signal
`type` : | the type of tab: `gtk.NOTEBOOK_TAB_FIRST` or `gtk.NOTEBOOK_TAB_LAST`
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)
Returns : | `True` if the signal was handled

The "focus-tab" signal is emitted when the focus is changed by tabbing.

### The "move-focus-out" gtk.Notebook Signal

        def callback(notebook, direction_type, user_param1, ...)

`notebook` : | the notebook that received the signal
`direction_type` : | the direction type of the focus move: `gtk.DIR_TAB_FORWARD`, `gtk.DIR_TAB_BACKWARD`, `gtk.DIR_UP`, `gtk.DIR_DOWN`, `gtk.DIR_LEFT` or `gtk.DIR_RIGHT`
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

The "move-focus-out" signal is emitted when the focus is moved out of the notebook with the specified `direction_type`.

### The "page-added" Signal

        def callback(notebook, child, page_num, user_param1, ...)

`notebook` : | the notebook that received the signal
`child` : | the child `gtk.Widget` affected
`page_num` : | the new page number for `child`
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

### Note

This signal is available in PyGTK 2.10 and above.

The "page-added" signal is emitted when a page is added to the notebook.

### The "page-removed" Signal

        def callback(notebook, child, page_num, user_param1, ...)

`notebook` : | the notebook that received the signal
`child` : | the child `gtk.Widget` affected
`page_num` : | the new page number for `child`
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

### Note

This signal is available in PyGTK 2.10 and above.

The "page-removed" signal is emitted after a page is removed from the notebook.

### The "page-reordered" Signal

        def callback(notebook, child, page_num, user_param1, ...)

`notebook` : | the notebook that received the signal
`child` : | the child `gtk.Widget` affected
`page_num` : | the new page number for `child`
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

### Note

This signal is available in PyGTK 2.10 and above.

The "page-reordered" signal is emitted when a page has been reordered.

### The "select-page" gtk.Notebook Signal

        def callback(notebook, move_focus, user_param1, ...)

`notebook` : | the notebook that received the signal
`move_focus` : | if `True` move the focus to a child widget
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)
Returns : | `True` if the signal was handled

The "select-page" signal is emitted when a new child page is selected.

### The "switch-page" gtk.Notebook Signal

        def callback(notebook, page, page_num, user_param1, ...)

`notebook` : | the notebook that received the signal
`page` : | the new current page
`page_num` : | the index of the new current page
`user_param1` : | the first user parameter (if any) specified with the `connect`() method
`...` : | additional user parameters (if any)

The "switch-page" signal is emitted when the notebook page is changed. Note the `page` parameter is a GPointer and not usable within PyGTK. Use the `page_num` parameter to retrieve the new current page using the `get_nth_page`() method.

Prev | Up | Next
gtk.Misc | Home | gtk.Object