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

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

Since: 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 может встречаться и в обычном тексте, поэтому это не надёжный индикатор наличия в буфере пикча или виджета.

gtk_text_buffer_insert_pixbuf ()

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

Вставляет изображение в буфер текста в позиции iter . Изображение будет считаться одним символом при подсчёте символов и при получении содержимого буфера в виде строки будет представлено Юникод-символом «замещение объекта» 0xFFFC. Обратите внимание, что варианты «слайса» для получения частей буфера в виде строки включают этот символ для пикча, но варианты «текста» — нет. См. например, 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() как более удобную альтернативу этой функции. Буфер добавит ссылку на анкор, поэтому вы можете его unref после вставки.

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() для получения метки с именем «insert», но немного эффективнее и требует меньше набора текста.

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

Эта функция перемещает метки «insert» и «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);

Эта функция перемещает метки «insert» и «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. Весь буфер находится в диапазоне от первой позиции в буфере (чтобы получить позицию символа 0, вызовите gtk_text_buffer_get_start_iter()) до итератора конца.

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

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 будет GtkClipboard типа 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.

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

Флаги: Run Last

Сигнал “insert-text”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               char          *text,
               int            len,
               gpointer       user_data)

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

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

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

Флаги: Run Last

Сигнал “mark-deleted”

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

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

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

Флаги: Run Last

Сигнал “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().

Флаги: Run Last

Сигнал “modified-changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

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

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

Флаги: Run Last

Сигнал “paste-done”

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

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

Флаги: Run Last

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

Флаги: Run Last