Changeset View
Changeset View
Standalone View
Standalone View
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); | |||||
} |