GtkTextView

Name

GtkTextView -- Widget that displays a GtkTextBuffer

Synopsis


#include <gtk/gtk.h>


struct      GtkTextView;
enum        GtkTextWindowType;
GtkWidget*  gtk_text_view_new               (void);
GtkWidget*  gtk_text_view_new_with_buffer   (GtkTextBuffer *buffer);
void        gtk_text_view_set_buffer        (GtkTextView *text_view,
                                             GtkTextBuffer *buffer);
GtkTextBuffer* gtk_text_view_get_buffer     (GtkTextView *text_view);
gboolean    gtk_text_view_scroll_to_mark    (GtkTextView *text_view,
                                             GtkTextMark *mark,
                                             gint mark_within_margin);
gboolean    gtk_text_view_move_mark_onscreen
                                            (GtkTextView *text_view,
                                             GtkTextMark *mark);
gboolean    gtk_text_view_place_cursor_onscreen
                                            (GtkTextView *text_view);
void        gtk_text_view_get_visible_rect  (GtkTextView *text_view,
                                             GdkRectangle *visible_rect);
void        gtk_text_view_set_wrap_mode     (GtkTextView *text_view,
                                             GtkWrapMode wrap_mode);
GtkWrapMode gtk_text_view_get_wrap_mode     (GtkTextView *text_view);
void        gtk_text_view_set_editable      (GtkTextView *text_view,
                                             gboolean setting);
gboolean    gtk_text_view_get_editable      (GtkTextView *text_view);
void        gtk_text_view_set_cursor_visible
                                            (GtkTextView *text_view,
                                             gboolean setting);
gboolean    gtk_text_view_get_cursor_visible
                                            (GtkTextView *text_view);
void        gtk_text_view_get_iter_location (GtkTextView *text_view,
                                             const GtkTextIter *iter,
                                             GdkRectangle *location);
void        gtk_text_view_get_line_at_y     (GtkTextView *text_view,
                                             GtkTextIter *target_iter,
                                             gint y,
                                             gint *line_top);
void        gtk_text_view_get_line_yrange   (GtkTextView *text_view,
                                             const GtkTextIter *iter,
                                             gint *y,
                                             gint *height);
void        gtk_text_view_get_iter_at_location
                                            (GtkTextView *text_view,
                                             GtkTextIter *iter,
                                             gint x,
                                             gint y);
void        gtk_text_view_buffer_to_window_coords
                                            (GtkTextView *text_view,
                                             GtkTextWindowType win,
                                             gint buffer_x,
                                             gint buffer_y,
                                             gint *window_x,
                                             gint *window_y);
void        gtk_text_view_window_to_buffer_coords
                                            (GtkTextView *text_view,
                                             GtkTextWindowType win,
                                             gint window_x,
                                             gint window_y,
                                             gint *buffer_x,
                                             gint *buffer_y);
GdkWindow*  gtk_text_view_get_window        (GtkTextView *text_view,
                                             GtkTextWindowType win);
GtkTextWindowType gtk_text_view_get_window_type
                                            (GtkTextView *text_view,
                                             GdkWindow *window);
void        gtk_text_view_set_border_window_size
                                            (GtkTextView *text_view,
                                             GtkTextWindowType type,
                                             gint size);
void        gtk_text_view_set_text_window_size
                                            (GtkTextView *text_view,
                                             gint width,
                                             gint height);
void        gtk_text_view_add_child_at_anchor
                                            (GtkTextView *text_view,
                                             GtkWidget *child,
                                             GtkTextChildAnchor *anchor);
void        gtk_text_view_add_child_in_window
                                            (GtkTextView *text_view,
                                             GtkWidget *child,
                                             GtkTextWindowType which_window,
                                             gint xpos,
                                             gint ypos);
void        gtk_text_view_move_child        (GtkTextView *text_view,
                                             GtkWidget *child,
                                             gint xpos,
                                             gint ypos);


Object Hierarchy


  GtkObject
   +----GtkWidget
         +----GtkContainer
               +----GtkTextView

Args


  "height_lines"         gint                 : Read / Write
  "width_columns"        gint                 : Read / Write
  "pixels_above_lines"   gint                 : Read / Write
  "pixels_below_lines"   gint                 : Read / Write
  "pixels_inside_wrap"   gint                 : Read / Write
  "editable"             gboolean             : Read / Write
  "wrap_mode"            GEnum                : Read / Write

Signal Prototypes


"copy-clipboard"
            void        user_function      (GtkTextView *textview,
                                            gpointer user_data);
"cut-clipboard"
            void        user_function      (GtkTextView *textview,
                                            gpointer user_data);
"delete-from-cursor"
            void        user_function      (GtkTextView *textview,
                                            GtkDeleteType arg1,
                                            gint arg2,
                                            gpointer user_data);
"insert-at-cursor"
            void        user_function      (GtkTextView *textview,
                                            gstring arg1,
                                            gpointer user_data);
"move-cursor"
            void        user_function      (GtkTextView *textview,
                                            GtkMovementStep arg1,
                                            gint arg2,
                                            gboolean arg3,
                                            gpointer user_data);
"paste-clipboard"
            void        user_function      (GtkTextView *textview,
                                            gpointer user_data);
"set-anchor"
            void        user_function      (GtkTextView *textview,
                                            gpointer user_data);
"set-scroll-adjustments"
            void        user_function      (GtkTextView *textview,
                                            GtkAdjustment arg1,
                                            GtkAdjustment arg2,
                                            gpointer user_data);
"toggle-overwrite"
            void        user_function      (GtkTextView *textview,
                                            gpointer user_data);

Description

You may wish to begin by reading the text widget conceptual overview which gives an overview of all the objects and data types related to the text widget and how they work together.

Details

struct GtkTextView

struct GtkTextView;


enum GtkTextWindowType

typedef enum
{
  GTK_TEXT_WINDOW_PRIVATE,
  GTK_TEXT_WINDOW_WIDGET,
  GTK_TEXT_WINDOW_TEXT,
  GTK_TEXT_WINDOW_LEFT,
  GTK_TEXT_WINDOW_RIGHT,
  GTK_TEXT_WINDOW_TOP,
  GTK_TEXT_WINDOW_BOTTOM
} GtkTextWindowType;


gtk_text_view_new ()

GtkWidget*  gtk_text_view_new               (void);

Creates a new GtkTextView. If you don't call gtk_text_view_set_buffer() before using the text view, an empty default buffer will be created for you. Get the buffer with gtk_text_view_get_buffer(). If you want to specify your own buffer, consider gtk_text_view_new_with_buffer().

Returns : a new GtkTextView


gtk_text_view_new_with_buffer ()

GtkWidget*  gtk_text_view_new_with_buffer   (GtkTextBuffer *buffer);

Creates a new GtkTextView widget displaying the buffer buffer. One buffer can be shared among many widgets. buffer may be NULL to create a default buffer, in which case this function is equivalent to gtk_text_view_new(). The text view adds its own reference count to the buffer; it does not take over an existing reference.

buffer : a GtkTextBuffer
Returns : a new GtkTextView.


gtk_text_view_set_buffer ()

void        gtk_text_view_set_buffer        (GtkTextView *text_view,
                                             GtkTextBuffer *buffer);

Sets buffer as the buffer being displayed by text_view. The previous buffer displayed by the text view is unreferenced, and a reference is added to buffer. If you owned a reference to buffer before passing it to this function, you must remove that reference yourself; GtkTextView will not "adopt" it.

text_view : a GtkTextView
buffer : a GtkTextBuffer


gtk_text_view_get_buffer ()

GtkTextBuffer* gtk_text_view_get_buffer     (GtkTextView *text_view);

Returns the GtkTextBuffer being displayed by this text view. The reference count on the buffer is not incremented; the caller of this function won't own a new reference.

text_view : a GtkTextView
Returns : a GtkTextBuffer


gtk_text_view_scroll_to_mark ()

gboolean    gtk_text_view_scroll_to_mark    (GtkTextView *text_view,
                                             GtkTextMark *mark,
                                             gint mark_within_margin);

Scrolls text_view so that mark is on the screen. If mark_within_margin is nonzero, the mark will be moved onscreen by that many pixels. For example, if mark_within_margin is 5, the mark will be at least 5 pixels away from the edge of the screen, if possible.

text_view : a GtkTextView
mark : a GtkTextMark
mark_within_margin : a margin
Returns : TRUE if scrolling occurred


gtk_text_view_move_mark_onscreen ()

gboolean    gtk_text_view_move_mark_onscreen
                                            (GtkTextView *text_view,
                                             GtkTextMark *mark);

Moves a mark within the buffer so that it's located within the currently-visible text area.

text_view : a GtkTextView
mark : a GtkTextMark
Returns : TRUE if scrolling occurred


gtk_text_view_place_cursor_onscreen ()

gboolean    gtk_text_view_place_cursor_onscreen
                                            (GtkTextView *text_view);

Moves the cursor to the currently visible region of the buffer, it it isn't there already.

text_view : a GtkTextView
Returns : TRUE if the cursor had to be moved.


gtk_text_view_get_visible_rect ()

void        gtk_text_view_get_visible_rect  (GtkTextView *text_view,
                                             GdkRectangle *visible_rect);

Fills visible_rect with the currently-visible region of the buffer, in buffer coordinates. Convert to window coordinates with gtk_text_view_buffer_to_window_coords().

text_view : a GtkTextView
visible_rect : rectangle to fill


gtk_text_view_set_wrap_mode ()

void        gtk_text_view_set_wrap_mode     (GtkTextView *text_view,
                                             GtkWrapMode wrap_mode);

Sets the line wrapping for the view.

text_view : a GtkTextView
wrap_mode : a GtkWrapMode


gtk_text_view_get_wrap_mode ()

GtkWrapMode gtk_text_view_get_wrap_mode     (GtkTextView *text_view);

Gets the line wrapping for the view.

text_view : a GtkTextView
Returns : the line wrap setting


gtk_text_view_set_editable ()

void        gtk_text_view_set_editable      (GtkTextView *text_view,
                                             gboolean setting);

Sets the default editability of the GtkTextView. You can override this default setting with tags in the buffer, using the "editable" attribute of tags.

text_view : a GtkTextView
setting : whether it's editable


gtk_text_view_get_editable ()

gboolean    gtk_text_view_get_editable      (GtkTextView *text_view);

Returns the default editability of the GtkTextView. Tags in the buffer may override this setting for some ranges of text.

text_view : a GtkTextView
Returns : whether text is editable by default


gtk_text_view_set_cursor_visible ()

void        gtk_text_view_set_cursor_visible
                                            (GtkTextView *text_view,
                                             gboolean setting);

Toggles whether the insertion point is displayed. A buffer with no editable text probably shouldn't have a visible cursor, so you may want to turn the cursor off.

text_view : a GtkTextView
setting : whether to show the insertion cursor


gtk_text_view_get_cursor_visible ()

gboolean    gtk_text_view_get_cursor_visible
                                            (GtkTextView *text_view);

Find out whether the cursor is being displayed.

text_view : a GtkTextView
Returns : whether the insertion mark is visible


gtk_text_view_get_iter_location ()

void        gtk_text_view_get_iter_location (GtkTextView *text_view,
                                             const GtkTextIter *iter,
                                             GdkRectangle *location);

Gets a rectangle which roughly contains the character at iter. The rectangle position is in buffer coordinates; use gtk_text_view_buffer_to_window_coords() to convert these coordinates to coordinates for one of the windows in the text view.

text_view : a GtkTextView
iter : a GtkTextIter
location : bounds of the character at iter


gtk_text_view_get_line_at_y ()

void        gtk_text_view_get_line_at_y     (GtkTextView *text_view,
                                             GtkTextIter *target_iter,
                                             gint y,
                                             gint *line_top);

Gets the GtkTextIter at the start of the line containing the coordinate y. y is in buffer coordinates, convert from window coordinates with gtk_text_view_window_to_buffer_coords(). If non-NULL, line_top will be filled with the coordinate of the top edge of the line.

text_view : a GtkTextView
target_iter : a GtkTextIter
y : a y coordinate
line_top : return location for top coordinate of the line


gtk_text_view_get_line_yrange ()

void        gtk_text_view_get_line_yrange   (GtkTextView *text_view,
                                             const GtkTextIter *iter,
                                             gint *y,
                                             gint *height);

Gets the y coordinate of the top of the line containing iter, and the height of the line. The coordinate is a buffer coordinate; convert to window coordinates with gtk_text_view_buffer_to_window_coords().

text_view : a GtkTextView
iter : a GtkTextIter
y : return location for a y coordinate
height : return location for a height


gtk_text_view_get_iter_at_location ()

void        gtk_text_view_get_iter_at_location
                                            (GtkTextView *text_view,
                                             GtkTextIter *iter,
                                             gint x,
                                             gint y);

Retrieves the iterator at buffer coordinates x and y. Buffer coordinates are coordinates for the entire buffer, not just the currently-displayed portion. If you have coordinates from an event, you have to convert those to buffer coordinates with gtk_text_view_window_to_buffer_coords().

text_view : a GtkTextView
iter : a GtkTextIter
x : x position, in buffer coordinates
y : y position, in buffer coordinates


gtk_text_view_buffer_to_window_coords ()

void        gtk_text_view_buffer_to_window_coords
                                            (GtkTextView *text_view,
                                             GtkTextWindowType win,
                                             gint buffer_x,
                                             gint buffer_y,
                                             gint *window_x,
                                             gint *window_y);

Converts coordinate (buffer_x, buffer_y) to coordinates for the window win, and stores the result in (window_x, window_y).

text_view : a GtkTextView
win : a GtkTextWindowType
buffer_x : buffer x coordinate
buffer_y : buffer y coordinate
window_x : window x coordinate return location
window_y : window y coordinate return location


gtk_text_view_window_to_buffer_coords ()

void        gtk_text_view_window_to_buffer_coords
                                            (GtkTextView *text_view,
                                             GtkTextWindowType win,
                                             gint window_x,
                                             gint window_y,
                                             gint *buffer_x,
                                             gint *buffer_y);

Converts coordinates on the window identified by win to buffer coordinates, storing the result in (buffer_x,buffer_y).

text_view : a GtkTextView
win : a GtkTextWindowType
window_x : window x coordinate
window_y : window y coordinate
buffer_x : buffer x coordinate return location
buffer_y : buffer y coordinate return location


gtk_text_view_get_window ()

GdkWindow*  gtk_text_view_get_window        (GtkTextView *text_view,
                                             GtkTextWindowType win);

Retrieves the GdkWindow corresponding to an area of the text view; possible windows include the overall widget window, child windows on the left, right, top, bottom, and the window that displays the text buffer. Windows are NULL and nonexistent if their width or height is 0, and are nonexistent before the widget has been realized.

text_view : a GtkTextView
win : window to get
Returns : a GdkWindow, or NULL


gtk_text_view_get_window_type ()

GtkTextWindowType gtk_text_view_get_window_type
                                            (GtkTextView *text_view,
                                             GdkWindow *window);

Usually used to find out which window an event corresponds to. If you connect to an event signal on text_view, this function should be called on <literal>event-&gt;window</literal> to see which window it was.

text_view : a GtkTextView
window : a window type
Returns : the window type.


gtk_text_view_set_border_window_size ()

void        gtk_text_view_set_border_window_size
                                            (GtkTextView *text_view,
                                             GtkTextWindowType type,
                                             gint size);

Sets the width of GTK_TEXT_WINDOW_LEFT or GTK_TEXT_WINDOW_RIGHT, or the height of GTK_TEXT_WINDOW_TOP or GTK_TEXT_WINDOW_BOTTOM. Automatically destroys the corresponding window if the size is set to 0, and creates the window if the size is set to non-zero.

text_view : a GtkTextView
type : window to affect
size : width or height of the window


gtk_text_view_set_text_window_size ()

void        gtk_text_view_set_text_window_size
                                            (GtkTextView *text_view,
                                             gint width,
                                             gint height);

Sets the size request for the main text window (GTK_TEXT_WINDOW_TEXT). If the widget gets more space than it requested, the main text window will be larger than this.

text_view : a GtkTextView
width : a width in pixels
height : a height in pixels


gtk_text_view_add_child_at_anchor ()

void        gtk_text_view_add_child_at_anchor
                                            (GtkTextView *text_view,
                                             GtkWidget *child,
                                             GtkTextChildAnchor *anchor);

text_view : 
child : 
anchor : 


gtk_text_view_add_child_in_window ()

void        gtk_text_view_add_child_in_window
                                            (GtkTextView *text_view,
                                             GtkWidget *child,
                                             GtkTextWindowType which_window,
                                             gint xpos,
                                             gint ypos);

text_view : 
child : 
which_window : 
xpos : 
ypos : 


gtk_text_view_move_child ()

void        gtk_text_view_move_child        (GtkTextView *text_view,
                                             GtkWidget *child,
                                             gint xpos,
                                             gint ypos);

text_view : 
child : 
xpos : 
ypos : 

Args

"height_lines" (gint : Read / Write)

"width_columns" (gint : Read / Write)

"pixels_above_lines" (gint : Read / Write)

"pixels_below_lines" (gint : Read / Write)

"pixels_inside_wrap" (gint : Read / Write)

"editable" (gboolean : Read / Write)

"wrap_mode" (GEnum : Read / Write)

Signals

The "copy-clipboard" signal

void        user_function                  (GtkTextView *textview,
                                            gpointer user_data);

textview :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "cut-clipboard" signal

void        user_function                  (GtkTextView *textview,
                                            gpointer user_data);

textview :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "delete-from-cursor" signal

void        user_function                  (GtkTextView *textview,
                                            GtkDeleteType arg1,
                                            gint arg2,
                                            gpointer user_data);

textview :the object which received the signal.
arg1 : 
arg2 : 
user_data :user data set when the signal handler was connected.


The "insert-at-cursor" signal

void        user_function                  (GtkTextView *textview,
                                            gstring arg1,
                                            gpointer user_data);

textview :the object which received the signal.
arg1 : 
user_data :user data set when the signal handler was connected.


The "move-cursor" signal

void        user_function                  (GtkTextView *textview,
                                            GtkMovementStep arg1,
                                            gint arg2,
                                            gboolean arg3,
                                            gpointer user_data);

textview :the object which received the signal.
arg1 : 
arg2 : 
arg3 : 
user_data :user data set when the signal handler was connected.


The "paste-clipboard" signal

void        user_function                  (GtkTextView *textview,
                                            gpointer user_data);

textview :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "set-anchor" signal

void        user_function                  (GtkTextView *textview,
                                            gpointer user_data);

textview :the object which received the signal.
user_data :user data set when the signal handler was connected.


The "set-scroll-adjustments" signal

void        user_function                  (GtkTextView *textview,
                                            GtkAdjustment arg1,
                                            GtkAdjustment arg2,
                                            gpointer user_data);

textview :the object which received the signal.
arg1 : 
arg2 : 
user_data :user data set when the signal handler was connected.


The "toggle-overwrite" signal

void        user_function                  (GtkTextView *textview,
                                            gpointer user_data);

textview :the object which received the signal.
user_data :user data set when the signal handler was connected.

See Also

GtkTextBuffer, GtkTextIter