Come spostare una sottostruttura ad un altro sottostruttura in emacs org-mode

Question

mi piacerebbe svolgere un compito semplice, ma non sembra esserci alcuna soluzione chiara per esso:

ho una struttura di sottostrutture in questo modo:

* Tree A 
** Subtree A1 
** Subtree A2 
* Tree B 
** Subtree B1 
** Subtree B2 

mi piacerebbe impostare un tasto di scelta rapida per spostare sottostrutture da Albero a a B. Albero Moving all'archivio sembra essere facile, ma hai qualche idea di come farlo all'interno di un unico file?

Qualsiasi aiuto apprezzato! Grazie!

Answer 1

Si può provare a riempire la sottostruttura con C-c C-w (funziona anche per spostare la sottostruttura in un altro file).

Un altro modo è piegare il sottostruttura, quindi ucciderlo con C-k C-k e incollarlo dove dovrebbe essere.

La terza soluzione che uso po 'di tempo è quello di modificare il livello della sottostruttura con M-sinistra, quindi di muoversi con M-up e M-down, quindi M-destra put di nuovo al livello corretto. Questa terza via ha la lacuna che qualche volta fa spostare altra parte dell'albero.

Answer 2

Io uso M-sinistra, M-up/down e poi M-destra se la struttura del file non è troppo complesso. Ma di tenere presente che se si tenta di spostare sottostruttura A1 a Tree B utilizzando questo metodo, si perderà il suo bambino Subsubtree A1.1, a meno che non ci si sposta con MS-sinistra/destra:

* Tree A 
** Subtree A1    <=== move this heading with M-S-left 
*** Subsubtree A1.1  <=== or you will leave this heading behind 
** Subtree A2 

* Tree B 
** Subtree B1 
** Subtree B2 

Answer 3

È puoi rifilare la sottostruttura usando Cc Cw, a seconda di come hai impostato il refile. A seconda della profondità della tua destinazione potresti non essere in grado di usarlo come destinazione valida.

Si può uccidere o copiare una sottostruttura senza dover piegare la struttura utilizzando i comandi sottostruttura uccisione/copia: Cc Cx Cw e Cc Cx Mw rispettivamente, tirando una sottostruttura è o Cc Cx Cy o semplicemente Cy

Answer 4

volevo anche un modo per org-refile per refile facilmente ad una sottostruttura, così ho scritto un po 'di codice e generalizzato in modo che esso fisserà un obiettivo immediato arbitrario ovunque (non solo nello stesso file).

Utilizzo base è quello di spostare da qualche parte in Tree B e digitare Cc Cx Cm per contrassegnare l'obiettivo per riclassificazione, per poi passare alla voce in Tree A che si desidera refile e digitare Cc Cw che immediatamente refile nella posizione target impostata su Tree B senza che venga richiesto, a meno che non si chiamicon un prefisso arg Cu Cc Cx Cm.

Si noti che se si preme Cc Cw in rapida successione per refile più voci che manterrà l'ordine delle voci, anche se org-reverse-note-order è impostato su t, ma è possibile disattivarla per rispettare l'impostazione di org-reverse-note-order con un prefisso doppio arg Cu Cu Cc Cx Cm.

(defvar org-refile-immediate nil 
    "Refile immediately using `org-refile-immediate-target' instead of prompting.") 
(make-local-variable 'org-refile-immediate) 

(defvar org-refile-immediate-preserve-order t 
    "If last command was also `org-refile' then preserve ordering.") 
(make-local-variable 'org-refile-immediate-preserve-order) 

(defvar org-refile-immediate-target nil) 
"Value uses the same format as an item in `org-refile-targets'." 
(make-local-variable 'org-refile-immediate-target) 

(defadvice org-refile (around org-immediate activate) 
    (if (not org-refile-immediate) 
     ad-do-it 
    ;; if last command was `org-refile' then preserve ordering 
    (let ((org-reverse-note-order 
      (if (and org-refile-immediate-preserve-order 
        (eq last-command 'org-refile)) nil org-reverse-note-order))) 
     (ad-set-arg 2 (assoc org-refile-immediate-target (org-refile-get-targets))) 
     (prog1 ad-do-it 
     (setq this-command 'org-refile))))) 

(defadvice org-refile-cache-clear (after org-refile-history-clear activate) 
    (setq org-refile-targets (default-value 'org-refile-targets)) 
    (setq org-refile-immediate nil) 
    (setq org-refile-immediate-target nil) 
    (setq org-refile-history nil)) 

;;;###autoload 
(defun org-refile-immediate-target (&optional arg) 
    "Set current entry as `org-refile' target. 
Non-nil turns off `org-refile-immediate', otherwise `org-refile' 
will immediately refile without prompting for target using most 
recent entry in `org-refile-targets' that matches 
`org-refile-immediate-target' as the default." 
    (interactive "P") 
    (if (equal arg '(16)) 
     (progn 
     (setq org-refile-immediate-preserve-order 
       (not org-refile-immediate-preserve-order)) 
     (message "Order preserving is turned: %s" 
       (if org-refile-immediate-preserve-order 
        "on" "off"))) 

    (setq org-refile-immediate (unless arg t)) 
    (make-local-variable 'org-refile-targets) 
    (let* ((components (org-heading-components)) 
      (level (first components)) 
      (heading (nth 4 components)) 
      (string (substring-no-properties heading))) 
     (add-to-list 'org-refile-targets 
        (append (list (buffer-file-name)) 
          (cons :regexp 
           (format "^%s %s$" 
             (make-string level ?*) 
             string)))) 
     (setq org-refile-immediate-target heading)))) 

(define-key org-mode-map "\C-c\C-x\C-m" 'org-refile-immediate-target) 

E 'stato difficile trovare una chiave che era libero sul prefisso Cc Cx, quindi ho usato m con il mnemonico i * mm * ediata

Answer 5

(require 'org-archive)                    
(setq org-archive-save-context-info nil)                
(setq org-archive-location "::* Archived Tasks") 

run (org-archive-sottostruttura) nella sottostruttura che si desidera spostare, verrà spostato in "* Archiviato Compiti" intestazione

Answer 6

Lo spostamento di un sottostruttura all'interno dello stesso buffer può essere eseguito ne con org-refile. Durante lo spostamento, puoi persino modificare la gerarchia dell'originale (numero di stelle). Tuttavia, potrebbe non funzionare fuori dalla scatola principalmente perché il buffer con cui si sta lavorando non è nello org-refile-targets. È possibile aggiungere il file nelle destinazioni di refile utilizzando C-[, quindi eseguire org-refile con C-c C-w e infine rimuovere il file dagli obiettivi di refile con C-]. Potrebbe essere troppo (e potrebbe fallire se l'impostazioneè troppo bassa, che è comunque possibile modificare). In alternativa, per automatizzare questa procedura in un colpo solo, è necessario prima definire una funzione come questa:

(defun refile-in-current() 
"refile current item in current buffer" 
(interactive) 
(let ((org-refile-use-outline-path t) 
    (org-refile-targets '((nil . (:maxlevel . 5))))) 
(org-refile))) 

Il nil in là significa "buffer corrente". Lo let ridefinisce le variabili solo localmente. Dovrai quindi aggiungere un collegamento per eseguire la funzione. Qui è un modo per legare a C-c m:

(add-hook 'org-mode-hook (lambda() 
     (local-set-key "\C-c m" 'refile-in-current)