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

82 lines
3 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
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
bool selection_enabled(const struct terminal *term, struct seat *seat);
selection: track selection type; normal or block selection
2020-01-03 23:29:45 +01:00
void selection_start(
struct terminal *term, int col, int row, enum selection_kind kind);
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);
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
void selection_extend( struct seat *seat, struct terminal *term,
int col, int row, uint32_t serial);
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: 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);
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
void selection_mark_word(
struct seat *seat, struct terminal *term, int col, int row,
bool spaces_only, uint32_t serial);
void selection_mark_row(
struct seat *seat, struct terminal *term, int row, uint32_t serial);
selection: add support for pasting from clipboard
2019-07-11 12:33:31 +02:00
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);
Reference in a new issue Copy permalink