--- /dev/null
+/* $OpenBSD: window.c,v 1.28 2011/08/01 12:15:23 lum Exp $ */
+
+/* This file is in the public domain. */
+
+/*
+ * Window handling.
+ */
+
+#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). If GOSREC is undefined, default is 0, so it acts
+ * like GNU. If GOSREC is defined, with no argument it defaults to 1 and
+ * works like in Gosling.
+ */
+/* ARGSUSED */
+int
+reposition(int f, int n)
+{
+#ifndef GOSREC
+ curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0;
+#else /* !GOSREC */
+ curwp->w_frame = n;
+#endif /* !GOSREC */
+ 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) {
+ ewprintf("Display unusable");
+ return (FALSE);
+ }
+ wp->w_ntrows = nrow - wp->w_toprow - 2;
+ sgarbf = TRUE;
+ update();
+ } 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;
+ }
+ 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;
+ }
+ 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) {
+ ewprintf("Cannot split a %d line window", curwp->w_ntrows);
+ return (FALSE);
+ }
+ wp = new_window(curbp);
+ if (wp == NULL) {
+ 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) {
+ 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) {
+ 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) {
+ ewprintf("Only one window");
+ return (FALSE);
+ }
+ /*
+ * Bit of flakiness - KRANDOM means it was an internal call, and
+ * to be trusted implicitly about sizes.
+ */
+ if (!(f & FFRAND) && curwp->w_ntrows <= n) {
+ 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;
+ }
+
+ /* 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);
+}
projects / pd_readline / blobdiff