707 lines
18 KiB
C
707 lines
18 KiB
C
/* $NetBSD: selection.c,v 1.12 2023/02/07 20:37:48 mlelstv Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2002, 2003, 2004, 2007 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Julio M. Merino Vidal.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. The name authors may not be used to endorse or promote products
|
|
* derived from this software without specific prior written
|
|
* permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: selection.c,v 1.12 2023/02/07 20:37:48 mlelstv Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/tty.h>
|
|
#include <dev/wscons/wsconsio.h>
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <err.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "pathnames.h"
|
|
#include "wsmoused.h"
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Public interface exported by the `selection' mode.
|
|
*/
|
|
|
|
int selection_startup(struct mouse *m);
|
|
int selection_cleanup(void);
|
|
void selection_wsmouse_event(struct wscons_event);
|
|
void selection_wscons_event(struct wscons_event, int);
|
|
void selection_poll_timeout(void);
|
|
|
|
struct mode_bootstrap Selection_Mode = {
|
|
"selection",
|
|
selection_startup,
|
|
selection_cleanup,
|
|
selection_wsmouse_event,
|
|
selection_wscons_event,
|
|
selection_poll_timeout
|
|
};
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Structures used in this module only.
|
|
*/
|
|
|
|
/* The `selarea' structure is used to describe a selection in the screen.
|
|
It also holds a copy of the selected text. */
|
|
struct selarea {
|
|
size_t sa_x1; /* Start column */
|
|
size_t sa_y1; /* Start row */
|
|
size_t sa_x2; /* End column */
|
|
size_t sa_y2; /* End row */
|
|
size_t sa_startoff; /* Absolute offset of start position */
|
|
size_t sa_endoff; /* Absolute offset of end position */
|
|
size_t sa_buflen; /* Length of selected text */
|
|
char *sa_buf; /* A copy of the selected text */
|
|
};
|
|
|
|
/* The `selmouse' structure extends the `mouse' structure adding all fields
|
|
required for this module to work. */
|
|
struct selmouse {
|
|
struct mouse *sm_mouse; /* Pointer to parent structure */
|
|
|
|
int sm_ttyfd; /* Active TTY file descriptor */
|
|
|
|
size_t sm_x; /* Mouse pointer column */
|
|
size_t sm_y; /* Mouse pointer row */
|
|
size_t sm_max_x; /* Maximun column allowed */
|
|
size_t sm_max_y; /* Maximun row allowed */
|
|
|
|
size_t sm_slowdown_x; /* X axis slowdown */
|
|
size_t sm_slowdown_y; /* Y axis slowdown */
|
|
size_t sm_count_x; /* Number of X movements skipped */
|
|
size_t sm_count_y; /* Number of Y movements skipped */
|
|
|
|
int sm_visible; /* Whether pointer is visible or not */
|
|
int sm_selecting; /* Whether we are selecting or not */
|
|
|
|
int sm_but_select; /* Button number to select an area */
|
|
int sm_but_paste; /* Button number to paste buffer */
|
|
};
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Global variables.
|
|
*/
|
|
|
|
static struct selmouse Selmouse;
|
|
static struct selarea Selarea;
|
|
static int Initialized = 0;
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Prototypes for functions private to this module.
|
|
*/
|
|
|
|
static void cursor_hide(void);
|
|
static void cursor_show(void);
|
|
static void open_tty(int);
|
|
static void char_invert(size_t, size_t);
|
|
static void *alloc_sel(size_t);
|
|
static char *fill_buf(char *, size_t, size_t, size_t);
|
|
static size_t row_length(size_t);
|
|
static void selarea_copy_text(void);
|
|
static void selarea_start(void);
|
|
static void selarea_end(void);
|
|
static void selarea_calculate(void);
|
|
static void selarea_getrowcol(size_t, size_t *, size_t *);
|
|
static void selarea_hide(void);
|
|
static void selarea_show(void);
|
|
static void selarea_paste(void);
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Mode initialization. Reads configuration, checks if the kernel has
|
|
* support for mouse pointer and opens required files. */
|
|
int
|
|
selection_startup(struct mouse *m)
|
|
{
|
|
int i;
|
|
struct wsdisplay_char ch;
|
|
struct block *conf;
|
|
|
|
if (Initialized) {
|
|
log_warnx("selection mode already initialized");
|
|
return 1;
|
|
}
|
|
|
|
(void)memset(&Selmouse, 0, sizeof(struct selmouse));
|
|
Selmouse.sm_mouse = m;
|
|
|
|
conf = config_get_mode("selection");
|
|
Selmouse.sm_slowdown_x = block_get_propval_int(conf, "slowdown_x", 0);
|
|
Selmouse.sm_slowdown_y = block_get_propval_int(conf, "slowdown_y", 3);
|
|
if (block_get_propval_int(conf, "lefthanded", 0)) {
|
|
Selmouse.sm_but_select = 2;
|
|
Selmouse.sm_but_paste = 0;
|
|
} else {
|
|
Selmouse.sm_but_select = 0;
|
|
Selmouse.sm_but_paste = 2;
|
|
}
|
|
|
|
/* Open current tty */
|
|
(void)ioctl(Selmouse.sm_mouse->m_statfd, WSDISPLAYIO_GETACTIVESCREEN,
|
|
&i);
|
|
Selmouse.sm_ttyfd = -1;
|
|
open_tty(i);
|
|
|
|
/* Check if the kernel has character functions */
|
|
ch.row = ch.col = 0;
|
|
if (ioctl(Selmouse.sm_ttyfd, WSDISPLAYIO_GETWSCHAR, &ch) < 0) {
|
|
(void)close(Selmouse.sm_ttyfd);
|
|
log_warn("ioctl(WSDISPLAYIO_GETWSCHAR) failed");
|
|
return 0;
|
|
}
|
|
|
|
assert(Selmouse.sm_max_y != 0); /* Initialized by open_tty above. */
|
|
assert(Selmouse.sm_max_x != 0); /* Initialized by open_tty above. */
|
|
Selmouse.sm_y = Selmouse.sm_max_y / 2;
|
|
Selmouse.sm_x = Selmouse.sm_max_x / 2;
|
|
Selmouse.sm_count_y = 0;
|
|
Selmouse.sm_count_x = 0;
|
|
Selmouse.sm_visible = 0;
|
|
Selmouse.sm_selecting = 0;
|
|
Initialized = 1;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Mode cleanup. */
|
|
int
|
|
selection_cleanup(void)
|
|
{
|
|
|
|
cursor_hide();
|
|
if (Selmouse.sm_ttyfd >= 0)
|
|
(void)close(Selmouse.sm_ttyfd);
|
|
return 1;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Parse wsmouse events. Both motion and button events are handled. The
|
|
* former move the mouse across the screen and the later create a new
|
|
* selection or paste the buffer. */
|
|
void
|
|
selection_wsmouse_event(struct wscons_event evt)
|
|
{
|
|
const struct wsmouse_calibcoords *abs = &Selmouse.sm_mouse->m_calib;
|
|
|
|
if (IS_MOTION_EVENT(evt.type)) {
|
|
if (Selmouse.sm_selecting)
|
|
selarea_hide();
|
|
cursor_hide();
|
|
|
|
switch (evt.type) {
|
|
case WSCONS_EVENT_MOUSE_DELTA_X:
|
|
if (Selmouse.sm_count_x >= Selmouse.sm_slowdown_x) {
|
|
Selmouse.sm_count_x = 0;
|
|
if (evt.value > 0)
|
|
Selmouse.sm_x++;
|
|
else if (Selmouse.sm_x != 0)
|
|
Selmouse.sm_x--;
|
|
if (Selmouse.sm_x > Selmouse.sm_max_x)
|
|
Selmouse.sm_x = Selmouse.sm_max_x;
|
|
} else
|
|
Selmouse.sm_count_x++;
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_DELTA_Y:
|
|
if (Selmouse.sm_count_y >= Selmouse.sm_slowdown_y) {
|
|
Selmouse.sm_count_y = 0;
|
|
if (evt.value < 0)
|
|
Selmouse.sm_y++;
|
|
else if (Selmouse.sm_y != 0)
|
|
Selmouse.sm_y--;
|
|
if (Selmouse.sm_y > Selmouse.sm_max_y)
|
|
Selmouse.sm_y = Selmouse.sm_max_y;
|
|
} else
|
|
Selmouse.sm_count_y++;
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_DELTA_Z: /* FALLTHROUGH */
|
|
case WSCONS_EVENT_MOUSE_DELTA_W:
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_ABSOLUTE_X:
|
|
if (!Selmouse.sm_mouse->m_doabs)
|
|
break;
|
|
/* max x is inclusive in both selmouse and tpcalib */
|
|
Selmouse.sm_x
|
|
= ((evt.value - abs->minx) * (Selmouse.sm_max_x + 1))
|
|
/ (abs->maxx - abs->minx + 1);
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_ABSOLUTE_Y:
|
|
if (!Selmouse.sm_mouse->m_doabs)
|
|
break;
|
|
/* max y is inclusive in both selmouse and tpcalib */
|
|
Selmouse.sm_y
|
|
= ((evt.value - abs->miny) * (Selmouse.sm_max_y + 1))
|
|
/ (abs->maxy - abs->miny + 1);
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_ABSOLUTE_Z: /* FALLTHROUGH */
|
|
case WSCONS_EVENT_MOUSE_ABSOLUTE_W:
|
|
break;
|
|
|
|
default:
|
|
log_warnx("unknown event");
|
|
}
|
|
|
|
if (Selmouse.sm_selecting)
|
|
selarea_show();
|
|
cursor_show();
|
|
|
|
} else if (IS_BUTTON_EVENT(evt.type)) {
|
|
switch (evt.type) {
|
|
case WSCONS_EVENT_MOUSE_UP:
|
|
if (evt.value == Selmouse.sm_but_select) {
|
|
/* End selection */
|
|
selarea_end();
|
|
selarea_hide();
|
|
}
|
|
break;
|
|
|
|
case WSCONS_EVENT_MOUSE_DOWN:
|
|
if (evt.value == Selmouse.sm_but_select) {
|
|
/* Start selection */
|
|
selarea_start();
|
|
cursor_hide();
|
|
selarea_show();
|
|
} else if (evt.value == Selmouse.sm_but_paste) {
|
|
/* Paste selection */
|
|
selarea_paste();
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
log_warnx("unknown button event");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Parse wscons status events. */
|
|
void
|
|
selection_wscons_event(struct wscons_event evt, int preclose)
|
|
{
|
|
|
|
switch (evt.type) {
|
|
case WSCONS_EVENT_SCREEN_SWITCH:
|
|
if (preclose) {
|
|
if (Selmouse.sm_selecting)
|
|
selarea_hide();
|
|
cursor_hide();
|
|
} else {
|
|
if (!Selmouse.sm_mouse->m_disabled)
|
|
open_tty(evt.value);
|
|
|
|
cursor_show();
|
|
if (Selmouse.sm_selecting)
|
|
selarea_show();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Device polling has timed out, so we hide the mouse to avoid further
|
|
* console pollution. */
|
|
void
|
|
selection_poll_timeout(void)
|
|
{
|
|
|
|
if (!Selmouse.sm_selecting)
|
|
cursor_hide();
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Hides the mouse pointer, if visible. */
|
|
static void
|
|
cursor_hide(void)
|
|
{
|
|
|
|
if (Selmouse.sm_visible) {
|
|
char_invert(Selmouse.sm_y, Selmouse.sm_x);
|
|
Selmouse.sm_visible = 0;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Shows the mouse pointer, if not visible. */
|
|
static void
|
|
cursor_show(void)
|
|
{
|
|
|
|
if (!Selmouse.sm_visible) {
|
|
char_invert(Selmouse.sm_y, Selmouse.sm_x);
|
|
Selmouse.sm_visible = 1;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Opens the specified TTY device, used when switching consoles.
|
|
* Takes care to adjust the pointer status to make sense within the new
|
|
* console, whose dimensions may differ from the previous one. */
|
|
static void
|
|
open_tty(int ttyno)
|
|
{
|
|
char buf[20];
|
|
struct winsize ws;
|
|
|
|
if (Selmouse.sm_ttyfd >= 0)
|
|
(void)close(Selmouse.sm_ttyfd);
|
|
|
|
(void)snprintf(buf, sizeof(buf), _PATH_TTYPREFIX "%d", ttyno);
|
|
Selmouse.sm_ttyfd = open(buf, O_RDONLY | O_NONBLOCK);
|
|
if (Selmouse.sm_ttyfd < 0)
|
|
log_warnx("cannot open %s", buf);
|
|
|
|
/* Get terminal size and update the maximum cursor coordinates. */
|
|
if (ioctl(Selmouse.sm_ttyfd, TIOCGWINSZ, &ws) < 0) {
|
|
log_warn("cannot get terminal size");
|
|
/* Some defaults; not guaranteed to be correct but we
|
|
* cannot do better. */
|
|
Selmouse.sm_max_y = 24;
|
|
Selmouse.sm_max_x = 79;
|
|
} else {
|
|
Selmouse.sm_max_y = ws.ws_row - 1;
|
|
Selmouse.sm_max_x = ws.ws_col - 1;
|
|
}
|
|
|
|
/* Adjust current mouse position in case the terminal's size has
|
|
* changed. */
|
|
if (Selmouse.sm_x > Selmouse.sm_max_x)
|
|
Selmouse.sm_x = Selmouse.sm_max_x;
|
|
if (Selmouse.sm_y > Selmouse.sm_max_y)
|
|
Selmouse.sm_y = Selmouse.sm_max_y;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Flips the background and foreground colors of the specified screen
|
|
* position. */
|
|
static void
|
|
char_invert(size_t row, size_t col)
|
|
{
|
|
int t;
|
|
struct wsdisplay_char ch;
|
|
|
|
ch.row = row;
|
|
ch.col = col;
|
|
|
|
if (ioctl(Selmouse.sm_ttyfd, WSDISPLAYIO_GETWSCHAR, &ch) == -1) {
|
|
log_warn("ioctl(WSDISPLAYIO_GETWSCHAR) failed");
|
|
return;
|
|
}
|
|
|
|
t = ch.foreground;
|
|
ch.foreground = ch.background;
|
|
ch.background = t;
|
|
|
|
if (ioctl(Selmouse.sm_ttyfd, WSDISPLAYIO_PUTWSCHAR, &ch) == -1)
|
|
log_warn("ioctl(WSDISPLAYIO_PUTWSCHAR) failed");
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Allocates memory for a selection. This function is very simple but is
|
|
* used to get a consistent warning message. */
|
|
static void *
|
|
alloc_sel(size_t len)
|
|
{
|
|
void *ptr;
|
|
|
|
ptr = malloc(len);
|
|
if (ptr == NULL)
|
|
log_warn("cannot allocate memory for selection (%lu bytes)",
|
|
(unsigned long)len);
|
|
return ptr;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Copies a region of a line inside the buffer pointed by `ptr'. */
|
|
static char *
|
|
fill_buf(char *ptr, size_t row, size_t col, size_t end)
|
|
{
|
|
struct wsdisplay_char ch;
|
|
|
|
ch.row = row;
|
|
for (ch.col = col; ch.col < end; ch.col++) {
|
|
if (ioctl(Selmouse.sm_ttyfd, WSDISPLAYIO_GETWSCHAR,
|
|
&ch) == -1) {
|
|
log_warn("ioctl(WSDISPLAYIO_GETWSCHAR) failed");
|
|
*ptr++ = ' ';
|
|
} else {
|
|
*ptr++ = ch.letter;
|
|
}
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Scans the specified line and checks its length. Characters at the end
|
|
* of it which match isspace() are discarded. */
|
|
static size_t
|
|
row_length(size_t row)
|
|
{
|
|
struct wsdisplay_char ch;
|
|
|
|
ch.col = Selmouse.sm_max_x;
|
|
ch.row = row;
|
|
do {
|
|
if (ioctl(Selmouse.sm_ttyfd, WSDISPLAYIO_GETWSCHAR, &ch) == -1)
|
|
log_warn("ioctl(WSDISPLAYIO_GETWSCHAR) failed");
|
|
ch.col--;
|
|
} while (isspace((unsigned char)ch.letter) && ch.col >= 0);
|
|
return ch.col + 2;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Copies all the text selected to the selection buffer. Whitespace at
|
|
* end of lines is trimmed. */
|
|
static void
|
|
selarea_copy_text(void)
|
|
{
|
|
char *ptr, *str;
|
|
size_t l, r;
|
|
|
|
ptr = NULL; /* XXXGCC -Wuninitialized */
|
|
|
|
if (Selarea.sa_y1 == Selarea.sa_y2) {
|
|
/* Selection is one row */
|
|
l = row_length(Selarea.sa_y1);
|
|
if (Selarea.sa_x1 > l)
|
|
/* Selection is after last character,
|
|
* therefore it is empty */
|
|
str = NULL;
|
|
else {
|
|
if (Selarea.sa_x2 > l)
|
|
Selarea.sa_x2 = l;
|
|
ptr = str =
|
|
alloc_sel(Selarea.sa_x2 - Selarea.sa_x1 + 1);
|
|
if (ptr == NULL)
|
|
return;
|
|
|
|
ptr = fill_buf(ptr, Selarea.sa_y1, Selarea.sa_x1,
|
|
Selarea.sa_x2);
|
|
*ptr = '\0';
|
|
}
|
|
} else {
|
|
/* Selection is multiple rows */
|
|
ptr = str =
|
|
alloc_sel(Selarea.sa_endoff - Selarea.sa_startoff + 1);
|
|
if (ptr == NULL)
|
|
return;
|
|
|
|
/* Calculate and copy first line */
|
|
l = row_length(Selarea.sa_y1);
|
|
if (Selarea.sa_x1 < l) {
|
|
ptr = fill_buf(ptr, Selarea.sa_y1, Selarea.sa_x1, l);
|
|
*ptr++ = '\r';
|
|
}
|
|
|
|
/* Copy mid lines if there are any */
|
|
if ((Selarea.sa_y2 - Selarea.sa_y1) > 1) {
|
|
for (r = Selarea.sa_y1 + 1; r <= Selarea.sa_y2 - 1;
|
|
r++) {
|
|
ptr = fill_buf(ptr, r, 0, row_length(r));
|
|
*ptr++ = '\r';
|
|
}
|
|
}
|
|
|
|
/* Calculate and copy end line */
|
|
l = row_length(Selarea.sa_y2);
|
|
if (Selarea.sa_x2 < l)
|
|
l = Selarea.sa_x2;
|
|
ptr = fill_buf(ptr, Selarea.sa_y2, 0, l);
|
|
*ptr = '\0';
|
|
}
|
|
|
|
if (Selarea.sa_buf != NULL) {
|
|
free(Selarea.sa_buf);
|
|
Selarea.sa_buf = NULL;
|
|
}
|
|
|
|
if (str != NULL) {
|
|
Selarea.sa_buf = str;
|
|
Selarea.sa_buflen = ptr - str;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Starts a selection. */
|
|
static void
|
|
selarea_start(void)
|
|
{
|
|
|
|
if (Selarea.sa_buf != NULL) {
|
|
free(Selarea.sa_buf);
|
|
Selarea.sa_buf = NULL;
|
|
}
|
|
|
|
Selarea.sa_y1 = Selmouse.sm_y;
|
|
Selarea.sa_x1 = Selmouse.sm_x;
|
|
selarea_calculate();
|
|
Selmouse.sm_selecting = 1;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Ends a selection. Highlighted text is copied to the buffer. */
|
|
static void
|
|
selarea_end(void)
|
|
{
|
|
size_t i;
|
|
|
|
selarea_calculate();
|
|
|
|
/* Invert sel coordinates if needed */
|
|
if (Selarea.sa_x1 > Selarea.sa_x2) {
|
|
i = Selarea.sa_x2;
|
|
Selarea.sa_x2 = Selarea.sa_x1;
|
|
Selarea.sa_x1 = i;
|
|
}
|
|
if (Selarea.sa_y1 > Selarea.sa_y2) {
|
|
i = Selarea.sa_y2;
|
|
Selarea.sa_y2 = Selarea.sa_y1;
|
|
Selarea.sa_y1 = i;
|
|
}
|
|
|
|
selarea_copy_text();
|
|
Selmouse.sm_selecting = 0;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Calculates selection absolute positions in the screen buffer. */
|
|
static void
|
|
selarea_calculate(void)
|
|
{
|
|
size_t i;
|
|
|
|
i = Selmouse.sm_max_x + 1;
|
|
Selarea.sa_y2 = Selmouse.sm_y;
|
|
Selarea.sa_x2 = Selmouse.sm_x;
|
|
Selarea.sa_startoff = Selarea.sa_y1 * i + Selarea.sa_x1;
|
|
Selarea.sa_endoff = Selarea.sa_y2 * i + Selarea.sa_x2;
|
|
|
|
if (Selarea.sa_startoff > Selarea.sa_endoff) {
|
|
i = Selarea.sa_endoff;
|
|
Selarea.sa_endoff = Selarea.sa_startoff;
|
|
Selarea.sa_startoff = i;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Turns selection absolute position in the screen buffer back into
|
|
row, col co-ordinates */
|
|
static void
|
|
selarea_getrowcol(size_t pos, size_t* row, size_t* col)
|
|
{
|
|
size_t xres = Selmouse.sm_max_x + 1;
|
|
|
|
*row = pos / xres;
|
|
*col = pos - (*row * xres);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Hides the highlighted region, returning it to normal colors. */
|
|
static void
|
|
selarea_hide(void)
|
|
{
|
|
size_t i, row, col;
|
|
|
|
for (i = Selarea.sa_startoff; i <= Selarea.sa_endoff; i++) {
|
|
selarea_getrowcol(i, &row, &col);
|
|
char_invert(row, col);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Highlights the selected region. */
|
|
static void
|
|
selarea_show(void)
|
|
{
|
|
size_t i, row, col;
|
|
|
|
selarea_calculate();
|
|
for (i = Selarea.sa_startoff; i <= Selarea.sa_endoff; i++) {
|
|
selarea_getrowcol(i, &row, &col);
|
|
char_invert(row, col);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Pastes selected text into the active console. */
|
|
static void
|
|
selarea_paste(void)
|
|
{
|
|
size_t i;
|
|
|
|
if (Selarea.sa_buf == NULL)
|
|
return;
|
|
for (i = 0; i < Selarea.sa_buflen; i++)
|
|
if (ioctl(Selmouse.sm_ttyfd, TIOCSTI,
|
|
&Selarea.sa_buf[i]) == -1)
|
|
log_warn("ioctl(TIOCSTI)");
|
|
}
|