Quando modifico documenti di grandi dimensioni, vorrei vedere dove mi trovo vedendo il contorno (senza contenuto) in un buffer separato. Come quando leggi un file PDF, c'è un sommario sulla sinistra. (vedi sotto)

In modalità org è possibile espandere / comprimere il contorno. Ma è possibile avere un contorno statico a sinistra (o destra) in un buffer separato in modo che quando si fa clic sulle intestazioni, l'altro buffer si sposta in quella posizione?

Un po 'come questo, ma per la modalità org?

[Edit]
L' clone-indirect-bufferè molto vicino a quello che voglio. Il pezzo mancante del puzzle è saltare nella stessa posizione quando si fa clic su un'intestazione / (o su qualsiasi punto in realtà).

Per questo ho provato a scrivere del codice: passare ad altro buffer clonato nello stesso punto? (sincronizzazione della posizione dei buffer indiretti) (modalità org)

Ma non funziona se il contenuto viene compresso. Se ciò può essere fatto funzionare, allora il clone-inderect-buffer è una soluzione completa a questo.

[Soluzione Edit2]
Il codice nel link sopra e nella risposta sotto combinano niceley per risolvere il salto avanti e indietro.

;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)

Vengono in mente alcune opzioni. I primi due sono speedbar, che presumibilmente gioca bene con org-mode, e minimap, sebbene non li abbia usati, non posso garantirli personalmente.

Quale potrebbe essere l'opzione più semplice (e anche la più flessibile), sarebbe utilizzare un buffer indiretto .

In pratica, andresti nel orgbuffer per il quale desideri uno schema, premi M-x clone-indirect-buffer(usa C-u M-x clone-indirect-bufferse vuoi controllare come viene chiamato il clone), e poi boom, c'è un'altra copia del buffer che puoi usare. Metti quel clone in una finestra o cornice fianco a fianco con il buffer originale e, nel clone, regola il contorno secondo i tuoi gusti.

Non ti dà la funzionalità "fai clic sull'intestazione nella struttura" che hai citato, ma ti dà lo spirito della barra laterale.

Modifica: in risposta al tuo commento, ecco un semplice comando che, quando invocato dal clone del buffer , passerà al buffer di base e sposterà il punto in cui si trovava il cursore nel clone del buffer:

(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)))))

Che ne dici di: M-x occur RET ^*+ RET(nota che c'è uno spazio alla fine della regexp).

Dopo aver letto la risposta di Dan e la tua soluzione basata su di essa, ho messo insieme questo. Apre un nuovo clone stretto e di sola lettura a sinistra del buffer corrente e si lega <mouse-1>e RETlocalmente nel clone per saltare a quella posizione nel buffer di 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)))))

Funzionerà con outline-modee outline-minor-mode, così come con le modalità che si basano su di essi, come org-mode. Ho trovato alcune informazioni su come ottenere le mappe delle chiavi locali, ma non so come scegliere quale copiare. C'è anche questa pagina che ha una funzione per creare automaticamente modalità secondarie specifiche del buffer per impostare le chiavi locali del buffer, ma sembra fuori portata per questo problema.

Infine, questo è stato implementato nel pacchetto org-sidebar:

due suggerimenti di affitto basso (cosa faccio) da un non programmatore a cui piace usare aquamacs per l'editor di testo:

1. alternare avanti e indietro con i comandi nel buffer:

STARTUP: indent (per mostrare più facilmente il contorno del tipo a cascata)

questo è per la visualizzazione basata su tab del buffer

e

+ OPZIONI: H: N, dove N = = il numero di livelli che desideri visualizzare nell'esportazione html, che è il suggerimento n. 2

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

2. esporta come html (CC CE hh) per vedere il sommario. non riesco a trovare nessuno in grado di ottenere facilmente il rientro del testo di html o di testo (CC CE ta)

Avevo bisogno di qualcosa di simile, quindi ho messo insieme la outline-tocmodalità . Dovrebbe funzionare per i documenti in modalità org.