/* return a region which goes from DOT to the far end of the current
selection region. shape is maintained. returns pointer to static
region struct.
*/
static REGION *
extended_region(void)
{
BUFFER *bp = curbp;
REGION *rp = NULL;
static REGION a, b;
MARK savemark;
savemark = MK;
regionshape = selregion.ar_shape;
MK = selregion.ar_region.r_orig;
DOT.o += BytesAt(DOT.l, DOT.o);
if (getregion(bp, &a) == TRUE) {
DOT.o -= BytesBefore(DOT.l, DOT.o);
MK = selregion.ar_region.r_end;
if (regionshape == rgn_FULLLINE)
MK.l = lback(MK.l);
/* region b is to the end of the selection */
if (getregion(bp, &b) == TRUE) {
/* if a is bigger, it's the one we want */
if (a.r_size > b.r_size)
rp = &a;
else
rp = &b;
}
} else {
DOT.o -= BytesBefore(DOT.l, DOT.o);
}
MK = savemark;
return rp;
}
/*
* Blast the region without saving . Ask "getregion"
* to figure out the bounds of the region.
* Move "." to the start, and kill the characters.
* Bound to "C-W".
*/
int
deleteregion(int f, int n)
{
REGION region;
if (curbp->b_mode&MDVIEW) /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
if (getregion(®ion, curwp->w_markp, curwp->w_marko) == TRUE){
curwp->w_dotp = region.r_linep;
curwp->w_doto = region.r_offset;
curwp->w_markp = NULL;
#ifdef _WINDOWS
mswin_allowcopycut(NULL);
#endif
if(ldelete(region.r_size, NULL)){
if(curwp->w_dotp == curwp->w_linep
&& curwp->w_dotp == curbp->b_linep){
curwp->w_force = 0; /* Center dot. */
curwp->w_flag |= WFFORCE;
}
return(TRUE);
}
}
return (FALSE);
}
// Set *np to the number of lines in the current region and *allp (if allp not NULL) to true if region includes all lines in
// the buffer. Place dot at beginning of region and return status.
int reglines(int *np,bool *allp) {
Line *lnp; // Position while scanning.
int n; // Number of lines in this current region.
Region region;
// Check for a valid region first.
if(getregion(®ion,allp) != SUCCESS)
return rc.status;
// Start at the top of the region...
lnp = region.r_dot.lnp;
region.r_size += region.r_dot.off;
n = 0;
// Scan the region ... counting lines.
while(region.r_size >= 0) {
region.r_size -= lused(lnp) + 1;
lnp = lforw(lnp);
++n;
}
// Place point at the beginning of the region and return result.
curwp->w_face.wf_dot = region.r_dot;
*np = n;
return rc.status;
}
/*
* set the highlight attribute accordingly on all characters in region
*/
int
markregion(int attr)
{
register LINE *linep;
register int loffs;
register int s;
REGION region;
CELL ac;
if ((s=getregion(®ion, curwp->w_markp, curwp->w_marko)) != TRUE)
return (s);
lchange(WFHARD);
linep = region.r_linep;
loffs = region.r_offset;
while (region.r_size--) {
if (loffs == llength(linep)) {
linep = lforw(linep);
loffs = 0;
} else {
ac = lgetc(linep, loffs);
ac.a = attr;
lputc(linep, loffs, ac);
++loffs;
}
}
return (TRUE);
}
/* ARGSUSED */
int
lowerregion(int f, int n)
{
struct line *linep;
struct region region;
int loffs, c, s;
if ((s = checkdirty(curbp)) != TRUE)
return (s);
if (curbp->b_flag & BFREADONLY) {
ewprintf("Buffer is read-only");
return (FALSE);
}
if ((s = getregion(®ion)) != TRUE)
return (s);
undo_add_change(region.r_linep, region.r_offset, region.r_size);
lchange(WFFULL);
linep = region.r_linep;
loffs = region.r_offset;
while (region.r_size--) {
if (loffs == llength(linep)) {
linep = lforw(linep);
loffs = 0;
} else {
c = lgetc(linep, loffs);
if (ISUPPER(c) != FALSE)
lputc(linep, loffs, TOLOWER(c));
++loffs;
}
}
return (TRUE);
}
/*
* Copy all of the characters in the
* region to the kill buffer. Don't move dot
* at all. This is a bit like a kill region followed
* by a yank. Bound to "M-W".
*/
int
copyregion(int f, int n)
{
register LINE *linep;
register int loffs;
register int s;
REGION region;
if ((s=getregion(®ion, curwp->w_markp, curwp->w_marko)) != TRUE)
return (s);
if ((lastflag&CFKILL) == 0) /* Kill type command. */
kdelete();
thisflag |= CFKILL;
linep = region.r_linep; /* Current line. */
loffs = region.r_offset; /* Current offset. */
while (region.r_size--) {
if (loffs == llength(linep)) { /* End of line. */
if ((s=kinsert('\n')) != TRUE)
return (s);
linep = lforw(linep);
loffs = 0;
} else { /* Middle of line. */
if ((s=kinsert(lgetc(linep, loffs).c)) != TRUE)
return (s);
++loffs;
}
}
return (TRUE);
}
/*
* Upper case region. Zap all of the lower
* case characters in the region to upper case. Use
* the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that
* redisplay is done in all buffers.
*/
int
upperregion (int f, int n, int k)
{
register LINE *linep;
register int loffs;
register int c;
register int s;
REGION region;
if ((s = getregion (®ion)) != TRUE)
return (s);
if (checkreadonly () == FALSE)
return FALSE;
lchange (WFHARD);
linep = region.r_pos.p;
loffs = region.r_pos.o;
while (region.r_size--)
{
if (loffs == llength (linep))
{
linep = lforw (linep);
loffs = 0;
}
else
{
c = lgetc (linep, loffs);
if (ISLOWER (c) != FALSE)
lputc (linep, loffs, TOUPPER (c));
++loffs;
}
}
return (TRUE);
}
/*ARGSUSED*/
copyregion(f, n)
{
register LINE *linep;
register int loffs;
register int s;
REGION region;
VOID kdelete();
if ((s=getregion(®ion)) != TRUE)
return s;
if ((lastflag&CFKILL) == 0) /* Kill type command. */
kdelete();
thisflag |= CFKILL;
linep = region.r_linep; /* Current line. */
loffs = region.r_offset; /* Current offset. */
while (region.r_size--) {
if (loffs == llength(linep)) { /* End of line. */
if ((s=kinsert('\n', KFORW)) != TRUE)
return (s);
linep = lforw(linep);
loffs = 0;
} else { /* Middle of line. */
if ((s=kinsert(lgetc(linep, loffs), KFORW)) != TRUE)
return s;
++loffs;
}
}
#ifdef CLIPBOARD
send_clipboard();
#endif /* CLIPBOARD */
return TRUE;
}
void ResourceDef::counttiles()
{
unsigned int tilecount = 0;
std::vector<Realms::Realm*>::iterator itr;
for ( itr = gamestate.Realms.begin(); itr != gamestate.Realms.end(); ++itr )
{
for ( unsigned short x = 0; x < ( *itr )->width(); ++x )
{
for ( unsigned short y = 0; y < ( *itr )->height(); ++y )
{
Plib::MAPTILE_CELL cell = ( *itr )->getmaptile( x, y );
if ( landtiles_.count( cell.landtile ) )
{
++tilecount;
ResourceRegion* rgn = getregion( x, y, *itr );
if ( rgn )
++rgn->tilecount_;
}
}
}
}
POLLOG_INFO << "Resource " << name() << ": " << tilecount << "\n";
for ( unsigned i = 0; i < regions_.size(); ++i )
{
ResourceRegion* rrgn = static_cast<ResourceRegion*>( regions_[i] );
POLLOG_INFO << "Region " << regions_[i]->name() << ": " << rrgn->tilecount_ << "\n";
}
}
// Delete or kill a region. Ask "getregion" to figure out the bounds of the region. Move dot to the start, and delete or
// kill the characters, depending on "kill" flag.
int dkregion(int n,bool kill) {
Region region;
if(getregion(®ion,NULL) != SUCCESS)
return rc.status;
kprep(kill);
curwp->w_face.wf_dot = region.r_dot;
return ldelete(region.r_size,kill ? DFKILL : DFDEL);
}
/*
* Indent region. Adjust the indentation of the lines
* in the region by the number of spaces in the argument.
* Call "lchange" to ensure that
* redisplay is done in all buffers.
*/
int
indentregion (int f, int n, int k)
{
register int nicol;
register int i;
register int c;
register int s;
REGION region;
int llen;
if ((s = getregion (®ion)) != TRUE)
return (s);
if (checkreadonly () == FALSE)
return FALSE;
lchange (WFHARD);
curwp->w_dot.p = region.r_pos.p;
curwp->w_dot.o = 0;
region.r_size += region.r_pos.o;
while (region.r_size > 0)
{
llen = llength (curwp->w_dot.p);
region.r_size -= llen + 1;
nicol = 0;
/* Find the indentation level of this line.
*/
for (i = 0; i < llen; ++i)
{
c = lgetc (curwp->w_dot.p, i);
if (c != ' ' && c != '\t')
break;
if (c == '\t')
nicol += (tabsize - nicol % tabsize) - 1;
++nicol;
}
/* Delete the leading white space in this line, and replace
* it with enough tabs and spaces to add the specified
* indentation. */
if (llen != 0 && (nicol += n) >= 0)
{
ldelete (i, FALSE);
if ((i = nicol / tabsize) != 0
&& linsert (i, '\t', NULLPTR) == FALSE)
return (FALSE);
if ((i = nicol % tabsize) != 0
&& linsert (i, ' ', NULLPTR) == FALSE)
return (FALSE);
}
curwp->w_dot.p = lforw (curwp->w_dot.p);
curwp->w_dot.o = 0;
}
return (TRUE);
}
// Count the number of words in the marked region, along with average word sizes, number of chars, etc, and report on them
// (interactive only).
int countWords(Value *rp,int n) {
Line *lnp; // Current line to scan.
int offset; // Current char to scan.
long size; // Size of region left to count.
int ch; // Current character to scan.
bool wordflag; // Is current character a word character?
bool inword; // Are we in a word now?
long nwords; // Total number of words.
long nchars; // Total number of word characters.
int nlines; // Total number of lines in region.
Region region; // Region to look at.
// Skip this if not displaying messages.
if(!(modetab[MDR_GLOBAL].flags & MDMSG))
return rc.status;
// Make sure we have a region to count.
if(getregion(®ion,NULL) != SUCCESS)
return rc.status;
lnp = region.r_dot.lnp;
offset = region.r_dot.off;
size = region.r_size;
// Count up things.
inword = false;
nchars = nwords = 0;
nlines = 0;
while(size--) {
// Get the current character...
if(offset == lused(lnp)) { // End of line.
ch = '\n';
lnp = lforw(lnp);
offset = 0;
++nlines;
}
else {
ch = lgetc(lnp,offset);
++offset;
}
// and tabulate it.
if((wordflag = isletter(ch) || isdigit(ch)))
++nchars;
if(wordflag && !inword)
++nwords;
inword = wordflag;
}
// and report on the info.
return rcset(SUCCESS,0,text100,nwords,nchars,region.r_size,nlines + 1,(nwords > 0) ? nchars * 1.0 / nwords : 0.0);
// "Words: %ld, word chars: %ld, region chars: %ld, lines: %d, avg. chars/word: %.2f"
}
/*
* Kill the region. Ask "getregion"
* to figure out the bounds of the region.
* Move "." to the start, and kill the characters.
* If an argument is provided, don't put the
* characters in the kill buffer (useful if
* you run out of memory while editing).
*/
int
killregion (int f, int n, int k)
{
register int s;
REGION region;
if ((s = getregion (®ion)) != TRUE)
return (s);
kdelete (); /* Purge kill buffer */
curwp->w_dot = region.r_pos;
return (ldelete (region.r_size, !f));
}
/*
* Upper case region. Zap all of the lower
* case characters in the region to upper case. Use
* the region code to set the limits. Scan the buffer,
* doing the changes. Call "lineSetChanged" to ensure that
* redisplay is done in all buffers. Bound to
* "C-X C-U".
*/
int
upperRegion(int f, int n)
{
meLine *line ;
int loffs ;
long lline ;
register char c;
register int s;
meRegion region;
if((s=getregion(®ion)) <= 0)
return (s);
if((s=bufferSetEdit()) <= 0) /* Check we can change the buffer */
return s ;
line = frameCur->windowCur->dotLine ;
loffs = frameCur->windowCur->dotOffset ;
lline = frameCur->windowCur->dotLineNo ;
frameCur->windowCur->dotLine = region.line ;
frameCur->windowCur->dotOffset = region.offset ;
frameCur->windowCur->dotLineNo = region.lineNo ;
while (region.size--)
{
if((c = meLineGetChar(frameCur->windowCur->dotLine, frameCur->windowCur->dotOffset)) == '\0')
{
frameCur->windowCur->dotLine = meLineGetNext(frameCur->windowCur->dotLine);
frameCur->windowCur->dotOffset = 0;
frameCur->windowCur->dotLineNo++ ;
}
else
{
if(isLower(c))
{
lineSetChanged(WFMAIN);
#if MEOPT_UNDO
meUndoAddRepChar() ;
#endif
c = toggleCase(c) ;
meLineSetChar(frameCur->windowCur->dotLine, frameCur->windowCur->dotOffset, c);
}
(frameCur->windowCur->dotOffset)++ ;
}
}
frameCur->windowCur->dotLine = line ;
frameCur->windowCur->dotOffset = loffs ;
frameCur->windowCur->dotLineNo = lline ;
return meTRUE ;
}
/*
* Kill the region. Ask "getregion"
* to figure out the bounds of the region.
* Move "." to the start, and kill the characters.
* Bound to "C-W".
*/
int
killRegion(int f, int n)
{
meRegion region;
if(n == 0)
return meTRUE ;
if(getregion(®ion) <= 0)
return meFALSE ;
if(bufferSetEdit() <= 0) /* Check we can change the buffer */
return meFALSE ;
frameCur->windowCur->dotLine = region.line ;
frameCur->windowCur->dotLineNo = region.lineNo ;
frameCur->windowCur->dotOffset = region.offset ;
return ldelete(region.size,(n > 0) ? 3:2);
}
/* ARGSUSED */
int
killregion(int f, int n)
{
int s;
struct region region;
if ((s = getregion(®ion)) != TRUE)
return (s);
/* This is a kill-type command, so do magic kill buffer stuff. */
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
curwp->w_dotp = region.r_linep;
curwp->w_doto = region.r_offset;
s = ldelete(region.r_size, KFORW);
clearmark(FFARG, 0);
return (s);
}
/* ARGSUSED */
int
prefixregion(int f, int n)
{
struct line *first, *last;
struct region region;
char *prefix = prefix_string;
int nline;
int s;
if ((s = checkdirty(curbp)) != TRUE)
return (s);
if (curbp->b_flag & BFREADONLY) {
dobeep();
ewprintf("Buffer is read-only");
return (FALSE);
}
if ((f == TRUE) && ((s = setprefix(FFRAND, 1)) != TRUE))
return (s);
/* get # of lines to affect */
if ((s = getregion(®ion)) != TRUE)
return (s);
first = region.r_linep;
last = (first == curwp->w_dotp) ? curwp->w_markp : curwp->w_dotp;
for (nline = 1; first != last; nline++)
first = lforw(first);
/* move to beginning of region */
curwp->w_dotp = region.r_linep;
curwp->w_doto = region.r_offset;
curwp->w_dotline = region.r_lineno;
/* for each line, go to beginning and insert the prefix string */
while (nline--) {
(void)gotobol(FFRAND, 1);
for (prefix = prefix_string; *prefix; prefix++)
(void)linsert(1, *prefix);
(void)forwline(FFRAND, 1);
}
(void)gotobol(FFRAND, 1);
return (TRUE);
}
/*
* Setup for iteration over region to attribute, ensure that DOT < MK.
*/
LINE *
setup_region(void)
{
BUFFER *bp = curbp;
LINE *pastline; /* pointer to line just past EOP */
if (!sameline(MK, DOT)) {
REGION region;
if (getregion(bp, ®ion) != TRUE)
return 0;
if (sameline(region.r_orig, MK))
swapmark();
}
pastline = MK.l;
if (pastline != win_head(curwp))
pastline = lforw(pastline);
DOT.o = 0;
regionshape = rgn_EXACT;
return pastline;
}
/*ARGSUSED*/
killregion(f, n)
{
register int s;
REGION region;
#ifdef READONLY /* 91.01.05 by S.Yoshida */
if (curbp->b_flag & BFRONLY) { /* If this buffer is read-only, */
warnreadonly(); /* do only displaying warning. */
return TRUE;
}
#endif /* READONLY */
if ((s=getregion(®ion)) != TRUE)
return (s);
if ((lastflag&CFKILL) == 0) /* This is a kill type */
kdelete(); /* command, so do magic */
thisflag |= CFKILL; /* kill buffer stuff. */
curwp->w_dotp = region.r_linep;
curwp->w_doto = region.r_offset;
return (ldelete(region.r_size, KFORW));
}
/*ARGSUSED */
int
piperegion(int f, int n)
{
struct region region;
int len;
char *cmd, cmdbuf[NFILEN], *text;
char *argv[] = {"sh", "-c", (char *) NULL, (char *) NULL};
/* C-u M-| is not supported yet */
if (n > 1)
return (ABORT);
if (curwp->w_markp == NULL) {
dobeep();
ewprintf("The mark is not set now, so there is no region");
return (FALSE);
}
if ((cmd = eread("Shell command on region: ", cmdbuf, sizeof(cmdbuf),
EFNEW | EFCR)) == NULL || (cmd[0] == '\0'))
return (ABORT);
argv[2] = cmd;
if (getregion(®ion) != TRUE)
return (FALSE);
len = region.r_size;
if ((text = malloc(len + 1)) == NULL) {
dobeep();
ewprintf("Cannot allocate memory.");
return (FALSE);
}
region_get_data(®ion, text, len);
return shellcmdoutput(argv, text, len);
}
/* ARGSUSED */
int
copyregion(int f, int n)
{
struct line *linep;
struct region region;
int loffs;
int s;
if ((s = getregion(®ion)) != TRUE)
return (s);
/* kill type command */
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
/* current line */
linep = region.r_linep;
/* current offset */
loffs = region.r_offset;
while (region.r_size--) {
if (loffs == llength(linep)) { /* End of line. */
if ((s = kinsert('\n', KFORW)) != TRUE)
return (s);
linep = lforw(linep);
loffs = 0;
} else { /* Middle of line. */
if ((s = kinsert(lgetc(linep, loffs), KFORW)) != TRUE)
return (s);
++loffs;
}
}
clearmark(FFARG, 0);
return (TRUE);
}
static int
selectregion(void)
{
BUFFER *bp = curbp;
int status;
REGION region;
MARK savedot;
MARK savemark;
int hadregion = FALSE;
savedot = DOT;
savemark = MK;
memset(®ion, 0, sizeof(region));
if (haveregion) { /* getregion() will clear this, so
we need to save it */
region = *haveregion;
hadregion = TRUE;
}
status = yankregion();
DOT = savedot;
MK = savemark;
if (status != TRUE)
return status;
if (hadregion || ((status = getregion(bp, ®ion)) == TRUE)) {
detach_attrib(startbufp, &startregion);
detach_attrib(selbufp, &selregion);
selbufp = curbp;
selregion.ar_region = region;
selregion.ar_vattr = VASEL | VOWN_SELECT;
selregion.ar_shape = regionshape;
#if OPT_HYPERTEXT
selregion.ar_hypercmd = 0;
#endif
attach_attrib(selbufp, &selregion);
OWN_SELECTION();
}
return status;
}
// Lower or upper case region. Change the case of all the characters in the region. Use the region code to set the
// limits. Scan the buffer, doing the changes. Call "lchange" to ensure that redisplay is done in all buffers.
int caseregion(int n,char *trantab) {
Line *lnp;
int offset;
Region region;
if(getregion(®ion,NULL) != SUCCESS)
return rc.status;
lchange(curbp,WFHARD);
lnp = region.r_dot.lnp;
offset = region.r_dot.off;
while(region.r_size-- > 0) {
if(offset == lused(lnp)) {
lnp = lforw(lnp);
offset = 0;
}
else {
lputc(lnp,offset,trantab[(int) lgetc(lnp,offset)]);
++offset;
}
}
return rc.status;
}
/*ARGSUSED*/
upperregion(f, n)
{
register LINE *linep;
register int loffs;
register int c;
register int s;
REGION region;
VOID lchange();
#ifdef READONLY /* 91.01.05 by S.Yoshida */
if (curbp->b_flag & BFRONLY) { /* If this buffer is read-only, */
warnreadonly(); /* do only displaying warning. */
return TRUE;
}
#endif /* READONLY */
if ((s=getregion(®ion)) != TRUE)
return s;
#ifdef UNDO
undo_reset(curbp); /* this function cannot undo */
#endif
lchange(WFHARD);
linep = region.r_linep;
loffs = region.r_offset;
while (region.r_size--) {
if (loffs == llength(linep)) {
linep = lforw(linep);
loffs = 0;
} else {
c = lgetc(linep, loffs);
if (ISLOWER(c) != FALSE)
lputc(linep, loffs, TOUPPER(c));
++loffs;
}
}
return TRUE;
}
/*
* Copy all of the characters in the
* region to the kill buffer. Don't move dot
* at all. This is a bit like a kill region followed
* by a yank.
*/
int
copyregion (int f, int n, int k)
{
register LINE *linep;
register int loffs;
register int chunk;
REGION region;
if (getregion (®ion) != TRUE)
return (FALSE);
kdelete (); /* Purge kill buffer */
linep = region.r_pos.p; /* Current line. */
loffs = region.r_pos.o; /* Current offset. */
while (region.r_size > 0)
{
if (loffs == llength (linep))
{ /* End of line. */
if (kinsert ("\n", 1) != TRUE)
return (FALSE);
linep = lforw (linep);
loffs = 0;
region.r_size--;
}
else
{ /* Middle of line. */
chunk = llength (linep) - loffs;
if (chunk > region.r_size)
chunk = region.r_size;
if (kinsert (lgets (linep) + loffs, chunk) != TRUE)
return (FALSE);
loffs += chunk;
region.r_size -= chunk;
}
}
return (TRUE);
}
/*
* Kill the region. Ask "getregion"
* to figure out the bounds of the region.
* Move "." to the start, and kill the characters.
* Bound to "C-W".
*/
int
killregion(int f, int n)
{
REGION region;
if (curbp->b_mode&MDVIEW) /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
if (getregion(®ion, curwp->w_markp, curwp->w_marko) != TRUE){
return (killtext(f, n));
}else {
mlerase();
}
if ((lastflag&CFKILL) == 0) /* This is a kill type */
kdelete(); /* command, so do magic */
thisflag |= CFKILL; /* kill buffer stuff. */
curwp->w_dotp = region.r_linep;
curwp->w_doto = region.r_offset;
curwp->w_markp = NULL;
#ifdef _WINDOWS
mswin_allowcopycut(NULL);
#endif
if(ldelete(region.r_size, kinsert)){
if(curwp->w_dotp == curwp->w_linep && curwp->w_dotp == curbp->b_linep){
curwp->w_force = 0; /* Center dot. */
curwp->w_flag |= WFFORCE;
}
return(TRUE);
}
return (FALSE);
}
/*
* Upper case region. Zap all of the lower
* case characters in the region to upper case. Use
* the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that
* redisplay is done in all buffers. Bound to
* "C-X C-L".
*/
int
upperregion(int f, int n)
{
register LINE *linep;
register int loffs;
register int c;
register int s;
REGION region;
CELL ac;
ac.a = 0;
if (curbp->b_mode&MDVIEW) /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
if ((s=getregion(®ion, curwp->w_markp, curwp->w_marko)) != TRUE)
return (s);
lchange(WFHARD);
linep = region.r_linep;
loffs = region.r_offset;
while (region.r_size--) {
if (loffs == llength(linep)) {
linep = lforw(linep);
loffs = 0;
} else {
c = lgetc(linep, loffs).c;
if (c>='a' && c<='z'){
ac.c = c - 'a' + 'A';
lputc(linep, loffs, ac);
}
++loffs;
}
}
return (TRUE);
}
/*
* The region we're filling is the region from dot to mark.
* We cut out that region and then put it back in filled.
* The cut out part is saved in the ldelete call and the
* reinstalled region is noted in addedregion, so that yank()
* can delete it and restore the saved part.
*/
int
fillregion(UCS *qstr, REGION *addedregion)
{
long c, sz, last_char = 0;
int i, j, qlen, same_word,
spaces, word_len, word_ind, line_len, ww;
int starts_midline = 0;
int ends_midline = 0;
int offset_into_start;
LINE *line_before_start, *lp;
UCS line_last, word[NSTRING];
REGION region;
/* if region starts midline insert a newline */
if(curwp->w_doto > 0 && curwp->w_doto < llength(curwp->w_dotp))
starts_midline++;
/* if region ends midline insert a newline at end */
if(curwp->w_marko > 0 && curwp->w_marko < llength(curwp->w_markp))
ends_midline++;
/* cut the paragraph into our fill buffer */
fdelete();
if(!getregion(®ion, curwp->w_markp, curwp->w_marko))
return(FALSE);
if(!ldelete(region.r_size, finsert))
return(FALSE);
line_before_start = lback(curwp->w_dotp);
offset_into_start = curwp->w_doto;
if(starts_midline)
lnewline();
/* Now insert it back wrapped */
spaces = word_len = word_ind = line_len = same_word = 0;
qlen = qstr ? ucs4_strlen(qstr) : 0;
/* Beginning with leading quoting... */
if(qstr){
i = 0;
while(qstr[i]){
ww = wcellwidth(qstr[i]);
line_len += (ww >= 0 ? ww : 1);
linsert(1, qstr[i++]);
}
line_last = ' '; /* no word-flush space! */
}
/* remove first leading quotes if any */
if(starts_midline)
i = 0;
else
for(i = qlen; (c = fremove(i)) == ' ' || c == TAB; i++){
linsert(1, line_last = (UCS) c);
line_len += ((c == TAB) ? (~line_len & 0x07) + 1 : 1);
}
/* then digest the rest... */
while((c = fremove(i++)) >= 0){
last_char = c;
switch(c){
case '\n' :
/* skip next quote string */
j = 0;
while(j < qlen && ((c = fremove(i+j)) == qstr[j] || c == ' '))
j++;
i += j;
if(!spaces)
spaces++;
same_word = 0;
break;
case TAB :
case ' ' :
spaces++;
same_word = 0;
break;
default :
if(spaces){ /* flush word? */
if((line_len - qlen > 0)
&& line_len + word_len + 1 > fillcol
&& ((ucs4_isspace(line_last))
|| (linsert(1, ' ')))
&& (line_len = fpnewline(qstr)))
line_last = ' '; /* no word-flush space! */
if(word_len){ /* word to write? */
if(line_len && !ucs4_isspace(line_last)){
linsert(1, ' '); /* need padding? */
line_len++;
}
line_len += word_len;
for(j = 0; j < word_ind; j++)
linsert(1, line_last = word[j]);
if(spaces > 1 && strchr(".?!:;\")", line_last)){
linsert(2, line_last = ' ');
line_len += 2;
}
word_len = word_ind = 0;
}
spaces = 0;
}
if(word_ind + 1 >= NSTRING){
/* Magic! Fake that we output a wrapped word */
if((line_len - qlen > 0) && !same_word++){
if(!ucs4_isspace(line_last))
linsert(1, ' ');
line_len = fpnewline(qstr);
}
line_len += word_len;
for(j = 0; j < word_ind; j++)
linsert(1, word[j]);
word_len = word_ind = 0;
line_last = ' ';
}
word[word_ind++] = (UCS) c;
ww = wcellwidth((UCS) c);
word_len += (ww >= 0 ? ww : 1);
break;
}
}
if(word_len){
if((line_len - qlen > 0) && (line_len + word_len + 1 > fillcol)){
if(!ucs4_isspace(line_last))
linsert(1, ' ');
(void) fpnewline(qstr);
}
else if(line_len && !ucs4_isspace(line_last))
linsert(1, ' ');
for(j = 0; j < word_ind; j++)
linsert(1, word[j]);
}
if(last_char == '\n')
lnewline();
if(ends_midline)
(void) fpnewline(qstr);
/*
* Calculate the size of the region that was added.
*/
swapmark(0,1); /* mark current location after adds */
addedregion->r_linep = lforw(line_before_start);
addedregion->r_offset = offset_into_start;
lp = addedregion->r_linep;
sz = llength(lp) - addedregion->r_offset;
if(lforw(lp) != curwp->w_markp->l_fp){
lp = lforw(lp);
while(lp != curwp->w_markp->l_fp){
sz += llength(lp) + 1;
lp = lforw(lp);
}
}
sz -= llength(curwp->w_markp) - curwp->w_marko;
addedregion->r_size = sz;
swapmark(0,1);
if(ends_midline){
/*
* We want to back up to the end of the original
* region instead of being here after the added newline.
*/
curwp->w_doto = 0;
backchar(0, 1);
unmarkbuffer();
markregion(1);
}
return(TRUE);
}
/* Justify the entire buffer instead of just a paragraph */
int
fillbuf(int f, int n)
{
LINE *eobline;
REGION region;
if(curbp->b_mode&MDVIEW){ /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
}
else if (fillcol == 0) { /* no fill column set */
mlwrite_utf8("No fill column set", NULL);
return(FALSE);
}
if((lastflag & CFFILL) && (lastflag & CFFLBF)){
/* no use doing a full justify twice */
thisflag |= (CFFLBF | CFFILL);
return(TRUE);
}
/* record the pointer of the last line */
if(gotoeob(FALSE, 1) == FALSE)
return(FALSE);
eobline = curwp->w_dotp; /* last line of buffer */
if(!llength(eobline))
eobline = lback(eobline);
/* and back to the beginning of the buffer */
gotobob(FALSE, 1);
thisflag |= CFFLBF; /* CFFILL also gets set in fillpara */
if(!Pmaster)
sgarbk = TRUE;
curwp->w_flag |= WFMODE;
/*
* clear the kill buffer, that's where we'll store undo
* information, we can't do the fill buffer because
* fillpara relies on its contents
*/
kdelete();
curwp->w_doto = 0;
getregion(®ion, eobline, llength(eobline));
/* Put full message in the kill buffer for undo */
if(!ldelete(region.r_size, kinsert))
return(FALSE);
/* before yank'ing, clear lastflag so we don't just unjustify */
lastflag &= ~(CFFLBF | CFFILL);
/* Now in kill buffer, bring back text to use in fillpara */
yank(FALSE, 1);
gotobob(FALSE, 1);
/* call fillpara until we're at the end of the buffer */
while(curwp->w_dotp != curbp->b_linep)
if(!(fillpara(FALSE, 1)))
return(FALSE);
return(TRUE);
}
int
setquotelevelinregion(int quotelevel, REGION *addedregion)
{
int i, standards_based = 0;
int quote_chars = 0, backuptoprevline = 0;
int starts_midline = 0, ends_midline = 0, offset_into_start;
long c, sz;
UCS qstr_def1[] = { '>', ' ', 0}, qstr_def2[] = { '>', 0};
LINE *lp, *line_before_start;
REGION region;
if(curbp->b_mode&MDVIEW) /* don't allow this command if */
return(rdonly()); /* we are in read only mode */
if(!glo_quote_str
|| !ucs4_strcmp(glo_quote_str, qstr_def1)
|| !ucs4_strcmp(glo_quote_str, qstr_def2))
standards_based++;
if(!standards_based){
emlwrite("Quote level setting only works with standard \"> \" quotes", NULL);
return(FALSE);
}
/* if region starts midline insert a newline */
if(curwp->w_doto > 0 && curwp->w_doto < llength(curwp->w_dotp))
starts_midline++;
/* if region ends midline insert a newline at end */
if(curwp->w_marko > 0 && curwp->w_marko < llength(curwp->w_markp)){
ends_midline++;
backuptoprevline++;
/* count quote chars for re-insertion */
for(i = 0; i < llength(curwp->w_markp); ++i)
if(lgetc(curwp->w_markp, i).c != '>')
break;
quote_chars = i;
}
else if(curwp->w_marko == 0)
backuptoprevline++;
/* find the size of the region */
getregion(®ion, curwp->w_markp, curwp->w_marko);
/* cut the paragraph into our fill buffer */
fdelete();
if(!ldelete(region.r_size, finsert))
return(FALSE);
line_before_start = lback(curwp->w_dotp);
offset_into_start = curwp->w_doto;
/* if region starts midline add a newline */
if(starts_midline)
lnewline();
i = 0;
while(fremove(i) >= 0){
/* remove all quote strs from current line */
if(standards_based){
while((c = fremove(i)) == '>')
i++;
if(c == ' ')
i++;
}
else{
}
/* insert quotelevel quote strs */
if(standards_based){
linsert(quotelevel, '>');
if(quotelevel > 0)
linsert(1, ' ');
}
else{
}
/* put back the actual line */
while((c = fremove(i++)) >= 0 && c != '\n')
linsert(1, (UCS) c);
if(c == '\n')
lnewline();
}
/* if region ends midline add a newline */
if(ends_midline){
lnewline();
if(quote_chars){
linsert(quote_chars, '>');
if(curwp->w_doto < llength(curwp->w_dotp)
&& lgetc(curwp->w_dotp, curwp->w_doto).c != ' ')
linsert(1, ' ');
}
}
/*
* Calculate the size of the region that was added.
*/
swapmark(0,1); /* mark current location after adds */
addedregion->r_linep = lforw(line_before_start);
addedregion->r_offset = offset_into_start;
lp = addedregion->r_linep;
sz = llength(lp) - addedregion->r_offset;
if(lforw(lp) != curwp->w_markp->l_fp){
lp = lforw(lp);
while(lp != curwp->w_markp->l_fp){
sz += llength(lp) + 1;
lp = lforw(lp);
}
}
sz -= llength(curwp->w_markp) - curwp->w_marko;
addedregion->r_size = sz;
swapmark(0,1);
/*
* This puts us at the end of the quoted region instead
* of on the following line. This makes it convenient
* for the user to follow a quotelevel adjustment with
* a Justify if desired.
*/
if(backuptoprevline){
curwp->w_doto = 0;
backchar(0, 1);
}
if(ends_midline){ /* doesn't need fixing otherwise */
unmarkbuffer();
markregion(1);
}
return (TRUE);
}
