in org-mode, come piegare/nascondere le note a piè di pagina?

Question

In modalità org Emacs, c'è un modo per far sì che le definizioni della nota inline vengano visualizzate come compresse?

In modo che, per esempio, una linea come questa: potrebbe semplicemente apparire

This effect is due to the strength of weak ties[fn:: Newman, Mark, Albert-László Barabási, and Duncan J. Watts. 2006. The Structure and Dynamics of Networks. Princeton, NJ: Princeton University Press]. 

come questo:

This effect is due to the strength of weak ties[✭]. 

avrei anche bisogno di un comando per visualizzare le note quando necessario. Quindi forse ciò che è necessario sono due comandi: org-hide-footnotes e org-show-footnotes.

Answer 1

INIZIALE (6 Febbraio 2014): progetto In primo luogo di lavoro.

EDIT 18 Febbraio 2014: Revised la funzione lawlist-toggle-block-visibility in modo che contenga una corretta if/then/else - vale a dire, se la linea contiene il requisito di iniziare regione di espressioni regolari, quindi la visibilità blocco sarà attivato, altrimenti un messaggio che dice scusa. . . . Aggiunta una citazione a un thread correlato per la piegatura del codice. Revisionato il messaggio di errore per fare riferimento a un punto anziché a una linea.

Il codice sorgente per la risposta sotto è memorizzato anche su Github: https://github.com/lawlist/lawlist-org-block-toggle/blob/master/lawlist-org-block-toggle.el

Su un problema correlato (cioè, per nascondere completamente i proprietà cassetto compresa la parola :PROPERTIES:), fare riferimento alla seguente discussione: Completely hide the :PROPERTIES: drawer in org-mode

Su un problema semi-correlato (es., per creare un blocco personalizzato da piegare con il codice), vedere anche: https://tex.stackexchange.com/a/161196/26911

Questa soluzione è stata testata con una versione abbastanza recente di Emacs Trunk (costruita il 19 gennaio 2014), che contiene la versione 8.2 di org-mode. 5c. Poiché il cassetto :PROPERTIES: tramite il suo :END: viene piegato separatamente dalle note a piè di pagina e dai blocchi html, questa soluzione prevede che i blocchi di codice nota e/o html corrispondano a non all'interno del cassetto delle proprietà. La nota a piè di pagina può apparire ovunque nel paragrafo del testo, ma non può avere un'altra coppia di parentesi quadre all'interno della nota a piè di pagina, poiché questo codice cerca la prima parentesi quadra finale per contrassegnare la fine della regione piegata. Questo codice prevede che #+BEGIN_HTML e #+END_HTML siano entrambi a filo-sinistra con il margine sinistro. Le viste di avvio funzionano ancora allo stesso modo, ad esempio le variabili org-startup-folded e org-hide-block-startup.

La modifica di org-cycle-internal-local consente il ciclo di schede per tutte le forme di piegatura in modalità org. Tutto ciò che abbiamo fatto è stato correggere l'impaginazione della funzione per renderla più leggibile e aggiungere la seguente condizione: ((eq org-cycle-subtree-status 'subtree) (org-show-subtree) (message "ALL") (setq org-cycle-subtree-status 'all)). La funzione interattiva org-cycle viene ancora utilizzata per il ciclo di tabulazione tra tutte le varie viste piegate/non aperte. La funzione è una funzione di supporto non interattiva utilizzata da org-cycle. Le due porzioni del codice defalias in questa soluzione sono necessarie affinché tutto funzioni correttamente. Anziché utilizzare scheda ciclismo, l'utente può anche chiamare la funzione interattiva direttamente all'inizio delle voci o sottovoci con: M-x org-cycle RET

Per passare visibilità del blocco nota o html direttamente, utilizziamo la funzione interattiva lawlist-toggle-block-visibility. Posizionare il cursore in qualsiasi punto della riga che contiene il inizio della nota o, il inizio del blocco html, e il tipo: M-x lawlist-toggle-block-visibility RET

(require 'org) 

(defalias 'org-cycle-hide-drawers 'lawlist-block-org-cycle-hide-drawers) 

(defun lawlist-block-org-cycle-hide-drawers (state) 
    "Re-hide all drawers, footnotes or html blocks after a visibility state change." 
    (when 
    (and 
     (derived-mode-p 'org-mode) 
     (not (memq state '(overview folded contents)))) 
    (save-excursion 
     (let* (
      (globalp (memq state '(contents all))) 
      (beg (if globalp (point-min) (point))) 
      (end 
      (cond 
       (globalp 
       (point-max)) 
       ((eq state 'children) 
       (save-excursion (outline-next-heading) (point))) 
       (t (org-end-of-subtree t))))) 
     (goto-char beg) 
     (while 
      (re-search-forward 
      ".*\\[fn\\|^\\#\\+BEGIN_HTML.*$\\|^[ \t]*:PROPERTIES:[ \t]*$" end t) 
      (lawlist-org-flag t)))))) 

(defalias 'org-cycle-internal-local 'lawlist-block-org-cycle-internal-local) 

(defun lawlist-block-org-cycle-internal-local() 
    "Do the local cycling action." 
    (let ((goal-column 0) eoh eol eos has-children children-skipped struct) 
    (save-excursion 
     (if (org-at-item-p) 
     (progn 
      (beginning-of-line) 
      (setq struct (org-list-struct)) 
      (setq eoh (point-at-eol)) 
      (setq eos (org-list-get-item-end-before-blank (point) struct)) 
      (setq has-children (org-list-has-child-p (point) struct))) 
     (org-back-to-heading) 
     (setq eoh (save-excursion (outline-end-of-heading) (point))) 
     (setq eos (save-excursion (1- (org-end-of-subtree t t)))) 
     (setq has-children 
      (or 
      (save-excursion 
       (let ((level (funcall outline-level))) 
       (outline-next-heading) 
       (and 
        (org-at-heading-p t) 
        (> (funcall outline-level) level)))) 
      (save-excursion 
       (org-list-search-forward (org-item-beginning-re) eos t))))) 
     (beginning-of-line 2) 
     (if (featurep 'xemacs) 
     (while 
      (and 
       (not (eobp)) 
       (get-char-property (1- (point)) 'invisible)) 
      (beginning-of-line 2)) 
     (while 
      (and 
       (not (eobp)) 
       (get-char-property (1- (point)) 'invisible)) 
      (goto-char (next-single-char-property-change (point) 'invisible)) 
      (and 
      (eolp) 
      (beginning-of-line 2)))) 
     (setq eol (point))) 
    (cond 
     ((= eos eoh) 
     (unless (org-before-first-heading-p) 
      (run-hook-with-args 'org-pre-cycle-hook 'empty)) 
     (org-unlogged-message "EMPTY ENTRY") 
     (setq org-cycle-subtree-status nil) 
     (save-excursion 
      (goto-char eos) 
      (outline-next-heading) 
      (if (outline-invisible-p) 
      (org-flag-heading nil)))) 
     ((and 
      (or 
      (>= eol eos) 
      (not (string-match "\\S-" (buffer-substring eol eos)))) 
      (or 
      has-children 
      (not (setq children-skipped 
       org-cycle-skip-children-state-if-no-children)))) 
     (unless (org-before-first-heading-p) 
      (run-hook-with-args 'org-pre-cycle-hook 'children)) 
     (if (org-at-item-p) 
      ;; then 
      (org-list-set-item-visibility (point-at-bol) struct 'children) 
      ;; else 
      (org-show-entry) 
      (org-with-limited-levels (show-children)) 
      (when (eq org-cycle-include-plain-lists 'integrate) 
      (save-excursion 
       (org-back-to-heading) 
       (while (org-list-search-forward (org-item-beginning-re) eos t) 
       (beginning-of-line 1) 
       (let* (
        (struct (org-list-struct)) 
        (prevs (org-list-prevs-alist struct)) 
        (end (org-list-get-bottom-point struct))) 
        (mapc (lambda (e) (org-list-set-item-visibility e struct 'folded)) 
        (org-list-get-all-items (point) struct prevs)) 
        (goto-char (if (< end eos) end eos))))))) 
     (org-unlogged-message "CHILDREN") 
     (save-excursion 
      (goto-char eos) 
      (outline-next-heading) 
      (if (outline-invisible-p) 
      (org-flag-heading nil))) 
     (setq org-cycle-subtree-status 'children) 
     (unless (org-before-first-heading-p) 
      (run-hook-with-args 'org-cycle-hook 'children))) 
     ((or 
      children-skipped 
      (and 
      (eq last-command this-command) 
      (eq org-cycle-subtree-status 'children))) 
     (unless (org-before-first-heading-p) 
      (run-hook-with-args 'org-pre-cycle-hook 'subtree)) 
     (outline-flag-region eoh eos nil) 
     (org-unlogged-message 
     (if children-skipped 
      "SUBTREE (NO CHILDREN)" 
      "SUBTREE")) 
     (setq org-cycle-subtree-status 'subtree) 
     (unless (org-before-first-heading-p) 
      (run-hook-with-args 'org-cycle-hook 'subtree))) 
     ((eq org-cycle-subtree-status 'subtree) 
     (org-show-subtree) 
     (message "ALL") 
     (setq org-cycle-subtree-status 'all)) 
     (t 
     (run-hook-with-args 'org-pre-cycle-hook 'folded) 
     (outline-flag-region eoh eos t) 
     (org-unlogged-message "FOLDED") 
     (setq org-cycle-subtree-status 'folded) 
     (unless (org-before-first-heading-p) 
     (run-hook-with-args 'org-cycle-hook 'folded)))))) 

(defun lawlist-org-flag (flag) 
    "When FLAG is non-nil, hide any of the following: html code block; 
footnote; or, the properties drawer. Otherwise make it visible." 
    (save-excursion 
    (beginning-of-line 1) 
    (cond 
     ((looking-at ".*\\[fn") 
     (let* (
      (begin (match-end 0)) 
      end-footnote) 
      (if (re-search-forward "\\]" 
       (save-excursion (outline-next-heading) (point)) t) 
      (progn 
       (setq end-footnote (point)) 
       (outline-flag-region begin end-footnote flag)) 
      (user-error "Error beginning at point %s." begin)))) 
     ((looking-at "^\\#\\+BEGIN_HTML.*$\\|^[ \t]*:PROPERTIES:[ \t]*$") 
     (let* ((begin (match-end 0))) 
      (if (re-search-forward "^\\#\\+END_HTML.*$\\|^[ \t]*:END:" 
       (save-excursion (outline-next-heading) (point)) t) 
      (outline-flag-region begin (point-at-eol) flag) 
      (user-error "Error beginning at point %s." begin))))))) 

(defun lawlist-toggle-block-visibility() 
"For this function to work, the cursor must be on the same line as the regexp." 
(interactive) 
    (if 
     (save-excursion 
     (beginning-of-line 1) 
      (looking-at 
      ".*\\[fn\\|^\\#\\+BEGIN_HTML.*$\\|^[ \t]*:PROPERTIES:[ \t]*$")) 
    (lawlist-org-flag (not (get-char-property (match-end 0) 'invisible))) 
    (message "Sorry, you are not on a line containing the beginning regexp."))) 

Answer 2

Non credo sia possibile al momento. Anche usando TAB come la chiave di espansione all'interno di esso probabilmente causerebbe un sovraccarico ancora maggiore della chiave.

D'altra parte, c'è qualche ragione particolare per non utilizzare una sezione delle note a piè di pagina per le note a piè di pagina?

C-c C-x f creerà/interagirà con qualsiasi nota a piè di pagina.

(org-nota-action & opzionale SPECIALE)

Fare la cosa giusta per note.

Quando si fa riferimento a una nota a piè di pagina, passare alla definizione.

Quando a una definizione, passare ai riferimenti se esistono, offrire a di creare altrimenti.

Quando né alla definizione né al riferimento, creare una nuova nota in calce, in modo interattivo.

Con il prefisso SPEC, offrire comandi aggiuntivi in ​​un menu.

I comandi aggiuntivi che sono:

 s Sort the footnote definitions by reference sequence. During editing, 
      Org makes no effort to sort footnote definitions into a particular 
      sequence. If you want them sorted, use this command, which will 
      also move entries according to org-footnote-section. Automatic 
      sorting after each insertion/deletion can be configured using the 
      variable org-footnote-auto-adjust. 
     r Renumber the simple fn:N footnotes. Automatic renumbering 
      after each insertion/deletion can be configured using the variable 
      org-footnote-auto-adjust. 
     S Short for first r, then s action. 
     n Normalize the footnotes by collecting all definitions (including 
      inline definitions) into a special section, and then numbering them 
      in sequence. The references will then also be numbers. This is 
      meant to be the final step before finishing a document (e.g., sending 
      off an email). The exporters do this automatically, and so could 
      something like message-send-hook. 
     d Delete the footnote at point, and all definitions of and references 
      to it.