/* * $Xorg: cursor.c,v 1.3 2000/08/17 19:55:08 cpqbld Exp $ */ /* $XFree86: xc/programs/xterm/cursor.c,v 3.15 2002/04/28 19:04:20 dickey Exp $ */ /* * Copyright 2002 by Thomas E. Dickey * * All Rights Reserved * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * Except as contained in this notice, the name(s) of the above copyright * holders shall not be used in advertising or otherwise to promote the * sale, use or other dealings in this Software without prior written * authorization. * * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. * * All Rights Reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, * provided that the above copyright notice appear in all copies and that * both that copyright notice and this permission notice appear in * supporting documentation, and that the name of Digital Equipment * Corporation not be used in advertising or publicity pertaining to * distribution of the software without specific, written prior permission. * * * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ /* cursor.c */ #include <xterm.h> #include <data.h> /* * Clear the selection if the cursor moves "before" the current position. * Moving "after" is ok. * * That sounds fine - if the cursor really had anything direct relationship to * the selection. For instance, if the cursor moved due to command line * editing, it would be nice to deselect. However, what that means in practice * is that a fullscreen program which scrolls back a line will (because it must * temporarily reposition the cursor) clear the selection. * * However, it has an indirect relationship to the selection - we want to * prevent the application from changing the screen contents under the * highlighted region. */ #define _CheckSelection(screen) \ if ((screen->cur_row < screen->endHRow) || \ (screen->cur_row == screen->endHRow && \ screen->cur_col < screen->endHCol)) \ DisownSelection(term); /* * Moves the cursor to the specified position, checking for bounds. * (this includes scrolling regions) * The origin is considered to be 0, 0 for this procedure. */ void CursorSet(register TScreen * screen, register int row, register int col, unsigned flags) { register int maxr; col = (col < 0 ? 0 : col); screen->cur_col = (col <= screen->max_col ? col : screen->max_col); maxr = screen->max_row; if (flags & ORIGIN) { row += screen->top_marg; maxr = screen->bot_marg; } row = (row < 0 ? 0 : row); screen->cur_row = (row <= maxr ? row : maxr); screen->do_wrap = 0; _CheckSelection(screen); } /* * moves the cursor left n, no wrap around */ void CursorBack(register TScreen * screen, int n) { register int i, j, k, rev; if ((rev = (term->flags & (REVERSEWRAP | WRAPAROUND)) == (REVERSEWRAP | WRAPAROUND)) != 0 && screen->do_wrap) n--; if ((screen->cur_col -= n) < 0) { if (rev) { if ((i = ((j = screen->max_col + 1) * screen->cur_row) + screen->cur_col) < 0) { k = j * (screen->max_row + 1); i += ((-i) / k + 1) * k; } screen->cur_row = i / j; screen->cur_col = i % j; } else screen->cur_col = 0; } screen->do_wrap = 0; _CheckSelection(screen); } /* * moves the cursor forward n, no wraparound */ void CursorForward(register TScreen * screen, int n) { screen->cur_col += n; if (screen->cur_col > CurMaxCol(screen, screen->cur_row)) screen->cur_col = CurMaxCol(screen, screen->cur_row); screen->do_wrap = 0; _CheckSelection(screen); } /* * moves the cursor down n, no scrolling. * Won't pass bottom margin or bottom of screen. */ void CursorDown(register TScreen * screen, int n) { register int max; max = (screen->cur_row > screen->bot_marg ? screen->max_row : screen->bot_marg); screen->cur_row += n; if (screen->cur_row > max) screen->cur_row = max; screen->do_wrap = 0; _CheckSelection(screen); } /* * moves the cursor up n, no linestarving. * Won't pass top margin or top of screen. */ void CursorUp(register TScreen * screen, int n) { register int min; min = (screen->cur_row < screen->top_marg ? 0 : screen->top_marg); screen->cur_row -= n; if (screen->cur_row < min) screen->cur_row = min; screen->do_wrap = 0; _CheckSelection(screen); } /* * Moves cursor down amount lines, scrolls if necessary. * Won't leave scrolling region. No carriage return. */ void xtermIndex(register TScreen * screen, register int amount) { register int j; /* * indexing when below scrolling region is cursor down. * if cursor high enough, no scrolling necessary. */ if (screen->cur_row > screen->bot_marg || screen->cur_row + amount <= screen->bot_marg) { CursorDown(screen, amount); return; } CursorDown(screen, j = screen->bot_marg - screen->cur_row); xtermScroll(screen, amount - j); } /* * Moves cursor up amount lines, reverse scrolls if necessary. * Won't leave scrolling region. No carriage return. */ void RevIndex(register TScreen * screen, register int amount) { /* * reverse indexing when above scrolling region is cursor up. * if cursor low enough, no reverse indexing needed */ if (screen->cur_row < screen->top_marg || screen->cur_row - amount >= screen->top_marg) { CursorUp(screen, amount); return; } RevScroll(screen, amount - (screen->cur_row - screen->top_marg)); CursorUp(screen, screen->cur_row - screen->top_marg); } /* * Moves Cursor To First Column In Line * (Note: xterm doesn't implement SLH, SLL which would affect use of this) */ void CarriageReturn(register TScreen * screen) { screen->cur_col = 0; screen->do_wrap = 0; _CheckSelection(screen); } /* * Save Cursor and Attributes */ void CursorSave(register XtermWidget tw) { register TScreen *screen = &tw->screen; register SavedCursor *sc = &screen->sc[screen->alternate != False]; sc->saved = True; sc->row = screen->cur_row; sc->col = screen->cur_col; sc->flags = tw->flags; sc->curgl = screen->curgl; sc->curgr = screen->curgr; #if OPT_ISO_COLORS sc->cur_foreground = tw->cur_foreground; sc->cur_background = tw->cur_background; sc->sgr_foreground = tw->sgr_foreground; #endif memmove(sc->gsets, screen->gsets, sizeof(screen->gsets)); } /* * We save/restore all visible attributes, plus wrapping, origin mode, and the * selective erase attribute. */ #define DECSC_FLAGS (ATTRIBUTES|ORIGIN|WRAPAROUND|PROTECTED) /* * Restore Cursor and Attributes */ void CursorRestore(register XtermWidget tw) { register TScreen *screen = &tw->screen; register SavedCursor *sc = &screen->sc[screen->alternate != False]; /* Restore the character sets, unless we never did a save-cursor op. * In that case, we'll reset the character sets. */ if (sc->saved) { memmove(screen->gsets, sc->gsets, sizeof(screen->gsets)); screen->curgl = sc->curgl; screen->curgr = sc->curgr; } else { resetCharsets(screen); } tw->flags &= ~DECSC_FLAGS; tw->flags |= sc->flags & DECSC_FLAGS; CursorSet(screen, ((tw->flags & ORIGIN) ? sc->row - screen->top_marg : sc->row), sc->col, tw->flags); #if OPT_ISO_COLORS tw->sgr_foreground = sc->sgr_foreground; SGR_Foreground(tw->flags & FG_COLOR ? sc->cur_foreground : -1); SGR_Background(tw->flags & BG_COLOR ? sc->cur_background : -1); #endif } /* * Move the cursor to the first column of the n-th next line. */ void CursorNextLine(TScreen * screen, int count) { CursorDown(screen, count < 1 ? 1 : count); CarriageReturn(screen); do_xevents(); } /* * Move the cursor to the first column of the n-th previous line. */ void CursorPrevLine(TScreen * screen, int count) { CursorUp(screen, count < 1 ? 1 : count); CarriageReturn(screen); do_xevents(); }