/* Word wrap on n-spaces. Back-over whatever precedes the point on the current
* line and stop on the first word-break or the beginning of the line. If we
* reach the beginning of the line, jump back to the end of the word and start
* a new line. Otherwise, break the line at the word-break, eat it, and jump
* back to the end of the word.
* Returns TRUE on success, FALSE on errors.
*/
wrapword()
{
register int cnt; /* size of word wrapped to next line */
register int bp; /* index to wrap on */
register int first = -1;
register int i;
if(curwp->w_doto <= 0) /* no line to wrap? */
return(FALSE);
for(bp = cnt = i = 0; cnt < llength(curwp->w_dotp) && !bp; cnt++, i++){
if(isspace((unsigned char) lgetc(curwp->w_dotp, cnt).c)){
first = 0;
if(lgetc(curwp->w_dotp, cnt).c == TAB)
while(i+1 & 0x07)
i++;
}
else if(!first)
first = cnt;
if(first > 0 && i >= fillcol)
bp = first;
}
if(!bp)
return(FALSE);
/* bp now points to the first character of the next line */
cnt = curwp->w_doto - bp;
curwp->w_doto = bp;
if(!lnewline()) /* break the line */
return(FALSE);
/*
* if there's a line below, it doesn't start with whitespace
* and there's room for this line...
*/
if(!(curbp->b_flag & BFWRAPOPEN)
&& lforw(curwp->w_dotp) != curbp->b_linep
&& llength(lforw(curwp->w_dotp))
&& !isspace((unsigned char) lgetc(lforw(curwp->w_dotp), 0).c)
&& (llength(curwp->w_dotp) + llength(lforw(curwp->w_dotp)) < fillcol)){
gotoeol(0, 1); /* then pull text up from below */
if(lgetc(curwp->w_dotp, curwp->w_doto - 1).c != ' ')
linsert(1, ' ');
forwdel(0, 1);
gotobol(0, 1);
}
curbp->b_flag &= ~BFWRAPOPEN; /* don't open new line next wrap */
/* restore dot (account for NL) */
if(cnt && !forwchar(0, cnt < 0 ? cnt-1 : cnt))
return(FALSE);
return(TRUE);
}
/*
* Delete backwards. This is quite easy too, because it's all done with other
* functions. Just move the cursor back, and delete forwards. Like delete
* forward, this actually does a kill if presented with an argument. Bound to
* both "RUBOUT" and "C-H"
*/
int backdel(int f, int n)
{
int s;
if (n < 0)
return (forwdel(f, -n));
if (f != FALSE)
{ /* Really a kill */
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
}
if ((s = backchar(f, n)) == TRUE)
s = ldelete(n, f);
return (s);
}
/*
* breplace - replace the current window's text with the given
* LINEs
*/
void
breplace(void *w)
{
register LINE *lp;
register LINE *fp;
fp = lforw(curbp->b_linep);
while((lp = fp) != curbp->b_linep){ /* blast old lines */
fp = lforw(lp);
free(lp);
}
free(curbp->b_linep);
curbp->b_linep = PT(w)->linep; /* arrange pointers */
/*
* Undo space-stuffing that was done when we were preparing to send.
* Some error happened so we're back to the composer.
*/
if(Pmaster && Pmaster->space_stuffed){
Pmaster->space_stuffed = 0;
for(lp = lforw(curbp->b_linep); lp != curbp->b_linep; lp = lforw(lp)){
if(llength(lp) && ucs4_isspace(lgetc(lp, 0).c)){
curwp->w_dotp = lp;
curwp->w_doto = 0;
forwdel(FALSE,1);
}
}
}
curwp->w_linep = lforw(curbp->b_linep);
curwp->w_dotp = lforw(curbp->b_linep);
curwp->w_doto = 0;
curwp->w_markp = curwp->w_imarkp = NULL;
curwp->w_marko = curwp->w_imarko = 0;
curbp->b_dotp = curwp->w_dotp;
curbp->b_doto = curbp->b_marko = 0;
curbp->b_markp = NULL;
curbp->b_linecnt = -1;
curwp->w_flag |= WFHARD;
}
/*
* Delete backwards. This is quite easy too, because it's all done with other
* functions. Just move the cursor back, and delete forwards. Like delete
* forward, this actually does a kill if presented with an argument. Bound to
* both "RUBOUT" and "C-H".
*/
int
backdel(int f, int n)
{
register int s;
if (curbp->b_mode&MDVIEW) /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
if (n < 0)
return (forwdel(f, -n));
if(TERM_OPTIMIZE && curwp->w_dotp != curwp->w_bufp->b_linep){
int l;
if(worthit(&l) && curwp->w_doto == 0 &&
lback(curwp->w_dotp) != curwp->w_bufp->b_linep){
if(l == curwp->w_toprow)
scrollup(curwp, l+1, 1);
else if(llength(lback(curwp->w_dotp)) == 0)
scrollup(curwp, l-1, 1);
else
scrollup(curwp, l, 1);
}
}
if (f != FALSE) { /* Really a kill. */
if ((lastflag&CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
}
if ((s=backchar(f, n)) == TRUE)
s = ldelete((long) n, f ? kinsert : NULL);
return (s);
}
