/* 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); }