GtkTextBuffer

gtk_text_buffer_new ()

GtkTextBuffer *
gtk_text_buffer_new (GtkTextTagTable *table);

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

gtk_text_buffer_get_line_count ()

gint
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);

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

gtk_text_buffer_get_char_count ()

gint
gtk_text_buffer_get_char_count (GtkTextBuffer *buffer);

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

gtk_text_buffer_get_tag_table ()

GtkTextTagTable *
gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer);

Получить GtkTextTagTable, связанный с этим буфером.

gtk_text_buffer_insert ()

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

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

gtk_text_buffer_insert_at_cursor ()

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

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

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

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

gtk_text_buffer_insert_range ()

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

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

Реализовано с помощью испускания сигналов insert_text и apply_tag, так что ожидайте их.

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

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() — просто удобная функция.

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(), но позволяет передавать имена тегов вместо самих объектов тегов.

gtk_text_buffer_insert_markup ()

void
gtk_text_buffer_insert_markup (GtkTextBuffer *buffer,
                               GtkTextIter *iter,
                               const gchar *markup,
                               gint len);

Вставляет текст из markup в позицию iter. markup будет вставлен полностью и должен быть завершён нулём, а также быть корректным UTF-8. Издаёт сигнал “insert-text”, возможно, несколько раз; вставка фактически происходит в обработчике по умолчанию для сигнала. iter будет указывать на конец вставленного текста по возвращении.

С: 3.16

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 будут повторно инициализированы, чтобы указывать на место, где был удалён текст.

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 перепроверяются, чтобы указать на место последнего удалённого диапазона, или остаются неизменными, если текст не был удалён.

gtk_text_buffer_backspace ()

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

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

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

С: 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 должен быть завершён нулём. text должен быть корректным кодированным в UTF-8.

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

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 равен FALSE. Возвращаемая строка включает символ 0xFFFC всякий раз, когда буфер содержит вложенные изображения, поэтому индексы байтов и символов в возвращаемой строке соответствуют индексам байтов и символов в буфере. Противопоставьте gtk_text_buffer_get_text(). Обратите внимание, что 0xFFFC может встречаться и в обычном тексте, поэтому он не является надёжным индикатором наличия pixbuf или виджета в буфере.

gtk_text_buffer_insert_pixbuf ()

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

Вставляет изображение в буфер текста в позиции iter . Изображение будет учитываться как один символ при подсчёте символов и при получении содержимого буфера в виде строки будет представлено Юникод-символом «заполнитель объекта» 0xFFFC. Обратите внимание, что в вариантах «срезов» для получения частей буфера в виде строки этот символ включён для pixbuf, но не включён в вариантах «текста». Например, см. gtk_text_buffer_get_slice() и gtk_text_buffer_get_text().

gtk_text_buffer_insert_child_anchor ()

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

Вставляет якорь дочернего виджета в буфер текста в позиции iter. Якорь будет учитываться как один символ при подсчёте символов и при получении содержимого буфера в виде строки будет представлен Юникод-символом «заполнитель объекта» 0xFFFC. Обратите внимание, что варианты «срезов» для получения частей буфера в виде строки включают этот символ для якорей дочерних виджетов, но варианты «текста» — нет. См. gtk_text_buffer_get_slice() и gtk_text_buffer_get_text(). В качестве более удобной альтернативы этой функции рассмотрите gtk_text_buffer_create_child_anchor(). Буфер добавит ссылку на якорь, поэтому вы можете освободить его после вставки.

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

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 = FALSE), метка окажется справа от вставленного текста. Стандартный курсор слева направо — это метка с правой гравитацией (когда вы печатаете, курсор остаётся справа от текста, который вы печатаете).

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

Выдаёт сигнал “mark-set” как уведомление об исходном размещении метки.

gtk_text_buffer_move_mark ()

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

Перемещает mark в новое местоположение where . Выдаёт сигнал “mark-set” в качестве уведомления о перемещении.

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

gtk_text_buffer_add_mark ()

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

Добавляет метку в позиции where . Метка не должна быть добавлена в другой буфер, и если её имя не NULL, то в буфере не должно быть другой метки с таким же именем.

Выдаёт сигнал “mark-set” как уведомление об исходном размещении метки.

С: 2.12

gtk_text_buffer_delete_mark ()

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

Удаляет mark, чтобы она больше не находилась в буфере. Удаляет ссылку, которая хранится в буфере на метку, поэтому если вы не вызывали g_object_ref() на метке, она будет освобождена. Даже если метка не освобождена, большинство операций с mark становятся недопустимыми до тех пор, пока она не будет добавлена в буфер снова с помощью gtk_text_buffer_add_mark(). Используйте gtk_text_mark_get_deleted(), чтобы узнать, была ли метка удалена из её буфера. Сигнал “mark-deleted” будет выдан в качестве уведомления после удаления метки.

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

gtk_text_buffer_get_mark ()

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

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

gtk_text_buffer_get_insert ()

GtkTextMark *
gtk_text_buffer_get_insert (GtkTextBuffer *buffer);

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

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() — это еще одна удобная функция для обработки выделения, если вам просто нужно узнать, есть ли выделение и каковы его границы.

gtk_text_buffer_get_has_selection ()

gboolean
gtk_text_buffer_get_has_selection (GtkTextBuffer *buffer);

Указывает, есть ли в буфере выделенный текст.

Since: 2.10

gtk_text_buffer_place_cursor ()

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

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

gtk_text_buffer_select-range ()

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

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

Since: 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 не обязательно должны быть упорядочены.

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 не обязательно должны быть упорядочены.

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

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

gtk_text_buffer_remove_all_tags ()

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

Удаляет все теги в диапазоне между 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().

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 в данной строке. Обратите внимание на символы, а не байты; UTF-8 может кодировать один символ как несколько байтов.

До версии 3.20 не разрешалось передавать некорректное расположение.

Начиная с версии 3.20, если line_number больше, чем количество строк в buffer, возвращается итератор конца. А если 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 инициализируется итератором конца, итератором, расположенным после последнего допустимого символа в буфере.

gtk_text_buffer_get_iter_at_line ()

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

Инициализирует iter в начале заданной строки. Если line_number больше, чем количество строк в buffer, возвращается итератор конца.

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 символа. Обратите внимание на байты, а не символы; UTF-8 может кодировать один символ как несколько байтов.

До версии 3.20 не разрешалось передавать недопустимое расположение.

Начиная с версии 3.20, если line_number больше, чем количество строк в buffer, возвращается итератор конца. А если 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 .

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 .

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.

gtk_text_buffer_get_end_iter ()

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

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

gtk_text_buffer_get_bounds ()

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

Получает первые и последние итераторы в буфере, т.е. весь буфер находится в диапазоне [start ,end ).

gtk_text_buffer_get_modified ()

gboolean
gtk_text_buffer_get_modified (GtkTextBuffer *buffer);

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

gtk_text_buffer_set_modified ()

void
gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
                              gboolean setting);

Используется для отслеживания того, был ли буфер изменён с момента последнего сохранения. Всякий раз, когда буфер сохраняется на диск, вызывается gtk_text_buffer_set_modified (buffer , FALSE). При изменении буфера автоматически устанавливается модифицированный бит. Когда бит изменения меняется, буфер излучает сигнал “modified-changed”.

gtk_text_buffer_delete_selection ()

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

Удаляет диапазон между метками «вставка» и «предел_выделения», то есть, текущий выделенный текст. Если interactive равно TRUE, редактируемость выделения будет учитываться (пользователи не могут удалить нередактируемый текст).

gtk_text_buffer_paste_clipboard ()

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

Вставляет содержимое буфера обмена. Если override_location равно NULL, вставленный текст будет помещен в позицию курсора или выделение буфера будет заменено, если оно не пусто.

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

gtk_text_buffer_copy_clipboard ()

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

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

gtk_text_buffer_cut_clipboard ()

void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
                               GtkClipboard *clipboard,
                               gboolean 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, то они не заполняются, но возвращаемое значение всё равно указывает, выделен ли текст.

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(), и генерирует сигналы «начало-операции-пользователя» и «конец-операции-пользователя» только для внешней пары вызовов. Это позволяет вам создавать пользовательские действия из других пользовательских действий.

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

gtk_text_buffer_end_user_action ()

void
gtk_text_buffer_end_user_action (GtkTextBuffer *buffer);

Должен быть использован в паре с вызовом gtk_text_buffer_begin_user_action(). См. эту функцию для полного объяснения.

gtk_text_buffer_add_selection_clipboard ()

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

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

gtk_text_buffer_remove_selection_clipboard ()

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

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

GtkTextBufferDeserializeFunc ()

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

Функция, вызываемая для десериализации форматированного текста, сериализованного с помощью gtk_text_buffer_serialize(), и вставки его в iter.

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

Эта функция десериализует форматированный текст в формате format и вставляет его в iter.

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

С: 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()

С: 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);

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

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

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

С: 2.10

gtk_text_buffer_get_copy_target_list ()

GtkTargetList *
gtk_text_buffer_get_copy_target_list (GtkTextBuffer *buffer);

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

С: 2.10

gtk_text_buffer_get_deserialize_formats ()

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

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

С: 2.10

gtk_text_buffer_get_paste_target_list ()

GtkTargetList *
gtk_text_buffer_get_paste_target_list (GtkTextBuffer *buffer);

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

С: 2.10

gtk_text_buffer_get_serialize_formats ()

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

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

С: 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);

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

С: 2.10

gtk_text_buffer_register_deserialize_tagset ()

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

Эта функция регистрирует внутренний формат сериализации форматированного текста GTK+ в указанный buffer . Подробности см. в gtk_text_buffer_register_serialize_tagset().

С: 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);

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

С: 2.10

gtk_text_buffer_register_serialize_tagset ()

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

Эта функция регистрирует внутренний формат сериализации форматированного текста GTK+ в переданном buffer. Внутренний формат не соответствует ни одному стандартному формату форматированного текста и работает только между объектами GtkTextBuffer. Он способен сериализовать все теги и встроенные pixbuфы буфера текста.

Эта функция является просто обёрткой вокруг gtk_text_buffer_register_serialize_format(). Используемый mime-тип для регистрации — “application/x-gtk-text-buffer-rich-text”, или “application/x-gtk-text-buffer-rich-text;format=tagset_name ”, если был передан tagset_name.

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

С: 2.10

GtkTextBufferSerializeFunc ()

guint8 *
(*GtkTextBufferSerializeFunc) (GtkTextBuffer *register_buffer,
                               GtkTextBuffer *content_buffer,
                               const GtkTextIter *start,
                               const GtkTextIter *end,
                               gsize *length,
                               gpointer 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 в формате форматированного текста, представленном format.

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

С: 2.10

gtk_text_buffer_unregister_deserialize_format ()

void
gtk_text_buffer_unregister_deserialize_format
                               (GtkTextBuffer *buffer,
                                GdkAtom format);

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

С: 2.10

gtk_text_buffer_unregister_serialize_format ()

void
gtk_text_buffer_unregister_serialize_format
                               (GtkTextBuffer *buffer,
                                GdkAtom format);

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

С версии: 2.10

Сигнал “apply-tag”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextTag    *tag,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::apply-tag генерируется для применения тега к диапазону текста в GtkTextBuffer. Применение происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен их перепроверять).

См. также: gtk_text_buffer_apply_tag(), gtk_text_buffer_insert_with_tags(), gtk_text_buffer_insert_range().

Флаги: Выполнить последним

Сигнал “begin-user-action”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::begin-user-action генерируется в начале видимого пользователю действия над GtkTextBuffer.

См. также: gtk_text_buffer_begin_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection().

Флаги: Выполнить последним

Сигнал “changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::changed генерируется, когда содержимое GtkTextBuffer изменилось.

Флаги: Выполнить последним

Сигнал “delete-range”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::delete-range генерируется для удаления диапазона из GtkTextBuffer.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен их перепроверять). Обработчик сигнала по умолчанию перепроверяет итераторы start и end, чтобы оба указывали на место, где был удалён текст. Обработчики, выполняющиеся после обработчика по умолчанию (см. g_signal_connect_after()), не имеют доступа к удалённому тексту.

См. также: gtk_text_buffer_delete().

Флаги: Выполнить последним

Сигнал “end-user-action”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::end-user-action генерируется в конце видимого пользователю действия над GtkTextBuffer.

См. также: gtk_text_buffer_end_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection(), gtk_text_buffer_backspace().

Флаги: Выполнить последним

Сигнал “insert-child-anchor”

void
user_function (GtkTextBuffer      *textbuffer,
               GtkTextIter        *location,
               GtkTextChildAnchor *anchor,
               gpointer            user_data)

Сигнал ::insert-child-anchor генерируется для вставки GtkTextChildAnchor в GtkTextBuffer. Вставка происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен его перепроверять). Обработчик сигнала по умолчанию перепроверяет его, чтобы он был размещён после вставленного anchor.

См. также: gtk_text_buffer_insert_child_anchor().

Флаги: Выполнить последним

Сигнал “insert-pixbuf”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               GdkPixbuf     *pixbuf,
               gpointer       user_data)

Сигнал ::insert-pixbuf генерируется для вставки GdkPixbuf в GtkTextBuffer. Вставка фактически происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен перепроверить его). Обработчик сигнала по умолчанию перепроверяет его, чтобы он был размещён после вставленного pixbuf.

См. также: gtk_text_buffer_insert_pixbuf().

Флаги: Выполнить последним

Сигнал “insert-text”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               gchar         *text,
               gint           len,
               gpointer       user_data)

Сигнал ::insert-text генерируется для вставки текста в GtkTextBuffer. Вставка фактически происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен перепроверить его). Обработчик сигнала по умолчанию перепроверяет его, чтобы он указывал на конец вставленного текста.

См. также: gtk_text_buffer_insert(), gtk_text_buffer_insert_range().

Флаги: Выполнить последним

Сигнал “mark-deleted”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextMark   *mark,
               gpointer       user_data)

Сигнал ::mark-deleted генерируется в качестве уведомления после удаления GtkTextMark.

См. также: gtk_text_buffer_delete_mark().

Флаги: Выполнить последним

Сигнал “mark-set”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               GtkTextMark   *mark,
               gpointer       user_data)

Сигнал ::mark-set генерируется как уведомление после установки GtkTextMark.

См. также: gtk_text_buffer_create_mark(), gtk_text_buffer_move_mark().

Флаги: Выполнить последним

Сигнал “modified-changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::modified-changed генерируется, когда изменяется модифицированный бит GtkTextBuffer.

См. также: gtk_text_buffer_set_modified().

Флаги: Выполнить последним

Сигнал “paste-done”

void
user_function (GtkTextBuffer *textbuffer,
               GtkClipboard  *clipboard,
               gpointer       user_data)

Сигнал paste-done генерируется после завершения операции вставки. Это полезно для правильной прокрутки просмотра до конца вставленного текста. Подробнее см. gtk_text_buffer_paste_clipboard().

Флаги: Выполнить последним

С версии 2.16

Сигнал “remove-tag”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextTag    *tag,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::remove-tag генерируется для удаления всех вхождений tag из диапазона текста в GtkTextBuffer. Удаление фактически происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен перепроверить их).

См. также: gtk_text_buffer_remove_tag().

Флаги: Выполнить последним