[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [O] [RFC] Make QUOTE an export keyword instead of an element type

From: Nicolas Goaziou
Subject: Re: [O] [RFC] Make QUOTE an export keyword instead of an element type
Date: Mon, 03 Feb 2014 23:41:14 +0100

Nicolas Goaziou <address@hidden> writes:

> It is clearer now, thank you. I'll send a patch later on the ML.

Here is the function. If it is good enough, I'll add tests and wrap it
up in a patch.

#+begin_src emacs-lisp
(defun org-toggle-fixed-width ()
  "Toggle fixed-width markup.

Add or remove fixed-width markup on current line, whenever it
makes sense. Return an error otherwise.

If a region is active and if it contains only fixed-width areas
or blank lines, remove all fixed-width markup in it. If the
region contains anything else, convert all non-fixed-width lines
to fixed-width ones."
  (if (not (org-region-active-p))
      (if (org-at-heading-p)
          (user-error "Cannot insert a fixed-width line here")
        (let* ((element (org-element-at-point))
               (type (org-element-type element)))
           ((and (eq type 'fixed-width)
                 (looking-at "[ \t]*\\(:\\(?: \\|$\\)\\)"))
             "" nil nil nil (if (= (line-end-position) (match-end 0)) 0 1)))
           ((and (eq type 'paragraph)
                 (<= (org-element-property :post-affiliated element) (point)))
            (skip-chars-forward " \t")
            (insert ": "))
           ((and (org-looking-at-p "[ \t]*$")
                 (or (memq type '(headline inlinetask))
                       (skip-chars-forward " \r\t\n")
                       (<= (org-element-property :end element) (point)))))
            (delete-region (point) (line-end-position))
            (insert ": "))
           (t (user-error "Cannot insert a fixed-width line here")))))
    (let* ((begin (save-excursion
                    (goto-char (region-beginning))
           (end (copy-marker
                   (goto-char (region-end))
                   (unless (eolp) (beginning-of-line))
                   (if (save-excursion (re-search-backward "\\S-" begin t))
                       (progn (skip-chars-backward " \r\t\n") (point))
            (catch 'not-all-p
                (goto-char begin)
                (skip-chars-forward " \r\t\n")
                (when (eobp) (throw 'not-all-p nil))
                (while (< (point) end)
                  (let ((element (org-element-at-point)))
                    (if (eq (org-element-type element) 'fixed-width)
                        (goto-char (org-element-property :end element))
                      (throw 'not-all-p nil))))
      (if all-fixed-width-p
            (goto-char begin)
            (while (< (point) end)
              (when (looking-at "[ \t]*\\(:\\(?: \\|$\\)\\)")
                 "" nil nil nil
                 (if (= (line-end-position) (match-end 0)) 0 1)))
        (let ((min-ind (point-max)))
          ;; Find minimum indentation across all lines.
            (goto-char begin)
            (if (not (save-excursion (re-search-forward "\\S-" end t)))
                (setq min-ind 0)
              (catch 'zerop
                (while (< (point) end)
                  (unless (org-looking-at-p "[ \t]*$")
                    (let ((ind (org-get-indentation)))
                      (setq min-ind (min min-ind ind))
                      (when (zerop ind) (throw 'zerop t))))
          ;; Loop over all lines and add fixed-width markup everywhere
          ;; but in fixed-width lines.
            (goto-char begin)
            (while (< (point) end)
                (insert ": ")
                (while (and (< (point) end) (org-looking-at-p "[ \t]*$"))
                  (insert ":")
               ((org-looking-at-p "[ \t]*:\\( \\|$\\)")
                (let* ((element (org-element-at-point))
                       (element-end (org-element-property :end element)))
                  (if (eq (org-element-type element) 'fixed-width)
                      (progn (goto-char element-end)
                             (skip-chars-backward " \r\t\n")
                    (let ((limit (min end element-end)))
                      (while (< (point) limit)
                        (let ((buffer-invisibility-spec nil))
                          (org-move-to-column min-ind t))
                        (insert ": ")
                (let ((buffer-invisibility-spec nil))
                  (org-move-to-column min-ind t))
                (insert ": ")
      (set-marker end nil))))

Nicolas Goaziou

reply via email to

[Prev in Thread] Current Thread [Next in Thread]