mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-04 04:06:06 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/selection.h

88 lines
3.2 KiB
C
Raw Normal View History

selection: add a selection API
2019-07-11 09:51:51 +02:00
#pragma once
selection: mark-word using spaces only as word separator When the user double-clicks with ctrl pressed, we now select the word under the cursor using spaces only as word separator.
2019-08-05 19:02:27 +02:00
#include <stdbool.h>
selection: initial copy-to-clipboard functionality
2019-07-11 12:16:50 +02:00
#include <wayland-client.h>
selection: add a selection API
2019-07-11 09:51:51 +02:00
#include "terminal.h"
selection: initial copy-to-clipboard functionality
2019-07-11 12:16:50 +02:00
extern const struct wl_data_device_listener data_device_listener;
selection: add support for pasting *from* primary
2019-07-11 17:02:21 +02:00
extern const struct zwp_primary_selection_device_v1_listener primary_selection_device_listener;
selection: initial copy-to-clipboard functionality
2019-07-11 12:16:50 +02:00
selection: track selection type; normal or block selection
2020-01-03 23:29:45 +01:00
void selection_start(
selection: wip: update selection word-wise when initial selection was by word
2021-01-02 21:20:41 +01:00
struct terminal *term, int col, int row,
selection: combine enum selection_kind with selection_semantic
2021-01-06 10:53:27 +01:00
enum selection_kind new_kind, bool spaces_only);
selection: add a selection API
2019-07-11 09:51:51 +02:00
void selection_update(struct terminal *term, int col, int row);
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
void selection_finalize(
struct seat *seat, struct terminal *term, uint32_t serial);
selection/render: sync cells' 'selected' bit before rendering For performance reasons, we track whether a cell is selected or not using a bit in a cell's attributes. This makes it easy for the renderer to determine if the cells should be rendered as selected or not - it just have to look at the 'selected' bit instead of doing a complex range check against the current selection. This works nicely in most cases. But, if the cell is updated, the 'selected' bit is cleared. This results in the renderer rendering the cell normally, i.e. _not_ selected. Checking for this, and re-setting the 'selected' bit when the cell is updated (printed to) is way too expensive as it is in the hot path. Instead, sync the 'selected' bits just before rendering. This isn't so bad as it may sound; if there is no selection this is a no-op. Even if there is a selection, only those cells whose 'selected' bit have been cleared are dirtied (and thus re-rendered) - these cells would have been re-rendered anyway.
2020-05-16 21:36:08 +02:00
void selection_dirty_cells(struct terminal *term);
selection: add a selection API
2019-07-11 09:51:51 +02:00
void selection_cancel(struct terminal *term);
config: add ‘select-extend-character-wise’ bind action This forces the (new) selection mode to be character-wise when extending a word- or line-wise selection. Default key binding is ctrl+RMB.
2021-01-06 11:11:46 +01:00
void selection_extend(
struct seat *seat, struct terminal *term,
int col, int row, enum selection_kind kind);
osc: implement copy/paste to/from primary
2019-08-09 21:27:51 +02:00
term: scrolling: hopefully fix all selection/scrolling related crashes When scrolling, there are a couple of cases where an existing selection must be canceled because we cannot meaningfully represent it after scrolling. These are when the selection is (partly) inside: * The top scrolling region * The bottom scrolling region * The new lines scrolled in. I.e. re-used lines For the scrolling regions, the real problem is when the selection crosses the scrolling region boundary; a selection that is completely inside a scrolling regions _might_ be possible to keep, but we would need to translate the selection coordinates to the new scrolling region lines. For simplicity, we cancel the selection if it touches the scrolling region. Period. The last item, newly scrolled in lines is when the selection covers very old lines and we're now wrapping around the scrollback history. Then there's a fourth problem case: when the user has started a selection, but hasn't yet moved the cursor. In this case, we have no end point. What's more problematic is that when the user (after scrolling) moves the cursor, we try to create a huge selection that covers mostly empty (NULL) rows, causing us to crash. This can happen e.g. when reverse scrolling in such a way that we wrap around the scrollback history. The actual viewport in this case is something like `-n - m`. But the selection we'll end up trying to create will be `m - (rows - n)`. This range may very well contain NULL rows. To deal with this, we simply cancel the selection.
2020-05-17 15:34:49 +02:00
bool selection_on_rows(const struct terminal *term, int start, int end);
osc: implement copy/paste to/from primary
2019-08-09 21:27:51 +02:00
selection: selection_on_rows(): use scrollback relative coords When checking if the current selection intersects with the region (passed as parameter to the function), use scrollback relative coordinates. This fixes an issue where selections crossing the scrollback wrap-around being misdetected, resulting in either the selection being canceled while scrolling, even though it wasn’t scrolled out, or the selection _not_ being canceled, when it _was_ scrolled out.
2022-07-28 18:27:13 +02:00
void selection_scroll_up(struct terminal *term, int rows);
void selection_scroll_down(struct terminal *term, int rows);
selection: handle viewport wrap around correctly When the viewport wraps around, the selection points may be "incorrect".
2020-05-19 18:49:42 +02:00
void selection_view_up(struct terminal *term, int new_view);
void selection_view_down(struct terminal *term, int new_view);
selection: add selection_<type>_unset() These functions clear the current selection.
2020-09-09 18:44:49 +02:00
void selection_clipboard_unset(struct seat *seat);
void selection_primary_unset(struct seat *seat);
selection: add selection_<type>_has_data() Returns true when there is data available for paste in the clipboard/primary selection.
2020-09-09 18:45:10 +02:00
bool selection_clipboard_has_data(const struct seat *seat);
bool selection_primary_has_data(const struct seat *seat);
config: add 'pipe-selected' key binding This works just like pipe-visible and pipe-scrollback, but pipes the user-selected text, if any, to the external tool. Closes #51
2020-07-31 17:02:53 +02:00
char *selection_to_text(const struct terminal *term);
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
void selection_to_clipboard(
struct seat *seat, struct terminal *term, uint32_t serial);
void selection_from_clipboard(
struct seat *seat, struct terminal *term, uint32_t serial);
void selection_to_primary(
struct seat *seat, struct terminal *term, uint32_t serial);
void selection_from_primary(struct seat *seat, struct terminal *term);
selection: add text_to_clipboard() This function takes a string and makes it available to the clipboard.
2019-07-19 11:12:14 +02:00
selection: document the asynchronous behavior of text_from_{primary,clipboard}
2019-11-05 09:13:47 +01:00
/* Copy text *to* primary/clipboard */
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
bool text_to_clipboard(
struct seat *seat, struct terminal *term, char *text, uint32_t serial);
bool text_to_primary(
struct seat *seat, struct terminal *term, char *text, uint32_t serial);
selection: document the asynchronous behavior of text_from_{primary,clipboard}
2019-11-05 09:13:47 +01:00
/*
* Copy text *from* primary/clipboard
*
* Note that these are asynchronous; they *will* return
* immediately. The 'cb' callback will be called 0..n times with
* clipboard data. When done (or on error), the 'done' callback is
* called.
*
* As such, keep this in mind:
* - The 'user' context must not be stack allocated
* - Don't expect clipboard data to have been received when these
* functions return (it will *never* have been received at this
* point).
*/
selection: add text_from_clipboard() This function reads data from the clipboard, and calls a user-provided callback for each chunk of clipboard data.
2019-07-19 14:20:00 +02:00
void text_from_clipboard(
seat: use separate 'enter' serials for keyboard and mouse
2020-07-09 11:20:46 +02:00
struct seat *seat, struct terminal *term,
selection: add support for different mime-types Add support for `text/plain`, `text/plain;charset=utf-8` and `text/uri-list` to regular copy operations (both from clipboard and primary selection) and drag-and-drop operations.
2020-10-28 19:16:04 +01:00
void (*cb)(char *data, size_t size, void *user),
selection: text_from_{clipboard,primary}: add 'done' callback This callback is *always* called, including when there has been an error. This is in preparation for making text_from_{clipboard,primary} asynchronous.
2019-11-05 08:49:32 +01:00
void (*done)(void *user), void *user);
osc: implement copy/paste to/from primary
2019-08-09 21:27:51 +02:00
void text_from_primary(
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
struct seat *seat, struct terminal *term,
selection: add support for different mime-types Add support for `text/plain`, `text/plain;charset=utf-8` and `text/uri-list` to regular copy operations (both from clipboard and primary selection) and drag-and-drop operations.
2020-10-28 19:16:04 +01:00
void (*cb)(char *data, size_t size, void *user),
selection: text_from_{clipboard,primary}: add 'done' callback This callback is *always* called, including when there has been an error. This is in preparation for making text_from_{clipboard,primary} asynchronous.
2019-11-05 08:49:32 +01:00
void (*dont)(void *user), void *user);
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
void selection_start_scroll_timer(
struct terminal *term, int interval_ns,
enum selection_scroll_direction direction, int col);
void selection_stop_scroll_timer(struct terminal *term);
selection: expose find_word_boundary_{left,right}()
2021-03-28 21:03:53 +02:00
void selection_find_word_boundary_left(
struct terminal *term, struct coord *pos, bool spaces_only);
void selection_find_word_boundary_right(
selection: find_word_boundary_right: add “stop-on-space-to-word-boundary” When true, selection_find_word_boundary_right() behaves as before - it stops as soon as it encounters a character that isn’t of the same *type* as the “initial” character (the last character in the selection). Take this, for example: The Quick Brown Fox The selection will first stop at the end of “the”, then just *before* “quick”, then at the end of “quick”. Then just *before* “brown”, and then at the end of “brown”, and so on. This suits mouse selections pretty good. But when selection_find_word_boundary_right() is used to extend a search match, it’s better to ignore space-to-word character transitions. That is, we want The Quick Brown Fox to first extend to the end of “the”, then immediately to the end of “quick”, then to the end of “brown”, and so on. Setting the ‘stop_to_space_to_word_boundary’ argument to false results in latter behavior. This is now done by search, when executing the “extend-to-word-boundary” and “extend-to-next-whitespace” key bindings.
2022-04-27 18:44:57 +02:00
struct terminal *term, struct coord *pos, bool spaces_only,
bool stop_on_space_to_word_boundary);
selection: add start/end coordinate getters Internally, selection coordinates are *unbounded* (that is, the row numbers may be larger than grid->num_rows) while a selection is ongoing. Only after it has been finalized are the coordinates bounded. This means it isn’t safe to use term->selection.coords.* directly.
2022-04-25 19:59:23 +02:00
struct coord selection_get_start(const struct terminal *term);
struct coord selection_get_end(const struct terminal *term);
Reference in a new issue Copy permalink