Lorsque je modifie des documents volumineux, j'aimerais voir où j'en suis en voyant le plan (sans contenu) dans un tampon séparé. Comme lorsque vous lisez un fichier PDF, il y a une table des matières sur la gauche. (voir ci-dessous)

En mode organisation, il est possible de développer / réduire le contour. Mais est-il possible d'avoir un contour statique à gauche (ou à droite) dans un tampon séparé afin que lorsque vous cliquez sur les en-têtes, l'autre tampon se déplace vers cette position?

Un peu comme ça, mais pour le mode org?

[Modifier]
Le clone-indirect-bufferest très proche de ce que je veux. La pièce manquante du puzzle est de sauter au même endroit lorsque vous cliquez sur un titre / (ou n'importe quel point vraiment).

Pour cela, j'ai essayé d'écrire du code: Déplacer vers un autre tampon cloné au même point? (position de synchronisation des tampons indirects) (mode org)

Mais cela ne fonctionne pas si le contenu est réduit. Si cela peut fonctionner, le tampon cléron-indérect est une solution complète à cela.

[Solution Edit2]
Le code dans le lien ci-dessus et dans la réponse ci-dessous combine niceley pour résoudre les sauts d'avant en arrière.

;first call 'clone-indirect-buffer'. Then...

;This function works between buffer and it's clone.
(defun my/goto-same-spot-in-other-buffer () 
  "Go to the same location in the other buffer. Useful for when you have cloned indirect buffers"
  (interactive)
  (let ((my/goto-current-point (point)))
       (other-window 1)
       (goto-char my/goto-current-point)
       (when (invisible-p (point))
        (org-reveal)))
)

;This function is a clone-to-buffer jump only:
; It does find the other buffer first thou instead of just jumping to the other 
; window as does the function above.
(defun my/jump-to-point-and-show ()
  "Switch to a cloned buffer's base buffer and move point to the
cursor position in the clone."
  (interactive)
  (let ((buf (buffer-base-buffer)))
    (unless buf
      (error "You need to be in a cloned buffer!"))
    (let ((pos (point))
          (win (car (get-buffer-window-list buf))))
      (if win
          (select-window win)
        (other-window 1)
        (switch-to-buffer buf))
      (goto-char pos)
      (when (invisible-p (point))
        (show-branches)))))


(global-set-key (kbd "<s-mouse-1>") 'my/goto-same-spot-in-other-buffer)
(global-set-key (kbd "s-m") 'my/goto-same-spot-in-other-buffer)
(global-set-key (kbd "<C-s-mouse-1>") 'my/jump-to-point-and-show)
(global-set-key (kbd "C-s-m") 'my/jump-to-point-and-show)

Quelques options me viennent à l'esprit. Les deux premiers le sont speedbar, ce qui semble bien fonctionner avec org-mode, et minimap, bien que je ne les ai pas utilisés, je ne peux donc pas en témoigner personnellement.

Ce qui pourrait être l'option la plus simple (et aussi la plus flexible), serait d'utiliser un tampon indirect .

Dans la pratique, vous iriez au orgtampon pour lequel vous souhaitez un contour, appuyez sur M-x clone-indirect-buffer(utilisez C-u M-x clone-indirect-buffersi vous souhaitez contrôler le nom du clone), puis boum, il y a une autre copie du tampon à utiliser. Placez ce clone dans une fenêtre ou un cadre côte à côte avec le tampon d'origine et, dans le clone, ajustez le contour à vos goûts.

Il ne vous donne pas la fonctionnalité "cliquez sur le titre dans le plan" que vous avez mentionnée, mais vous donne l'esprit de la barre latérale.

Edit: en réponse à votre commentaire, voici une commande simple qui, lorsqu'elle est invoquée à partir du clone de tampon , basculera vers le tampon de base et se déplacera vers l'endroit où se trouvait le curseur dans le clone de tampon:

(defun jump-to-point-and-show ()
  "Switch to a cloned buffer's base buffer and move point to the
cursor position in the clone."
  (interactive)
  (let ((buf (buffer-base-buffer)))
    (unless buf
      (error "You need to be in a cloned buffer!"))
    (let ((pos (point))
          (win (car (get-buffer-window-list buf))))
      (if win
          (select-window win)
        (other-window 1)
        (switch-to-buffer buf))
      (goto-char pos)
      (when (invisible-p (point))
        (show-branches)))))

Que diriez-vous: M-x occur RET ^*+ RET(notez qu'il y a un espace à la fin de l'expression rationnelle).

Après avoir lu la réponse de Dan et votre solution basée sur celle-ci, j'ai mis cela ensemble. Il ouvre un nouveau clone étroit et en lecture seule à gauche du tampon actuel, et il se lie <mouse-1>et RETlocalement dans le clone pour accéder à cette position dans le tampon de base.

(defun my/open-tree-view ()
  "Open a clone of the current buffer to the left, resize it to 30 columns, and bind <mouse-1> to jump to the same position in the base buffer."
  (interactive)
  (let ((new-buffer-name (concat "<tree>" (buffer-name))))
    ;; Create tree buffer
    (split-window-right 30)
    (if (get-buffer new-buffer-name)
        (switch-to-buffer new-buffer-name)  ; Use existing tree buffer
      ;; Make new tree buffer
      (progn  (clone-indirect-buffer new-buffer-name nil t)
              (switch-to-buffer new-buffer-name)
              (read-only-mode)
              (hide-body)
              (toggle-truncate-lines)

              ;; Do this twice in case the point is in a hidden line
              (dotimes (_ 2 (forward-line 0)))

              ;; Map keys
              (use-local-map (copy-keymap outline-mode-map))
              (local-set-key (kbd "q") 'delete-window)
              (mapc (lambda (key) (local-set-key (kbd key) 'my/jump-to-point-and-show))
                    '("<mouse-1>" "RET"))))))

(defun my/jump-to-point-and-show ()
  "Switch to a cloned buffer's base buffer and move point to the cursor position in the clone."
  (interactive)
  (let ((buf (buffer-base-buffer)))
    (unless buf
      (error "You need to be in a cloned buffer!"))
    (let ((pos (point))
          (win (car (get-buffer-window-list buf))))
      (if win
          (select-window win)
        (other-window 1)
        (switch-to-buffer buf))
      (goto-char pos)
      (when (invisible-p (point))
        (show-branches)))))

Cela fonctionnera avec outline-modeet outline-minor-mode, ainsi qu'avec les modes qui s'appuient sur eux, tels que org-mode. J'ai trouvé des informations sur l'obtention des mappes de clés locales, mais je ne sais pas comment choisir celle à copier. Il y a aussi cette page qui a une fonction pour créer automatiquement des modes mineurs spécifiques au tampon pour définir les clés locales du tampon, mais cela semble hors de portée pour ce problème.

Enfin, cela a été implémenté dans le package org-sidebar:

deux suggestions de faible loyer (ce que je fais) d'un non-programmeur qui aime utiliser aquamacs pour l'éditeur de texte:

1. basculer d'avant en arrière avec les commandes in-buffer:

DÉMARRAGE: retrait (pour afficher le contour du type de cascade plus facile à voir dans son ensemble)

c'est pour la visualisation tabulée du tampon

et

+ OPTIONS: H: N, où N = = le nombre de niveaux que vous souhaitez voir dans l'exportation html, qui est la suggestion # 2

voir: https://emacsclub.github.io/html/org_tutorial.html

2. exporter en html (CC CE hh) pour voir la table des matières. je ne trouve personne qui puisse facilement obtenir la sortie de texte html ou texte (CC CE ta) pour mettre en retrait

J'avais besoin de quelque chose de similaire, alors j'ai mis en place le outline-tocmode . Cela devrait fonctionner pour les documents en mode organisation.