GtkTextBuffer

Каталог документации / Раздел "Программирование, языки" / Оглавление документа

			GTK+ Reference Manual
Top \| Description \| Object Hierarchy \| Properties \| Signals

GtkTextBuffer

GtkTextBuffer Хранение текста с атрибутами для отображения в GtkTextView

Краткое описание

#include <gtk/gtk.h>


            GtkTextBuffer;
GtkTextBuffer* gtk_text_buffer_new          (GtkTextTagTable *table);
gint        gtk_text_buffer_get_line_count  (GtkTextBuffer *buffer);

gint        gtk_text_buffer_get_char_count  (GtkTextBuffer *buffer);
GtkTextTagTable* gtk_text_buffer_get_tag_table
                                            (GtkTextBuffer *buffer);
void        gtk_text_buffer_insert          (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len);
void        gtk_text_buffer_insert_at_cursor

                                            (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len);
gboolean    gtk_text_buffer_insert_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             gboolean default_editable);

gboolean    gtk_text_buffer_insert_interactive_at_cursor
                                            (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len,
                                             gboolean default_editable);
void        gtk_text_buffer_insert_range    (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

gboolean    gtk_text_buffer_insert_range_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean default_editable);
void        gtk_text_buffer_insert_with_tags

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             GtkTextTag *first_tag,
                                             ...);
void        gtk_text_buffer_insert_with_tags_by_name

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             const gchar *first_tag_name,
                                             ...);
void        gtk_text_buffer_delete          (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);

gboolean    gtk_text_buffer_delete_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *start_iter,
                                             GtkTextIter *end_iter,
                                             gboolean default_editable);

gboolean    gtk_text_buffer_backspace       (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gboolean interactive,
                                             gboolean default_editable);
void        gtk_text_buffer_set_text        (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len);

gchar*      gtk_text_buffer_get_text        (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean include_hidden_chars);

gchar*      gtk_text_buffer_get_slice       (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean include_hidden_chars);
void        gtk_text_buffer_insert_pixbuf   (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GdkPixbuf *pixbuf);
void        gtk_text_buffer_insert_child_anchor

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextChildAnchor *anchor);
GtkTextChildAnchor* gtk_text_buffer_create_child_anchor
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);

GtkTextMark* gtk_text_buffer_create_mark    (GtkTextBuffer *buffer,
                                             const gchar *mark_name,
                                             const GtkTextIter *where,
                                             gboolean left_gravity);
void        gtk_text_buffer_move_mark       (GtkTextBuffer *buffer,
                                             GtkTextMark *mark,
                                             const GtkTextIter *where);
void        gtk_text_buffer_move_mark_by_name

                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *where);
void        gtk_text_buffer_delete_mark     (GtkTextBuffer *buffer,
                                             GtkTextMark *mark);
void        gtk_text_buffer_delete_mark_by_name

                                            (GtkTextBuffer *buffer,
                                             const gchar *name);
GtkTextMark* gtk_text_buffer_get_mark       (GtkTextBuffer *buffer,
                                             const gchar *name);

GtkTextMark* gtk_text_buffer_get_insert     (GtkTextBuffer *buffer);
GtkTextMark* gtk_text_buffer_get_selection_bound
                                            (GtkTextBuffer *buffer);

gboolean    gtk_text_buffer_get_has_selection
                                            (GtkTextBuffer *buffer);
void        gtk_text_buffer_place_cursor    (GtkTextBuffer *buffer,
                                             const GtkTextIter *where);
void        gtk_text_buffer_select_range    (GtkTextBuffer *buffer,
                                             const GtkTextIter *ins,
                                             const GtkTextIter *bound);
void        gtk_text_buffer_apply_tag       (GtkTextBuffer *buffer,
                                             GtkTextTag *tag,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);
void        gtk_text_buffer_remove_tag      (GtkTextBuffer *buffer,
                                             GtkTextTag *tag,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);
void        gtk_text_buffer_apply_tag_by_name

                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);
void        gtk_text_buffer_remove_tag_by_name
                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);
void        gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

GtkTextTag* gtk_text_buffer_create_tag      (GtkTextBuffer *buffer,
                                             const gchar *tag_name,
                                             const gchar *first_property_name,
                                             ...);
void        gtk_text_buffer_get_iter_at_line_offset
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number,
                                             gint char_offset);
void        gtk_text_buffer_get_iter_at_offset

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint char_offset);
void        gtk_text_buffer_get_iter_at_line
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number);
void        gtk_text_buffer_get_iter_at_line_index

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number,
                                             gint byte_index);
void        gtk_text_buffer_get_iter_at_mark
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextMark *mark);
void        gtk_text_buffer_get_iter_at_child_anchor

                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextChildAnchor *anchor);
void        gtk_text_buffer_get_start_iter  (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);
void        gtk_text_buffer_get_end_iter    (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);
void        gtk_text_buffer_get_bounds      (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);

gboolean    gtk_text_buffer_get_modified    (GtkTextBuffer *buffer);
void        gtk_text_buffer_set_modified    (GtkTextBuffer *buffer,
                                             gboolean setting);

gboolean    gtk_text_buffer_delete_selection
                                            (GtkTextBuffer *buffer,
                                             gboolean interactive,
                                             gboolean default_editable);
void        gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard,
                                             GtkTextIter *override_location,
                                             gboolean default_editable);
void        gtk_text_buffer_copy_clipboard  (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);
void        gtk_text_buffer_cut_clipboard   (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard,
                                             gboolean default_editable);

gboolean    gtk_text_buffer_get_selection_bounds
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);
void        gtk_text_buffer_begin_user_action

                                            (GtkTextBuffer *buffer);
void        gtk_text_buffer_end_user_action (GtkTextBuffer *buffer);
void        gtk_text_buffer_add_selection_clipboard
                                            (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);
void        gtk_text_buffer_remove_selection_clipboard

                                            (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);

enum        GtkTextBufferTargetInfo;
gboolean    (*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GtkTextIter *iter,
                                             const guint8 *data,
                                             gsize length,
                                             gboolean create_tags,
                                             gpointer user_data,
                                             GError **error);

gboolean    gtk_text_buffer_deserialize     (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GdkAtom format,
                                             GtkTextIter *iter,
                                             const guint8 *data,
                                             gsize length,
                                             GError **error);

gboolean    gtk_text_buffer_deserialize_get_can_create_tags
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);
void        gtk_text_buffer_deserialize_set_can_create_tags
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format,
                                             gboolean can_create_tags);

GtkTargetList* gtk_text_buffer_get_copy_target_list
                                            (GtkTextBuffer *buffer);
GdkAtom*    gtk_text_buffer_get_deserialize_formats
                                            (GtkTextBuffer *buffer,
                                             gint *n_formats);

GtkTargetList* gtk_text_buffer_get_paste_target_list
                                            (GtkTextBuffer *buffer);
GdkAtom*    gtk_text_buffer_get_serialize_formats
                                            (GtkTextBuffer *buffer,
                                             gint *n_formats);

GdkAtom     gtk_text_buffer_register_deserialize_format
                                            (GtkTextBuffer *buffer,
                                             const gchar *mime_type,
                                             GtkTextBufferDeserializeFunc function,
                                             gpointer user_data,
                                             GDestroyNotify user_data_destroy);

GdkAtom     gtk_text_buffer_register_deserialize_tagset
                                            (GtkTextBuffer *buffer,
                                             const gchar *tagset_name);
GdkAtom     gtk_text_buffer_register_serialize_format
                                            (GtkTextBuffer *buffer,
                                             const gchar *mime_type,
                                             GtkTextBufferSerializeFunc function,
                                             gpointer user_data,
                                             GDestroyNotify user_data_destroy);

GdkAtom     gtk_text_buffer_register_serialize_tagset
                                            (GtkTextBuffer *buffer,
                                             const gchar *tagset_name);
guint8*     (*GtkTextBufferSerializeFunc)   (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gsize *length,
                                             gpointer user_data);

guint8*     gtk_text_buffer_serialize       (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GdkAtom format,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gsize *length);
void        gtk_text_buffer_unregister_deserialize_format

                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);
void        gtk_text_buffer_unregister_serialize_format
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);

Иерархия объектов

  GObject
   +----GtkTextBuffer

Свойства

  "copy-target-list"     GtkTargetList         : Read
  "cursor-position"      gint                  : Read
  "has-selection"        gboolean              : Read
  "paste-target-list"    GtkTargetList         : Read
  "tag-table"            GtkTextTagTable       : Read / Write / Construct Only
  "text"                 gchararray            : Read / Write

Сигналы

"apply-tag" void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextTag    *arg1,
                                            GtkTextIter   *arg2,
                                            GtkTextIter   *arg3,
                                            gpointer       user_data)       : Run last
"begin-user-action"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last
"changed"   void        user_function      (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last
"delete-range"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GtkTextIter   *arg2,
                                            gpointer       user_data)       : Run last
"end-user-action"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last
"insert-child-anchor"
            void        user_function      (GtkTextBuffer      *textbuffer,
                                            GtkTextIter        *arg1,
                                            GtkTextChildAnchor *arg2,
                                            gpointer            user_data)       : Run last
"insert-pixbuf"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GdkPixbuf     *arg2,
                                            gpointer       user_data)       : Run last
"insert-text"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            gchar         *arg2,
                                            gint           arg3,
                                            gpointer       user_data)       : Run last
"mark-deleted"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextMark   *arg1,
                                            gpointer       user_data)       : Run last
"mark-set"  void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GtkTextMark   *arg2,
                                            gpointer       user_data)       : Run last
"modified-changed"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last
"remove-tag"
            void        user_function      (GtkTextBuffer *textbuffer,
                                            GtkTextTag    *arg1,
                                            GtkTextIter   *arg2,
                                            GtkTextIter   *arg3,
                                            gpointer       user_data)       : Run last

Описание

Для начала вы можете прочесть text widget conceptual overview который даёт краткое описание всех объектов и типов данных связанных с текстовыми виджетами и как они взаимодействуют.

Детали

GtkTextBuffer

typedef struct _GtkTextBuffer GtkTextBuffer;

gtk_text_buffer_new ()

GtkTextBuffer* gtk_text_buffer_new          (GtkTextTagTable *table);

Создаёт новый текстовый буфер.

`table` :	таблица тегов, или NULL для создания новой
Возвращает :	новый текстовый буфер

gtk_text_buffer_get_line_count ()

gint        gtk_text_buffer_get_line_count  (GtkTextBuffer *buffer);

Определяет количество строк в буфере. Это значение кэшируется, поэтому функция очень быстрая.

`buffer` :	GtkTextBuffer
Возвращает :	Количество строк в буфере

gtk_text_buffer_get_char_count ()

gint        gtk_text_buffer_get_char_count  (GtkTextBuffer *buffer);

Определяет количество символов в буфере; помните что символы и байты не тоже самое. Количество символов кэшируется, поэтому функция очень быстрая.

`buffer` :	GtkTextBuffer
Возвращает :	Количество символов в буфере

gtk_text_buffer_get_tag_table ()

GtkTextTagTable* gtk_text_buffer_get_tag_table
                                            (GtkTextBuffer *buffer);

Выдаёт GtkTextTagTable связанный с этим буфером.

`buffer` :	GtkTextBuffer
Возвращает :	Буферная таблица тегов

gtk_text_buffer_insert ()

void        gtk_text_buffer_insert          (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len);

Вставляет len байт text в позицию iter. Если len это -1, text должен быть nul-terminated и будет вставлен полностью. Издаёт сигнал "insert_text"; вставка фактически происходит в обработчике для этого сигнала по умолчанию. iter недействителен когда происходит вставка (потому что содержимое буфера изменяется), но по умолчанию обработчик сигнала подтверждает эту точку для завершения вставки.

`buffer` :	GtkTextBuffer
`iter` :	Позиция в буфере
`text` :	Текст для вставки в формате UTF-8
`len` :	Длина текста в байтах, или -1

gtk_text_buffer_insert_at_cursor ()

void        gtk_text_buffer_insert_at_cursor
                                            (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len);

Простой вызов gtk_text_buffer_insert(), использует текущую позицию курсора как точку для вставки.

`buffer` :	GtkTextBuffer
`text` :	Текст в формате UTF-8
`len` :	Длина текста, в байтах

gtk_text_buffer_insert_interactive ()

gboolean    gtk_text_buffer_insert_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             gboolean default_editable);

Как gtk_text_buffer_insert(), но вставка не происходит если iter в недоступном для редактирования участке буфера. Обычно нужно предотвращать вставку в не редактируемые участки, если вставка результат действия пользователя (интерактивно).

default_editable указывает редактируемость текста который не имеет тега влияющего на свойство редактируемости применяемого к нему. Обычно результат gtk_text_view_get_editable() соответствует этому.

`buffer` :	GtkTextBuffer
`iter` :	Позиция в `buffer`
`text` :	Текст в кодировке UTF-8
`len` :	Длина текста в байтах, или -1
`default_editable` :	редактируемость буфера по умолчанию
Возвращает :	Вставлен ли текст

gtk_text_buffer_insert_interactive_at_cursor ()

gboolean    gtk_text_buffer_insert_interactive_at_cursor
                                            (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len,
                                             gboolean default_editable);

Вызывает gtk_text_buffer_insert_interactive() в позиции курсора.

default_editable указывает редактируемость текста который не имеет тега влияющего на свойство редактируемости применяемого к нему. Обычно результат gtk_text_view_get_editable() соответствует этому.

`buffer` :	GtkTextBuffer
`text` :	текст в кодировке UTF-8
`len` :	длина текста в байтах, или -1
`default_editable` :	редактируемость буфера по умолчанию
Возвращает :	Вставлен ли текст

gtk_text_buffer_insert_range ()

void        gtk_text_buffer_insert_range    (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Копирует текст, теги и изображения в промежутке между start и end (порядок start и end не имеет значения) и вставляет копию в iter. Используется вместо простого получения/вставки текста потому что это позволяет сохранить изображения и теги. Если start и end находятся в буфере отличном от buffer, два буфера должны использовать совместно таблицу тегов.

Осуществляет через эмиссию insert_text и apply_tag сигналов.

`buffer` :	GtkTextBuffer
`iter` :	Позиция в `buffer`
`start` :	Позиция в GtkTextBuffer
`end` :	Другая позиция в том же буфере где `start`

gtk_text_buffer_insert_range_interactive ()

gboolean    gtk_text_buffer_insert_range_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean default_editable);

Тоже самое как gtk_text_buffer_insert_range(), но не делает ничего если точка вставки нередактируема. Параметр default_editable указывает редактируем ли текст в позиции iter, если нет тегов включающих iter влияющих на редактируемость. Обычно результат соответствует результату gtk_text_view_get_editable().

`buffer` :	GtkTextBuffer
`iter` :	Позиция в `buffer`
`start` :	Позиция в GtkTextBuffer
`end` :	Другая позиция в том же буфере где `start`
`default_editable` :	Редактируемость буфера по умолчанию
Возвращает :	Была ли вставка возможна в `iter`

gtk_text_buffer_insert_with_tags ()

void        gtk_text_buffer_insert_with_tags
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             GtkTextTag *first_tag,
                                             ...);

Вставляет текст text в buffer в позицию iter, применяя список тегов к вновь вставленному тексту. Последний тег должен быть определен NULL для завершения списка. Эквивалент для вызова gtk_text_buffer_insert(), затем gtk_text_buffer_apply_tag() на вставленном тексте; gtk_text_buffer_insert_with_tags() это просто удобная функция.

`buffer` :	GtkTextBuffer
`iter` :	Итератор в `buffer`
`text` :	UTF-8 текст
`len` :	Длина `text`, или -1
`first_tag` :	Первый тег для применения к `text`
`...` :	NULL-завершенный список применяемых тегов

gtk_text_buffer_insert_with_tags_by_name ()

void        gtk_text_buffer_insert_with_tags_by_name
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             const gchar *text,
                                             gint len,
                                             const gchar *first_tag_name,
                                             ...);

Тоже самое как gtk_text_buffer_insert_with_tags(), но позволяет вставить имя тега вместо объектов тега.

`buffer` :	GtkTextBuffer
`iter` :	Позиция в `buffer`
`text` :	UTF-8 текст
`len` :	длина `text`, или -1
`first_tag_name` :	Имя тега для применения к `text`
`...` :	Имена тегов

gtk_text_buffer_delete ()

void        gtk_text_buffer_delete          (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);

Удаляет текст между start и end. Порядок start и end не имеет значения; gtk_text_buffer_delete() будет перестраивать их. Эта функция фактически издаёт сигнал "delete_range", а обработчик по умолчанию для этого сигнала удаляет текст. Поскольку буфер изменяется, все нереализованные итераторы становятся недопустимы после вызова этой функции; однако, start и end будут пере инициализированы для указания размещения удаленного текста.

`buffer` :	GtkTextBuffer
`start` :	Позиция в `buffer`
`end` :	Другая позиция в `buffer`

gtk_text_buffer_delete_interactive ()

gboolean    gtk_text_buffer_delete_interactive
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *start_iter,
                                             GtkTextIter *end_iter,
                                             gboolean default_editable);

Удаляет весь допустимый для редактирования текст в указанном диапазоне. Вызывает gtk_text_buffer_delete() для каждого доступного для редактирования участка [start,end]. start и end повторно утверждаются для указания места последнего удаленного диапазона, или сброшены если текст не был удалён.

`buffer` :	GtkTextBuffer
`start_iter` :	Начало диапазона для удаления
`end_iter` :	Конец диапазона
`default_editable` :	Редактируем ли буфер по умолчанию
Возвращает :	Удален ли реально некоторый текст

gtk_text_buffer_backspace ()

gboolean    gtk_text_buffer_backspace       (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gboolean interactive,
                                             gboolean default_editable);

Выполняет соответствующее действие как если пользователь нажмет на клавишу delete в позиции курсора определённой iter. Обычно удаляется единственный символ, но когда объединяются включённые акценты, может быть удалено больше чем один символ, а когда предварительно составленный символ и акцент объединены, удаляется меньше одного символа.

Поскольку буфер изменён, все не выполненные итераторы становятся не доступны после вызова этой функции; однако, iter будет пере-инициализирован для указания места где был удалён текст.

`buffer` :	GtkTextBuffer
`iter` :	Позиция в `buffer`
`interactive` :	Вызвано ли удаление взаимодействием с пользователем
`default_editable` :	Редактируем ли буфер по умолчанию
Возвращает :	`TRUE` если буфер был модифицирован

Начиная с версии 2.6

gtk_text_buffer_set_text ()

void        gtk_text_buffer_set_text        (GtkTextBuffer *buffer,
                                             const gchar *text,
                                             gint len);

Удаляет текущеме содержимое buffer, и вставляет вместо него text. Если len равен -1, text должен быть nul-завершённый. text должен быть в кодировке UTF-8.

`buffer` :	GtkTextBuffer
`text` :	UTF-8 текст для вставки
`len` :	длина текста в байтах

gtk_text_buffer_get_text ()

gchar*      gtk_text_buffer_get_text        (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean include_hidden_chars);

Возвращает текст в диапазон [start,end]. Исключает не-отображаемый текст (текст маркированный тегами устанавливающими свойство невидимости) если include_hidden_chars равен FALSE. Не включая символы представляющие изображения, таким образом перечень байт и символов в возвращаемой строке не соответствует байтам и символам в буфере. Противоположно действию gtk_text_buffer_get_slice().

`buffer` :	GtkTextBuffer
`start` :	Начало диапазона
`end` :	Конец диапазона
`include_hidden_chars` :	Включён ли невидимый текст
Возвращает :	строка UTF-8

gtk_text_buffer_get_slice ()

gchar*      gtk_text_buffer_get_slice       (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gboolean include_hidden_chars);

Возвращает текст в диапазоне [start,end]. Исключает не-отображаемый текст (текст маркированный тегами устанавливающими свойство невидимости) если include_hidden_chars равен FALS. Возвращаемая строка включает символ 0xFFFC каждый раз когда буфер содержит встроенное изображение, таким образом перечень байт и символов внутри возвращаемой строки соответствует перечню байт и символов буфера. Противоположно gtk_text_buffer_get_text(). Помните, символ 0xFFFC может располагать также и в обычном тексте, поэтому он не является надёжным индикатором изображения или виджетов в буфере.

`buffer` :	GtkTextBuffer
`start` :	Начало диапазона
`end` :	Конец диапазона
`include_hidden_chars` :	Включён ли невидимый текст
Возвращает :	строка UTF-8

gtk_text_buffer_insert_pixbuf ()

void        gtk_text_buffer_insert_pixbuf   (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GdkPixbuf *pixbuf);

Вставляет изображение в текстовый буфер в позицию iter. Изображение считается как один символ в подсчете символов, а когда определяется контекст буфера как строка, будет представлено как символ Unicode "object replacement character" 0xFFFC. Помните, "slice" варианты определения частей буфера как строки включают этот символ для изображений, но "text" варианты нет. Например смотрите gtk_text_buffer_get_slice() и gtk_text_buffer_get_text().

`buffer` :	GtkTextBuffer
`iter` :	Положение для вставки изображения
`pixbuf` :	GdkPixbuf

gtk_text_buffer_insert_child_anchor ()

void        gtk_text_buffer_insert_child_anchor
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextChildAnchor *anchor);

Вставляет дочерний виджет якорь в текстовый буфер в положение iter. Якорь считается как единственный символ в счете символов, а когда определяется контекст буфера как строка, будет представлен как символ Unicode "object replacement character" 0xFFFC. Помните, "slice" варианты определения частей буфера как строки включают этот символ для дочерних якорей, но "text" варианты нет. Смотрите gtk_text_buffer_get_slice() и gtk_text_buffer_get_text(). Рассматривайте gtk_text_buffer_create_child_anchor() как более удобную альтернативу этой функции. Буфер создаёт ссылки для якоря, поэтому вы можете сбрасывать их после вставки.

`buffer` :	GtkTextBuffer
`iter` :	Положение вставляемого якоря
`anchor` :	GtkTextChildAnchor

gtk_text_buffer_create_child_anchor ()

GtkTextChildAnchor* gtk_text_buffer_create_child_anchor
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);

Это удобная функция просто создаёт дочерний якорь с помощью gtk_text_child_anchor_new() и вставляет его в буфер с помощью gtk_text_buffer_insert_child_anchor(). Новый якорь принадлежит буферу; не возвращается количество для вызывающего gtk_text_buffer_create_child_anchor().

`buffer` :	GtkTextBuffer
`iter` :	Расположение в буфере
Возвращает :	Созданный дочерний якорь

gtk_text_buffer_create_mark ()

GtkTextMark* gtk_text_buffer_create_mark    (GtkTextBuffer *buffer,
                                             const gchar *mark_name,
                                             const GtkTextIter *where,
                                             gboolean left_gravity);

Создаёт маркер в позиции where. Если mark_name равен NULL, маркер без имени; иначе, маркеру присваивается имя с помощью gtk_text_buffer_get_mark(). Если маркер имеет левое притяжение (left gravity), а текст вставляется в текущеме положение маркера, маркер будет перемещён влево от вновь вставленного текста. Если маркер имеет правое притяжение (left_gravity = FALSE), маркер перемещается в право от вновь вставленного текста. При стандартном с лево на право (left-to-right) курсоре маркер с правым притяжением (когда вы печатаете, курсор остаётся справа от вашего ввода).

Вызывающий эту функцию не владеет ссылкой на возвращаемый GtkTextMark, поэтому вы можете игнорировать возвращаемое значение, если вам нравится. Маркеры принадлежат буферу и уходят вместе сним.

Издаёт сигнал "mark_set" как уведомление о начальном размещении маркера.

`buffer` :	GtkTextBuffer
`mark_name` :	Имя для маркера, или `NULL`
`where` :	Положение для маркера
`left_gravity` :	Имеет ли маркер левое притяжение
Возвращает :	Новый объект GtkTextMark

gtk_text_buffer_move_mark ()

void        gtk_text_buffer_move_mark       (GtkTextBuffer *buffer,
                                             GtkTextMark *mark,
                                             const GtkTextIter *where);

Перемещает mark в новое положение where. Издаёт сигнал "mark_set" как уведомление о переещении.

`buffer` :	GtkTextBuffer
`mark` :	GtkTextMark
`where` :	Новое положение для `mark` в `buffer`

gtk_text_buffer_move_mark_by_name ()

void        gtk_text_buffer_move_mark_by_name
                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *where);

Перемещает маркер с именем name (должно существовать) в положение where. Детали смотрите в gtk_text_buffer_move_mark().

`buffer` :	GtkTextBuffer
`name` :	Имя маркера
`where` :	Новое положение для маркера

gtk_text_buffer_delete_mark ()

void        gtk_text_buffer_delete_mark     (GtkTextBuffer *buffer,
                                             GtkTextMark *mark);

Удаляет mark. Удаляет ссылки на маркер находящиеся в буфере, поэтому если вы не вызвали g_object_ref() на маркере, он будет освобожден. Даже если маркер не освобождён, большинство операций с mark будут невозможны. Восстановление маркера не возможно. gtk_text_mark_get_deleted() возвращает TRUE после вызова этой функции на маркере; gtk_text_mark_get_deleted() указывает что маркер больше не размещается в буфере. Сигнал "mark_deleted" издаётся как уведомление после удаления маркера.

`buffer` :	GtkTextBuffer
`mark` :	GtkTextMark в `buffer`

gtk_text_buffer_delete_mark_by_name ()

void        gtk_text_buffer_delete_mark_by_name
                                            (GtkTextBuffer *buffer,
                                             const gchar *name);

Удаляет маркер с именем name; маркер должен существовать. Детали смотрите в gtk_text_buffer_delete_mark().

`buffer` :	GtkTextBuffer
`name` :	Имя маркера в `buffer`

gtk_text_buffer_get_mark ()

GtkTextMark* gtk_text_buffer_get_mark       (GtkTextBuffer *buffer,
                                             const gchar *name);

Возвращает маркер с именем name в буфере buffer, или NULL если в буфере нет такого маркера.

`buffer` :	GtkTextBuffer
`name` :	имя маркера
Возвращает :	GtkTextMark, или NULL

gtk_text_buffer_get_insert ()

GtkTextMark* gtk_text_buffer_get_insert     (GtkTextBuffer *buffer);

Возвращает маркер который представляет курсор (точка вставки). Эквивалентно вызову gtk_text_buffer_get_mark() для получения маркера с именем "insert", но более эффективна и требует меньше ввода.

`buffer` :	GtkTextBuffer
Возвращает :	Маркер точки вставки

gtk_text_buffer_get_selection_bound ()

GtkTextMark* gtk_text_buffer_get_selection_bound
                                            (GtkTextBuffer *buffer);

Возвращает маркер представляющий границы выделения. Эквивалентно вызову gtk_text_buffer_get_mark() для получения маркера с именем "selection_bound", но более эффективна и требует меньше ввода.

Текущий выделенный текст в buffer, это область между "selection_bound" и "insert" маркерами. Если "selection_bound" и "insert" одно и тоже, то когда нет текущемго выделения. gtk_text_buffer_get_selection_bounds() другая удобная функция для обработки выделения, если вам просто нужно знать есть ли выделение и каковы его границы.

`buffer` :	GtkTextBuffer
Возвращает :	Маркер границы выделения

gtk_text_buffer_get_has_selection ()

gboolean    gtk_text_buffer_get_has_selection
                                            (GtkTextBuffer *buffer);

Указывает имеет ли некоторый текст текущеме выделение.

`buffer` :	GtkTextBuffer
Возвращает :	`TRUE` если есть выделенный текст

Начиная с версии 2.10

gtk_text_buffer_place_cursor ()

void        gtk_text_buffer_place_cursor    (GtkTextBuffer *buffer,
                                             const GtkTextIter *where);

Эта функция одновременно перемещает маркеры "insert" и "selection_bound". Если вы перемещаете их в два этапа с помощью gtk_text_buffer_move_mark(), вы будете временно выделять область между старым и новым положением, что может быть очень не эффективно, так как временно-выбранная область будет вынужденно пересчитываться. Эта функция перемещает их как объединение, которое может быть оптимизировано.

`buffer` :	GtkTextBuffer
`where` :	Где помещается курсор

gtk_text_buffer_select_range ()

void        gtk_text_buffer_select_range    (GtkTextBuffer *buffer,
                                             const GtkTextIter *ins,
                                             const GtkTextIter *bound);

`buffer` :	GtkTextBuffer
`ins` :	Куда помещать "insert" маркер
`bound` :	Куда помещать "selection_bound" маркер

Начиная с версии 2.4

gtk_text_buffer_apply_tag ()

void        gtk_text_buffer_apply_tag       (GtkTextBuffer *buffer,
                                             GtkTextTag *tag,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Издаёт сигнал "apply_tag" в buffer. По умолчанию обработчик для сигнала применяет tag для данной области. start и end могут быть не упорядочены.

`buffer` :	GtkTextBuffer
`tag` :	GtkTextTag
`start` :	Один конец области для отметки
`end` :	Другой конец области для отметки

gtk_text_buffer_remove_tag ()

void        gtk_text_buffer_remove_tag      (GtkTextBuffer *buffer,
                                             GtkTextTag *tag,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Издаёт сигнал "remove_tag". По умолчанию обработчик сигнала удалит все теги соответствующие tag из данной области. start и end могут быть не упорядочены.

`buffer` :	GtkTextBuffer
`tag` :	GtkTextTag
`start` :	Один конец области
`end` :	Другой конец области

gtk_text_buffer_apply_tag_by_name ()

void        gtk_text_buffer_apply_tag_by_name
                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Вызывает gtk_text_tag_table_lookup() в таблице тегов буфера для получения GtkTextTag, затем вызывает gtk_text_buffer_apply_tag().

`buffer` :	GtkTextBuffer
`name` :	имя GtkTextTag
`start` :	Один конец области
`end` :	Другой конец области

gtk_text_buffer_remove_tag_by_name ()

void        gtk_text_buffer_remove_tag_by_name
                                            (GtkTextBuffer *buffer,
                                             const gchar *name,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Вызывает gtk_text_tag_table_lookup() в таблице тегов буфера для получения GtkTextTag, затем вызывает gtk_text_buffer_remove_tag().

`buffer` :	GtkTextBuffer
`name` :	имя GtkTextTag
`start` :	Один конец области
`end` :	Другой конец области

gtk_text_buffer_remove_all_tags ()

void        gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end);

Удаляет все теги в диапазоне между start и end. Будьте внимательны с этой функцией; она может удалить теги добавленные в код не связанный с кодом который вы пишете в текущий момент. Поэтому, использование этой функции вероятно будет плохой идеей если вы имеете два и более несвязанных разделов кода в которые добавляете теги.

`buffer` :	GtkTextBuffer
`start` :	Одна граница диапазона
`end` :	Другая граница диапазона

gtk_text_buffer_create_tag ()

GtkTextTag* gtk_text_buffer_create_tag      (GtkTextBuffer *buffer,
                                             const gchar *tag_name,
                                             const gchar *first_property_name,
                                             ...);

Создаёт тег и добавляет его в таблицу тегов для buffer. Эквивалент для вызова gtk_text_tag_new() и затем добавления тега в таблицу тегов буфера. Возвращаемым тегом владеет таблица тегов буфера, поэтому счет будет равен одному.

Если tag_name это NULL, тег без имени.

Если tag_name не-NULL, тег названный tag_name не должен уже существовать в таблице тегов для этого буфера.

Аргумент first_property_name и последующие параметры являются списком свойств для установки тега, как с помощью g_object_set().

`buffer` :	GtkTextBuffer
`tag_name` :	Имя нового тега, или `NULL`
`first_property_name` :	Имя первого свойства для установки, или `NULL`
`...` :	`NULL`-законченный список свойств имен и значений
Возвращает :	Новый тег

gtk_text_buffer_get_iter_at_line_offset ()

void        gtk_text_buffer_get_iter_at_line_offset
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number,
                                             gint char_offset);

Определяет итератор размещаемый в точке char_offset внутри данной строки. Точка char_offset должна существовать, смещение с конца строки не допускаются. Помните символы, не байты; UTF-8 может закодировать один символ несколькими байтами.

`buffer` :	GtkTextBuffer
`iter` :	Инициализируемый итератор
`line_number` :	Строка начиная с 0
`char_offset` :	Смещение символов с начала строки

gtk_text_buffer_get_iter_at_offset ()

void        gtk_text_buffer_get_iter_at_offset
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint char_offset);

Инициализирует iter указывающий char_offset символ с начала буферного ввода. Если char_offset равен -1 или больше количества символов в буфере, iter инициализируется как конечный итератор, итератор соответствующий последнему доступному символу в буфере.

`buffer` :	GtkTextBuffer
`iter` :	Инициализируемый итератор
`char_offset` :	Символьное смещение с начала буфера, начиная с 0, или -1

gtk_text_buffer_get_iter_at_line ()

void        gtk_text_buffer_get_iter_at_line
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number);

Инициализирует iter для начала данной строки.

`buffer` :	GtkTextBuffer
`iter` :	Инициализируемый итератор
`line_number` :	Строка начиная с 0

gtk_text_buffer_get_iter_at_line_index ()

void        gtk_text_buffer_get_iter_at_line_index
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             gint line_number,
                                             gint byte_index);

Определяет итератор указывающий byte_index внутри данной строки. byte_index должен быть началом символа UTF-8, и не должен быть концом строки. Помните bytes, не символы; UTF-8 может закодировать один символ несколькими байтами.

`buffer` :	GtkTextBuffer
`iter` :	Инициализируемый итератор
`line_number` :	Строка начиная с 0
`byte_index` :	Количество байт с начала строки

gtk_text_buffer_get_iter_at_mark ()

void        gtk_text_buffer_get_iter_at_mark
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextMark *mark);

Инициализирует iter текущемй позицией mark.

`buffer` :	GtkTextBuffer
`iter` :	инициализируемый итератор
`mark` :	GtkTextMark в `buffer`

gtk_text_buffer_get_iter_at_child_anchor ()

void        gtk_text_buffer_get_iter_at_child_anchor
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *iter,
                                             GtkTextChildAnchor *anchor);

Определяет размещение anchor внутри buffer.

`buffer` :	GtkTextBuffer
`iter` :	Инициализируемый итератор
`anchor` :	Дочерний якорь который находится в `buffer`

gtk_text_buffer_get_start_iter ()

void        gtk_text_buffer_get_start_iter  (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);

Инициализирует iter первой позицией в текстовом буфере. Тоже самое как использовать gtk_text_buffer_get_iter_at_offset() для получения итератора символьного смещения равного 0.

`buffer` :	GtkTextBuffer
`iter` :	инициализируемый итератор

gtk_text_buffer_get_end_iter ()

void        gtk_text_buffer_get_end_iter    (GtkTextBuffer *buffer,
                                             GtkTextIter *iter);

Инициализирует iter как "end iterator", последний доступный символ в текстовом буфере. Если разыменован с помощью gtk_text_iter_get_char(), конечный итератор имеет значение 0. Вся площадь буфера в диапазоне с первой позиции (вызывает gtk_text_buffer_get_start_iter() для получения символа в позиции 0) до конечного итератора.

`buffer` :	GtkTextBuffer
`iter` :	инициализируемый итератор

gtk_text_buffer_get_bounds ()

void        gtk_text_buffer_get_bounds      (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);

Определяет первый и последний итератор в буфере, то есть вся площадь буфера в диапазоне [start,end].

`buffer` :	GtkTextBuffer
`start` :	инициализируемый итератор первой позицией буфера
`end` :	инициализируемый итератор конечным итератором

gtk_text_buffer_get_modified ()

gboolean    gtk_text_buffer_get_modified    (GtkTextBuffer *buffer);

Указывает был ли буфер изменён, с тех пор когда последний вызов gtk_text_buffer_set_modified() устанавливал флажок изменения в FALSE. Используется например для включения функции "save" в текстовых редакторах.

`buffer` :	GtkTextBuffer
Возвращает :	`TRUE` если буфер был изменён

gtk_text_buffer_set_modified ()

void        gtk_text_buffer_set_modified    (GtkTextBuffer *buffer,
                                             gboolean setting);

Используется для слежения за изменениями буфера, с момента последнего сохранения. Каждый раз при сохранении буфера на диск, вызывается gtk_text_buffer_set_modified (buffer, FALSE). Когда буфер изменяется, это будет автоматически переключено на модифицирующий бит снова. Когда модифицирующий бит изменяется, буфер издаёт сигнал "modified_changed".

`buffer` :	GtkTextBuffer
`setting` :	Установки флажка изменений

gtk_text_buffer_delete_selection ()

gboolean    gtk_text_buffer_delete_selection
                                            (GtkTextBuffer *buffer,
                                             gboolean interactive,
                                             gboolean default_editable);

Удаляет диапазон между "insert" и "selection_bound" маркерами, который является текущим выделенным текстом. Если interactive равно TRUE, возможность редактирования будет принята во внимание (пользователь не может удалять не доступны для редактирования текст).

`buffer` :	GtkTextBuffer
`interactive` :	Вызвано ли удаление пользователем
`default_editable` :	Доступен ли буфер для редактирования по умолчанию
Возвращает :	Не было ли пустым выделение для удаления

gtk_text_buffer_paste_clipboard ()

void        gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard,
                                             GtkTextIter *override_location,
                                             gboolean default_editable);

Вставляет содержимое буфера обмена в точку вставки, или в override_location. (Примечание: вставка является асинхронной, то есть, мы запрашиваем для вставки данные и возвращаем, а немного позже после выполнения основного цикла, вставляемые данные будут вставлены.)

`buffer` :	GtkTextBuffer
`clipboard` :	GtkClipboard из которого вставляются данные
`override_location` :	Размещение вставляемого текста, или `NULL` для размещения на курсоре
`default_editable` :	Редактируем ли буфер по умолчанию

gtk_text_buffer_copy_clipboard ()

void        gtk_text_buffer_copy_clipboard  (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);

Копирует выделенный текст в буфер обмена.

`buffer` :	GtkTextBuffer
`clipboard` :	GtkClipboard объект для копирования.

gtk_text_buffer_cut_clipboard ()

void        gtk_text_buffer_cut_clipboard   (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard,
                                             gboolean default_editable);

Копирует текущеме выделение текста в буфер обмена, затем удаляет скажем текст, если он доступен для редактирования.

`buffer` :	GtkTextBuffer
`clipboard` :	GtkClipboard объект для вырезания.
`default_editable` :	Редактируемость буфера по умолчанию

gtk_text_buffer_get_selection_bounds ()

gboolean    gtk_text_buffer_get_selection_bounds
                                            (GtkTextBuffer *buffer,
                                             GtkTextIter *start,
                                             GtkTextIter *end);

Возвращает TRUE если некоторый текст выделен; помещает границы выделения в start и end (если выделение имеет длину 0, то когда start и end заполняются одинаковым значением). start и end будут в порядке возрастания. Если start и end равны NULL, то когда они не заполняются, но возвращаемое значение всё ещё указывает выделен ли текст.

`buffer` :	GtkTextBuffer
`start` :	инициализируемый итератор началом выделения
`end` :	инициализируемый итератор концом выделения
Возвращает :	Имеет ли выделение не нулевую длину

gtk_text_buffer_begin_user_action ()

void        gtk_text_buffer_begin_user_action
                                            (GtkTextBuffer *buffer);

Вызывается для указания буферных операций между этой и вызовом gtk_text_buffer_end_user_action() являющихся частью одной видимой пользователем операции. Операции между gtk_text_buffer_begin_user_action() и gtk_text_buffer_end_user_action() могут группироваться создавая стек отмены действий. GtkTextBuffer поддерживает подсчет вызовов gtk_text_buffer_begin_user_action() которые не были закрыты вызовом gtk_text_buffer_end_user_action(), и издаёт сигналы "begin_user_action" и "end_user_action" только для парных крайних вызовов. Это позволяет создавать действия пользователя из других действий пользователя.

Функции интерактивных ("interactive") изменений буфера, такие как gtk_text_buffer_insert_interactive(), автоматически вызывают начало/конец действия пользователя около буферных операций которые они вызвали, поэтому нет необходимости в дополнительных вызовах, если ваше пользовательское действие состоит из вызова одной из этих функций.

buffer :

GtkTextBuffer

gtk_text_buffer_end_user_action ()

void        gtk_text_buffer_end_user_action (GtkTextBuffer *buffer);

Должна быть парной с функцией gtk_text_buffer_begin_user_action().

buffer :

GtkTextBuffer

gtk_text_buffer_add_selection_clipboard ()

void        gtk_text_buffer_add_selection_clipboard
                                            (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);

Добавляет clipboard в список буферов обмена в которых выбор содержимого buffer является доступным. В большинстве случаев, clipboard будет GtkClipboard типа GDK_SELECTION_PRIMARY для просмотра buffer.

`buffer` :	GtkTextBuffer
`clipboard` :	GtkClipboard

gtk_text_buffer_remove_selection_clipboard ()

void        gtk_text_buffer_remove_selection_clipboard
                                            (GtkTextBuffer *buffer,
                                             GtkClipboard *clipboard);

Удаляет GtkClipboard добавленный с помощью gtk_text_buffer_add_selection_clipboard()

`buffer` :	GtkTextBuffer
`clipboard` :	GtkClipboard добавляемый к `buffer` функцией `gtk_text_buffer_add_selection_clipboard()`.

enum GtkTextBufferTargetInfo

typedef enum
{
  GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS = G_MAXUINT - 0,
  GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT       = G_MAXUINT - 1,
  GTK_TEXT_BUFFER_TARGET_INFO_TEXT            = G_MAXUINT - 2
} GtkTextBufferTargetInfo;

GtkTextBufferDeserializeFunc ()

gboolean    (*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GtkTextIter *iter,
                                             const guint8 *data,
                                             gsize length,
                                             gboolean create_tags,
                                             gpointer user_data,
                                             GError **error);

`register_buffer` :
`content_buffer` :
`iter` :
`data` :
`length` :
`create_tags` :
`user_data` :
`error` :
Возвращает :

gtk_text_buffer_deserialize ()

gboolean    gtk_text_buffer_deserialize     (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GdkAtom format,
                                             GtkTextIter *iter,
                                             const guint8 *data,
                                             gsize length,
                                             GError **error);

Эта функция преобразует RTF текст в формат format и вставляет его в iter.

formatы для использования должны быть зарегистрированы с помощью gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset() заранее.

`register_buffer` :	GtkTextBuffer `format` в котором зарегистрирован
`content_buffer` :	GtkTextBuffer в который преобразуется
`format` :	RTF формат для преобразования
`iter` :	Расположение для преобразованного текста
`data` :	Данные для преобразования
`length` :	Длина `data`
`error` :	Возвращаемое расположение для GError
Возвращает :	`TRUE` если выполнено, иначе `FALSE`.

Начиная с версии 2.10

gtk_text_buffer_deserialize_get_can_create_tags ()

gboolean    gtk_text_buffer_deserialize_get_can_create_tags
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);

Эта функция возвращает значение установленное с помощью gtk_text_buffer_deserialize_set_can_create_tags()

`buffer` :	GtkTextBuffer
`format` :	GdkAtom зарегистрированного формата RTF
Возвращает :	Может ли преобразование этого формата создать теги

Начиная с версии 2.10

gtk_text_buffer_deserialize_set_can_create_tags ()

void        gtk_text_buffer_deserialize_set_can_create_tags
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format,
                                             gboolean can_create_tags);

Используйте эту функцию чтобы позволить функциям преобразования RTF текста создать новые теги в полученном буфере. Помните, что использование этих функций постоянно, плохая идея, потому что функции RTF текста зарегистрированные вами, должны знать как отобразить RTF формат обработанный ими в ваш текстовый буфер с установленными тегами.

Способна создавать новые (произвольные!) теги в полученном буфере, имеется ввиду для специальных форматов RTF, как внутренние которые зарегистрированы с помощью gtk_text_buffer_register_deserialize_tagset(), потому что этот формат по существу дамп внутренней структуры исходного буфера, включая имена тегов.

Вы должны позволять создание новых тегов, только если вы знаете что делаете, например если вы определите имя для установленных тегов текстовых буферов вашего приложения и вы знаете что это прекрасно для получения новых тегов из этих буферов, так как вы знаете что ваше приложение может обработать вновь созданные теги.

`buffer` :	GtkTextBuffer
`format` :	GdkAtom представляющий регистрируемый RTF формат
`can_create_tags` :	Может ли преобразование этого формата создавать теги

Начиная с версии 2.10

gtk_text_buffer_get_copy_target_list ()

GtkTargetList* gtk_text_buffer_get_copy_target_list
                                            (GtkTextBuffer *buffer);

Эта функция возвращает список адресов, которые этот текстовый буфер может обеспечить для копирования и как источник DND. Адреса в списке добавляются со значением info из перечисления GtkTextBufferTargetInfo enum, используя gtk_target_list_add_rich_text_targets() и gtk_target_list_add_text_targets()

`buffer` :	GtkTextBuffer
Возвращает :	GtkTargetList

Начиная с версии 2.10

gtk_text_buffer_get_deserialize_formats ()

GdkAtom*    gtk_text_buffer_get_deserialize_formats
                                            (GtkTextBuffer *buffer,
                                             gint *n_formats);

Эта функция возвращает RTF преобразованный формат зарегистрированный с buffer используя gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset()

`buffer` :	GtkTextBuffer
`n_formats` :	Место хранения возвращаемого значения количества форматов
Возвращает :	массив GdkAtoms представляющий зарегистрированные форматы.

Начиная с версии 2.10

gtk_text_buffer_get_paste_target_list ()

GtkTargetList* gtk_text_buffer_get_paste_target_list
                                            (GtkTextBuffer *buffer);

Эта функция возвращает список адресов поддерживаемых этим текстовым буфером для вставки и как место назначения DND. Адреса в списке добавляются со значением info из перечисления GtkTextBufferTargetInfo, используя gtk_target_list_add_rich_text_targets() и gtk_target_list_add_text_targets()

`buffer` :	GtkTextBuffer
Возвращает :	GtkTargetList

Начиная с версии 2.10

gtk_text_buffer_get_serialize_formats ()

GdkAtom*    gtk_text_buffer_get_serialize_formats
                                            (GtkTextBuffer *buffer,
                                             gint *n_formats);

Эта функция возвращает RTF формат зарегистрированный с buffer используя gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset()

`buffer` :	GtkTextBuffer
`n_formats` :	Место хранения возвращаемого значения количества форматов
Возвращает :	массив GdkAtoms представляющий зарегистрированные форматы.

Начиная с версии 2.10

gtk_text_buffer_register_deserialize_format ()

GdkAtom     gtk_text_buffer_register_deserialize_format
                                            (GtkTextBuffer *buffer,
                                             const gchar *mime_type,
                                             GtkTextBufferDeserializeFunc function,
                                             gpointer user_data,
                                             GDestroyNotify user_data_destroy);

Эта функция регистрирует RTF текстовую function преобразования из последовательной формы в параллельную вместе с её mime_type с переданным buffer.

`buffer` :	GtkTextBuffer
`mime_type` :	форматы mime-type
`function` :	Функция преобразования для регистрации
`user_data` :	`function`'s user_data
`user_data_destroy` :	Функция вызываемая когда user_data больше не нужна
Возвращает :	GdkAtom который соответствует вновь зарегистрированному формату mime-type.

Начиная с версии 2.10

gtk_text_buffer_register_deserialize_tagset ()

GdkAtom     gtk_text_buffer_register_deserialize_tagset
                                            (GtkTextBuffer *buffer,
                                             const gchar *tagset_name);

Эта функция регистрирует внутри GTK+'s RTF преобразованный из последовательной формы в параллельную формат с переданным buffer. Смотрите gtk_text_buffer_register_serialize_tagset().

`buffer` :	GtkTextBuffer
`tagset_name` :	Дополнительно имя установленного тега, или `NULL`
Возвращает :	GdkAtom который соответствует вновь зарегистрированному формату mime-type.

Начиная с версии 2.10

gtk_text_buffer_register_serialize_format ()

GdkAtom     gtk_text_buffer_register_serialize_format
                                            (GtkTextBuffer *buffer,
                                             const gchar *mime_type,
                                             GtkTextBufferSerializeFunc function,
                                             gpointer user_data,
                                             GDestroyNotify user_data_destroy);

Эта функция регистрирует RTF текстовую function преобразования в последовательную форму с её mime_type с переданным buffer.

`buffer` :	GtkTextBuffer
`mime_type` :	форматы mime-type
`function` :	Функция преобразования для регистрации
`user_data` :	`function`'s user_data
`user_data_destroy` :	Функция вызываемая когда user_data больше не нужна
Возвращает :	GdkAtom который соответствует вновь зарегистрированному формату mime-type.

Начиная с версии 2.10

gtk_text_buffer_register_serialize_tagset ()

GdkAtom     gtk_text_buffer_register_serialize_tagset
                                            (GtkTextBuffer *buffer,
                                             const gchar *tagset_name);

Эта функция регистрирует внутри GTK+'s RTF преобразованный в последовательную форму формат с переданным buffer. Внутренний формат не подчиняется никакому стандарту RTF и работает только между образцов GtkTextBuffer. Это способствует преобразованию в последовательную форму всех тегов текстовых буферов и внедрённых изображений.

Эта функция просто оболочка для gtk_text_buffer_register_serialize_format(). mime_type используемые для регистрации это "application/x-gtk-text-buffer-rich-text", или "application/x-gtk-text-buffer-rich-text;format=tagset_name" если tagset_name было помещено.

tagset_name может использоваться для ограничения передачи RTF в буферы с совмещенными наборами тегов, исключая неизвестные теги. Это вероятно обычный способ передать идентификатор != NULL, так как NULL заставляет получающий буфер иметь дело со вставкой произвольных тегов.

`buffer` :	GtkTextBuffer
`tagset_name` :	Дополнительно имя устанавливаемого тега, или `NULL`
Возвращает :	GdkAtom который соответствует вновь зарегистрированному формату mime-type.

Начиная с версии 2.10

GtkTextBufferSerializeFunc ()

guint8*     (*GtkTextBufferSerializeFunc)   (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gsize *length,
                                             gpointer user_data);

`register_buffer` :
`content_buffer` :
`start` :
`end` :
`length` :
`user_data` :
Возвращает :

gtk_text_buffer_serialize ()

guint8*     gtk_text_buffer_serialize       (GtkTextBuffer *register_buffer,
                                             GtkTextBuffer *content_buffer,
                                             GdkAtom format,
                                             const GtkTextIter *start,
                                             const GtkTextIter *end,
                                             gsize *length);

Эта функция преобразует в последовательный формат часть текста находящийся между start и end в RTF представленном format.

formats для использования должны быть предварительно зарегистрированы с помощью gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset().

`register_buffer` :	GtkTextBuffer `format` который зарегистрирован
`content_buffer` :	GtkTextBuffer для преобразования в последовательный формат
`format` :	RTF используемый для преобразования в последовательный формат
`start` :	Начало блока текста для преобразования
`end` :	Конец блока текста для преобразования
`length` :	Место хранения возвращаемого значения длины преобразуемых в последовательный формат данных
Возвращает :	Преобразованные в последовательный формат данные, закодированные как `format`

Начиная с версии 2.10

gtk_text_buffer_unregister_deserialize_format ()

void        gtk_text_buffer_unregister_deserialize_format
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);

Снимает регистрацию RTF который был предварительно зарегистрирован с помощью gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset()

`buffer` :	GtkTextBuffer
`format` :	GdkAtom соответствующий зарегистрированному RTF формату.

Начиная с версии 2.10

gtk_text_buffer_unregister_serialize_format ()

void        gtk_text_buffer_unregister_serialize_format
                                            (GtkTextBuffer *buffer,
                                             GdkAtom format);

Снимает регистрацию RTF который был предварительно зарегистрирован с помощью gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset()

`buffer` :	GtkTextBuffer
`format` :	GdkAtom соответствующий зарегистрированному RTF формату.

Начиная с версии 2.10

Детали свойств

Свойство "`copy-target-list`"

  "copy-target-list"     GtkTargetList         : Read

Список адресов поддерживаемых этим буфером для копирования через буфер обмена и как источник DND.

Начиная с версии 2.10

Свойство "`cursor-position`"

  "cursor-position"      gint                  : Read

Позиция вставляемого маркера (как смещение из начала буфера). Это полезно для получения уведомления о перемещении курсора.

Допустимые значения: >= 0

Значение по умолчанию: 0

Начиная с версии 2.10

Свойство "`has-selection`"

  "has-selection"        gboolean              : Read

Имеет ли буфер текущеме текстовое выделение.

Значение по умолчанию: FALSE

Начиная с версии 2.10

Свойство "`paste-target-list`"

  "paste-target-list"    GtkTargetList         : Read

Список целей поддерживаемых этим буфером для вставки через буфер обмена и как место назначения DND.

Начиная с версии 2.10

Свойство "`tag-table`"

  "tag-table"            GtkTextTagTable       : Read / Write / Construct Only

Таблица текстовых тегов.

Свойство "`text`"

  "text"                 gchararray            : Read / Write

Текстовый контекст буфера. Без дочерних виджетов и изображений, для большей информации смотрите gtk_text_buffer_get_text().

Значение по умолчанию: ""

Начиная с версии 2.8

Детали сигналов

Сигнал "apply-tag"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextTag    *arg1,
                                            GtkTextIter   *arg2,
                                            GtkTextIter   *arg3,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`arg3` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "begin-user-action"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "changed"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "delete-range"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GtkTextIter   *arg2,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "end-user-action"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "insert-child-anchor"

void        user_function                  (GtkTextBuffer      *textbuffer,
                                            GtkTextIter        *arg1,
                                            GtkTextChildAnchor *arg2,
                                            gpointer            user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "insert-pixbuf"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GdkPixbuf     *arg2,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "insert-text"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            gchar         *arg2,
                                            gint           arg3,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`arg3` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "mark-deleted"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextMark   *arg1,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "mark-set"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextIter   *arg1,
                                            GtkTextMark   *arg2,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "modified-changed"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Сигнал "remove-tag"

void        user_function                  (GtkTextBuffer *textbuffer,
                                            GtkTextTag    *arg1,
                                            GtkTextIter   *arg2,
                                            GtkTextIter   *arg3,
                                            gpointer       user_data)       : Run last

`textbuffer` :	объект получающий сигнал.
`arg1` :
`arg2` :
`arg3` :
`user_data` :	пользовательские данные устанавливаемые при подключении обработчика сигнала.

Смотрите также

GtkTextView, GtkTextIter, GtkTextMark

Партнёры:

Хостинг:

Закладки на сайте
Проследить за страницей

Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру