From: Ihor Radchenko <yantar92@gmail.com>
To: Bastien <bzg@gnu.org>, Kyle Meyer <kyle@kyleam.com>,
Nicolas Goaziou <mail@nicolasgoaziou.fr>,
Karl Voit <devnull@Karl-Voit.at>,
Christian Heinrich <christian@gladbachcity.de>,
emacs-orgmode@gnu.org
Cc: Ihor Radchenko <yantar92@gmail.com>
Subject: [PATCH 01/35] Add org-fold-core: new folding engine
Date: Sat, 29 Jan 2022 19:37:53 +0800 [thread overview]
Message-ID: <74cd7fc06a4540b1d63d1e7f9f2542f83e1eaaae.1643454545.git.yantar92@gmail.com> (raw)
In-Reply-To: <cover.1643454545.git.yantar92@gmail.com>
[-- Attachment #1: Type: text/plain, Size: 155 bytes --]
---
lisp/org-fold-core.el | 1490 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 1490 insertions(+)
create mode 100644 lisp/org-fold-core.el
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Add-org-fold-core-new-folding-engine.patch --]
[-- Type: text/x-patch; name="0001-Add-org-fold-core-new-folding-engine.patch", Size: 78656 bytes --]
diff --git a/lisp/org-fold-core.el b/lisp/org-fold-core.el
new file mode 100644
index 000000000..121c6b5c4
--- /dev/null
+++ b/lisp/org-fold-core.el
@@ -0,0 +1,1490 @@
+;;; org-fold-core.el --- Folding buffer text -*- lexical-binding: t; -*-
+;;
+;; Copyright (C) 2020-2020 Free Software Foundation, Inc.
+;;
+;; Author: Ihor Radchenko <yantar92 at gmail dot com>
+;; Keywords: folding, invisible text
+;; Homepage: https://orgmode.org
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Commentary:
+
+;; This file contains library to control temporary invisibility
+;; (folding and unfolding) of text in buffers.
+
+;; The file implements the following functionality:
+;;
+;; - Folding/unfolding regions of text
+;; - Searching and examining boundaries of folded text
+;; - Interactive searching in folded text (via isearch)
+;; - Handling edits in folded text
+;; - Killing/yanking (copying/pasting) of the folded text
+;; - Fontification of the folded text
+
+;; To setup folding in an arbitrary buffer, one must call
+;; `org-fold-core-initialize', optionally providing the list of folding specs to be
+;; used in the buffer. The specs can be added, removed, or
+;; re-configured later. Read below for more details.
+
+;;; Folding/unfolding regions of text
+
+;; User can temporarily hide/reveal (fold/unfold) arbitrary regions or
+;; text. The folds can be nested.
+
+;; Internally, nested folds are marked with different folding specs
+;; Overlapping folds marked with the same folding spec are
+;; automatically merged, while folds with different folding specs can
+;; coexist and be folded/unfolded independently.
+
+;; When multiple folding specs are applied to the same region of text,
+;; text visibility is decided according to the folding spec with
+;; topmost priority.
+
+;; By default, we define two types of folding specs:
+;; - 'org-fold-visible :: the folded text is not hidden
+;; - 'org-fold-hidden :: the folded text is completely hidden
+;;
+;; The 'org-fold-visible spec has highest priority allowing parts of
+;; text folded with 'org-fold-hidden to be shown unconditionally.
+
+;; Consider the following Org mode link:
+;; [[file:/path/to/file/file.ext][description]]
+;; Only the word "description" is normally visible in this link.
+;;
+;; The way this partial visibility is achieved is combining the two
+;; folding specs. The whole link is folded using 'org-fold-hidden
+;; folding spec, but the visible part is additionally folded using
+;; 'org-fold-visible:
+;;
+;; <begin org-fold-hidden>[[file:/path/to/file/file.ext][<begin org-fold-visible>description<end org-fold-visible>]]<end org-fold-hidden>
+;;
+;; Because 'org-fold-visible has higher priority than
+;; 'org-fold-hidden, it suppresses the 'org-fold-hidden effect and
+;; thus reveals the description part of the link.
+
+;; Similar to 'org-fold-visible, display of any arbitrary folding spec
+;; can be configured using folding spec properties. In particular,
+;; `:visible' folding spec proprety controls whether the folded text
+;; is visible or not. If the `:visible' folding spec property is nil,
+;; folded text is hidden or displayed as a constant string (ellipsis)
+;; according to the value of `:ellipsis' folding spec property. See
+;; docstring of `org-fold-core--specs' for the description of all the available
+;; folding spec properties.
+
+;; Folding spec properties of any valid folding spec can be changed
+;; any time using `org-fold-core-set-folding-spec-property'.
+
+;; If necessary, one can add or remove folding specs using
+;; `org-fold-core-add-folding-spec' and `org-fold-core-remove-folding-spec'.
+
+;; If a buffer initialised with `org-fold-core-initialize' is cloned into indirect
+;; buffers, it's folding state is copied to that indirect buffer.
+;; The folding states are independent.
+
+;; When working with indirect buffers that are handled by this
+;; library, one has to keep in mind that folding state is preserved on
+;; copy when using non-interactive functions. Moreover, the folding
+;; states of all the indirect buffers will be copied together.
+;;
+;; Example of the implications:
+;; Consider a base buffer and indirect buffer with the following state:
+;; ----- base buffer --------
+;; * Heading<begin fold>
+;; Some text folded in the base buffer, but unfolded in the indirect buffer<end fold>
+;; * Other heading
+;; Heading unfolded in both the buffers.
+;; ---------------------------
+;; ------ indirect buffer ----
+;; * Heading
+;; Some text folded in the base buffer, but unfolded in the indirect buffer
+;; * Other heading
+;; Heading unfolded in both the buffers.
+;; ----------------------------
+;; If some Elisp code copies the whole "Heading" from the indirect
+;; buffer with `buffer-substring' or match data and inserts it into
+;; the base buffer, the inserted heading will be folded since the
+;; internal setting for the folding state is shared between the base
+;; and indirect buffers. It's just that the indirect buffer ignores
+;; the base buffer folding settings. However, as soon as the text is
+;; copied back to the base buffer, the folding state will become
+;; respected again.
+
+;; If the described situation is undesired, Elisp code can use
+;; `filter-buffer-substring' instead of `buffer-substring'. All the
+;; folding states that do not belong to the currently active buffer
+;; will be cleared in the copied text then. See
+;; `org-fold-core--buffer-substring-filter' for more details.
+
+;; Because of details of implementation of the folding, it is also not
+;; recommended to set text visibility in buffer directly by setting
+;; `invisible' text property to anything other than t. While this
+;; should usually work just fine, normal folding can be broken if one
+;; sets `invisible' text property to a value not listed in
+;; `buffer-invisibility-spec'.
+
+;;; Searching and examining boundaries of folded text
+
+;; It is possible to examine folding specs (there may be several) of
+;; text at point or search for regions with the same folding spec.
+;; See functions defined under ";;;; Searching and examining folded
+;; text" below for details.
+
+;; All the folding specs can be specified by symbol representing their
+;; name. However, this is not always convenient, especially if the
+;; same spec can be used for fold different syntaxical structures.
+;; Any folding spec can be additionally referenced by a symbol listed
+;; in the spec's `:alias' folding spec property. For example, Org
+;; mode's `org-fold-outline' folding spec can be referened as any
+;; symbol from the following list: '(headline heading outline
+;; inlinetask plain-list) The list is the value of the spec's `:alias'
+;; property.
+
+;; Most of the functions defined below that require a folding spec
+;; symbol as their argument, can also accept any symbol from the
+;; `:alias' spec property to reference that folding spec.
+
+;; If one wants to search invisible text without using the provided
+;; functions, it is important to keep in mind that 'invisible text
+;; property may have multiple possible values (not just nil and
+;; t). Hence, (next-single-char-property-change pos 'invisible) is not
+;; guarantied to return the boundary of invisible/visible text.
+
+;;; Interactive searching inside folded text (via isearch)
+
+;; The library provides a way to control if the folded text can be
+;; searchable using isearch. If the text is searchable, it is also
+;; possible to control to unfold it temporarily during interactive
+;; isearch session.
+
+;; The isearch behaviour is controlled on per-folding-spec basis by
+;; setting `isearch-open' and `isearch-ignore' folding spec
+;; properties. The the docstring of `org-fold-core--specs' for more details.
+
+;;; Handling edits inside folded text
+
+;; The visibility of the text inserted in front, rear, or in the
+;; middle of a folded region is managed according to `:front-sticky'
+;; and `:rear-sticky' folding properties of the corresponding folding
+;; spec. The rules are the same with stickyness of text properties in
+;; Elisp.
+
+;; If a text being inserted into the buffer is already folded and
+;; invisible (before applying the stickyness rules), then it is
+;; revealed. This behaviour can be changed by wrapping the insertion
+;; code into `org-fold-core-ignore-modifications' macro. The macro will disable
+;; all the processing related to buffer modifications.
+
+;; The library also provides a way to unfold the text after some
+;; destructive changes breaking syntaxical structure of the buffer.
+;; For example, Org mode automatically reveals folded drawers when the
+;; drawer becomes syntaxically incorrect:
+;; ------- before modification -------
+;; :DRAWER:<begin fold>
+;; Some folded text inside drawer
+;; :END:<end fold>
+;; -----------------------------------
+;; If the ":END:" is edited, drawer syntax is not correct anymore and
+;; the folded text is automatically unfolded.
+;; ------- after modification --------
+;; :DRAWER:
+;; Some folded text inside drawer
+;; :EN:
+;; -----------------------------------
+
+;; The described automatic unfolding is controlled by `:fragile'
+;; folding spec property. It's value can be a function checking if
+;; changes inside (or around) the fold should drigger the unfold. By
+;; default, only changes that directly involve folded regions will
+;; trigger the check. In addition, `org-fold-core-extend-changed-region-functions'
+;; can be set to extend the checks to all folded regions intersecting
+;; with the region returned by the functions listed in the variable.
+
+;; The fragility checks can be bypassed if the code doing
+;; modifications is wrapped into `org-fold-core-ignore-fragility-checks' macro.
+
+;;; Fontification of the folded text
+
+;; When working with huge buffers, `font-lock' may take a lot of time
+;; to fontify all the buffer text during startup. This library
+;; provides a way to delay fontification of initially folded text to
+;; the time when the text is unfolded. The fontification is
+;; controlled on per-folding-spec basis according to `:font-lock-skip'
+;; folding spec property.
+
+;; This library replaces `font-lock-fontify-region-function' to implement the
+;; delayed fontification. However, it only does so when
+;; `font-lock-fontify-region-function' is not modified at the initialisation
+;; time. If one needs to use both delayed fontification and custom
+;; `font-lock-fontify-region-function', it is recommended to consult the
+;; source code of `org-fold-core-fontify-region'.
+
+;;; Performance considerations
+
+;; This library is using text properties to hide text. Text
+;; properties are much faster than overlays, that could be used for
+;; the same purpose. Overlays are implemented with O(n) complexity in
+;; Emacs (as for 2021-03-11). It means that any attempt to move
+;; through hidden text in a file with many invisible overlays will
+;; require time scaling with the number of folded regions (the problem
+;; Overlays note of the manual warns about). For curious, historical
+;; reasons why overlays are not efficient can be found in
+;; https://www.jwz.org/doc/lemacs.html.
+
+;; Despite using text properties, the performance is still limited by
+;; Emacs display engine. For example, >7Mb of text hidden within
+;; visible part of a buffer may cause noticeable lags (which is still
+;; orders of magnitude better in comparison with overlays). If the
+;; performance issues become critical while using this library, it is
+;; recommended to minimise the number of folding specs used in the
+;; same buffer at a time.
+
+;; Alternatively, the library provides `org-fold-core--optimise-for-huge-buffers'
+;; for additional speedup. This can be used as a file-local variable
+;; in huge buffers. The variable can be set to enable various levels
+;; of extra optimisation. See the docstring for detailed information.
+
+;; It is worth noting that when using `org-fold-core--optimise-for-huge-buffers'
+;; with `grab-invisible' option, folded regions copied to other
+;; buffers (including buffers that do not use this library) will
+;; remain invisible. org-fold-core provides functions to work around
+;; this issue: `org-fold-core-remove-optimisation' and `org-fold-core-update-optimisation', but
+;; it is unlikely that a random external package will use them.
+
+;; Another possible bottleneck is the fragility check after the change
+;; related to the folded text. The functions used in `:fragile'
+;; folding properties must be optimised. Also,
+;; `org-fold-core-ignore-fragility-checks' or even `org-fold-core-ignore-modifications' may be
+;; used when appropriate in the performance-critical code. When
+;; inserting text from within `org-fold-core-ignore-modifications' macro, it is
+;; recommended to use `insert-and-inherit' instead of `insert' and
+;; `insert-before-markers-and-inherit' instead of
+;; `insert-before-markers' to avoid revealing inserted text in the
+;; middle of a folded region.
+
+;; Performance of isearch is currently limited by Emacs isearch
+;; implementation. For now, Emacs isearch only supports searching
+;; through text hidden using overlays. This library handles isearch
+;; by converting folds with matching text to overlays, which may
+;; affect performance in case of large number of matches. In the
+;; future, Emacs will hopefully accept the relevant patch allowing
+;; isearch to work with text hidden via text properties, but the
+;; performance hit has to be accepted meanwhile.
+
+;;; Code:
+
+(require 'org-macs)
+(require 'org-compat)
+
+(declare-function isearch-filter-visible "isearch" (beg end))
+
+;;; Customization
+
+(defcustom org-fold-core-style 'text-properties
+ "Internal implementation detail used to hide folded text.
+Can be either `text-properties' or `overlays'.
+The former is faster on large files, while the latter is generally
+less error-prone."
+ :group 'org
+ :package-version '(Org . "9.6")
+ :type '(choice
+ (const :tag "Overlays" 'overlays)
+ (const :tag "Text properties" 'text-properties)))
+
+(defcustom org-fold-core-first-unfold-functions nil
+ "Functions executed after first unfolding during fontification.
+Each function is exectured with two arguments: begin and end points of
+the unfolded region."
+ :group 'org
+ :package-version '(Org . "9.6")
+ :type 'hook)
+
+(defvar-local org-fold-core-isearch-open-function #'org-fold-core--isearch-reveal
+ "Function used to reveal hidden text found by isearch.
+The function is called with a single argument - point where text is to
+be revealed.")
+
+(defvar-local org-fold-core--optimise-for-huge-buffers nil
+ "Non-nil turns on extra speedup on huge buffers (Mbs of folded text).
+
+This setting is risky and may cause various artefacts and degraded
+functionality, especially when using external packages. It is
+recommended to enable it on per-buffer basis as file-local variable.
+
+When set to non-nil, must be a list containing one or multiple the
+following symbols:
+
+- `grab-invisible': Use `invisible' text property to hide text. This
+ will reduce the load on Emacs display engine and one may use it if
+ moving point across folded regions becomes slow. However, as a side
+ effect, some external packages extracting i.e. headlings from folded
+ parts of buffer may keep the text invisible.
+
+- `ignore-fragility-checks': Do not try to detect when user edits
+ break structure of the folded elements. This will speed up
+ modifying the folded regions at the cost that some higher-level
+ functions relying on this package might not be able to unfold the
+ edited text. For example, removed leading stars from a folded
+ headline in Org mode will break visibility cycling since Org mode
+ will not be avare that the following folded text belonged to
+ headline.
+
+- `ignore-modification-checks': Do not try to detect insertions in the
+ middle of the folded regions. This will speed up non-interactive
+ edits of the folded regions. However, text inserted in the middle
+ of the folded regions may become visible for some external packages
+ inserting text using `insert' instead of `insert-and-inherit' (the
+ latter is rarely used in practice).
+
+- `ignore-indirect': Do not decouple folding state in the indirect
+ buffers. This can speed up Emacs display engine (and thus motion of
+ point), especially when large number of indirect buffers is being
+ used.
+
+- `merge-folds': Do not distinguish between different types of folding
+ specs. This is the most aggressive optimisation with unforseen and
+ potentially drastic effects.")
+(put 'org-fold-core--optimise-for-huge-buffers 'safe-local-variable 'listp)
+
+;;; Core functionality
+
+;;;; Folding specs
+
+(defvar-local org-fold-core--specs '((org-fold-visible
+ (:visible . t)
+ (:alias . (visible)))
+ (org-fold-hidden
+ (:ellipsis . "...")
+ (:isearch-open . t)
+ (:alias . (hidden))))
+ "Folding specs defined in current buffer.
+
+Each spec is a list (SPEC-SYMBOL SPEC-PROPERTIES).
+SPEC-SYMBOL is the symbol respresenting the folding spec.
+SPEC-PROPERTIES is an alist defining folding spec properties.
+
+If a text region is folded using multiple specs, only the folding spec
+listed earlier is used.
+
+The following properties are known:
+- :ellipsis :: must be nil or string to show when text is folded
+ using this spec.
+- :global :: non-nil means that folding state will be preserved
+ when copying folded text between buffers.
+- :isearch-ignore :: non-nil means that folded text is not searchable
+ using isearch.
+- :isearch-open :: non-nil means that isearch can reveal text hidden
+ using this spec. This property does nothing
+ when 'isearch-ignore property is non-nil.
+- :front-sticky :: non-nil means that text prepended to the folded text
+ is automatically folded.
+- :rear-sticky :: non-nil means that text appended to the folded text
+ is folded.
+- :visible :: non-nil means that folding spec visibility is not
+ managed. Instead, visibility settings in
+ `buffer-invisibility-spec' will be used as is.
+ Note that changing this property from nil to t may
+ clear the setting in `buffer-invisibility-spec'.
+- :alias :: a list of aliases for the SPEC-SYMBOL.
+- :font-lock-skip :: Suppress font-locking in folded text.
+- :fragile :: Must be a function accepting two arguments.
+ Non-nil means that changes in region may cause
+ the region to be revealed. The region is
+ revealed after changes if the function returns
+ non-nil.
+ The function called after changes are made with
+ two arguments: cons (beg . end) representing the
+ folded region and spec symbol.")
+(defvar-local org-fold-core--spec-symbols nil
+ "Alist holding buffer spec symbols and aliases.
+
+This variable is defined to reduce load on Emacs garbage collector
+reducing the number of transiently allocated variables.")
+(defvar-local org-fold-core--spec-list nil
+ "List holding buffer spec symbols, but not aliases.
+
+This variable is defined to reduce load on Emacs garbage collector
+reducing the number of transiently allocated variables.")
+
+(defvar-local org-fold-core-extend-changed-region-functions nil
+ "Special hook run just before handling changes in buffer.
+
+This is used to account changes outside folded regions that still
+affect the folded region visibility. For example, removing all stars
+at the beginning of a folded Org mode heading should trigger the
+folded text to be revealed. Each function is called with two
+arguments: beginning and the end of the changed region.")
+
+;;; Utility functions
+
+(defsubst org-fold-core-folding-spec-list (&optional buffer)
+ "Return list of all the folding spec symbols in BUFFER."
+ (or (buffer-local-value 'org-fold-core--spec-list (or buffer (current-buffer)))
+ (with-current-buffer (or buffer (current-buffer))
+ (setq org-fold-core--spec-list (mapcar #'car org-fold-core--specs)))))
+
+(defun org-fold-core-get-folding-spec-from-alias (spec-or-alias)
+ "Return the folding spec symbol for SPEC-OR-ALIAS.
+Return nil when there is no matching folding spec."
+ (when spec-or-alias
+ (unless org-fold-core--spec-symbols
+ (dolist (spec (org-fold-core-folding-spec-list))
+ (push (cons spec spec) org-fold-core--spec-symbols)
+ (dolist (alias (assq :alias (assq spec org-fold-core--specs)))
+ (push (cons alias spec) org-fold-core--spec-symbols))))
+ (alist-get spec-or-alias org-fold-core--spec-symbols)))
+
+(defsubst org-fold-core-folding-spec-p (spec-or-alias)
+ "Check if SPEC-OR-ALIAS is a registered folding spec."
+ (org-fold-core-get-folding-spec-from-alias spec-or-alias))
+
+(defsubst org-fold-core--check-spec (spec-or-alias)
+ "Throw an error if SPEC-OR-ALIAS is not in `org-fold-core--spec-priority-list'."
+ (unless (org-fold-core-folding-spec-p spec-or-alias)
+ (error "%s is not a valid folding spec" spec-or-alias)))
+
+(defsubst org-fold-core-get-folding-spec-property (spec-or-alias property)
+ "Get PROPERTY of a folding SPEC-OR-ALIAS.
+Possible properties can be found in `org-fold-core--specs' docstring."
+ (org-fold-core--check-spec spec-or-alias)
+ (if (and (memql 'ignore-indirect org-fold-core--optimise-for-huge-buffers)
+ (eq property :global))
+ t
+ (if (and (memql 'merge-folds org-fold-core--optimise-for-huge-buffers)
+ (eq property :visible))
+ nil
+ (cdr (assq property (assq (org-fold-core-get-folding-spec-from-alias spec-or-alias) org-fold-core--specs))))))
+
+(defconst org-fold-core--spec-property-prefix "org-fold--spec-"
+ "Prefix used to create property symbol.")
+
+(defsubst org-fold-core-get-folding-property-symbol (spec &optional buffer global)
+ "Get folding text property using to store SPEC in current buffer or BUFFER.
+If GLOBAL is non-nil, do not make the property unique in the BUFFER."
+ (if (memql 'merge-folds org-fold-core--optimise-for-huge-buffers)
+ (intern (format "%s-global" org-fold-core--spec-property-prefix))
+ (intern (format (concat org-fold-core--spec-property-prefix "%s-%S")
+ (symbol-name spec)
+ ;; (sxhash buf) appears to be not constant over time.
+ ;; Using buffer-name is safe, since the only place where
+ ;; buffer-local text property actually matters is an indirect
+ ;; buffer, where the name cannot be same anyway.
+ (if global 'global
+ (sxhash (buffer-name (or buffer (current-buffer)))))))))
+
+(defsubst org-fold-core-get-folding-spec-from-folding-prop (folding-prop)
+ "Return folding spec symbol used for folding property with name FOLDING-PROP."
+ (catch :exit
+ (dolist (spec (org-fold-core-folding-spec-list))
+ ;; We know that folding properties have
+ ;; folding spec in their name.
+ (when (string-match-p (symbol-name spec)
+ (symbol-name folding-prop))
+ (throw :exit spec)))))
+
+(defvar org-fold-core--property-symbol-cache (make-hash-table :test 'equal)
+ "Saved values of folding properties for (buffer . spec) conses.")
+(defvar-local org-fold-core--indirect-buffers nil
+ "List of indirect buffers created from current buffer.
+
+The first element of the list is always the current buffer.
+
+This variable is needed to work around Emacs bug#46982, while Emacs
+does not provide a way `after-change-functions' in any other buffer
+than the buffer where the change was actually made.")
+
+(defmacro org-fold-core-cycle-over-indirect-buffers (&rest body)
+ "Execute BODY in current buffer and all its indirect buffers.
+
+Also, make sure that folding properties from killed buffers are not
+hanging around."
+ (declare (debug (form body)) (indent 1))
+ `(let (buffers dead-properties)
+ (if (and (not (buffer-base-buffer))
+ (not (eq (current-buffer) (car org-fold-core--indirect-buffers))))
+ ;; We are in base buffer with `org-fold-core--indirect-buffers' value from
+ ;; different buffer. This can happen, for example, when
+ ;; org-capture copies local variables into *Capture* buffer.
+ (setq buffers (list (current-buffer)))
+ (dolist (buf (cons (or (buffer-base-buffer) (current-buffer))
+ (buffer-local-value 'org-fold-core--indirect-buffers (or (buffer-base-buffer) (current-buffer)))))
+ (if (buffer-live-p buf)
+ (push buf buffers)
+ (dolist (spec (org-fold-core-folding-spec-list))
+ (when (and (not (org-fold-core-get-folding-spec-property spec :global))
+ (gethash (cons buf spec) org-fold-core--property-symbol-cache))
+ ;; Make sure that dead-properties variable can be passed
+ ;; as argument to `remove-text-properties'.
+ (push t dead-properties)
+ (push (gethash (cons buf spec) org-fold-core--property-symbol-cache)
+ dead-properties))))))
+ (dolist (buf buffers)
+ (with-current-buffer buf
+ (with-silent-modifications
+ (save-restriction
+ (widen)
+ (remove-text-properties
+ (point-min) (point-max)
+ dead-properties)))
+ ,@body))))
+
+;; This is the core function used to fold text in buffers. We use
+;; text properties to hide folded text, however 'invisible property is
+;; not directly used (unless risky `org-fold-core--optimise-for-huge-buffers' is
+;; enabled). Instead, we define unique text property (folding
+;; property) for every possible folding spec and add the resulting
+;; text properties into `char-property-alias-alist', so that
+;; 'invisible text property is automatically defined if any of the
+;; folding properties is non-nil. This approach lets us maintain
+;; multiple folds for the same text region - poor man's overlays (but
+;; much faster). Additionally, folding properties are ensured to be
+;; unique for different buffers (especially for indirect
+;; buffers). This is done to allow different folding states in
+;; indirect buffers.
+(defun org-fold-core--property-symbol-get-create (spec &optional buffer return-only)
+ "Return a unique symbol suitable as folding text property.
+Return value is unique for folding SPEC in BUFFER.
+If the buffer already have buffer-local setup in `char-property-alias-alist'
+and the setup appears to be created for different buffer,
+copy the old invisibility state into new buffer-local text properties,
+unless RETURN-ONLY is non-nil."
+ (if (eq org-fold-core-style 'overlays)
+ (org-fold-core-get-folding-property-symbol spec nil 'global)
+ (let* ((buf (or buffer (current-buffer))))
+ ;; Create unique property symbol for SPEC in BUFFER
+ (let ((local-prop (or (gethash (cons buf spec) org-fold-core--property-symbol-cache)
+ (puthash (cons buf spec)
+ (org-fold-core-get-folding-property-symbol
+ spec buf
+ (org-fold-core-get-folding-spec-property spec :global))
+ org-fold-core--property-symbol-cache))))
+ (prog1
+ local-prop
+ (unless return-only
+ (with-current-buffer buf
+ ;; Update folding properties carried over from other
+ ;; buffer (implying that current buffer is indirect
+ ;; buffer). Normally, `char-property-alias-alist' in new
+ ;; indirect buffer is a copy of the same variable from
+ ;; the base buffer. Then, `char-property-alias-alist'
+ ;; would contain folding properties, which are not
+ ;; matching the generated `local-prop'.
+ (unless (member local-prop (cdr (assq 'invisible char-property-alias-alist)))
+ ;; Add current buffer to the list of indirect buffers in the base buffer.
+ (when (buffer-base-buffer)
+ (with-current-buffer (buffer-base-buffer)
+ (setq-local org-fold-core--indirect-buffers
+ (let (bufs)
+ (org-fold-core-cycle-over-indirect-buffers
+ (push (current-buffer) bufs))
+ (push buf bufs)
+ (delete-dups bufs)))))
+ ;; Copy all the old folding properties to preserve the folding state
+ (with-silent-modifications
+ (dolist (old-prop (cdr (assq 'invisible char-property-alias-alist)))
+ (org-with-wide-buffer
+ (let* ((pos (point-min))
+ (spec (org-fold-core-get-folding-spec-from-folding-prop old-prop))
+ ;; Generate new buffer-unique folding property
+ (new-prop (when spec (org-fold-core--property-symbol-get-create spec nil 'return-only))))
+ ;; Copy the visibility state for `spec' from `old-prop' to `new-prop'
+ (unless (eq old-prop new-prop)
+ (while (< pos (point-max))
+ (let ((val (get-text-property pos old-prop))
+ (next (next-single-char-property-change pos old-prop)))
+ (when val
+ (put-text-property pos next new-prop val))
+ (setq pos next)))))))
+ ;; Update `char-property-alias-alist' with folding
+ ;; properties unique for the current buffer.
+ (setq-local char-property-alias-alist
+ (cons (cons 'invisible
+ (mapcar (lambda (spec)
+ (org-fold-core--property-symbol-get-create spec nil 'return-only))
+ (org-fold-core-folding-spec-list)))
+ (remove (assq 'invisible char-property-alias-alist)
+ char-property-alias-alist)))
+ ;; Set folding property stickyness according to
+ ;; their `:font-sticky' and `:rear-sticky'
+ ;; parameters.
+ (let (full-prop-list)
+ (org-fold-core-cycle-over-indirect-buffers
+ (setq full-prop-list
+ (append full-prop-list
+ (delq nil
+ (mapcar (lambda (spec)
+ (cond
+ ((org-fold-core-get-folding-spec-property spec :front-sticky)
+ (cons (org-fold-core--property-symbol-get-create spec nil 'return-only)
+ nil))
+ ((org-fold-core-get-folding-spec-property spec :rear-sticky)
+ nil)
+ (t
+ (cons (org-fold-core--property-symbol-get-create spec nil 'return-only)
+ t))))
+ (org-fold-core-folding-spec-list))))))
+ (org-fold-core-cycle-over-indirect-buffers
+ (setq-local text-property-default-nonsticky
+ (delete-dups (append
+ text-property-default-nonsticky
+ full-prop-list))))))))))))))
+
+(defun org-fold-core-decouple-indirect-buffer-folds ()
+ "Copy and decouple folding state in a newly created indirect buffer.
+This function is mostly indented to be used in `clone-indirect-buffer-hook'."
+ (when (and (buffer-base-buffer)
+ (eq org-fold-core-style 'text-properties))
+ (org-fold-core--property-symbol-get-create (car (org-fold-core-folding-spec-list)))))
+
+;;; API
+
+;;;; Modifying folding specs
+
+(defun org-fold-core-set-folding-spec-property (spec property value &optional force)
+ "Set PROPERTY of a folding SPEC to VALUE.
+Possible properties and values can be found in `org-fold-core--specs' docstring.
+Do not check previous value when FORCE is non-nil."
+ (pcase property
+ (:ellipsis
+ (unless (and (not force) (equal value (org-fold-core-get-folding-spec-property spec :ellipsis)))
+ (remove-from-invisibility-spec (cons spec (org-fold-core-get-folding-spec-property spec :ellipsis)))
+ (unless (org-fold-core-get-folding-spec-property spec :visible)
+ (add-to-invisibility-spec (cons spec value)))))
+ (:visible
+ (unless (or (memql 'merge-folds org-fold-core--optimise-for-huge-buffers)
+ (and (not force) (equal value (org-fold-core-get-folding-spec-property spec :visible))))
+ (if value
+ (remove-from-invisibility-spec (cons spec (org-fold-core-get-folding-spec-property spec :ellipsis)))
+ (add-to-invisibility-spec (cons spec (org-fold-core-get-folding-spec-property spec :ellipsis))))))
+ (:alias
+ ;; Clear symbol cache.
+ (setq org-fold-core--spec-symbols nil))
+ (:isearch-open nil)
+ (:isearch-ignore nil)
+ (:front-sticky nil)
+ (:rear-sticky nil)
+ (_ nil))
+ (setf (cdr (assq property (assq spec org-fold-core--specs))) value))
+
+(defun org-fold-core-add-folding-spec (spec &optional properties buffer append)
+ "Add a new folding SPEC with PROPERTIES in BUFFER.
+
+SPEC must be a symbol. BUFFER can be a buffer to set SPEC in or nil to
+set SPEC in current buffer.
+
+By default, the added SPEC will have highest priority among the
+previously defined specs. When optional APPEND argument is non-nil,
+SPEC will have the lowest priority instead. If SPEC was already
+defined earlier, it will be redefined according to provided optional
+arguments.
+`
+The folding spec properties will be set to PROPERTIES (see
+`org-fold-core--specs' for details)."
+ (when (eq spec 'all) (error "Cannot use reserved folding spec symbol 'all"))
+ (with-current-buffer (or buffer (current-buffer))
+ ;; Clear the cache.
+ (setq org-fold-core--spec-list nil
+ org-fold-core--spec-symbols nil)
+ (let* ((full-properties (mapcar (lambda (prop) (cons prop (cdr (assq prop properties))))
+ '( :visible :ellipsis :isearch-ignore
+ :global :isearch-open :front-sticky
+ :rear-sticky :fragile :alias
+ :font-lock-skip)))
+ (full-spec (cons spec full-properties)))
+ (add-to-list 'org-fold-core--specs full-spec append)
+ (mapc (lambda (prop-cons) (org-fold-core-set-folding-spec-property spec (car prop-cons) (cdr prop-cons) 'force)) full-properties)
+ ;; Update buffer inivisibility specs.
+ (org-fold-core--property-symbol-get-create spec))))
+
+(defun org-fold-core-remove-folding-spec (spec &optional buffer)
+ "Remove a folding SPEC in BUFFER.
+
+SPEC must be a symbol.
+
+BUFFER can be a buffer to remove SPEC in, nil to remove SPEC in current
+buffer, or 'all to remove SPEC in all open `org-mode' buffers and all
+future org buffers."
+ (org-fold-core--check-spec spec)
+ (when (eq buffer 'all)
+ (setq-default org-fold-core--specs (delete (cdr (assq spec org-fold-core--specs)) org-fold-core--specs))
+ (mapc (lambda (buf)
+ (org-fold-core-remove-folding-spec spec buf))
+ (buffer-list)))
+ (let ((buffer (or buffer (current-buffer))))
+ (with-current-buffer buffer
+ ;; Clear the cache.
+ (setq org-fold-core--spec-list nil
+ org-fold-core--spec-symbols nil)
+ (org-fold-core-set-folding-spec-property spec :visible t)
+ (setq org-fold-core--specs (delete (cdr (assq spec org-fold-core--specs)) org-fold-core--specs)))))
+
+(defun org-fold-core-initialize (&optional specs)
+ "Setup folding in current buffer using SPECS as value of `org-fold-core--specs'."
+ ;; Preserve the priorities.
+ (when specs (setq specs (nreverse specs)))
+ (unless specs (setq specs org-fold-core--specs))
+ (setq org-fold-core--specs nil
+ org-fold-core--spec-list nil
+ org-fold-core--spec-symbols nil)
+ (dolist (spec specs)
+ (org-fold-core-add-folding-spec (car spec) (cdr spec)))
+ (add-hook 'after-change-functions 'org-fold-core--fix-folded-region nil 'local)
+ (add-hook 'clone-indirect-buffer-hook #'org-fold-core-decouple-indirect-buffer-folds nil 'local)
+ ;; Optimise buffer fontification to not fontify folded text.
+ (when (eq font-lock-fontify-region-function #'font-lock-default-fontify-region)
+ (setq-local font-lock-fontify-region-function 'org-fold-core-fontify-region))
+ ;; Setup killing text
+ (setq-local filter-buffer-substring-function #'org-fold-core--buffer-substring-filter)
+ (if (and (boundp 'isearch-opened-regions)
+ (eq org-fold-core-style 'text-properties))
+ ;; Use new implementation of isearch allowing to search inside text
+ ;; hidden via text properties.
+ (org-fold-core--isearch-setup 'text-properties)
+ (org-fold-core--isearch-setup 'overlays)))
+
+;;;; Searching and examining folded text
+
+(defsubst org-fold-core-folded-p (&optional pos spec-or-alias)
+ "Non-nil if the character after POS is folded.
+If POS is nil, use `point' instead.
+If SPEC-OR-ALIAS is a folding spec, only check the given folding spec."
+ (org-fold-core-get-folding-spec spec-or-alias pos))
+
+(defun org-fold-core-region-folded-p (beg end &optional spec-or-alias)
+ "Non-nil if the region between BEG and END is folded.
+If SPEC-OR-ALIAS is a folding spec, only check the given folding spec."
+ (org-with-point-at beg
+ (catch :visible
+ (while (< (point) end)
+ (unless (org-fold-core-get-folding-spec spec-or-alias) (throw :visible nil))
+ (goto-char (org-fold-core-next-folding-state-change spec-or-alias nil end)))
+ t)))
+
+(defun org-fold-core-get-folding-spec (&optional spec-or-alias pom)
+ "Get folding state at `point' or POM.
+Return nil if there is no folding at point or POM.
+If SPEC-OR-ALIAS is nil, return a folding spec with highest priority
+among present at `point' or POM.
+If SPEC-OR-ALIAS is 'all, return the list of all present folding
+specs.
+If SPEC-OR-ALIAS is a valid folding spec or a spec alias, return the
+corresponding folding spec (if the text is folded using that spec)."
+ (let ((spec (if (eq spec-or-alias 'all)
+ 'all
+ (org-fold-core-get-folding-spec-from-alias spec-or-alias))))
+ (when (and spec (not (eq spec 'all))) (org-fold-core--check-spec spec))
+ (org-with-point-at pom
+ (cond
+ ((eq spec 'all)
+ (let ((result))
+ (dolist (spec (org-fold-core-folding-spec-list))
+ (let ((val (get-char-property (point) (org-fold-core--property-symbol-get-create spec nil t))))
+ (when val (push val result))))
+ (reverse result)))
+ ((null spec)
+ (let ((result (get-char-property (point) 'invisible)))
+ (when (org-fold-core-folding-spec-p result) result)))
+ (t (get-char-property (point) (org-fold-core--property-symbol-get-create spec nil t)))))))
+
+(defun org-fold-core-get-folding-specs-in-region (beg end)
+ "Get all folding specs in region from BEG to END."
+ (let ((pos beg)
+ all-specs)
+ (while (< pos end)
+ (setq all-specs (append all-specs (org-fold-core-get-folding-spec nil pos)))
+ (setq pos (org-fold-core-next-folding-state-change nil pos end)))
+ (unless (listp all-specs) (setq all-specs (list all-specs)))
+ (delete-dups all-specs)))
+
+(defun org-fold-core-get-region-at-point (&optional spec-or-alias pom)
+ "Return region folded using SPEC-OR-ALIAS at POM.
+If SPEC is nil, return the largest possible folded region.
+The return value is a cons of beginning and the end of the region.
+Return nil when no fold is present at point of POM."
+ (let ((spec (org-fold-core-get-folding-spec-from-alias spec-or-alias)))
+ (org-with-point-at (or pom (point))
+ (if spec
+ (if (eq org-fold-core-style 'text-properties)
+ (org-find-text-property-region (point) (org-fold-core--property-symbol-get-create spec nil t))
+ (let ((ov (cdr (get-char-property-and-overlay (point) (org-fold-core--property-symbol-get-create spec nil t)))))
+ (when ov (cons (overlay-start ov) (overlay-end ov)))))
+ (let ((region (cons (point) (point))))
+ (dolist (spec (org-fold-core-get-folding-spec 'all))
+ (let ((local-region (org-fold-core-get-region-at-point spec)))
+ (when (< (car local-region) (car region))
+ (setcar region (car local-region)))
+ (when (> (cdr local-region) (cdr region))
+ (setcdr region (cdr local-region)))))
+ (unless (eq (car region) (cdr region)) region))))))
+
+(defun org-fold-core-next-visibility-change (&optional pos limit ignore-hidden-p previous-p)
+ "Return next point from POS up to LIMIT where text becomes visible/invisible.
+By default, text hidden by any means (i.e. not only by folding, but
+also via fontification) will be considered.
+If IGNORE-HIDDEN-P is non-nil, consider only folded text.
+If PREVIOUS-P is non-nil, search backwards."
+ (let* ((pos (or pos (point)))
+ (invisible-p (if ignore-hidden-p
+ #'org-fold-core-folded-p
+ #'invisible-p))
+ (invisible-initially? (funcall invisible-p pos))
+ (limit (or limit (if previous-p
+ (point-min)
+ (point-max))))
+ (cmp (if previous-p #'> #'<))
+ (next-change (if previous-p
+ (if ignore-hidden-p
+ (lambda (p) (org-fold-core-previous-folding-state-change (org-fold-core-get-folding-spec nil p) p limit))
+ (lambda (p) (max limit (1- (previous-single-char-property-change p 'invisible nil limit)))))
+ (if ignore-hidden-p
+ (lambda (p) (org-fold-core-next-folding-state-change (org-fold-core-get-folding-spec nil p) p limit))
+ (lambda (p) (next-single-char-property-change p 'invisible nil limit)))))
+ (next pos))
+ (while (and (funcall cmp next limit)
+ (not (org-xor invisible-initially? (funcall invisible-p next))))
+ (setq next (funcall next-change next)))
+ next))
+
+(defun org-fold-core-previous-visibility-change (&optional pos limit ignore-hidden-p)
+ "Call `org-fold-core-next-visibility-change' searching backwards."
+ (org-fold-core-next-visibility-change pos limit ignore-hidden-p 'previous))
+
+(defun org-fold-core-next-folding-state-change (&optional spec-or-alias pos limit previous-p)
+ "Return point after POS where folding state changes up to LIMIT.
+If SPEC-OR-ALIAS is nil, return next point where _any_ single folding
+spec changes.
+For example, (org-fold-core-next-folding-state-change nil) with point
+somewhere in the below structure will return the nearest <...> point.
+
+* Headline <begin outline fold>
+:PROPERTIES:<begin drawer fold>
+:ID: test
+:END:<end drawer fold>
+
+Fusce suscipit, wisi nec facilisis facilisis, est dui fermentum leo,
+quis tempor ligula erat quis odio.
+
+** Another headline
+:DRAWER:<begin drawer fold>
+:END:<end drawer fold>
+** Yet another headline
+<end of outline fold>
+
+If SPEC-OR-ALIAS is a folding spec symbol, only consider that folding
+spec.
+
+If SPEC-OR-ALIAS is a list, only consider changes of folding specs
+from the list.
+
+Search backwards when PREVIOUS-P is non-nil."
+ (when (and spec-or-alias (symbolp spec-or-alias))
+ (setq spec-or-alias (list spec-or-alias)))
+ (when spec-or-alias
+ (setq spec-or-alias
+ (mapcar (lambda (spec-or-alias)
+ (or (org-fold-core-get-folding-spec-from-alias spec-or-alias)
+ spec-or-alias))
+ spec-or-alias))
+ (mapc #'org-fold-core--check-spec spec-or-alias))
+ (unless spec-or-alias
+ (setq spec-or-alias (org-fold-core-folding-spec-list)))
+ (setq pos (or pos (point)))
+ (apply (if previous-p
+ #'max
+ #'min)
+ (mapcar (if previous-p
+ (lambda (prop) (max (or limit (point-min)) (previous-single-property-change pos prop nil (or limit (point-min)))))
+ (lambda (prop) (next-single-property-change pos prop nil (or limit (point-max)))))
+ (mapcar (lambda (el) (org-fold-core--property-symbol-get-create el nil t))
+ spec-or-alias))))
+
+(defun org-fold-core-previous-folding-state-change (&optional spec-or-alias pos limit)
+ "Call `org-fold-core-next-folding-state-change' searching backwards."
+ (org-fold-core-next-folding-state-change spec-or-alias pos limit 'previous))
+
+(defun org-fold-core-search-forward (spec-or-alias &optional limit)
+ "Search next region folded via folding SPEC-OR-ALIAS up to LIMIT.
+Move point right after the end of the region, to LIMIT, or
+`point-max'. The `match-data' will contain the region."
+ (let ((spec (org-fold-core-get-folding-spec-from-alias spec-or-alias)))
+ (let ((prop-symbol (org-fold-core--property-symbol-get-create spec nil t)))
+ (goto-char (or (next-single-char-property-change (point) prop-symbol nil limit) limit (point-max)))
+ (when (and (< (point) (or limit (point-max)))
+ (not (org-fold-core-get-folding-spec spec)))
+ (goto-char (next-single-char-property-change (point) prop-symbol nil limit)))
+ (when (org-fold-core-get-folding-spec spec)
+ (let ((region (org-fold-core-get-region-at-point spec)))
+ (when (< (cdr region) (or limit (point-max)))
+ (goto-char (1+ (cdr region)))
+ (set-match-data (list (set-marker (make-marker) (car region) (current-buffer))
+ (set-marker (make-marker) (cdr region) (current-buffer))))))))))
+
+;;;; Changing visibility
+
+;;;;; Region visibility
+
+(defvar org-fold-core--fontifying nil
+ "Flag used to avoid font-lock recursion.")
+
+;; This is the core function performing actual folding/unfolding. The
+;; folding state is stored in text property (folding property)
+;; returned by `org-fold-core--property-symbol-get-create'. The value of the
+;; folding property is folding spec symbol.
+(defun org-fold-core-region (from to flag &optional spec-or-alias)
+ "Hide or show lines from FROM to TO, according to FLAG.
+SPEC-OR-ALIAS is the folding spec or foldable element, as a symbol.
+If SPEC-OR-ALIAS is omitted and FLAG is nil, unfold everything in the region."
+ (let ((spec (org-fold-core-get-folding-spec-from-alias spec-or-alias)))
+ (when spec (org-fold-core--check-spec spec))
+ (with-silent-modifications
+ (org-with-wide-buffer
+ (when (eq org-fold-core-style 'overlays) (remove-overlays from to 'invisible spec))
+ (if flag
+ (if (not spec)
+ (error "Calling `org-fold-core-region' with missing SPEC")
+ (if (eq org-fold-core-style 'overlays)
+ ;; Use `front-advance' since text right before to the beginning of
+ ;; the overlay belongs to the visible line than to the contents.
+ (let ((o (make-overlay from to nil
+ (org-fold-core-get-folding-spec-property spec :front-sticky)
+ (org-fold-core-get-folding-spec-property spec :rear-sticky))))
+ (overlay-put o 'evaporate t)
+ (overlay-put o (org-fold-core--property-symbol-get-create spec) spec)
+ (overlay-put o 'invisible spec)
+ (overlay-put o 'isearch-open-invisible #'org-fold-core--isearch-show)
+ (overlay-put o 'isearch-open-invisible-temporary #'org-fold-core--isearch-show-temporary))
+ (put-text-property from to (org-fold-core--property-symbol-get-create spec) spec)
+ (put-text-property from to 'isearch-open-invisible #'org-fold-core--isearch-show)
+ (put-text-property from to 'isearch-open-invisible-temporary #'org-fold-core--isearch-show-temporary)
+ (when (memql 'grab-invisible org-fold-core--optimise-for-huge-buffers)
+ ;; If the SPEC has highest priority, assign it directly
+ ;; to 'invisible property as well. This is done to speed
+ ;; up Emacs redisplay on huge (Mbs) folded regions where
+ ;; we don't even want Emacs to spend time cycling over
+ ;; `char-property-alias-alist'.
+ (when (eq spec (caar org-fold-core--specs)) (put-text-property from to 'invisible spec)))))
+ (if (not spec)
+ (mapc (lambda (spec) (org-fold-core-region from to nil spec)) (org-fold-core-folding-spec-list))
+ (when (and (memql 'grab-invisible org-fold-core--optimise-for-huge-buffers)
+ (eq org-fold-core-style 'text-properties))
+ (when (eq spec (caar org-fold-core--specs))
+ (let ((pos from))
+ (while (< pos to)
+ (if (eq spec (get-text-property pos 'invisible))
+ (let ((next (org-fold-core-next-folding-state-change spec pos to)))
+ (remove-text-properties pos next '(invisible t))
+ (setq pos next))
+ (setq pos (next-single-char-property-change pos 'invisible nil to)))))))
+ (when (eq org-fold-core-style 'text-properties)
+ (remove-text-properties from to (list (org-fold-core--property-symbol-get-create spec) nil)))
+ ;; Fontify unfolded text.
+ (unless (or (not font-lock-mode)
+ org-fold-core--fontifying
+ (not (org-fold-core-get-folding-spec-property spec :font-lock-skip))
+ (not (text-property-not-all from to 'org-fold-core-fontified t)))
+ (let ((org-fold-core--fontifying t))
+ (if jit-lock-mode
+ (jit-lock-refontify from to)
+ (save-match-data (font-lock-fontify-region from to)))))))))))
+
+;;; Make isearch search in some text hidden via text propertoes
+
+(defvar org-fold-core--isearch-overlays nil
+ "List of overlays temporarily created during isearch.
+This is used to allow searching in regions hidden via text properties.
+As for [2020-05-09 Sat], Isearch only has special handling of hidden overlays.
+Any text hidden via text properties is not revealed even if `search-invisible'
+is set to 't.")
+
+(defvar-local org-fold-core--isearch-local-regions (make-hash-table :test 'equal)
+ "Hash table storing temporarily shown folds from isearch matches.")
+
+(defun org-fold-core--isearch-setup (type)
+ "Initialize isearch in org buffer.
+TYPE can be either `text-properties' or `overlays'."
+ (pcase type
+ (`text-properties
+ (setq-local search-invisible 'open-all)
+ (add-hook 'isearch-mode-end-hook #'org-fold-core--clear-isearch-state nil 'local)
+ (add-hook 'isearch-mode-hook #'org-fold-core--clear-isearch-state nil 'local)
+ (setq-local isearch-filter-predicate #'org-fold-core--isearch-filter-predicate-text-properties))
+ (`overlays
+ (when (eq org-fold-core-style 'text-properties)
+ (setq-local isearch-filter-predicate #'org-fold-core--isearch-filter-predicate-overlays)
+ (add-hook 'isearch-mode-end-hook #'org-fold-core--clear-isearch-overlays nil 'local)))
+ (_ (error "%s: Unknown type of setup for `org-fold-core--isearch-setup'" type))))
+
+(defun org-fold-core--isearch-reveal (pos)
+ "Default function used to reveal hidden text at POS for isearch."
+ (let ((region (org-fold-core-get-region-at-point pos)))
+ (org-fold-core-region (car region) (cdr region) nil)))
+
+(defun org-fold-core--isearch-filter-predicate-text-properties (beg end)
+ "Make sure that folded text is searchable when user whant so.
+This function is intended to be used as `isearch-filter-predicate'."
+ (and
+ ;; Check folding specs that cannot be searched
+ (not (memq nil (mapcar (lambda (spec) (not (org-fold-core-get-folding-spec-property spec :isearch-ignore)))
+ (org-fold-core-get-folding-specs-in-region beg end))))
+ ;; Check 'invisible properties that are not folding specs.
+ (or (eq search-invisible t) ; User wants to search anyway, allow it.
+ (let ((pos beg)
+ unknown-invisible-property)
+ (while (and (< pos end)
+ (not unknown-invisible-property))
+ (when (and (get-text-property pos 'invisible)
+ (not (org-fold-core-folding-spec-p (get-text-property pos 'invisible))))
+ (setq unknown-invisible-property t))
+ (setq pos (next-single-char-property-change pos 'invisible)))
+ (not unknown-invisible-property)))
+ (or (and (eq search-invisible t)
+ ;; FIXME: this opens regions permanenly for now.
+ ;; I also tried to force search-invisible 'open-all around
+ ;; `isearch-range-invisible', but that somehow causes
+ ;; infinite loop in `isearch-lazy-highlight'.
+ (prog1 t
+ ;; We still need to reveal the folded location
+ (org-fold-core--isearch-show-temporary (cons beg end) nil)))
+ (not (isearch-range-invisible beg end)))))
+
+(defun org-fold-core--clear-isearch-state ()
+ "Clear `org-fold-core--isearch-local-regions'."
+ (clrhash org-fold-core--isearch-local-regions))
+
+(defun org-fold-core--isearch-show (region)
+ "Reveal text in REGION found by isearch."
+ (org-with-point-at (car region)
+ (while (< (point) (cdr region))
+ (funcall org-fold-core-isearch-open-function (car region))
+ (goto-char (org-fold-core-next-visibility-change (point) (cdr region) 'ignore-hidden)))))
+
+(defun org-fold-core--isearch-show-temporary (region hide-p)
+ "Temporarily reveal text in REGION.
+Hide text instead if HIDE-P is non-nil."
+ (if (not hide-p)
+ (let ((pos (car region)))
+ (while (< pos (cdr region))
+ (let ((spec-no-open
+ (catch :found
+ (dolist (spec (org-fold-core-get-folding-spec 'all pos))
+ (unless (org-fold-core-get-folding-spec-property spec :isearch-open)
+ (throw :found spec))))))
+ (if spec-no-open
+ ;; Skip regions folded with folding specs that cannot be opened.
+ (setq pos (org-fold-core-next-folding-state-change spec-no-open pos (cdr region)))
+ (dolist (spec (org-fold-core-get-folding-spec 'all pos))
+ (push (cons spec (org-fold-core-get-region-at-point spec pos)) (gethash region org-fold-core--isearch-local-regions)))
+ (org-fold-core--isearch-show region)
+ (setq pos (org-fold-core-next-folding-state-change nil pos (cdr region)))))))
+ (mapc (lambda (val) (org-fold-core-region (cadr val) (cddr val) t (car val))) (gethash region org-fold-core--isearch-local-regions))
+ (remhash region org-fold-core--isearch-local-regions)))
+
+(defvar-local org-fold-core--isearch-special-specs nil
+ "List of specs that can break visibility state when converted to overlays.
+This is a hack, but I do not see a better way around until isearch
+gets support of text properties.")
+(defun org-fold-core--create-isearch-overlays (beg end)
+ "Replace text property invisibility spec by overlays between BEG and END.
+All the searcheable folded regions will be changed to use overlays
+instead of text properties. The created overlays will be stored in
+`org-fold-core--isearch-overlays'."
+ (let ((pos beg))
+ (while (< pos end)
+ ;; We need loop below to make sure that we clean all invisible
+ ;; properties, which may be nested.
+ (dolist (spec (org-fold-core-get-folding-spec 'all pos))
+ (unless (org-fold-core-get-folding-spec-property spec :isearch-ignore)
+ (let* ((region (org-fold-core-get-region-at-point spec pos)))
+ (when (memq spec org-fold-core--isearch-special-specs)
+ (setq pos (min pos (car region)))
+ (setq end (max end (cdr region))))
+ ;; Changing text properties is considered buffer modification.
+ ;; We do not want it here.
+ (with-silent-modifications
+ (org-fold-core-region (car region) (cdr region) nil spec)
+ ;; The overlay is modelled after `outline-flag-region'
+ ;; [2020-05-09 Sat] overlay for 'outline blocks.
+ (let ((o (make-overlay (car region) (cdr region) nil 'front-advance)))
+ (overlay-put o 'evaporate t)
+ (overlay-put o 'invisible spec)
+ (overlay-put o 'org-invisible spec)
+ ;; Make sure that overlays are applied in the same order
+ ;; with the folding specs.
+ ;; Note: `memq` returns cdr with car equal to the first
+ ;; found matching element.
+ (overlay-put o 'priority (length (memq spec (org-fold-core-folding-spec-list))))
+ ;; `delete-overlay' here means that spec information will be lost
+ ;; for the region. The region will remain visible.
+ (if (org-fold-core-get-folding-spec-property spec :isearch-open)
+ (overlay-put o 'isearch-open-invisible #'delete-overlay)
+ (overlay-put o 'isearch-open-invisible #'ignore)
+ (overlay-put o 'isearch-open-invisible-temporary #'ignore))
+ (push o org-fold-core--isearch-overlays))))))
+ (setq pos (org-fold-core-next-folding-state-change nil pos end)))))
+
+(defun org-fold-core--isearch-filter-predicate-overlays (beg end)
+ "Return non-nil if text between BEG and END is deemed visible by isearch.
+This function is intended to be used as `isearch-filter-predicate'."
+ (org-fold-core--create-isearch-overlays beg end) ;; trick isearch by creating overlays in place of invisible text
+ (isearch-filter-visible beg end))
+
+(defun org-fold-core--clear-isearch-overlay (ov)
+ "Convert OV region back into using text properties."
+ (let ((spec (if isearch-mode-end-hook-quit
+ ;; Restore all folds.
+ (overlay-get ov 'org-invisible)
+ ;; Leave opened folds open.
+ (overlay-get ov 'invisible))))
+ ;; Ignore deleted overlays.
+ (when (and spec
+ (overlay-buffer ov))
+ ;; Changing text properties is considered buffer modification.
+ ;; We do not want it here.
+ (with-silent-modifications
+ (when (<= (overlay-end ov) (point-max))
+ (org-fold-core-region (overlay-start ov) (overlay-end ov) t spec)))))
+ (when (member ov isearch-opened-overlays)
+ (setq isearch-opened-overlays (delete ov isearch-opened-overlays)))
+ (delete-overlay ov))
+
+(defun org-fold-core--clear-isearch-overlays ()
+ "Convert overlays from `org-fold-core--isearch-overlays' back to text properties."
+ (when org-fold-core--isearch-overlays
+ (mapc #'org-fold-core--clear-isearch-overlay org-fold-core--isearch-overlays)
+ (setq org-fold-core--isearch-overlays nil)))
+
+;;; Handling changes in folded elements
+
+(defvar org-fold-core--ignore-modifications nil
+ "Non-nil: skip processing modifications in `org-fold-core--fix-folded-region'.")
+(defvar org-fold-core--ignore-fragility-checks nil
+ "Non-nil: skip fragility checks in `org-fold-core--fix-folded-region'.")
+
+(defmacro org-fold-core-ignore-modifications (&rest body)
+ "Run BODY ignoring buffer modifications in `org-fold-core--fix-folded-region'."
+ (declare (debug (form body)) (indent 1))
+ `(let ((org-fold-core--ignore-modifications t))
+ (unwind-protect (progn ,@body)
+ (setq org-fold-core--last-buffer-chars-modified-tick (buffer-chars-modified-tick)))))
+
+(defmacro org-fold-core-ignore-fragility-checks (&rest body)
+ "Run BODY skipping :fragility checks in `org-fold-core--fix-folded-region'."
+ (declare (debug (form body)) (indent 1))
+ `(let ((org-fold-core--ignore-fragility-checks t))
+ (progn ,@body)))
+
+(defvar-local org-fold-core--last-buffer-chars-modified-tick nil
+ "Variable storing the last return value of `buffer-chars-modified-tick'.")
+
+(defun org-fold-core--fix-folded-region (from to _)
+ "Process modifications in folded elements within FROM . TO region.
+This function intended to be used as one of `after-change-functions'.
+
+This function does nothing if text the only modification was changing
+text properties (for the sake of reducing overheads).
+
+If a text was inserted into invisible region, hide the inserted text.
+If a text was inserted in front/back of the region, hide it according
+to :font-sticky/:rear-sticky folding spec property.
+
+If the folded region is folded with a spec with non-nil :fragile
+property, unfold the region if the :fragile function returns non-nil."
+ ;; If no insertions or deletions in buffer, skip all the checks.
+ (unless (or (eq org-fold-core--last-buffer-chars-modified-tick (buffer-chars-modified-tick))
+ org-fold-core--ignore-modifications
+ (memql 'ignore-modification-checks org-fold-core--optimise-for-huge-buffers))
+ ;; Store the new buffer modification state.
+ (setq org-fold-core--last-buffer-chars-modified-tick (buffer-chars-modified-tick))
+ (save-match-data
+ ;; Handle changes in all the indirect buffers and in the base
+ ;; buffer. Work around Emacs bug#46982.
+ (when (eq org-fold-core-style 'text-properties)
+ (org-fold-core-cycle-over-indirect-buffers
+ ;; Re-hide text inserted in the middle/font/back of a folded
+ ;; region.
+ (unless (equal from to) ; Ignore deletions.
+ (dolist (spec (org-fold-core-folding-spec-list))
+ ;; Reveal fully invisible text inserted in the middle
+ ;; of visible portion of the buffer. This is needed,
+ ;; for example, when there was a deletion in a folded
+ ;; heading, the heading was unfolded, end `undo' was
+ ;; called. The `undo' would insert the folded text.
+ (when (and (or (eq from (point-min))
+ (not (org-fold-core-folded-p (1- from) spec)))
+ (or (eq to (point-max))
+ (not (org-fold-core-folded-p to spec)))
+ (org-fold-core-region-folded-p from to spec))
+ (org-fold-core-region from to nil spec))
+ ;; Look around and fold the new text if the nearby folds are
+ ;; sticky.
+ (unless (org-fold-core-region-folded-p from to spec)
+ (let ((spec-to (org-fold-core-get-folding-spec spec (min to (1- (point-max)))))
+ (spec-from (org-fold-core-get-folding-spec spec (max (point-min) (1- from)))))
+ ;; Reveal folds around undoed deletion.
+ (when undo-in-progress
+ (let ((lregion (org-fold-core-get-region-at-point spec (max (point-min) (1- from))))
+ (rregion (org-fold-core-get-region-at-point spec (min to (1- (point-max))))))
+ (if (and lregion rregion)
+ (org-fold-core-region (car lregion) (cdr rregion) nil spec)
+ (when lregion
+ (org-fold-core-region (car lregion) (cdr lregion) nil spec))
+ (when rregion
+ (org-fold-core-region (car rregion) (cdr rregion) nil spec)))))
+ ;; Hide text inserted in the middle of a fold.
+ (when (and (or spec-from (eq from (point-min)))
+ (or spec-to (eq to (point-max)))
+ (or spec-from spec-to)
+ (eq spec-to spec-from)
+ (or (org-fold-core-get-folding-spec-property spec :front-sticky)
+ (org-fold-core-get-folding-spec-property spec :rear-sticky)))
+ (unless (and (eq from (point-min)) (eq to (point-max))) ; Buffer content replaced.
+ (org-fold-core-region from to t (or spec-from spec-to))))
+ ;; Hide text inserted at the end of a fold.
+ (when (and spec-from (org-fold-core-get-folding-spec-property spec-from :rear-sticky))
+ (org-fold-core-region from to t spec-from))
+ ;; Hide text inserted in front of a fold.
+ (when (and spec-to
+ (not (eq to (point-max))) ; Text inserted at the end of buffer is not prepended anywhere.
+ (org-fold-core-get-folding-spec-property spec-to :front-sticky))
+ (org-fold-core-region from to t spec-to))))))))
+ ;; Process all the folded text between `from' and `to'. Do it
+ ;; only in current buffer to avoid verifying semantic structure
+ ;; multiple times in indirect buffers that have exactly same
+ ;; text anyway.
+ (unless (or org-fold-core--ignore-fragility-checks
+ (memql 'ignore-fragility-checks org-fold-core--optimise-for-huge-buffers))
+ (dolist (func org-fold-core-extend-changed-region-functions)
+ (let ((new-region (funcall func from to)))
+ (setq from (car new-region))
+ (setq to (cdr new-region))))
+ (dolist (spec (org-fold-core-folding-spec-list))
+ ;; No action is needed when :fragile is nil for the spec.
+ (when (org-fold-core-get-folding-spec-property spec :fragile)
+ (org-with-wide-buffer
+ ;; Expand the considered region to include partially present fold.
+ ;; Note: It is important to do this inside loop over all
+ ;; specs. Otherwise, the region may be expanded to huge
+ ;; outline fold, potentially involving majority of the
+ ;; buffer. That would cause the below code to loop over
+ ;; almost all the folds in buffer, which would be too slow.
+ (let ((local-from from)
+ (local-to to)
+ (region-from (org-fold-core-get-region-at-point spec (max (point-min) (1- from))))
+ (region-to (org-fold-core-get-region-at-point spec (min to (1- (point-max))))))
+ (when region-from (setq local-from (car region-from)))
+ (when region-to (setq local-to (cdr region-to)))
+ (let ((pos local-from))
+ ;; Move to the first hidden region.
+ (unless (org-fold-core-get-folding-spec spec pos)
+ (setq pos (org-fold-core-next-folding-state-change spec pos local-to)))
+ ;; Cycle over all the folds.
+ (while (< pos local-to)
+ (save-match-data ; we should not clobber match-data in after-change-functions
+ (let ((fold-begin (and (org-fold-core-get-folding-spec spec pos)
+ pos))
+ (fold-end (org-fold-core-next-folding-state-change spec pos local-to)))
+ (when (and fold-begin fold-end)
+ (when (save-excursion
+ (funcall (org-fold-core-get-folding-spec-property spec :fragile)
+ (cons fold-begin fold-end)
+ spec))
+ ;; Reveal completely, not just from the SPEC.
+ (org-fold-core-region fold-begin fold-end nil)))))
+ ;; Move to next fold.
+ (setq pos (org-fold-core-next-folding-state-change spec pos local-to))))))))))))
+
+;;; Hanlding killing/yanking of folded text
+
+;; Backward compatibility with Emacs 24.
+(defun org-fold-core--seq-partition (list n)
+ "Return list of elements of LIST grouped into sub-sequences of length N.
+The last list may contain less than N elements. If N is a
+negative integer or 0, nil is returned."
+ (if (fboundp 'seq-partition)
+ (seq-partition list n)
+ (unless (< n 1)
+ (let ((result '()))
+ (while list
+ (let (part)
+ (dotimes (_ n)
+ (when list (push (car list) part)))
+ (push part result))
+ (dotimes (_ n)
+ (setq list (cdr list))))
+ (nreverse result)))))
+
+;; By default, all the text properties of the killed text are
+;; preserved, including the folding text properties. This can be
+;; awkward when we copy a text from an indirect buffer to another
+;; indirect buffer (or the base buffer). The copied text might be
+;; visible in the source buffer, but might disappear if we yank it in
+;; another buffer. This happens in the following situation:
+;; ---- base buffer ----
+;; * Headline<begin fold>
+;; Some text hidden in the base buffer, but revealed in the indirect
+;; buffer.<end fold>
+;; * Another headline
+;;
+;; ---- end of base buffer ----
+;; ---- indirect buffer ----
+;; * Headline
+;; Some text hidden in the base buffer, but revealed in the indirect
+;; buffer.
+;; * Another headline
+;;
+;; ---- end of indirect buffer ----
+;; If we copy the text under "Headline" from the indirect buffer and
+;; insert it under "Another headline" in the base buffer, the inserted
+;; text will be hidden since it's folding text properties are copyed.
+;; Basically, the copied text would have two sets of folding text
+;; properties: (1) Properties for base buffer telling that the text is
+;; hidden; (2) Properties for the indirect buffer telling that the
+;; text is visible. The first set of the text properties in inactive
+;; in the indirect buffer, but will become active once we yank the
+;; text back into the base buffer.
+;;
+;; To avoid the above situation, we simply clear all the properties,
+;; unrealated to current buffer when a text is copied.
+;; FIXME: Ideally, we may want to carry the folding state of copied
+;; text between buffer (probably via user customisation).
+(defun org-fold-core--buffer-substring-filter (beg end &optional delete)
+ "Clear folding state in killed text.
+This function is intended to be used as `filter-buffer-substring-function'.
+The arguments and return value are as specified for `filter-buffer-substring'."
+ (let ((return-string (buffer-substring--filter beg end delete))
+ ;; The list will be used as an argument to `remove-text-properties'.
+ props-list)
+ ;; There is no easy way to examine all the text properties of a
+ ;; string, so we utilise the fact that printed string
+ ;; representation lists all its properties.
+ ;; Loop over the elements of string representation.
+ (unless (or (string= "" return-string)
+ (<= end beg)
+ (eq org-fold-core-style 'overlays))
+ ;; Collect all the text properties the string is completely
+ ;; hidden with.
+ (dolist (spec (org-fold-core-folding-spec-list))
+ (when (and (org-fold-core-region-folded-p beg end spec)
+ (org-region-invisible-p beg end))
+ (push (org-fold-core--property-symbol-get-create spec nil t) props-list)))
+ (dolist (plist
+ (if (fboundp 'object-intervals)
+ (object-intervals return-string)
+ ;; Backward compatibility with Emacs <28.
+ ;; FIXME: Is there any better way to do it?
+ ;; Yes, it is a hack.
+ ;; The below gives us string representation as a list.
+ ;; Note that we need to remove unreadable values, like markers (#<...>).
+ (org-fold-core--seq-partition
+ (cdr (let ((data (read (replace-regexp-in-string
+ "^#(" "("
+ (replace-regexp-in-string
+ " #(" " ("
+ (replace-regexp-in-string
+ "#<[^>]+>" "dummy"
+ ;; Get text representation of the string object.
+ ;; Make sure to print everything (see `prin1' docstring).
+ ;; `prin1' is used to print "%S" format.
+ (let (print-level print-length)
+ (format "%S" return-string))))))))
+ (if (listp data) data (list data))))
+ 3)))
+ (let* ((start (car plist))
+ (fin (cadr plist))
+ (plist (car (cddr plist))))
+ ;; Only lists contain text properties.
+ (when (listp plist)
+ ;; Collect all the relevant text properties.
+ (while plist
+ (let* ((prop (car plist))
+ (prop-name (symbol-name prop)))
+ ;; Reveal hard-hidden text. See
+ ;; `org-fold-core--optimise-for-huge-buffers'.
+ (when (and (eq prop 'invisible)
+ (member (cadr plist) (org-fold-core-folding-spec-list)))
+ (remove-text-properties start fin '(invisible t) return-string))
+ ;; We do not care about values now.
+ (setq plist (cddr plist))
+ (when (string-match-p org-fold-core--spec-property-prefix prop-name)
+ ;; Leave folding specs from current buffer. See
+ ;; comments in `org-fold-core--property-symbol-get-create' to
+ ;; understand why it works.
+ (unless (member prop (cdr (assq 'invisible char-property-alias-alist)))
+ (push prop props-list))))))))
+ (remove-text-properties 0 (length return-string) props-list return-string))
+ return-string))
+
+;;; Do not fontify folded text until needed.
+
+(defun org-fold-core-fontify-region (beg end loudly &optional force)
+ "Run `font-lock-default-fontify-region' in visible regions."
+ (let ((pos beg) next
+ (org-fold-core--fontifying t))
+ (while (< pos end)
+ (setq next (org-fold-core-next-folding-state-change
+ (if force nil
+ (let (result)
+ (dolist (spec (org-fold-core-folding-spec-list))
+ (when (and (not (org-fold-core-get-folding-spec-property spec :visible))
+ (org-fold-core-get-folding-spec-property spec :font-lock-skip))
+ (push spec result)))
+ result))
+ pos
+ end))
+ (while (and (not (catch :found
+ (dolist (spec (org-fold-core-get-folding-spec 'all next))
+ (when (org-fold-core-get-folding-spec-property spec :font-lock-skip)
+ (throw :found spec)))))
+ (< next end))
+ (setq next (org-fold-core-next-folding-state-change nil next end)))
+ (save-excursion
+ (font-lock-default-fontify-region pos next loudly)
+ (save-match-data
+ (unless (<= pos (point) next)
+ (run-hook-with-args 'org-fold-core-first-unfold-functions pos next))))
+ (put-text-property pos next 'org-fold-core-fontified t)
+ (setq pos next))))
+
+(defun org-fold-core-update-optimisation (beg end)
+ "Update huge buffer optimisation between BEG and END.
+See `org-fold-core--optimise-for-huge-buffers'."
+ (when (and (memql 'grab-invisible org-fold-core--optimise-for-huge-buffers)
+ (eq org-fold-core-style 'text-properties))
+ (let ((pos beg))
+ (while (< pos end)
+ (when (and (org-fold-core-folded-p pos (caar org-fold-core--specs))
+ (not (eq (caar org-fold-core--specs) (get-text-property pos 'invisible))))
+ (put-text-property pos (org-fold-core-next-folding-state-change (caar org-fold-core--specs) pos end)
+ 'invisible (caar org-fold-core--specs)))
+ (setq pos (org-fold-core-next-folding-state-change (caar org-fold-core--specs) pos end))))))
+
+(defun org-fold-core-remove-optimisation (beg end)
+ "Remove huge buffer optimisation between BEG and END.
+See `org-fold-core--optimise-for-huge-buffers'."
+ (when (and (memql 'grab-invisible org-fold-core--optimise-for-huge-buffers)
+ (eq org-fold-core-style 'text-properties))
+ (let ((pos beg))
+ (while (< pos end)
+ (if (and (org-fold-core-folded-p pos (caar org-fold-core--specs))
+ (eq (caar org-fold-core--specs) (get-text-property pos 'invisible)))
+ (remove-text-properties pos (org-fold-core-next-folding-state-change (caar org-fold-core--specs) pos end)
+ '(invisible t)))
+ (setq pos (org-fold-core-next-folding-state-change (caar org-fold-core--specs) pos end))))))
+
+(provide 'org-fold-core)
+
+;;; org-fold-core.el ends here
next prev parent reply other threads:[~2022-01-29 11:36 UTC|newest]
Thread overview: 192+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-04-24 6:55 [patch suggestion] Mitigating the poor Emacs performance on huge org files: Do not use overlays for PROPERTY and LOGBOOK drawers Ihor Radchenko
2020-04-24 8:02 ` Nicolas Goaziou
2020-04-25 0:29 ` stardiviner
2020-04-26 16:04 ` Ihor Radchenko
2020-05-04 16:56 ` Karl Voit
2020-05-07 7:18 ` Karl Voit
2020-05-09 15:43 ` Ihor Radchenko
2020-05-07 11:04 ` Christian Heinrich
2020-05-09 15:46 ` Ihor Radchenko
2020-05-08 16:38 ` Nicolas Goaziou
2020-05-09 13:58 ` Nicolas Goaziou
2020-05-09 16:22 ` Ihor Radchenko
2020-05-09 17:21 ` Nicolas Goaziou
2020-05-10 5:25 ` Ihor Radchenko
2020-05-10 9:47 ` Nicolas Goaziou
2020-05-10 13:29 ` Ihor Radchenko
2020-05-10 14:46 ` Nicolas Goaziou
2020-05-10 16:21 ` Ihor Radchenko
2020-05-10 16:38 ` Nicolas Goaziou
2020-05-10 17:08 ` Ihor Radchenko
2020-05-10 19:38 ` Nicolas Goaziou
2020-05-09 15:40 ` Ihor Radchenko
2020-05-09 16:30 ` Ihor Radchenko
2020-05-09 17:32 ` Nicolas Goaziou
2020-05-09 18:06 ` Ihor Radchenko
2020-05-10 14:59 ` Nicolas Goaziou
2020-05-10 15:15 ` Kyle Meyer
2020-05-10 16:30 ` Ihor Radchenko
2020-05-10 19:32 ` Nicolas Goaziou
2020-05-12 10:03 ` Nicolas Goaziou
2020-05-17 15:00 ` Ihor Radchenko
2020-05-17 15:40 ` Ihor Radchenko
2020-05-18 14:35 ` Nicolas Goaziou
2020-05-18 16:52 ` Ihor Radchenko
2020-05-19 13:07 ` Nicolas Goaziou
2020-05-23 13:52 ` Ihor Radchenko
2020-05-23 13:53 ` Ihor Radchenko
2020-05-23 15:26 ` Ihor Radchenko
2020-05-26 8:33 ` Nicolas Goaziou
2020-06-02 9:21 ` Ihor Radchenko
2020-06-02 9:23 ` Ihor Radchenko
2020-06-02 12:10 ` Bastien
2020-06-02 13:12 ` Ihor Radchenko
2020-06-02 13:23 ` Bastien
2020-06-02 13:30 ` Ihor Radchenko
2020-06-02 9:25 ` Ihor Radchenko
2020-06-05 7:26 ` Nicolas Goaziou
2020-06-05 8:18 ` Ihor Radchenko
2020-06-05 13:50 ` Nicolas Goaziou
2020-06-08 5:05 ` Ihor Radchenko
2020-06-08 5:06 ` Ihor Radchenko
2020-06-08 5:08 ` Ihor Radchenko
2020-06-10 17:14 ` Nicolas Goaziou
2020-06-21 9:52 ` Ihor Radchenko
2020-06-21 15:01 ` Nicolas Goaziou
2020-08-11 6:45 ` Ihor Radchenko
2020-08-11 23:07 ` Kyle Meyer
2020-08-12 6:29 ` Ihor Radchenko
2020-09-20 5:53 ` Ihor Radchenko
2020-09-20 11:45 ` Kévin Le Gouguec
2020-09-22 9:05 ` Ihor Radchenko
2020-09-22 10:00 ` Ihor Radchenko
2020-09-23 6:16 ` Kévin Le Gouguec
2020-09-23 6:48 ` Ihor Radchenko
2020-09-23 7:09 ` Bastien
2020-09-23 7:30 ` Ihor Radchenko
2020-09-24 18:07 ` Kévin Le Gouguec
2020-09-25 2:16 ` Ihor Radchenko
2020-12-15 17:38 ` [9.4] Fixing logbook visibility during isearch Kévin Le Gouguec
2020-12-16 3:15 ` Ihor Radchenko
2020-12-16 18:05 ` Kévin Le Gouguec
2020-12-17 3:18 ` Ihor Radchenko
2020-12-17 14:50 ` Kévin Le Gouguec
2020-12-18 2:23 ` Ihor Radchenko
2020-12-24 23:37 ` Kévin Le Gouguec
2020-12-25 2:51 ` Ihor Radchenko
2020-12-25 10:59 ` Kévin Le Gouguec
2020-12-25 12:32 ` Ihor Radchenko
2020-12-25 21:35 ` Kévin Le Gouguec
2020-12-26 4:14 ` Ihor Radchenko
2020-12-26 11:44 ` Kévin Le Gouguec
2020-12-26 12:22 ` Ihor Radchenko
2020-12-04 5:58 ` [patch suggestion] Mitigating the poor Emacs performance on huge org files: Do not use overlays for PROPERTY and LOGBOOK drawers Ihor Radchenko
2021-03-21 9:09 ` Ihor Radchenko
2021-05-03 17:28 ` Bastien
2021-09-21 13:32 ` Timothy
2021-10-26 17:25 ` Matt Price
2021-10-27 6:27 ` Ihor Radchenko
2022-01-29 11:37 ` [PATCH 00/35] Merge org-fold feature branch Ihor Radchenko
2022-01-29 11:37 ` Ihor Radchenko [this message]
2022-01-29 11:37 ` [PATCH 02/35] Separate folding functions from org.el into new library: org-fold Ihor Radchenko
2022-01-29 11:37 ` [PATCH 03/35] Separate cycling functions from org.el into new library: org-cycle Ihor Radchenko
2022-01-29 11:37 ` [PATCH 04/35] Remove functions from org.el that are now moved elsewhere Ihor Radchenko
2022-01-29 11:37 ` [PATCH 05/35] Disable native-comp in agenda Ihor Radchenko
2022-01-29 11:37 ` [PATCH 06/35] org-macs: New function org-find-text-property-region Ihor Radchenko
2022-01-29 11:37 ` [PATCH 07/35] org-at-heading-p: Accept optional argument Ihor Radchenko
2022-01-29 11:38 ` [PATCH 08/35] org-string-width: Reimplement to work with new folding Ihor Radchenko
2022-01-29 11:38 ` [PATCH 09/35] Rename old function call to use org-fold Ihor Radchenko
2022-01-29 11:38 ` [PATCH 10/35] Implement link folding Ihor Radchenko
2022-05-04 6:13 ` [BUG] 67275f4 broke evil-search " Tom Gillespie
2022-05-04 6:38 ` Ihor Radchenko
2022-05-28 2:17 ` Tom Gillespie
2022-05-28 2:37 ` Ihor Radchenko
2022-05-28 2:42 ` Tom Gillespie
2022-05-28 3:09 ` Ihor Radchenko
2022-05-28 3:11 ` Ihor Radchenko
2022-01-29 11:38 ` [PATCH 11/35] Implement overlay- and text-property-based versions of some functions Ihor Radchenko
2022-01-29 11:38 ` [PATCH 12/35] org-fold: Handle indirect buffer visibility Ihor Radchenko
2022-01-29 11:38 ` [PATCH 13/35] Fix subtle differences between overlays and invisible text properties Ihor Radchenko
2022-01-29 11:38 ` [PATCH 14/35] Support extra org-fold optimisations for huge buffers Ihor Radchenko
2022-01-29 11:38 ` [PATCH 15/35] Alias new org-fold functions to their old shorter names Ihor Radchenko
2022-01-29 11:38 ` [PATCH 16/35] Obsolete old function names that are now in org-fold Ihor Radchenko
2022-01-29 11:38 ` [PATCH 17/35] org-compat: Work around some third-party packages using outline-* functions Ihor Radchenko
2022-01-29 11:38 ` [PATCH 18/35] Move `org-buffer-list' to org-macs.el Ihor Radchenko
2022-01-29 11:38 ` [PATCH 19/35] Restore old visibility behaviour of org-refile Ihor Radchenko
2022-01-29 11:38 ` [PATCH 20/35] Add org-fold-related tests Ihor Radchenko
2022-01-29 11:38 ` [PATCH 21/35] org-manual: Update to new org-fold function names Ihor Radchenko
2022-01-29 11:38 ` [PATCH 22/35] ORG-NEWS: Add list of changes Ihor Radchenko
2022-01-29 20:31 ` New folding backend & outline (was: [PATCH 22/35] ORG-NEWS: Add list of changes) Kévin Le Gouguec
2022-01-30 2:15 ` Ihor Radchenko
2022-01-29 11:38 ` [PATCH 23/35] Backport contributed commits Ihor Radchenko
2022-01-29 11:38 ` [PATCH 24/35] Fix typo: delete-duplicates → delete-dups Ihor Radchenko
2022-01-29 11:38 ` [PATCH 25/35] Fix bug in org-get-heading Ihor Radchenko
2022-01-29 11:38 ` [PATCH 26/35] Rename remaining org-force-cycle-archived → org-cycle-force-archived Ihor Radchenko
2022-01-29 11:38 ` [PATCH 27/35] Fix org-fold--hide-drawers--overlays Ihor Radchenko
2022-01-29 11:38 ` [PATCH 28/35] org-string-width: Handle undefined behaviour in older Emacs Ihor Radchenko
2022-01-29 11:38 ` [PATCH 29/35] org-string-width: Work around `window-pixel-width' bug in old Emacs Ihor Radchenko
2022-01-29 11:38 ` [PATCH 30/35] org-fold-show-set-visibility: Fix edge case when folded region is at BOB Ihor Radchenko
2022-01-29 11:38 ` [PATCH 31/35] org-fold-core: Fix fontification inside folded regions Ihor Radchenko
2022-01-29 11:38 ` [PATCH 32/35] test-org/string-width: Add tests for strings with prefix properties Ihor Radchenko
2022-01-29 11:38 ` [PATCH 33/35] org--string-from-props: Fix handling folds in Emacs <28 Ihor Radchenko
2022-01-29 11:38 ` [PATCH 34/35] org-link-make-string: Throw error when both LINK and DESCRIPTION are empty Ihor Radchenko
2022-01-29 11:38 ` [PATCH 35/35] test-ol/org-toggle-link-display: Fix compatibility with old Emacs Ihor Radchenko
2022-02-03 6:27 ` [PATCH 00/35] Merge org-fold feature branch Bastien
2022-02-03 7:07 ` Ihor Radchenko
2022-04-20 13:23 ` [PATCH v2 00/38] Final call for comments: " Ihor Radchenko
2022-04-20 13:23 ` [PATCH v2 01/38] Add org-fold-core: new folding engine--- Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 02/38] Separate folding functions from org.el into new library: org-fold Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 03/38] Separate cycling functions from org.el into new library: org-cycle Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 04/38] Remove functions from org.el that are now moved elsewhere Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 05/38] Disable native-comp in agendaIt caused cryptic bugs in the past Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 06/38] org-macs: New function org-find-text-property-region--- Ihor Radchenko
2022-04-20 13:24 ` [PATCH v2 07/38] org-at-heading-p: Accept optional argument* lisp/org.el (org-at-heading-p): Use second argument to allow Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 08/38] org-string-width: Reimplement to work with new folding Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 09/38] Rename old function call to use org-fold--- Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 10/38] Implement link folding* lisp/ol.el (org-link--link-folding-spec): Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 11/38] Implement overlay- and text-property-based versions of some functions Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 12/38] org-fold: Handle indirect buffer visibility--- Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 13/38] Fix subtle differences between overlays and invisible text properties Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 14/38] Support extra org-fold optimisations for huge buffers Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 15/38] Alias new org-fold functions to their old shorter names Ihor Radchenko
2022-04-20 13:25 ` [PATCH v2 16/38] Obsolete old function names that are now in org-fold--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 17/38] org-compat: Work around some third-party packages using outline-* functions Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 18/38] Move `org-buffer-list' to org-macs.el--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 19/38] Restore old visibility behaviour of org-refile--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 20/38] Add org-fold-related tests--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 21/38] org-manual: Update to new org-fold function names--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 22/38] ORG-NEWS: Add list of changes--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 23/38] Backport contributed commits--- Ihor Radchenko
2022-04-20 13:26 ` [PATCH v2 24/38] Fix typo: delete-duplicates → delete-dups Anders Johansson
2022-04-20 13:26 ` [PATCH v2 25/38] Fix bug in org-get-headingFixes #26, where fontification could make the matching and extraction of heading Anders Johansson
2022-04-20 13:27 ` [PATCH v2 26/38] Rename remaining org-force-cycle-archived Anders Johansson
2022-04-20 13:27 ` [PATCH v2 27/38] Fix org-fold--hide-drawers--overlays--- Ihor Radchenko
2022-04-20 13:27 ` [PATCH v2 28/38] org-string-width: Handle undefined behaviour in older Emacs Ihor Radchenko
2022-04-20 13:27 ` [PATCH v2 29/38] org-string-width: Work around `window-pixel-width' bug in old Emacs Ihor Radchenko
2022-04-20 13:27 ` [PATCH v2 30/38] org-fold-show-set-visibility: Fix edge case when folded region is at BOB Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 31/38] org-fold-core: Fix fontification inside folded regions Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 32/38] test-org/string-width: Add tests for strings with prefix properties Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 33/38] org--string-from-props: Fix handling folds in Emacs <28 Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 34/38] org-link-make-string: Throw error when both LINK and DESCRIPTION are empty Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 35/38] test-ol/org-toggle-link-display: Fix compatibility with old Emacs Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 36/38] org-macs.el: Fix fontification checks take 2--- Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 37/38] org-fold-core-fontify-region: Fix cases when fontification is not registered Ihor Radchenko
2022-04-20 13:28 ` [PATCH v2 38/38] org-agenda.el: Re-enable native compilation* lisp/org-agenda.el: Re-enable native compilation as it does not Ihor Radchenko
2022-04-20 14:47 ` [PATCH v2 00/38] Final call for comments: Merge org-fold feature branch Bastien
2022-04-20 15:38 ` Ihor Radchenko
2022-04-20 16:22 ` Bastien
2022-04-21 6:01 ` Ihor Radchenko
2022-04-21 6:55 ` Bastien
2022-04-21 9:27 ` Ihor Radchenko
2022-04-21 9:43 ` Bastien
2022-04-22 18:54 ` Kévin Le Gouguec
2022-04-25 11:44 ` Ihor Radchenko
2022-04-25 13:02 ` Bastien
2022-04-25 13:25 ` Ihor Radchenko
2022-04-25 14:05 ` Bastien
2022-04-26 11:48 ` Ihor Radchenko
2022-04-25 11:45 ` Ihor Radchenko
2022-04-26 6:10 ` Kévin Le Gouguec
2022-05-03 4:44 ` [ISSUE] org-fold does not support auto-reveal for some external package commands Christopher M. Miles
[not found] ` <6270b43a.1c69fb81.835d4.54a6SMTPIN_ADDED_BROKEN@mx.google.com>
2022-05-03 6:33 ` Ihor Radchenko
2022-05-03 10:19 ` [DONE] " Christopher M. Miles
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
List information: https://www.orgmode.org/
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=74cd7fc06a4540b1d63d1e7f9f2542f83e1eaaae.1643454545.git.yantar92@gmail.com \
--to=yantar92@gmail.com \
--cc=bzg@gnu.org \
--cc=christian@gladbachcity.de \
--cc=devnull@Karl-Voit.at \
--cc=emacs-orgmode@gnu.org \
--cc=kyle@kyleam.com \
--cc=mail@nicolasgoaziou.fr \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).