How to insert a specific number of newlines in org-mode

Question

Inside org-mode, RETURN is bound to (org-return &optional INDENT). This command apparently ignores C-u numeric prefixes and so if you want to enter 10 newlines, you can't just type C-u 1 0 RET and have it work. You can do C-u 1 0 M-x newline and get expected behavior, but I would like to know if there's a simpler set of default keystrokes?

Answer 1

If you just want to insert newlines, without any automation for indentation or support for soft newlines, then you can use quoted-insert (C-q), which lets you enter any character including control characters. A newline character is C-j, but the Return key sends C-m, so you need to type C-u 1 0 C-q C-j (insert a newline, times 10).

If you want to call the newline function, you can advise org-return. Untested.

(defadvice org-return
  (around org-return-prefix-argument (&optional indent arg) activate compile)
  (interactive (list nil current-prefix-arg))
  (letf (((symbol-function 'true-newline) (symbol-function 'newline)
          (symbol-function 'newline) (lambda () (true-newline arg))))
    ad-do-it))

Answer 2

Here's another solution:

(defun my-org-return (&optional arg indent)
  (interactive "*p")
  (dotimes (number arg) (org-return indent)))
(define-key org-mode-map (kbd "<return>") 'my-org-return)

Answer 3

You can redefine org-return and org-return-indent as follows in your init.el (I have redefined the function found in emacs/24.4/lisp.org/org.el:

After the redefinition, you can do C-u10RET.

(defun org-return (&optional arg indent)
  "Goto next table row or insert a newline.

Calls `org-table-next-row' or `newline', depending on context.
See the individual commands for more information.
With ARG, call `org-return' that many times."
  (interactive "P")
  (let (org-ts-what)
    (cond
     ((or (bobp) (org-in-src-block-p))
      (if indent (newline-and-indent) (newline arg)))
     ((org-at-table-p)
      (org-table-justify-field-maybe)
      (call-interactively 'org-table-next-row))
     ;; when `newline-and-indent' is called within a list, make sure
     ;; text moved stays inside the item.
     ((and (org-in-item-p) indent)
      (if (and (org-at-item-p) (>= (point) (match-end 0)))
          (progn
            (save-match-data (newline arg))
            (org-indent-line-to (length (match-string 0))))
    (let ((ind (org-get-indentation)))
      (newline arg)
      (if (org-looking-back org-list-end-re)
              (org-indent-line)
        (org-indent-line-to ind)))))
     ((and org-return-follows-link
       (org-at-timestamp-p t)
       (not (eq org-ts-what 'after)))
      (org-follow-timestamp-link))
     ((and org-return-follows-link
       (let ((tprop (get-text-property (point) 'face)))
         (or (eq tprop 'org-link)
         (and (listp tprop) (memq 'org-link tprop)))))
      (call-interactively 'org-open-at-point))
     ((and (org-at-heading-p)
       (looking-at
        (org-re "\\([ \t]+\\(:[[:alnum:]_@#%:]+:\\)\\)[ \t]*$")))
      (org-show-entry)
      (end-of-line 1)
      (newline arg))
     (t (if indent (newline-and-indent) (newline arg))))))

Note that in newline-and-indent, the ARG input of newline is set to nil. So the same is done in the renewed definition of org-return-indent.

(defun org-return-indent ()
  "Goto next table row or insert a newline and indent.
Calls `org-table-next-row' or `newline-and-indent', depending on
context.  See the individual commands for more information."
  (interactive)
  (org-return nil t))