gtk.TextView

gtk.TextView
Prev	The gtk Class Reference	Next

gtk.TextView — a widget that displays the contents of a gtk.TextBuffer

Synopsis

class gtk.TextView(gtk.Container):
    gtk.TextView(buffer=None)
    def set_buffer(buffer)
    def get_buffer()
    def scroll_to_iter(iter, within_margin, use_align=FALSE, xalign=0.5, yalign=0.5)
    def scroll_to_mark(mark, within_margin, use_align=FALSE, xalign=0.5, yalign=0.5)
    def scroll_mark_onscreen(mark)
    def move_mark_onscreen(mark)
    def place_cursor_onscreen()
    def get_visible_rect()
    def set_cursor_visible(setting)
    def get_cursor_visible()
    def get_iter_location(iter)
    def get_iter_at_location(x, y)
    def get_line_yrange(iter)
    def get_line_at_y(target_iter)
    def buffer_to_window_coords(win, buffer_x, buffer_y)
    def window_to_buffer_coords(win, window_x, window_y)
    def get_window(win)
    def get_window_type(window)
    def set_border_window_size(type, size)
    def get_border_window_size(type)
    def forward_display_line(iter)
    def backward_display_line(iter)
    def forward_display_line_end(iter)
    def backward_display_line_start(iter)
    def starts_display_line(iter)
    def move_visually(iter, count)
    def add_child_at_anchor(child, anchor)
    def add_child_in_window(child, which_window, xpos, ypos)
    def move_child(child, xpos, ypos)
    def set_wrap_mode(wrap_mode)
    def get_wrap_mode()
    def set_editable(setting)
    def get_editable()
    def set_overwrite(overwrite)
    def get_overwrite()
    def set_accepts_tab(accepts_tab)
    def get_accepts_tab()
    def set_pixels_above_lines(pixels_above_lines)
    def get_pixels_above_lines()
    def set_pixels_below_lines(pixels_below_lines)
    def get_pixels_below_lines()
    def set_pixels_inside_wrap(pixels_inside_wrap)
    def get_pixels_inside_wrap()
    def set_justification(justification)
    def get_justification()
    def set_left_margin(left_margin)
    def get_left_margin()
    def set_right_margin(right_margin)
    def get_right_margin()
    def set_indent(indent)
    def get_indent()
    def set_tabs(tabs)
    def get_tabs()
    def get_default_attributes()

Ancestry

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

gtk.TextView Properties

gtk.Object Properties

gtk.Widget Properties

gtk.Container Properties

"accepts-tab"	Read-Write	If `TRUE`, pressing Tab will result in a tab character being entered; otherwise the focus will be moved. Available in GTK+ 2.4 and above.
"buffer"	Read-Write	The buffer that is displayed. Available in GTK+ 2.4 and above.
"cursor-visible"	Read-Write	If `TRUE`, the insertion cursor is shown
"editable"	Read-Write	If `TRUE`, the text can be modified by the user by default
"indent"	Read-Write	The default amount to indent the paragraph, in pixels
"justification"	Read-Write	The default text justification: `gtk.JUSTIFY_LEFT`, `gtk.JUSTIFY_RIGHT`, `gtk.JUSTIFY_CENTER` or `gtk.JUSTIFY_FILL`
"left-margin"	Read-Write	The default width of the left margin in pixels
"overwrite"	Read-Write	If `TRUE`, the entered text overwrites existing contents. Available in GTK+ 2.4 and above.
"pixels-above-lines"	Read-Write	The default number of pixels of blank space above paragraphs
"pixels-below-lines"	Read-Write	The default number of pixels of blank space below paragraphs
"pixels-inside-wrap"	Read-Write	The default number of pixels of blank space between wrapped lines in a paragraph
"right-margin"	Read-Write	The default width of the right margin in pixels
"tabs"	Read-Write	The default custom tabs
"wrap-mode"	Read-Write	The default wrap mode: `gtk.WRAP_NONE`, `gtk.WRAP_CHAR` or `gtk.WRAP_WORD`

gtk.TextView Style Properties

gtk.Widget Style Properties

"error-underline-color" Read-Write The gtk.gdk.Color with which to draw error-indication underlines. Available in GTK+ 2.4 and above.

gtk.TextView Signal Prototypes

gobject.GObject Signal Prototypes

gtk.Object Signal Prototypes

gtk.Widget Signal Prototypes

gtk.Container Signal Prototypes

"backspace	`def callback(textview, user_param1, ...)`
"copy-clipboard"	`def callback(textview, user_param1, ...)`
"cut-clipboard"	`def callback(textview, user_param1, ...)`
"delete-from-cursor"	`def callback(textview, delete_type, count, user_param1, ...)`
"insert-at-cursor"	`def callback(textview, string, user_param1, ...)`
"move-cursor"	`def callback(textview, step_size, count, extend_selection, user_param1, ...)`
"move-focus"	`def callback(textview, direction, user_param1, ...)`
"move-viewport"	`def callback(textview, scrollstep, count, user_param1, ...)`
"page-horizontally"	`def callback(textview, count, extend_selection, user_param1, ...)`
"paste-clipboard"	`def callback(textview, user_param1, ...)`
"populate-popup"	`def callback(textview, menu, user_param1, ...)`
"select-all"	`def callback(textview, select, user_param1, ...)`
"set-anchor"	`def callback(textview, user_param1, ...)`
"set-scroll-adjustments"	`def callback(textview, hadjustment, vadjustment, user_param1, ...)`
"toggle-overwrite"	`def callback(textview, user_param1, ...)`

Description

A gtk.TextView widget provides the display for the contents of a gtk.TextBuffer object. A textview provides a set of attributes for the default display of text from a textbuffer. The attributes set by gtk.TextTag objects override the attributes set on a gtk.TextView widget. Since a gtk.TextBuffer can be associated with multiple gtk.TextView widgets each having a different set of default attributes, the display of the same text in different textview widgets can be quite different except for those attributes that are overridden by texttags.

A gtk.TextView widget has several gtk.gdk.Window widgets most of which are not displayed by default:

`gtk.TEXT_WINDOW_WIDGET`	The widget window
`gtk.TEXT_WINDOW_TEXT`	The window that holds the text
`gtk.TEXT_WINDOW_LEFT`	The left border window - not displayed by default
`gtk.TEXT_WINDOW_RIGHT`	The right border window - not displayed by default
`gtk.TEXT_WINDOW_TOP`	The top border window - not displayed by default
`gtk.TEXT_WINDOW_BOTTOM`	The bottom border window - not displayed by default
`gtk.TEXT_WINDOW_PRIVATE`	An internal inaccessible `gtk.gdk.Window`

The border windows are not created until they are given a size by using the set_border_window_size() method.

Depending on the wrap mode of the textview a textbuffer line may be displayed as more than one screen display line. The textview has methods to navigate through the display lines.

A gtk.TextChildAnchor in a gtk.TextBuffer provides a place for a PyGTK widget to be placed in a gtk.TextView. Each textview displaying the same textbuffer with a child anchor must have a different widget placed at that child anchor. In addition, a widget can be placed at a specific location in one of the above gtk.TextView windows using the add_child_in_window() method. The widget will be clipped to the window boundaries if it is larger than the window or located where it extends beyond the window boundaries.

A gtk.TextView has a default popup menu that includes the usual cut, copy and paste capabilities. In PyGTK 2.2 gtk.Clipboard objects are supported so your program can access the contents of the cut, copy and paste clipboard through the gdk.SELECTION_CLIPBOARD clipboard. Also the selected text in a gtk.TextView is available on the gdk.SELECTION_PRIMARY clipboard.

Constructor

    gtk.TextView(buffer=None)

`buffer` :	a `gtk.TextBuffer` or `None`
Returns :	a new `gtk.TextView`.

Creates a new gtk.TextView widget displaying the gtk.TextBuffer specified by buffer. If buffer is None, a new gtk.TextBuffer will be created. One textbuffer can be shared among many widgets.

Methods

gtk.TextView.set_buffer

    def set_buffer(buffer)

buffer : a gtk.TextBuffer

The set_buffer() method sets the gtk.TextBuffer specified by buffer as the textbuffer being displayed by the textview.

gtk.TextView.get_buffer

    def get_buffer()

Returns : a gtk.TextBuffer

The get_buffer() method returns the gtk.TextBuffer being displayed by this textview.

gtk.TextView.scroll_to_iter

    def scroll_to_iter(iter, within_margin, use_align=FALSE, xalign=0.5, yalign=0.5)

`iter` :	a `gtk.TextIter` object
`within_margin` :	the margin as a [0.0,0.5) fraction of screen size
`use_align` :	if `TRUE` use the alignment arguments; if `FALSE`, just get `iter` on screen
`xalign` :	the horizontal alignment of `iter` within visible area.
`yalign` :	the vertical alignment of `iter` within visible area
Returns :	`TRUE` if scrolling occurred

The scroll_to_iter() method scrolls the textview so that the gtk.TextIter location specified by iter is on the screen in the position indicated by xalign and yalign. If use_align is TRUE the alignments specify the fraction of screen space to the left of or above the location of iter. If use_align is FALSE, the text scrolls the minimal distance to get iter on screen, possibly not scrolling at all. The effective screen for purposes of this method is reduced by a margin of size specified by within_margin.

Note

This method uses the currently-computed height of the lines in the text buffer. The line heights are computed in an idle handler so this method may not have the desired effect if it's called before the height computations are complete. To avoid oddness, consider using the scroll_to_mark() method that saves a point to be scrolled to after line validation.

gtk.TextView.scroll_to_mark

    def scroll_to_mark(mark, within_margin, use_align=FALSE, xalign=0.5, yalign=0.5)

`mark` :	a `gtk.TextMark` object
`within_margin` :	the margin as a [0.0,0.5) fraction of screen size
`use_align` :	if `TRUE` use the alignment arguments; if `FALSE`, just get `mark` on screen
`xalign` :	the horizontal alignment of `mark` within the visible area.
`yalign` :	the vertical alignment of `mark` within the visible area

The scroll_to_mark() method scrolls the textview so that the gtk.TextMark location specified by mark is on the screen in the position specified by xalign and yalign. If use_align is TRUE the alignments specify the fraction of screen space to the left of or above the location of mark. If use_align is FALSE, the text scrolls the minimal distance to get mark on screen, possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size specified by within_margin.

gtk.TextView.scroll_mark_onscreen

    def scroll_mark_onscreen(mark)

mark : a gtk.TextMark in the textbuffer for textview

The scroll_mark_onscreen() method scrolls the textview the minimum distance to place the gtk.TextMark location specified by mark within the visible area of the widget.

gtk.TextView.move_mark_onscreen

    def move_mark_onscreen(mark)

`mark` :	a `gtk.TextMark` object
Returns :	`TRUE` if `mark` moved (wasn't already on screen)

The move_mark_onscreen() moves the gtk.TextMark location specified by mark to a location within the currently-visible text area of the textview.

gtk.TextView.place_cursor_onscreen

    def place_cursor_onscreen()

Returns :

TRUE if the cursor had to be moved.

The place_cursor_onscreen() method moves the cursor to a new location within the currently visible region of the buffer, if it isn't there already.

gtk.TextView.get_visible_rect

    def get_visible_rect()

Returns : a gtk.gdk.Rectangle

The get_visible_rect() method returns a gtk.gdk.Rectangle containing the coordinates of the currently-visible region of the buffer. The rectangle is in buffer coordinates that can be converted to window coordinates with the buffer_to_window_coords() method.

gtk.TextView.set_cursor_visible

    def set_cursor_visible(setting)

setting : if TRUE show the insertion cursor

The set_cursor_visible() method sets the "cursor-visible" property to the value of setting. If setting is TRUE the cursor is visible; if FALSE, it is not. A buffer with no editable text probably shouldn't have a visible cursor, so you may want to turn the cursor off.

gtk.TextView.get_cursor_visible

    def get_cursor_visible()

Returns : TRUE if the insertion mark is visible

The get_cursor_visible() method returns the value of the "cursor-visible" property that determines if the insertion point is visible.

gtk.TextView.get_iter_location

    def get_iter_location(iter)

`iter` :	a `gtk.TextIter`
Returns :	a `gtk.gdk.Rectangle` containing the bounds of the character at `iter`

The get_iter_location() method returns a gtk.gdk.Rectangle that contains the character at the location specified by iter. The rectangle position is in buffer coordinates that can be converted to window coordinates with the buffer_to_window_coords() method.

gtk.TextView.get_iter_at_location

    def get_iter_at_location(x, y)

`x` :	x position, in buffer coordinates
`y` :	y position, in buffer coordinates
Returns :	a `gtk.TextIter`

The get_iter_at_location() method returns a gtk.TextIter that points at the location specified by the buffer coordinates x and y. Buffer coordinates are coordinates for the entire buffer, not just the currently-displayed portion. Window coordinates from an event, must be converted to buffer coordinates with the window_to_buffer_coords() method before using them with this method.

gtk.TextView.get_line_yrange

    def get_line_yrange(iter)

`iter` :	a `gtk.TextIter`
Returns :	a tuple containing a y coordinate and a height

The get_line_yrange() method locates the line containing the gtk.TextIter specified by iter and returns a tuple containing the y coordinate of the top of the line and the height of the line. The coordinate is a buffer coordinate that can be converted to window coordinates with the buffer_to_window_coords() method.

gtk.TextView.get_line_at_y

    def get_line_at_y(y)

`y` :	a y coordinate
Returns :	a tuple containing a `gtk.TextIter` pointing at the line start and the top coordinate of the line

The get_line_at_y() method returns a tuple containing:

a gtk.TextIter pointing at the start of the line with the vertical coordinate specified by y and,
the vertical coordinate of the top edge of the line.

y is in buffer coordinates that can be converted from window coordinates with the window_to_buffer_coords() method.

gtk.TextView.buffer_to_window_coords

    def buffer_to_window_coords(win, buffer_x, buffer_y)

`win` :	one of the textview windows except `gtk.TEXT_WINDOW_PRIVATE`
`buffer_x` :	buffer x coordinate
`buffer_y` :	buffer y coordinate
Returns :	a tuple containing the window x and y coordinates

The buffer_to_window_coords() method returns a tuple containing the x and y coordinates for the window specified by win that correspond to the textbuffer coordinates specified by buffer_x and buffer_y. See the above description for more details on textview window types.

Note

You can't convert coordinates for a non-existing window (see the set_border_window_size() method).

gtk.TextView.window_to_buffer_coords

    def window_to_buffer_coords(win, window_x, window_y)

`win` :	a textview window except `gtk.TEXT_WINDOW_PRIVATE`
`window_x` :	window x coordinate
`window_y` :	window y coordinate
Returns :	a tuple containing the textbuffer x and y coordinates

The window_to_buffer_coords() method returns a tuple containing the textbuffer x and y coordinates corresponding to the window_x and window_y coordinates in the window specified by win, See the above description for more details on textview window types.

Note

You can't convert coordinates for a non-existing window (see the set_border_window_size()) method.

gtk.TextView.get_window

    def get_window(win)

`win` :	a textview window type
Returns :	a `gtk.gdk.Window`, or `None`

The get_window() method returns the gtk.gdk.Window corresponding to an area of the textview specified by win:

`gtk.TEXT_WINDOW_WIDGET`	The widget window
`gtk.TEXT_WINDOW_TEXT`	The window that holds the text
`gtk.TEXT_WINDOW_LEFT`	The left border window - not displayed by default
`gtk.TEXT_WINDOW_RIGHT`	The right border window - not displayed by default
`gtk.TEXT_WINDOW_TOP`	The top border window - not displayed by default
`gtk.TEXT_WINDOW_BOTTOM`	The bottom border window - not displayed by default
`gtk.TEXT_WINDOW_PRIVATE`	An internal inaccessible `gtk.gdk.Window`

This method returns None if the window is nonexistent i.e. if its width or height is 0.

gtk.TextView.get_window_type

    def get_window_type(window)

`window` :	a window type
Returns :	the window type.

The get_window_type() method returns the type of the gtk.gdk.Window specified by window. This method is used to find out what window type an event corresponds to. If you connect to an event signal on the textview, this method can be called on event.window to see what window type it was. See the get_window() method for more details on window types.

gtk.TextView.set_border_window_size

    def set_border_window_size(type, size)

`type` :	a textview border window type
`size` :	the width or height of the window

The set_border_window_size() method sets the width of a gtk.TEXT_WINDOW_LEFT or gtk.TEXT_WINDOW_RIGHT window, or the height of a gtk.TEXT_WINDOW_TOP or gtk.TEXT_WINDOW_BOTTOM window. This method automatically destroys the corresponding window if the size is set to 0, and creates the window if the size is set to non-zero. This method can only be used for the "border windows", it doesn't work with the gtk.TEXT_WINDOW_WIDGET, gtk.TEXT_WINDOW_TEXT, or gtk.TEXT_WINDOW_PRIVATE windows.

gtk.TextView.get_border_window_size

    def get_border_window_size(type)

`type` :	a textview border window type
Returns :	the width or height of the textview border window

The get_border_window_size() method returns the width or height of the border window of the type specified by type. See the set_border_window_size() method for more details.

gtk.TextView.forward_display_line

    def forward_display_line(iter)

`iter` :	a `gtk.TextIter`
Returns :	`TRUE` if `iter` was moved and is not on the end iterator

The forward_display_line() method moves the location of iter forward by one display line. A textview display line is different from a textbuffer line. Textbuffer lines are paragraphs and are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a textbuffer line. If wrapping is turned off, display lines and textbuffer lines will be the same. Display lines are divided differently for each textview, since they depend on the textview's width and the textview's default wrap mode. Paragraphs are the same in all views, since they depend on the contents of the gtk.TextBuffer. This method returns TRUE if the location of iter moves to a dereferenceable position (i.e. not the end position).

gtk.TextView.backward_display_line

    def backward_display_line(iter)

`iter` :	a `gtk.TextIter`
Returns :	`TRUE` if `iter` was moved

The backward_display_line() method moves the location of iter backward by one display line. A textview display line is different from a textbuffer line. Textview lines are paragraphs and are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a textbuffer line. If wrapping is turned off, display lines and textbuffer lines will be the same. Display lines are divided differently for each textview, since they depend on the textview's width and the textview's default wrap mode. Paragraphs are the same in all views, since they depend on the contents of the gtk.TextBuffer. This method returns TRUE if the location of iter moves to a dereferenceable position (i.e. not the end position).

gtk.TextView.forward_display_line_end

    def forward_display_line_end(iter)

`iter` :	a `gtk.TextIter`
Returns :	`TRUE` if `iter` was moved and is not on the end iterator

The forward_display_line_end() method moves the location of iter forward to the next display line end. A textview display line is different from a textbuffer line. Textbuffer lines are paragraphs and are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a textbuffer line. If wrapping is turned off, display lines and textbuffer lines will be the same. Display lines are divided differently for each textview, since they depend on the textview's width and the textview's default wrap mode. Paragraphs are the same in all views, since they depend on the contents of the gtk.TextBuffer. This method returns TRUE if the location of iter moves to a dereferenceable position (i.e. not the end position).

gtk.TextView.backward_display_line_start

    def backward_display_line_start(iter)

`iter` :	a `gtk.TextIter`
Returns :	`TRUE` if `iter` was moved

The backward_display_line_start() method moves the location of iter backward to the next display line start. A textview display line is different from a textbuffer line. Textbuffer lines are paragraphs and are separated by newlines or other paragraph separator characters. Display lines are created by line-wrapping a textbuffer line. If wrapping is turned off, display lines and textbuffer lines will be the same. Display lines are divided differently for each textview, since they depend on the textview's width and the textview's default wrap mode. Paragraphs are the same in all views, since they depend on the contents of the gtk.TextBuffer. This method returns TRUE if the location of iter moves to a dereferenceable position (i.e. not the end position).

gtk.TextView.starts_display_line

    def starts_display_line(iter)

`iter` :	a `gtk.TextIter`
Returns :	`TRUE` if the location of `iter` is at the beginning of a display line

The starts_display_line() method returns TRUE if the location of iter is at the start of a display line. See the forward_display_line() method for an explanation of display lines vs. textbuffer lines (paragraphs).

gtk.TextView.move_visually

    def move_visually(iter, count)

`iter` :	a `gtk.TextIter`
`count` :	the number of characters to move (may be negative)
Returns :	`TRUE` if `iter` moved and is not on the end iterator

The move_visually() method moves the location of iter by count cursor positions. If count is negative the location moves against the normal text direction. Note a cursor position move may move over multiple characters when multiple characters combine to form one grapheme.

gtk.TextView.add_child_at_anchor

    def add_child_at_anchor(child, anchor)

`child` :	a `gtk.Widget`
`anchor` :	a `gtk.TextChildAnchor` in the textview's `gtk.TextBuffer`

The add_child_at_anchor() method adds the widget specified by child in the textview, at the gtk.TextChildAnchor specified by anchor.

gtk.TextView.add_child_in_window

    def add_child_in_window(child, which_window, xpos, ypos)

`child` :	a `gtk.Widget`
`which_window` :	the textview window `child` should appear in
`xpos` :	the X position of `child` in window coordinates
`ypos` :	the Y position of `child` in window coordinates

The add_child_in_window() method adds the widget specified by child at the fixed coordinates specified by xpos and ypos in one of the text widget's windows specified by which_window. The window must have nonzero size (see the set_border_window_size() method).

Note

The child coordinates are given relative to the gtk.gdk.Window specified by which_window, and these coordinates have no sane relationship to scrolling. When placing child in a gtk.TEXT_WINDOW_WIDGET window, scrolling is irrelevant, child floats above all scrollable areas. However, placing child in one of the scrollable windows (a border windows or the text window), you'll need to compute the correct position of child in textbuffer coordinates any time scrolling occurs or textbuffer changes occur, and then call the move_child() method to update the child's position. Unfortunately there's no good way to detect that scrolling has occurred, using the current API; a possible hack would be to update all child positions when the scroll adjustments change or the text buffer changes.

gtk.TextView.move_child

    def move_child(child, xpos, ypos)

`child` :	a child widget in the textview
`xpos` :	the new X position in window coordinates
`ypos` :	the new Y position in window coordinates

The move_child() method moves the position of child to the location (in its current window) specified by xpos and ypos.

gtk.TextView.set_wrap_mode

    def set_wrap_mode(wrap_mode)

wrap_mode : a wrap mode value

The set_wrap_mode() method sets the "wrap-mode" property of the textview to the value specified by wrap_mode. The value of wrap_mode can be one of: gtk.WRAP_NONE, gtk.WRAP_CHAR or gtk.WRAP_WORD. The "wrap-mode" property defines the wrap mode for text that is not influenced by a gtk.TextTag that sets its "wrap_mode" attribute.

gtk.TextView.get_wrap_mode

    def get_wrap_mode()

Returns :

the line wrap setting

The get_wrap_mode() method returns the value of the "wrap-mode" property. The value of "wrap-mode" can be one of: gtk.WRAP_NONE, gtk.WRAP_CHAR or gtk.WRAP_WORD. The "wrap-mode" property defines the wrap mode for text that is not influenced by a gtk.TextTag that sets its "wrap_mode" attribute.

gtk.TextView.set_editable

    def set_editable(setting)

setting : if TRUE the text is editable by default

The set_editable() method sets the "editable" property to the value of setting. If setting is TRUE the text in textview is editable by default. The "editable" property determines the editability of the gtk.TextView text that is not influenced by a gtk.TextTag that sets its "editable" attribute.

gtk.TextView.get_editable

    def get_editable()

Returns : TRUE if text is editable by default

The get_editable() method returns the value of the "editable" property. The "editable" property determines the editability of the gtk.TextView text that is not influenced by a gtk.TextTag that sets its "editable" attribute.

gtk.TextView.set_overwrite

    def set_overwrite(overwrite)

overwrite : if TRUE turn on overwrite mode; if FALSE turn it off

Note

This method is available in PyGTK 2.4 and above.

The set_overwrite() method sets the "overwrite" property to the value of overwrite. If overwrite is TRUE, inserted text overwrites the existing text.

gtk.TextView.get_overwrite

    def get_overwrite()

Returns : TRUE if the textview is in overwrite mode

Note

This method is available in PyGTK 2.4 and above.

The get_overwrite() method returns the value of the "overwrite" property. see the set_overwrite() method for more information.

gtk.TextView.set_accepts_tab

    def set_accepts_tab(accepts_tab)

accepts_tab : if TRUE pressing the Tab key should insert a tab character; if FALSE, pressing the Tab key should move the keyboard focus.

Note

This method is available in PyGTK 2.4 and above.

The set_accepts_tab() method sets the "accepts_tab" property to the value of accepts_tab. If accepts_tab is TRUE a tab character is inserted. If accepts_tab is FALSE the keyboard focus is moved to the next widget in the focus chain.

gtk.TextView.get_accepts_tab

    def get_accepts_tab()

Returns : TRUE if pressing the Tab key inserts a tab character, FALSE if pressing the Tab key moves the keyboard focus.

Note

This method is available in PyGTK 2.4 and above.

The get_accepts_tab() method returns the value of the "accepts_tab" property. See the set_accepts_tab() method for more information.

gtk.TextView.set_pixels_above_lines

    def set_pixels_above_lines(pixels_above_lines)

pixels_above_lines : the number of pixels above paragraphs

The set_pixels_above_lines() method sets the "pixels-above-lines" property to the value of pixels_above_lines. The "pixels-above-lines" property determines the number of blank pixels to place above textbuffer lines (paragraphs) in the textview for text that is not influenced by a gtk.TextTag that sets its "pixels-above-lines" attribute.

gtk.TextView.get_pixels_above_lines

    def get_pixels_above_lines()

Returns :

the default number of pixels above paragraphs

The get_pixels_above_lines() method returns the value of the "pixels-above-lines" property. The "pixels-above-lines" property determines the number of pixels to put above textbuffer lines (paragraphs) in the textview for text that is not influenced by a gtk.TextTag that sets its "pixels-above-lines" attribute.

gtk.TextView.set_pixels_below_lines

    def set_pixels_below_lines(pixels_below_lines)

pixels_below_lines : the default number of pixels below paragraphs

The set_pixels_below_lines() method sets the "pixels-below-lines" property to the value of pixels_below_lines. The "pixels-below-lines" property determines the number of blank pixels to place below textbuffer lines (paragraphs) in the textview for text that is not influenced by a gtk.TextTag that sets its "pixels-below-lines" attribute.

gtk.TextView.get_pixels_below_lines

    def get_pixels_below_lines()

Returns :

the default number of blank pixels below paragraphs

The get_pixels_below_lines() method returns the value of the "pixels-below-lines" property. The "pixels-below-lines" property determines the number of pixels to put below textbuffer lines (paragraphs) in the textview for text that is not influenced by a gtk.TextTag that sets its "pixels-below-lines" attribute.

gtk.TextView.set_pixels_inside_wrap

    def set_pixels_inside_wrap(pixels_inside_wrap)

pixels_inside_wrap : the default number of pixels between wrapped lines

The set_pixels_inside_wrap() method sets the "pixels-inside_wrap" property to the value of pixels_inside_wrap. The "pixels-inside_wrap" property determines the number of blank pixels to place between wrapped textbuffer lines (inside paragraphs) for text that is not influenced by a gtk.TextTag that sets its "pixels-inside_wrap" attribute.

gtk.TextView.get_pixels_inside_wrap

    def get_pixels_inside_wrap()

Returns :

the default number of pixels of blank space between wrapped lines

The get_pixels_inside_wrap() method returns the value of the "pixels-inside-wrap" property. The "pixels-inside-wrap" property determines the number of pixels to put between wrapped textbuffer lines (inside paragraphs) for text that is not influenced by a gtk.TextTag that sets its "pixels-inside-wrap" attribute.

gtk.TextView.set_justification

    def set_justification(justification)

justification : the text justification

The set_justification() method sets the "justification" property to the value of justification. The value of justification must be one of: gtk.JUSTIFY_LEFT, gtk.JUSTIFY_RIGHT, gtk.JUSTIFY_CENTER or gtk.JUSTIFY_FILL. The "justification" property determines the justification of text in the textview that is not influenced by a gtk.TextTag that set its "justification" attribute.

gtk.TextView.get_justification

    def get_justification()

Returns :

the default justification

The get_justification() method returns the value of the "justification" property. the default justification of paragraphs in text_view. The value of "justification" must be one of: gtk.JUSTIFY_LEFT, gtk.JUSTIFY_RIGHT, gtk.JUSTIFY_CENTER or gtk.JUSTIFY_FILL. The "justification" property determines the justification of text in the textview that is not influenced by a gtk.TextTag that set its "justification" attribute.

gtk.TextView.set_left_margin

    def set_left_margin(left_margin)

left_margin : the default left margin in pixels

The set_left_margin() method sets the "left-margin" property to the value of left_margin. The "left-margin"property determines the number of pixels of space for the left margin of text that is not influenced by a gtk.TextTag that sets its "left_margin" attribute.

gtk.TextView.get_left_margin

    def get_left_margin()

Returns :

the default left margin in pixels

The get_left_margin() method returns the value of the "left_margin" property. The "left-margin"property determines the number of pixels of space for the left margin of text that is not influenced by a gtk.TextTag that sets its "left_margin" attribute.

gtk.TextView.set_right_margin

    def set_right_margin(right_margin)

right_margin : the default right margin in pixels

The set_right_margin() method sets the "right-margin" property to the value of right_margin. The "right-margin"property determines the number of pixels of space for the right margin of text that is not influenced by a gtk.TextTag that sets its "right_margin" attribute.

gtk.TextView.get_right_margin

    def get_right_margin()

Returns :

the default right margin in pixels

The get_right_margin() method returns the value of the "right_margin" property. The "right-margin"property determines the number of pixels of space for the right margin of text that is not influenced by a gtk.TextTag that sets its "right_margin" attribute.

gtk.TextView.set_indent

    def set_indent(indent)

indent : the default indentation in pixels

The set_indent() method sets the "indent" property to the value of indent. The "indent" property determines the indentation for textview paragraphs that are not influenced by a gtk.TextTag that sets its "indent" attribute. The indentation may be negative.

gtk.TextView.get_indent

    def get_indent()

Returns :

the default number of pixels of indentation

The get_indent() method returns the value of the "indent" property. The "indent" property determines the indentation for textview paragraphs that are not influenced by a gtk.TextTag that sets its "indent" attribute. The indentation may be negative.

gtk.TextView.set_tabs

    def set_tabs(tabs)

tabs : the default tabs as a pango.TabArray

The set_tabs() method sets the "tabs" property to a copy of the value of tabs. The "tabs" property contains the custom tab stops for the textview paragraphs that are not influenced by a gtk.TextTag that sets its "tabs" attribute.

gtk.TextView.get_tabs

    def get_tabs()

Returns : a copy of default tab array, or None if "standard" tabs are used

The get_tabs() method returns the value of the "tabs" property. The "tabs" property contains the custom tab stops for the textview paragraphs that are not influenced by a gtk.TextTag that sets its "tabs" attribute. The returned value will be None if "standard" (8-space) tabs are used.

gtk.TextView.get_default_attributes

    def get_default_attributes()

Returns : a new gtk.TextAttributes

The get_default_attributes() method returns a copy of the default gtk.TextAttributes. These attributes are used for text unless the text is influenced by a gtk.TextTag. You'd typically pass the default attributes in to the gtk.TextIter.get_attributes() method to get the attributes in effect at a given text position.

Signals

The "backspace" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the object which received the signal.
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

Note

This signal is available in GTK+ 2.10 and above.

The "backspace" signal is emitted when the Backspace key is pressed.

The "copy-clipboard" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the textview that received the signal
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "copy-clipboard" signal is emitted when a selection is copied to the clipboard from textview.

The "cut-clipboard" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the textview that received the signal
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "cut-clipboard" signal is emitted when a selection is cut from textview to the clipboard.

The "delete-from-cursor" gtk.TextView Signal

    def callback(textview, delete_type, count, user_param1, ...)

`textview` :	the textview that received the signal
`delete_type` :	the type of deletion
`count` :	the number of deletions to do
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "delete-from-cursor" signal is emitted when a deletion of the type specified by delete_type is initiated by user action (e.g. pressing the Delete or Backspace keys). The value of delete_type must be one of:

gtk.DELETE_CHARS
gtk.DELETE_WORD_ENDS
gtk.DELETE_WORDS
gtk.DELETE_DISPLAY_LINES
gtk.DELETE_DISPLAY_LINE_ENDS
gtk.DELETE_PARAGRAPH_ENDS
gtk.DELETE_PARAGRAPHS
gtk.DELETE_WHITESPACE

count specifies the number of times that deletion should be applied.

The "insert-at-cursor" gtk.TextView Signal

    def callback(textview, string, user_param1, ...)

`textview` :	the textview that received the signal
`string` :	the text to be inserted
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "insert-at-cursor" signal is emitted when string is being inserted in textview.

The "move-cursor" gtk.TextView Signal

    def callback(textview, step_size, count, extend_selection, user_param1, ...)

`textview` :	the textview that received the signal
`step_size` :	the step size to move
`count` :	the number of steps to move
`extend_selection` :	if `TRUE` extend the selection
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "move-cursor" signal is emitted when the cursor is moved by count steps of step_size. If extend_selection is TRUE the selection is extended by the cursor movement. The value of step_size must be one of:

`gtk.MOVEMENT_LOGICAL_POSITIONS`	move by graphemes
`gtk.MOVEMENT_VISUAL_POSITIONS`	move by graphemes
`gtk.MOVEMENT_WORDS`	move by words
`gtk.MOVEMENT_DISPLAY_LINES`	move by lines(wrapped lines)
`gtk.MOVEMENT_DISPLAY_LINE_ENDS`	move to line ends(wrapped lines)
`gtk.MOVEMENT_PARAGRAPHS`	move by paragraphs(newline-ended lines)
`gtk.MOVEMENT_PARAGRAPH_ENDS`	move to ends of a paragraph
`gtk.MOVEMENT_PAGES`	move by pages
`gtk.MOVEMENT_BUFFER_ENDS`	move to ends of the buffer

The "move-focus" gtk.TextView Signal

    def callback(textview, direction, user_param1, ...)

`textview` :	the textview that received the signal
`direction` :	the direction to move the focus
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "move-focus" signal is emitted when the focus moves from textview in the direction specified by direction that must be one of: gtk.DIR_TAB_FORWARD, gtk.DIR_TAB_BACKWARD, gtk.DIR_UP, gtk.DIR_DOWN, gtk.DIR_LEFT or gtk.DIR_RIGHT

The "move-viewport" gtk.TextView Signal

    def callback(textview, scrollstep, count, user_param1, ...)

`textview` :	the textview that received the signal
`scrollstep` :	the size of the scroll step: `gtk.SCROLL_STEPS`, `gtk.SCROLL_PAGES`, `gtk.SCROLL_ENDS`, `gtk.SCROLL_HORIZONTAL_STEPS`, `gtk.SCROLL_HORIZONTAL_PAGES` or `gtk.SCROLL_HORIZONTAL_ENDS`
`count` :	the number of scroll steps of size `scrollstep` to take
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

Note

This signal is available in GTK+ 2.4 and above.

The "move-viewport" signal is emitted when the viewport is being moved usually as the result of user action in moving the cursor or using the scrollbars.

The "page-horizontally" gtk.TextView Signal

    def callback(textview, count, extend_selection, user_param1, ...)

`textview` :	the textview that received the signal
`count` :	the number of pages to move
`extend_selection` :	if `TRUE` extend the selection
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "page-horizontally" signal is emitted when user initiates horizontal paging by pressing one of the key combinations:

Control+Page Up	Page horizontally with `extend_selection` set to `FALSE`
Shift+Control+Page Up	Page horizontally with `extend_selection` set to `TRUE`

The "paste-clipboard" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the textview that received the signal
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "paste-clipboard" signal is emitted when the contents of the clipboard are pasted into textview.

The "populate-popup" gtk.TextView Signal

    def callback(textview, menu, user_param1, ...)

`textview` :	the textview that received the signal
`menu` :	the menu to populate
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "populate-popup" signal is emitted when the popup menu (specified by menu) associated with textview needs to be populated.

The "select-all" gtk.TextView Signal

    def callback(textview, select, user_param1, ...)

`textview` :	the textview that received the signal
`select` :	if `TRUE` select the buffer contents; otherwise deselect the buffer contents
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

Note

This signal is available in GTK+ 2.2 and above.

The "select-all" signal is emitted when the user presses one of:

Control+a or Control+/ to select all text in a buffer
Control+\ to deselect all text in a buffer

The "set-anchor" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the textview that received the signal
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "set-anchor" signal is emitted when an application calls the GObject.emit()() method on textview with "set-anchor" as the signal.

The "set-scroll-adjustments" gtk.TextView Signal

    def callback(textview, hadjustment, vadjustment, user_param1, ...)

`textview` :	the textview that received the signal
`hadjustment` :	the horizontal adjustment
`vadjustment` :	the vertical adjustment
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "set-scroll-adjustments" signal is emitted when one or both adjustments (specified by hadjustment and vadjustment) are set on textview.

The "toggle-overwrite" gtk.TextView Signal

    def callback(textview, user_param1, ...)

`textview` :	the textview that received the signal
`user_param1` :	the first user parameter (if any) specified with the `connect`() method
`...` :	additional user parameters (if any)

The "toggle-overwrite" signal is emitted when the user presses the Insert key.