Page MenuHomeFreeBSD
Differential D34411 Diff 103491 contrib/mg/window.c

Changeset View

Standalone View

View Options

contrib/mg/window.c

  • This file was added.
/* $OpenBSD: window.c,v 1.36 2015/11/18 18:21:06 jasper Exp $ */
/* This file is in the public domain. */
/*
* Window handling.
*/
#include <sys/queue.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include "def.h"
struct mgwin *
new_window(struct buffer *bp)
{
struct mgwin *wp;
wp = calloc(1, sizeof(struct mgwin));
if (wp == NULL)
return (NULL);
wp->w_bufp = bp;
wp->w_dotp = NULL;
wp->w_doto = 0;
wp->w_markp = NULL;
wp->w_marko = 0;
wp->w_rflag = 0;
wp->w_frame = 0;
wp->w_wrapline = NULL;
wp->w_dotline = wp->w_markline = 1;
if (bp)
bp->b_nwnd++;
return (wp);
}
/*
* Reposition dot in the current window to line "n". If the argument is
* positive, it is that line. If it is negative it is that line from the
* bottom. If it is 0 the window is centered (this is what the standard
* redisplay code does).
*/
/* ARGSUSED */
int
reposition(int f, int n)
{
curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0;
curwp->w_rflag |= WFFRAME;
sgarbf = TRUE;
return (TRUE);
}
/*
* Refresh the display. A call is made to the "ttresize" entry in the
* terminal handler, which tries to reset "nrow" and "ncol". They will,
* however, never be set outside of the NROW or NCOL range. If the display
* changed size, arrange that everything is redone, then call "update" to
* fix the display. We do this so the new size can be displayed. In the
* normal case the call to "update" in "main.c" refreshes the screen, and
* all of the windows need not be recomputed. This call includes a
* 'force' parameter to ensure that the redraw is done, even after a
* a suspend/continue (where the window size parameters will already
* be updated). Note that when you get to the "display unusable"
* message, the screen will be messed up. If you make the window bigger
* again, and send another command, everything will get fixed!
*/
int
redraw(int f, int n)
{
return (do_redraw(f, n, FALSE));
}
/* ARGSUSED */
int
do_redraw(int f, int n, int force)
{
struct mgwin *wp;
int oldnrow, oldncol;
oldnrow = nrow;
oldncol = ncol;
ttresize();
if (nrow != oldnrow || ncol != oldncol || force) {
/* find last */
wp = wheadp;
while (wp->w_wndp != NULL)
wp = wp->w_wndp;
/* check if too small */
if (nrow < wp->w_toprow + 3) {
dobeep();
ewprintf("Display unusable");
return (FALSE);
}
wp->w_ntrows = nrow - wp->w_toprow - 2;
sgarbf = TRUE;
update(CMODE);
} else
sgarbf = TRUE;
return (TRUE);
}
/*
* The command to make the next window (next => down the screen) the current
* window. There are no real errors, although the command does nothing if
* there is only 1 window on the screen.
*/
/* ARGSUSED */
int
nextwind(int f, int n)
{
struct mgwin *wp;
if ((wp = curwp->w_wndp) == NULL)
wp = wheadp;
curwp = wp;
curbp = wp->w_bufp;
return (TRUE);
}
/* not in GNU Emacs */
/*
* This command makes the previous window (previous => up the screen) the
* current window. There are no errors, although the command does not do
* a lot if there is only 1 window.
*/
/* ARGSUSED */
int
prevwind(int f, int n)
{
struct mgwin *wp1, *wp2;
wp1 = wheadp;
wp2 = curwp;
if (wp1 == wp2)
wp2 = NULL;
while (wp1->w_wndp != wp2)
wp1 = wp1->w_wndp;
curwp = wp1;
curbp = wp1->w_bufp;
return (TRUE);
}
/*
* This command makes the current window the only window on the screen. Try
* to set the framing so that "." does not have to move on the display. Some
* care has to be taken to keep the values of dot and mark in the buffer
* structures right if the destruction of a window makes a buffer become
* undisplayed.
*/
/* ARGSUSED */
int
onlywind(int f, int n)
{
struct mgwin *wp;
struct line *lp;
int i;
while (wheadp != curwp) {
wp = wheadp;
wheadp = wp->w_wndp;
if (--wp->w_bufp->b_nwnd == 0) {
wp->w_bufp->b_dotp = wp->w_dotp;
wp->w_bufp->b_doto = wp->w_doto;
wp->w_bufp->b_markp = wp->w_markp;
wp->w_bufp->b_marko = wp->w_marko;
wp->w_bufp->b_dotline = wp->w_dotline;
wp->w_bufp->b_markline = wp->w_markline;
}
free(wp);
}
while (curwp->w_wndp != NULL) {
wp = curwp->w_wndp;
curwp->w_wndp = wp->w_wndp;
if (--wp->w_bufp->b_nwnd == 0) {
wp->w_bufp->b_dotp = wp->w_dotp;
wp->w_bufp->b_doto = wp->w_doto;
wp->w_bufp->b_markp = wp->w_markp;
wp->w_bufp->b_marko = wp->w_marko;
wp->w_bufp->b_dotline = wp->w_dotline;
wp->w_bufp->b_markline = wp->w_markline;
}
free(wp);
}
lp = curwp->w_linep;
i = curwp->w_toprow;
while (i != 0 && lback(lp) != curbp->b_headp) {
--i;
lp = lback(lp);
}
curwp->w_toprow = 0;
/* 2 = mode, echo */
curwp->w_ntrows = nrow - 2;
curwp->w_linep = lp;
curwp->w_rflag |= WFMODE | WFFULL;
return (TRUE);
}
/*
* Split the current window. A window smaller than 3 lines cannot be split.
* The only other error that is possible is a "malloc" failure allocating the
* structure for the new window.
* If called with a FFOTHARG, flags on the new window are set to 'n'.
*/
/* ARGSUSED */
int
splitwind(int f, int n)
{
struct mgwin *wp, *wp1, *wp2;
struct line *lp;
int ntru, ntrd, ntrl;
if (curwp->w_ntrows < 3) {
dobeep();
ewprintf("Cannot split a %d line window", curwp->w_ntrows);
return (FALSE);
}
wp = new_window(curbp);
if (wp == NULL) {
dobeep();
ewprintf("Unable to create a window");
return (FALSE);
}
/* use the current dot and mark */
wp->w_dotp = curwp->w_dotp;
wp->w_doto = curwp->w_doto;
wp->w_markp = curwp->w_markp;
wp->w_marko = curwp->w_marko;
wp->w_dotline = curwp->w_dotline;
wp->w_markline = curwp->w_markline;
/* figure out which half of the screen we're in */
ntru = (curwp->w_ntrows - 1) / 2; /* Upper size */
ntrl = (curwp->w_ntrows - 1) - ntru; /* Lower size */
for (lp = curwp->w_linep, ntrd = 0; lp != curwp->w_dotp;
lp = lforw(lp))
ntrd++;
lp = curwp->w_linep;
/* old is upper window */
if (ntrd <= ntru) {
/* hit mode line */
if (ntrd == ntru)
lp = lforw(lp);
curwp->w_ntrows = ntru;
wp->w_wndp = curwp->w_wndp;
curwp->w_wndp = wp;
wp->w_toprow = curwp->w_toprow + ntru + 1;
wp->w_ntrows = ntrl;
/* old is lower window */
} else {
wp1 = NULL;
wp2 = wheadp;
while (wp2 != curwp) {
wp1 = wp2;
wp2 = wp2->w_wndp;
}
if (wp1 == NULL)
wheadp = wp;
else
wp1->w_wndp = wp;
wp->w_wndp = curwp;
wp->w_toprow = curwp->w_toprow;
wp->w_ntrows = ntru;
/* mode line */
++ntru;
curwp->w_toprow += ntru;
curwp->w_ntrows = ntrl;
while (ntru--)
lp = lforw(lp);
}
/* adjust the top lines if necessary */
curwp->w_linep = lp;
wp->w_linep = lp;
curwp->w_rflag |= WFMODE | WFFULL;
wp->w_rflag |= WFMODE | WFFULL;
/* if FFOTHARG, set flags) */
if (f & FFOTHARG)
wp->w_flag = n;
return (TRUE);
}
/*
* Enlarge the current window. Find the window that loses space. Make sure
* it is big enough. If so, hack the window descriptions, and ask redisplay
* to do all the hard work. You don't just set "force reframe" because dot
* would move.
*/
/* ARGSUSED */
int
enlargewind(int f, int n)
{
struct mgwin *adjwp;
struct line *lp;
int i;
if (n < 0)
return (shrinkwind(f, -n));
if (wheadp->w_wndp == NULL) {
dobeep();
ewprintf("Only one window");
return (FALSE);
}
if ((adjwp = curwp->w_wndp) == NULL) {
adjwp = wheadp;
while (adjwp->w_wndp != curwp)
adjwp = adjwp->w_wndp;
}
if (adjwp->w_ntrows <= n) {
dobeep();
ewprintf("Impossible change");
return (FALSE);
}
/* shrink below */
if (curwp->w_wndp == adjwp) {
lp = adjwp->w_linep;
for (i = 0; i < n && lp != adjwp->w_bufp->b_headp; ++i)
lp = lforw(lp);
adjwp->w_linep = lp;
adjwp->w_toprow += n;
/* shrink above */
} else {
lp = curwp->w_linep;
for (i = 0; i < n && lback(lp) != curbp->b_headp; ++i)
lp = lback(lp);
curwp->w_linep = lp;
curwp->w_toprow -= n;
}
curwp->w_ntrows += n;
adjwp->w_ntrows -= n;
curwp->w_rflag |= WFMODE | WFFULL;
adjwp->w_rflag |= WFMODE | WFFULL;
return (TRUE);
}
/*
* Shrink the current window. Find the window that gains space. Hack at the
* window descriptions. Ask the redisplay to do all the hard work.
*/
int
shrinkwind(int f, int n)
{
struct mgwin *adjwp;
struct line *lp;
int i;
if (n < 0)
return (enlargewind(f, -n));
if (wheadp->w_wndp == NULL) {
dobeep();
ewprintf("Only one window");
return (FALSE);
}
/*
* Bit of flakiness - FFRAND means it was an internal call, and
* to be trusted implicitly about sizes.
*/
if (!(f & FFRAND) && curwp->w_ntrows <= n) {
dobeep();
ewprintf("Impossible change");
return (FALSE);
}
if ((adjwp = curwp->w_wndp) == NULL) {
adjwp = wheadp;
while (adjwp->w_wndp != curwp)
adjwp = adjwp->w_wndp;
}
/* grow below */
if (curwp->w_wndp == adjwp) {
lp = adjwp->w_linep;
for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_headp; ++i)
lp = lback(lp);
adjwp->w_linep = lp;
adjwp->w_toprow -= n;
/* grow above */
} else {
lp = curwp->w_linep;
for (i = 0; i < n && lp != curbp->b_headp; ++i)
lp = lforw(lp);
curwp->w_linep = lp;
curwp->w_toprow += n;
}
curwp->w_ntrows -= n;
adjwp->w_ntrows += n;
curwp->w_rflag |= WFMODE | WFFULL;
adjwp->w_rflag |= WFMODE | WFFULL;
return (TRUE);
}
/*
* Delete current window. Call shrink-window to do the screen updating, then
* throw away the window.
*/
/* ARGSUSED */
int
delwind(int f, int n)
{
struct mgwin *wp, *nwp;
wp = curwp; /* Cheap... */
/* shrinkwind returning false means only one window... */
if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE)
return (FALSE);
if (--wp->w_bufp->b_nwnd == 0) {
wp->w_bufp->b_dotp = wp->w_dotp;
wp->w_bufp->b_doto = wp->w_doto;
wp->w_bufp->b_markp = wp->w_markp;
wp->w_bufp->b_marko = wp->w_marko;
wp->w_bufp->b_dotline = wp->w_dotline;
wp->w_bufp->b_markline = wp->w_markline;
}
/* since shrinkwind did't crap out, we know we have a second window */
if (wp == wheadp)
wheadp = curwp = wp->w_wndp;
else if ((curwp = wp->w_wndp) == NULL)
curwp = wheadp;
curbp = curwp->w_bufp;
for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp)
if (nwp->w_wndp == wp) {
nwp->w_wndp = wp->w_wndp;
break;
}
free(wp);
return (TRUE);
}