Function: justify-current-line
justify-current-line is an interactive and byte-compiled function
defined in fill.el.gz.
Signature
(justify-current-line &optional HOW EOP NOSQUEEZE)
Documentation
Do some kind of justification on this line.
Normally does full justification: adds spaces to the line to make it end at
the column given by current-fill-column.
Optional first argument HOW specifies alternate type of justification:
it can be left, right, full, center, or none; for their
meaning, see default-justification.
If HOW is t, will justify however the current-justification function says to.
If HOW is nil or missing, full justification is done by default.
Second arg EOP non-nil means that this is the last line of the paragraph, so
it will not be stretched by full justification.
Third arg NOSQUEEZE non-nil means to leave interior whitespace unchanged,
otherwise it is made canonical.
Probably introduced at or before Emacs version 19.29.
Key Bindings
Source Code
;; Defined in /usr/src/emacs/lisp/textmodes/fill.el.gz
;; A line has up to six parts:
;;
;; >>> hello.
;; [Indent-1][FP][ Indent-2 ][text][trailing whitespace][newline]
;;
;; "Indent-1" is the left-margin indentation; normally it ends at column
;; given by the `current-left-margin' function.
;; "FP" is the fill-prefix. It can be any string, including whitespace.
;; "Indent-2" is added to justify a line if the `current-justification' is
;; `center' or `right'. In `left' and `full' justification regions, any
;; whitespace there is part of the line's text, and should not be changed.
;; Trailing whitespace is not counted as part of the line length when
;; center- or right-justifying.
;;
;; All parts of the line are optional, although the final newline can
;; only be missing on the last line of the buffer.
(defun justify-current-line (&optional how eop nosqueeze)
"Do some kind of justification on this line.
Normally does full justification: adds spaces to the line to make it end at
the column given by `current-fill-column'.
Optional first argument HOW specifies alternate type of justification:
it can be `left', `right', `full', `center', or `none'; for their
meaning, see `default-justification'.
If HOW is t, will justify however the `current-justification' function says to.
If HOW is nil or missing, full justification is done by default.
Second arg EOP non-nil means that this is the last line of the paragraph, so
it will not be stretched by full justification.
Third arg NOSQUEEZE non-nil means to leave interior whitespace unchanged,
otherwise it is made canonical."
(interactive "*")
(if (eq t how) (setq how (or (current-justification) 'none))
(if (null how) (setq how 'full)
(or (memq how '(none left right center))
(setq how 'full))))
(or (memq how '(none left)) ; No action required for these.
(let ((fc (current-fill-column))
(pos (point-marker))
fp-end ; point at end of fill prefix
beg ; point at beginning of line's text
end ; point at end of line's text
indent ; column of `beg'
endcol ; column of `end'
ncols ; new indent point or offset
(nspaces 0) ; number of spaces between words
; in line (not space characters)
(curr-fracspace 0) ; current fractional space amount
count)
(end-of-line)
;; Check if this is the last line of the paragraph.
(if (and use-hard-newlines (null eop)
(get-text-property (point) 'hard))
(setq eop t))
(skip-chars-backward " \t")
;; Quick exit if it appears to be properly justified already
;; or there is no text.
(if (or (bolp)
(and (memq how '(full right))
(= (current-column) fc)))
nil
(setq end (point))
(beginning-of-line)
(skip-chars-forward " \t")
;; Skip over fill-prefix.
(if (and fill-prefix
(not (string-equal fill-prefix ""))
(equal fill-prefix
(buffer-substring
(point) (min (point-max) (+ (length fill-prefix)
(point))))))
(forward-char (length fill-prefix))
(if (and adaptive-fill-mode
(looking-at adaptive-fill-regexp))
(goto-char (match-end 0))))
(setq fp-end (point))
(skip-chars-forward " \t")
;; This is beginning of the line's text.
(setq indent (current-column))
(setq beg (point))
(goto-char end)
(setq endcol (current-column))
;; HOW can't be null or left--we would have exited already
(cond ((eq 'right how)
(setq ncols (- fc endcol))
(if (< ncols 0)
;; Need to remove some indentation
(delete-region
(progn (goto-char fp-end)
(if (< (current-column) (+ indent ncols))
(move-to-column (+ indent ncols) t))
(point))
(progn (move-to-column indent) (point)))
;; Need to add some
(goto-char beg)
(indent-to (+ indent ncols))
;; If point was at beginning of text, keep it there.
(if (= beg pos)
(move-marker pos (point)))))
((eq 'center how)
;; Figure out how much indentation is needed
(setq ncols (+ (current-left-margin)
(/ (- fc (current-left-margin) ;avail. space
(- endcol indent)) ;text width
2)))
(if (< ncols indent)
;; Have too much indentation - remove some
(delete-region
(progn (goto-char fp-end)
(if (< (current-column) ncols)
(move-to-column ncols t))
(point))
(progn (move-to-column indent) (point)))
;; Have too little - add some
(goto-char beg)
(indent-to ncols)
;; If point was at beginning of text, keep it there.
(if (= beg pos)
(move-marker pos (point)))))
((eq 'full how)
;; Insert extra spaces between words to justify line
(save-restriction
(narrow-to-region beg end)
(or nosqueeze
(canonically-space-region beg end))
(goto-char (point-max))
;; count word spaces in line
(while (search-backward " " nil t)
(setq nspaces (1+ nspaces))
(skip-chars-backward " "))
(setq ncols (- fc endcol))
;; Ncols is number of additional space chars needed
(when (and (> ncols 0) (> nspaces 0) (not eop))
(setq curr-fracspace (+ ncols (/ nspaces 2))
count nspaces)
(while (> count 0)
(skip-chars-forward " ")
(insert-char ?\s (/ curr-fracspace nspaces) t)
(search-forward " " nil t)
(setq count (1- count)
curr-fracspace
(+ (% curr-fracspace nspaces) ncols))))))
(t (error "Unknown justification value"))))
(goto-char pos)
(move-marker pos nil)))
nil)