[elpa] externals/ilist 95bcbf4b00 12/24: ilist: leave new lines when hiding groups

[ELPA Syncer]

branch: externals/ilist
commit 95bcbf4b002c835daefe286cde14cb136fe87e66
Author: JSDurand <mmemmew@gmail.com>
Commit: JSDurand <mmemmew@gmail.com>

    ilist: leave new lines when hiding groups
    
    * ilist.el (ilist-length, ilist-display): Replace ilist-length by
      string-width.
    
    (ilist-string): Leave a newline at the end of a group without the
    invisible property.  Then hiding the group will not hide that
    newline.  This is intentional: if hidden groups are put side-by-side,
    there will be problems when moving across them.
    
    I cannot figure out the problem at all: if I call the command
    manually, either via eval-expression or via "M-x", then no problems
    occur; but if I call the command via a key-binding, it will move to
    the wrong place.
    
    So I decided to leave a newline in between the hidden groups.  Indeed
    this prevents the wrong motions now.
    
    (ilist-skip-boundary, ilist-skip-properties, ilist-forward-line): Skip
    invisible lines by default.  The default behaviour is to skip
    invisible lines.  The reason is that the occasion for these commands
    without skipping invisible lines is quite rare.
---
 ilist.el | 111 ++++++++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 68 insertions(+), 43 deletions(-)

diff --git a/ilist.el b/ilist.el
index 8696a2919e..b3c7005823 100644
--- a/ilist.el
+++ b/ilist.el
@@ -132,11 +132,15 @@ but got %S" align)))
 
 ;;; Calculate the length of a string correctly
 
+;; NOTE: This is obsolete now and should not be used, in case this is
+;; not clear enough.
+
 (defun ilist-length (str)
   "Return the length of STR.
 Characters that take up more than one column will be counted with
 1.7 columns."
-  (declare (side-effect-free t) (pure t))
+  (declare (side-effect-free t) (pure t)
+           (obsolete string-width "2021-12-19 23:53:42.283857"))
   (let ((len 0))
     (mapc (lambda (char)
             (let ((name (get-char-code-property char 'name))
@@ -192,7 +196,7 @@ trailing spaces."
            (let* ((str (funcall
                         (ilist-column-fun column)
                         element))
-                  (str-len (ilist-length str))
+                  (str-len (string-width str))
                   (max-len (ilist-column-max column))
                   (elide (ilist-column-elide column))
                   (str
@@ -201,18 +205,12 @@ trailing spaces."
                           (> str-len max-len))
                      (cond
                       ((stringp elide)
-                       (concat
-                        (substring
-                         str
-                         0
-                         (max (- (min max-len
-                                      (length str))
-                                 (ilist-length elide))
-                              0))
-                        elide))
-                      ((substring str 0 max-len))))
-                    (str))))
-             (cons (ilist-length str) str)))
+                       (truncate-string-to-width
+                        str max-len 0 nil elide))
+                      ((truncate-string-to-width str max-len))))
+                    (str))
+                   ))
+             (cons (string-width str) str)))
          columns))
       ls))
     ;; The list column-widths has a special convention: if a width is
@@ -458,7 +456,7 @@ trailing spaces."
           (let* ((width (nth index column-widths))
                  (alignment (ilist-column-align col))
                  (name (ilist-column-name col))
-                 (complement (- width (ilist-length name)))
+                 (complement (- width (string-width name)))
                  (floor-len (floor complement 2)))
             ;; we increase the index before the end of the form
             (setq index (1+ index))
@@ -494,7 +492,7 @@ trailing spaces."
           (let* ((width (nth index column-widths))
                  (alignment (ilist-column-align col))
                  (name (ilist-column-name col))
-                 (name-len (ilist-length name))
+                 (name-len (string-width name))
                  (name-sep (make-string name-len ?-))
                  (complement (- width name-len))
                  (floor-len (floor complement 2)))
@@ -565,10 +563,7 @@ trailing spaces."
                    (string #xa)
                    'invisible (intern (car element))))
                  (cond
-                  ((< index len)
-                   (propertize
-                    (string #xa)
-                    'invisible (intern (car element)))))))
+                  ((< index len) (string #xa)))))
               group-strs))))
     (mapconcat #'identity group-strs (string))))
 
@@ -801,7 +796,8 @@ the buffer."
 ;;;; skip the boundary
 
 ;; REVIEW: Maybe we should call it "round-boundary" instead?
-(defun ilist-skip-boundary (rounded forwardp other-end)
+(defun ilist-skip-boundary (rounded forwardp other-end
+                                    &optional no-skip-invisible)
   "Skip the boundary of the buffer if needed.
 If ROUNDED is non-nil, then try not to stay at the boundary of
 the buffer.
@@ -809,13 +805,21 @@ the buffer.
 FORWARDP determines in which direction to move.
 
 OTHER-END specifies where to go when the boundary is
-encountered."
+encountered.
+
+If NO-SKIP-INVISIBLE is non-nil, then invisible lines will not be
+skipped."
   (cond
    ((and rounded (ilist-boundary-buffer-p forwardp))
     (goto-char other-end)
     (let ((continuep t))
-      (while (and continuep
-                  (ilist-boundary-buffer-p (not forwardp)))
+      (while (and
+              continuep
+              (or
+               (and (not no-skip-invisible)
+                    (memq (get-text-property (point) 'invisible)
+                          buffer-invisibility-spec))
+               (ilist-boundary-buffer-p (not forwardp))))
         (forward-line (cond (forwardp 1) (-1)))
         (cond
          ((ilist-boundary-buffer-p forwardp)
@@ -824,28 +828,38 @@ encountered."
 
 ;;;; skip properties
 
-(defun ilist-skip-properties (skip-groups forwardp properties)
+(defun ilist-skip-properties (skip-groups
+                              forwardp properties
+                              &optional no-skip-invisible)
   "Try to skip text PROPERTIES if SKIP-GROUPS is non-nil.
 PROPERTIES is a list of text properties to skip.
 
-FORWARDP determines the direction to test for the boundary."
+FORWARDP determines the direction to test for the boundary.
+
+If NO-SKIP-INVISIBLE is non-nil, then invisible lines will not be
+skipped."
   (while (and skip-groups
-              (let ((fake-properties properties)
-                    res)
-                (while (and (not res)
-                            (consp fake-properties))
-                  (setq res
-                        (get-text-property
-                         (point) (car fake-properties)))
-                  (setq fake-properties (cdr fake-properties)))
-                res)
+              (or
+               (and (not no-skip-invisible)
+                    (memq (get-text-property (point) 'invisible)
+                          buffer-invisibility-spec))
+               (let ((fake-properties properties)
+                     res)
+                 (while (and (not res)
+                             (consp fake-properties))
+                   (setq res
+                         (get-text-property
+                          (point) (car fake-properties)))
+                   (setq fake-properties (cdr fake-properties)))
+                 res))
               ;; check boundaries to prevent infinite loops
               (not (ilist-boundary-buffer-p forwardp)))
     (forward-line (cond (forwardp 1) (-1)))))
 
 ;;;; moving between lines
 
-(defun ilist-forward-line (&optional arg rounded skip-groups no-skip-invisible)
+(defun ilist-forward-line
+    (&optional arg rounded skip-groups no-skip-invisible)
   "Go to ARG th next line.
 If ROUNDED is non-nil, assume the top of the buffer is connected
 to the bottom of the buffer.
@@ -863,14 +877,20 @@ skipped."
                              (goto-char (point-max))
                              (line-beginning-position)))))
          (original-point (point))
-         (line-move-ignore-invisible t)
          (arg (abs arg)))
     (ilist-skip-properties t forwardp
                            '(ilist-header
                              ilist-title-sep))
     (ilist-skip-properties skip-groups forwardp
                            '(ilist-group-header))
-    (cond ((/= original-point (point))
+    (cond ((and
+            (/= original-point (point))
+            (not (memq
+                  (get-text-property (point) 'invisible)
+                  buffer-invisibility-spec))
+            (or (null skip-groups)
+                (not (get-text-property
+                      (point) 'ilist-group-header))))
            (setq arg (1- arg))))
     (while (> arg 0)
       (forward-line (cond (forwardp 1) (-1)))
@@ -881,11 +901,16 @@ skipped."
         (forward-line (cond (forwardp 1) (-1))))
       ;; skip the group and the boundary twice to ensure that we avoid
       ;; the edges as much as possible.
-      (ilist-skip-boundary rounded forwardp other-end)
-      (ilist-skip-properties skip-groups forwardp '(ilist-group-header))
-      (ilist-skip-boundary rounded forwardp other-end)
-      (ilist-skip-properties skip-groups forwardp '(ilist-group-header))
-      (setq arg (1- arg)))))
+      (ilist-skip-boundary rounded forwardp other-end no-skip-invisible)
+      (ilist-skip-properties skip-groups forwardp '(ilist-group-header)
+                             no-skip-invisible)
+      (ilist-skip-boundary rounded forwardp other-end no-skip-invisible)
+      (ilist-skip-properties skip-groups forwardp '(ilist-group-header)
+                             no-skip-invisible)
+      (setq arg (1- arg)))
+    (ilist-skip-boundary rounded forwardp other-end no-skip-invisible)
+    (ilist-skip-properties skip-groups forwardp '(ilist-group-header)
+                           no-skip-invisible)))
 
 (defun ilist-backward-line (&optional arg rounded skip-groups)
   "Go to ARG th previous line.