1 #+OPTIONS: H:3 num:nil toc:t \n:nil @:t ::t |:t ^:t -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
2 #+STARTUP: align fold nodlcheck hidestars oddeven lognotestate
3 #+SEQ_TODO: TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
4 #+TAGS: Write(w) Update(u) Fix(f) Check(c)
5 #+TITLE: Org ad hoc code, quick hacks and workarounds
7 #+EMAIL: bzg AT altern DOT org
12 # This file is the default header for new Org files in Worg. Feel free
13 # to tailor it to your needs.
15 [[file:index.org][{Back to Worg's index}]]
17 This page is for ad hoc bits of code. Feel free to add quick hacks and
20 * Automatically add an appointment when clocking in a task
22 #+BEGIN_SRC emacs-lisp
23 ;; Make sure you have a sensible value for `appt-message-warning-time'
24 (defvar bzg-org-clock-in-appt-delay 100
25 "Number of minutes for setting an appointment by clocking-in")
28 This function let's you add an appointment for the current entry.
29 This can be useful when you need a reminder.
31 #+BEGIN_SRC emacs-lisp
32 (defun bzg-org-clock-in-add-appt (&optional n)
33 "Add an appointment for the Org entry at point in N minutes."
36 (org-back-to-heading t)
37 (looking-at org-complex-heading-regexp)
38 (let* ((msg (match-string-no-properties 4))
39 (ct-time (decode-time))
40 (appt-min (+ (cadr ct-time)
41 (or n bzg-org-clock-in-appt-delay)))
42 (appt-time ; define the time for the appointment
43 (progn (setf (cadr ct-time) appt-min) ct-time)))
44 (appt-add (format-time-string
45 "%H:%M" (apply 'encode-time appt-time)) msg)
46 (if (interactive-p) (message "New appointment for %s" msg)))))
49 You can advise =org-clock-in= so that =C-c C-x C-i= will automatically
52 #+BEGIN_SRC emacs-lisp
53 (defadvice org-clock-in (after org-clock-in-add-appt activate)
54 "Add an appointment when clocking a task in."
55 (bzg-org-clock-in-add-appt))
58 You may also want to delete the associated appointment when clocking
59 out. This function does this:
61 #+BEGIN_SRC emacs-lisp
62 (defun bzg-org-clock-out-delete-appt nil
63 "When clocking out, delete any associated appointment."
66 (org-back-to-heading t)
67 (looking-at org-complex-heading-regexp)
68 (let* ((msg (match-string-no-properties 4)))
69 (setq appt-time-msg-list
73 (if (not (string-match (regexp-quote msg)
79 And here is the advice for =org-clock-out= (=C-c C-x C-o=)
81 #+BEGIN_SRC emacs-lisp
82 (defadvice org-clock-out (before org-clock-out-delete-appt activate)
83 "Delete an appointment when clocking a task out."
84 (bzg-org-clock-out-delete-appt))
87 *IMPORTANT*: You can add appointment by clocking in in both an
88 =org-mode= and an =org-agenda-mode= buffer. But clocking out from
89 agenda buffer with the advice above will bring an error.
91 * Use Org-mode with Screen [Andrew Hyatt]
93 "The general idea is that you start a task in which all the work will
94 take place in a shell. This usually is not a leaf-task for me, but
95 usually the parent of a leaf task. From a task in your org-file, M-x
96 ash-org-screen will prompt for the name of a session. Give it a name,
97 and it will insert a link. Open the link at any time to go the screen
98 session containing your work!"
100 http://article.gmane.org/gmane.emacs.orgmode/5276
102 #+BEGIN_SRC emacs-lisp
105 (defun ash-org-goto-screen (name)
106 "Open the screen with the specified name in the window"
107 (interactive "MScreen name: ")
108 (let ((screen-buffer-name (ash-org-screen-buffer-name name)))
109 (if (member screen-buffer-name
110 (mapcar 'buffer-name (buffer-list)))
111 (switch-to-buffer screen-buffer-name)
112 (switch-to-buffer (ash-org-screen-helper name "-dr")))))
114 (defun ash-org-screen-buffer-name (name)
115 "Returns the buffer name corresponding to the screen name given."
116 (concat "*screen " name "*"))
118 (defun ash-org-screen-helper (name arg)
119 ;; Pick the name of the new buffer.
120 (let ((term-ansi-buffer-name
121 (generate-new-buffer-name
122 (ash-org-screen-buffer-name name))))
123 (setq term-ansi-buffer-name
125 term-ansi-buffer-name "/usr/bin/screen" nil arg name))
126 (set-buffer term-ansi-buffer-name)
129 (term-set-escape-char ?\C-x)
130 term-ansi-buffer-name))
132 (defun ash-org-screen (name)
133 "Start a screen session with name"
134 (interactive "MScreen name: ")
136 (ash-org-screen-helper name "-S"))
137 (insert-string (concat "[[screen:" name "]]")))
139 ;; And don't forget to add ("screen" . "elisp:(ash-org-goto-screen
140 ;; \"%s\")") to org-link-abbrev-alist.
143 * Org Agenda + Appt + Zenity
145 Russell Adams posted this setup [[http://article.gmane.org/gmane.emacs.orgmode/5806][on the list]]. It make sure your agenda
146 appointments are known by Emacs, and it displays warnings in a [[http://live.gnome.org/Zenity][zenity]]
149 #+BEGIN_SRC emacs-lisp
150 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
151 ; For org appointment reminders
153 ;; Get appointments for today
154 (defun my-org-agenda-to-appt ()
156 (setq appt-time-msg-list nil)
157 (let ((org-deadline-warning-days 0)) ;; will be automatic in org 5.23
158 (org-agenda-to-appt)))
160 ;; Run once, activate and schedule refresh
161 (my-org-agenda-to-appt)
163 (run-at-time "24:01" nil 'my-org-agenda-to-appt)
166 (setq appt-message-warning-time 15)
167 (setq appt-display-interval 5)
169 ; Update appt each time agenda opened.
170 (add-hook 'org-finalize-agenda-hook 'my-org-agenda-to-appt)
172 ; Setup zenify, we tell appt to use window, and replace default function
173 (setq appt-display-format 'window)
174 (setq appt-disp-window-function (function my-appt-disp-window))
176 (defun my-appt-disp-window (min-to-app new-time msg)
177 (save-window-excursion (shell-command (concat
178 "/usr/bin/zenity --info --title='Appointment' --text='"
179 msg "' &") nil nil)))
182 * Org-Mode + gnome-osd
184 Richard Riley uses gnome-osd in interaction with Org-Mode to display
185 appointments. You can look at the code on the [[http://www.emacswiki.org/emacs-en/OrgMode-OSD][emacswiki]].
191 http://article.gmane.org/gmane.emacs.orgmode/5073
194 Remind (http://www.roaringpenguin.com/products/remind) is a very powerful
195 command line calendaring program. Its features superseed the possibilities
196 of orgmode in the area of date specifying, so that I want to use it
197 combined with orgmode.
199 Using the script below I'm able use remind and incorporate its output in my
200 agenda views. The default of using 13 months look ahead is easily
201 changed. It just happens I sometimes like to look a year into the
205 * org-remember-anything
207 [[http://www.emacswiki.org/cgi-bin/wiki/Anything][Anything]] users may find the snippet below interesting:
209 #+BEGIN_SRC emacs-lisp
210 (defvar org-remember-anything
211 '((name . "Org Remember")
212 (candidates . (lambda () (mapcar 'car org-remember-templates)))
213 (action . (lambda (name)
214 (let* ((orig-template org-remember-templates)
215 (org-remember-templates
216 (list (assoc name orig-template))))
217 (call-interactively 'org-remember))))))
220 You can add it to your 'anything-sources' variable and open remember directly
221 from anything. I imagine this would be more interesting for people with many
222 remember templatesm, so that you are out of keys to assign those to. You should
223 get something like this:
225 [[file:images/thumbs/org-remember-anything.png]]
229 As of Org version 6.23b (released Sunday Feb 22, 2009) there is a new
230 function to reload org files.
232 Normally you want to use the compiled files since they are faster.
233 If you update your org files you can easily reload them with
237 If you run into a bug and want to generate a useful backtrace you can
238 reload the source files instead of the compiled files with
242 and turn on the "Enter Debugger On Error" option. Redo the action
243 that generates the error and cut and paste the resulting backtrace.
244 To switch back to the compiled version just reload again with
248 * Split horizontally for agenda
250 If you would like to split the frame into two side-by-side windows when
251 displaying the agenda, try this hack from Jan Rehders, which uses the
252 `toggle-window-split' from
254 http://www.emacswiki.org/cgi-bin/wiki/ToggleWindowSplit
256 #+BEGIN_SRC emacs-lisp
257 ;; Patch org-mode to use vertical splitting
258 (defadvice org-prepare-agenda (after org-fix-split)
259 (toggle-window-split))
260 (ad-activate 'org-prepare-agenda)
262 * Highlight the agenda line under cursor
264 This is useful to make sure what task you are operating on.
266 #+BEGIN_SRC emacs-lisp
267 (add-hook 'org-agenda-mode-hook '(lambda () (hl-line-mode 1)))
272 #+BEGIN_SRC emacs-lisp
273 ;; hl-line seems to be only for emacs
275 (add-hook 'org-agenda-mode-hook '(lambda () (highline-mode 1)))
277 ;; highline-mode does not work straightaway in tty mode.
278 ;; I use a black background
280 '(highline-face ((((type tty) (class color))
281 (:background "white" :foreground "black")))))
284 * Remove time grid lines that are in an appointment
286 The agenda shows lines for the time grid. Some people think that
287 these lines are a distraction when there are appointments at those
288 times. You can get rid of the lines which coincide exactly with the
289 beginning of an appointment. Michael Ekstrand has written a piece of
290 advice that also removes lines that are somewhere inside an
293 #+begin_src emacs-lisp
294 (defun org-time-to-minutes (time)
295 "Convert an HHMM time to minutes"
296 (+ (* (/ time 100) 60) (% time 100)))
298 (defun org-time-from-minutes (minutes)
299 "Convert a number of minutes to an HHMM time"
300 (+ (* (/ minutes 60) 100) (% minutes 60)))
302 (defadvice org-agenda-add-time-grid-maybe (around mde-org-agenda-grid-tweakify
304 (if (member 'remove-match (car org-agenda-time-grid))
305 (flet ((extract-window
307 (let ((start (get-text-property 1 'time-of-day line))
308 (dur (get-text-property 1 'duration line)))
312 (org-time-from-minutes
313 (+ dur (org-time-to-minutes start)))))
316 (let* ((windows (delq nil (mapcar 'extract-window list)))
317 (org-agenda-time-grid
318 (list (car org-agenda-time-grid)
319 (cadr org-agenda-time-grid)
325 (and (>= time (car w))
328 (caddr org-agenda-time-grid)))))
331 (ad-activate 'org-agenda-add-time-grid-maybe)
334 * Group task list by a property
336 This advice allows you to group a task list in Org-Mode. To use it,
337 set the variable =org-agenda-group-by-property= to the name of a
338 property in the option list for a TODO or TAGS search. The resulting
339 agenda view will group tasks by that property prior to searching.
341 #+begin_src emacs-lisp
342 (defvar org-agenda-group-by-property nil
343 "Set this in org-mode agenda views to group tasks by property")
345 (defun org-group-bucket-items (prop items)
348 (let* ((marker (get-text-property 0 'org-marker item))
349 (pvalue (org-entry-get marker prop t))
350 (cell (assoc pvalue buckets)))
352 (setcdr cell (cons item (cdr cell)))
353 (setq buckets (cons (cons pvalue (list item))
355 (setq buckets (mapcar (lambda (bucket)
357 (reverse (cdr bucket))))
359 (sort buckets (lambda (i1 i2)
360 (string< (car i1) (car i2))))))
362 (defadvice org-finalize-agenda-entries (around org-group-agenda-finalize
363 (list &optional nosort))
364 "Prepare bucketed agenda entry lists"
365 (if org-agenda-group-by-property
366 ;; bucketed, handle appropriately
368 (dolist (bucket (org-group-bucket-items
369 org-agenda-group-by-property
371 (let ((header (concat "Property "
372 org-agenda-group-by-property
374 (or (car bucket) "<nil>") ":\n")))
375 (add-text-properties 0 (1- (length header))
376 (list 'face 'org-agenda-structure)
380 ;; recursively process
381 (let ((org-agenda-group-by-property nil))
382 (org-finalize-agenda-entries
383 (cdr bucket) nosort))
385 (setq ad-return-value text))
387 (ad-activate 'org-finalize-agenda-entries)
389 * Link to Gnus messages by Message-Id
391 In a [[http://thread.gmane.org/gmane.emacs.orgmode/8860][recent thread]] on the Org-Mode mailing list, there was some
392 discussion about linking to Gnus messages without encoding the folder
393 name in the link. The following code hooks in to the store-link
394 function in Gnus to capture links by Message-Id when in nnml folders,
395 and then provides a link type "mid" which can open this link. The
396 =mde-org-gnus-open-message-link= function uses the
397 =mde-mid-resolve-methods= variable to determine what Gnus backends to
398 scan. It will go through them, in order, asking each to locate the
399 message and opening it from the first one that reports success.
401 It has only been tested with a single nnml backend, so there may be
402 bugs lurking here and there.
404 The logic for finding the message was adapted from [[http://www.emacswiki.org/cgi-bin/wiki/FindMailByMessageId][an Emacs Wiki
407 #+begin_src emacs-lisp
408 ;; Support for saving Gnus messages by Message-ID
409 (defun mde-org-gnus-save-by-mid ()
410 (when (memq major-mode '(gnus-summary-mode gnus-article-mode))
411 (when (eq major-mode 'gnus-article-mode)
412 (gnus-article-show-summary))
413 (let* ((group gnus-newsgroup-name)
414 (method (gnus-find-method-for-group group)))
415 (when (eq 'nnml (car method))
416 (let* ((article (gnus-summary-article-number))
417 (header (gnus-summary-article-header article))
418 (from (mail-header-from header))
421 (let ((mid (mail-header-id header)))
422 (if (string-match "<\\(.*\\)>" mid)
424 (error "Malformed message ID header %s" mid)))))
425 (date (mail-header-date header))
426 (subject (gnus-summary-subject-string)))
427 (org-store-link-props :type "mid" :from from :subject subject
428 :message-id message-id :group group
429 :link (org-make-link "mid:" message-id))
430 (apply 'org-store-link-props
431 :description (org-email-link-description)
432 org-store-link-plist)
435 (defvar mde-mid-resolve-methods '()
436 "List of methods to try when resolving message ID's. For Gnus,
437 it is a cons of 'gnus and the select (type and name).")
438 (setq mde-mid-resolve-methods
441 (defvar mde-org-gnus-open-level 1
442 "Level at which Gnus is started when opening a link")
443 (defun mde-org-gnus-open-message-link (msgid)
444 "Open a message link with Gnus"
448 (message "[MID linker] Resolving %s" msgid)
449 (dolist (method mde-mid-resolve-methods)
451 ((and (eq (car method) 'gnus)
452 (eq (cadr method) 'nnml))
453 (funcall (cdr (assq 'gnus org-link-frame-setup))
454 mde-org-gnus-open-level)
455 (when gnus-other-frame-object
456 (select-frame gnus-other-frame-object))
457 (let* ((msg-info (nnml-find-group-number
458 (concat "<" msgid ">")
460 (group (and msg-info (car msg-info)))
461 (message (and msg-info (cdr msg-info)))
463 (if (gnus-methods-equal-p
467 (gnus-group-full-name group (cdr method))))))
469 (gnus-summary-read-group qname nil t)
470 (gnus-summary-goto-article message nil t))
471 (throw 'method-found t)))
472 (t (error "Unknown link type"))))))
474 (eval-after-load 'org-gnus
476 (add-to-list 'org-store-link-functions 'mde-org-gnus-save-by-mid)
477 (org-add-link-type "mid" 'mde-org-gnus-open-message-link)))
479 * Dynamically adjust tag position
480 Here is a bit of code that allows you to have the tags always
481 right-adjusted in the buffer.
483 This is useful when you have bigger window than default window-size
484 and you dislike the aesthetics of having the tag in the middle of the
487 This hack solves the problem of adjusting it whenever you change the
489 Before saving it will revert the file to having the tag position be
490 left-adjusted so that if you track your files with version control,
491 you won't run into artificial diffs just because the window-size
494 *IMPORTANT*: This is probably slow on very big files.
496 #+begin_src emacs-lisp
497 (setq ba/org-adjust-tags-column t)
499 (defun ba/org-adjust-tags-column-reset-tags ()
500 "In org-mode buffers it will reset tag position according to
503 (not (string= (buffer-name) "*Remember*"))
504 (eql major-mode 'org-mode))
505 (let ((b-m-p (buffer-modified-p)))
508 (goto-char (point-min))
509 (command-execute 'outline-next-visible-heading)
510 ;; disable (message) that org-set-tags generates
511 (flet ((message (&rest ignored) nil))
513 (set-buffer-modified-p b-m-p))
516 (defun ba/org-adjust-tags-column-now ()
517 "Right-adjust `org-tags-column' value, then reset tag position."
518 (set (make-local-variable 'org-tags-column)
519 (- (- (window-width) (length org-ellipsis))))
520 (ba/org-adjust-tags-column-reset-tags))
522 (defun ba/org-adjust-tags-column-maybe ()
523 "If `ba/org-adjust-tags-column' is set to non-nil, adjust tags."
524 (when ba/org-adjust-tags-column
525 (ba/org-adjust-tags-column-now)))
527 (defun ba/org-adjust-tags-column-before-save ()
528 "Tags need to be left-adjusted when saving."
529 (when ba/org-adjust-tags-column
530 (setq org-tags-column 1)
531 (ba/org-adjust-tags-column-reset-tags)))
533 (defun ba/org-adjust-tags-column-after-save ()
534 "Revert left-adjusted tag position done by before-save hook."
535 (ba/org-adjust-tags-column-maybe)
536 (set-buffer-modified-p nil))
538 ; automatically align tags on right-hand side
539 (add-hook 'window-configuration-change-hook
540 'ba/org-adjust-tags-column-maybe)
541 (add-hook 'before-save-hook 'ba/org-adjust-tags-column-before-save)
542 (add-hook 'after-save-hook 'ba/org-adjust-tags-column-after-save)
543 (add-hook 'org-agenda-mode-hook '(lambda ()
544 (setq org-agenda-tags-column (- (window-width)))))
546 * Compiling Org without make
548 :CUSTOM_ID: compiling-org-without-make
551 This file is the result of [[http://article.gmane.org/gmane.emacs.orgmode/15264][one of our discussions]] on the mailing list.
552 Enhancements wellcome.
554 To use this function, adjust the variables =my/org-lisp-directory= and
555 =my/org-compile-sources= to suite your needs.
557 #+BEGIN_SRC emacs-lisp
558 (defvar my/org-lisp-directory "~/.emacs.d/org/lisp"
559 "Directory where your org-mode files live.")
561 (defvar my/org-compile-sources t
562 "If `nil', never compile org-sources. `my/compile-org' will only create
563 the autoloads file `org-install.el' then. If `t', compile the sources, too.")
566 (setq my/org-lisp-directory "~/.emacs.d/org/lisp")
569 (setq my/org-compile-sources t)
571 (defun my/compile-org(&optional directory)
572 "Compile all *.el files that come with org-mode."
574 (setq directory (concat
576 (or directory my/org-lisp-directory)) "/"))
578 (add-to-list 'load-path directory)
580 (let ((list-of-org-files (file-expand-wildcards (concat directory "*.el"))))
582 ;; create the org-install file
584 (setq esf/org-install-file (concat directory "org-install.el"))
585 (find-file esf/org-install-file)
588 (generate-file-autoloads x))
590 (insert "\n(provide (quote org-install))\n")
593 (byte-compile-file esf/org-install-file t)
595 (dolist (f list-of-org-files)
596 (if (file-exists-p (concat f "c")) ; delete compiled files
597 (delete-file (concat f "c")))
598 (if my/org-compile-sources ; Compile, if `my/org-compile-sources' is t
599 (byte-compile-file f)))))
601 * Customize the size of the frame for remember
604 On emacs-orgmode, Ryan C. Thompson suggested this:
607 I am using org-remember set to open a new frame when used,
608 and the default frame size is much too large. To fix this, I have
609 designed some advice and a custom variable to implement custom
610 parameters for the remember frame:
613 #+begin_src emacs-lisp
614 (defcustom remember-frame-alist nil
615 "Additional frame parameters for dedicated remember frame."
619 (defadvice remember (around remember-frame-parameters activate)
620 "Set some frame parameters for the remember frame."
621 (let ((default-frame-alist (append remember-frame-alist
622 default-frame-alist)))
626 Setting remember-frame-alist to =((width . 80) (height . 15)))= give a
627 reasonable size for the frame.
630 * Add an effort estimate on the fly when clocking in
632 You can use =org-clock-in-prepare-hook= to add an effort estimate.
633 This way you can easily have a "tea-timer" for your tasks when they
634 don't already have an effort estimate.
636 #+begin_src emacs-lisp
637 (add-hook 'org-clock-in-prepare-hook
638 'my-org-mode-ask-effort)
640 (defun my-org-mode-ask-effort ()
641 "Ask for an effort estimate when clocking in."
642 (unless (org-entry-get (point) "Effort")
646 (org-entry-get-multivalued-property (point) "Effort"))))
647 (unless (equal effort "")
648 (org-set-property "Effort" effort)))))
651 Or you can use a default effort for such a timer:
653 #+begin_src emacs-lisp
654 (add-hook 'org-clock-in-prepare-hook
655 'my-org-mode-add-default-effort)
657 (defvar org-clock-default-effort "1:00")
659 (defun my-org-mode-add-default-effort ()
660 "Add a default effort estimation."
661 (unless (org-entry-get (point) "Effort")
662 (org-set-property "Effort" org-clock-default-effort)))
667 *** Question ([[http://article.gmane.org/gmane.emacs.orgmode/15692][Xin Shi]])
669 I have a table in org which stores the date, I'm wondering if there is
670 any function to calculate the duration? For example:
672 | Start Date | End Date | Duration |
673 |------------+------------+----------|
674 | 2004.08.07 | 2005.07.08 | |
676 I tried to use B&-C&, but failed ...
678 *** Answer ([[http://article.gmane.org/gmane.emacs.orgmode/15694][Nick Dokos]])
682 | Start Date | End Date | Duration |
683 |------------+------------+----------|
684 | 2004.08.07 | 2005.07.08 | 335 |
685 :#+TBLFM: $3=(date(<$2>)-date(<$1>))
689 http://thread.gmane.org/gmane.emacs.orgmode/7741
691 as well as this post (which is really a followup on the
694 http://article.gmane.org/gmane.emacs.orgmode/7753
696 The problem that this last article pointed out was solved
699 http://article.gmane.org/gmane.emacs.orgmode/8001
701 and Chris Randle's original musings are at
703 http://article.gmane.org/gmane.emacs.orgmode/6536/
705 ** Field coordinates in formulas (=@#= and =$#=)
709 Following are some use cases that can be implemented with the
710 _field coordinates in formulas_ described in the corresponding
711 chapter in the [[http://orgmode.org/manual/References.html#References][Org manual]], available since =org-version= 6.35.
713 *** Copy a column from a remote table into a column
715 current column =$3= = remote column =$2=:
716 : #+TBLFM: $3 = remote(FOO, @@#$2)
718 *** Copy a row from a remote table transposed into a column
720 current column =$1= = transposed remote row =@1=:
721 : #+TBLFM: $1 = remote(FOO, @$#$@#)
723 *** Transpose a table
727 This is more like a demonstration of using _field coordinates in formulas_
728 to [[http://en.wikipedia.org/wiki/Transpose][transpose]] a table or to do it without using org-babel. The efficient
729 and simple solution for this with the help of org-babel and Emacs Lisp has
730 been provided by Thomas S. Dye on the [[http://thread.gmane.org/gmane.emacs.orgmode/23809/focus=23815][mailing list]].
732 To transpose this 4x7 table
735 : | year | 2004 | 2005 | 2006 | 2007 | 2008 | 2009 |
736 : |------+------+------+------+------+------+------|
737 : | min | 401 | 501 | 601 | 701 | 801 | 901 |
738 : | avg | 402 | 502 | 602 | 702 | 802 | 902 |
739 : | max | 403 | 503 | 603 | 703 | 803 | 903 |
741 start with a 7x4 table without any horizontal line (to have filled
742 also the column header) and yet empty:
752 Then add the =TBLFM= below with the same formula repeated for each column.
753 After recalculation this will end up with the transposed copy:
755 : | year | min | avg | max |
756 : | 2004 | 401 | 402 | 403 |
757 : | 2005 | 501 | 502 | 503 |
758 : | 2006 | 601 | 602 | 603 |
759 : | 2007 | 701 | 702 | 703 |
760 : | 2008 | 801 | 802 | 803 |
761 : | 2009 | 901 | 902 | 903 |
762 : #+TBLFM: $1 = remote(FOO, @$#$@#) :: $2 = remote(FOO, @$#$@#) :: $3 = remote(FOO, @$#$@#) :: $4 = remote(FOO, @$#$@#)
764 The formulas simply exchange row and column numbers by taking
765 - the absolute remote row number =@$#= from the current column number =$#=
766 - the absolute remote column number =$@#= from the current row number =@#=
768 Possible field formulas from the remote table will have to be transferred
769 manually. Since there are no row formulas yet there is no need to transfer
770 column formulas to row formulas or vice versa.
772 *** Dynamic variation of ranges
776 In this example all columns next to =quote= are calculated from the column
777 =quote= and show the average change of the time series =quote[year]=
778 during the period of the preceding =1=, =2=, =3= or =4= years:
780 : | year | quote | 1 a | 2 a | 3 a | 4 a |
781 : |------+-------+-------+-------+-------+-------|
782 : | 2005 | 10 | | | | |
783 : | 2006 | 12 | 0.200 | | | |
784 : | 2007 | 14 | 0.167 | 0.183 | | |
785 : | 2008 | 16 | 0.143 | 0.155 | 0.170 | |
786 : | 2009 | 18 | 0.125 | 0.134 | 0.145 | 0.158 |
787 : #+TBLFM: $3=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$4=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$5=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$6=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3
789 The formula is the same for each column =$3= through =$6=. This can easily
790 be seen with the great formula editor invoked by C-c ' on the
791 table. The important part of the formula without the field blanking is:
793 : ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1
795 which is the Emacs Calc implementation of the equation
797 /AvgChange(i, a) = (quote[i] / quote[i - a]) ^ 1 / n - 1/
799 where /i/ is the current time and /a/ is the length of the preceding period.
801 * Org-mode and saveplace.el
803 Fix a problem with saveplace.el putting you back in a folded position:
805 #+begin_src emacs-lisp
806 (add-hook 'org-mode-hook
808 (when (outline-invisible-p)
810 (outline-previous-visible-heading 1)
811 (org-show-subtree)))))
813 * Easy customization of TODO colors
816 Here is some code I came up with some code to make it easier to
817 customize the colors of various TODO keywords. As long as you just
818 want a different color and nothing else, you can customize the
819 variable org-todo-keyword-faces and use just a string color (i.e. a
820 string of the color name) as the face, and then org-get-todo-face
821 will convert the color to a face, inheriting everything else from
822 the standard org-todo face.
824 To demonstrate, I currently have org-todo-keyword-faces set to
826 #+BEGIN_SRC emacs-lisp
827 (("IN PROGRESS" . "dark orange")
829 ("CANCELED" . "saddle brown"))
832 Here's the code, in a form you can put in your =.emacs=
834 #+BEGIN_SRC emacs-lisp
835 (eval-after-load 'org-faces
837 (defcustom org-todo-keyword-faces nil
838 "Faces for specific TODO keywords.
839 This is a list of cons cells, with TODO keywords in the car and
840 faces in the cdr. The face can be a symbol, a color, or a
841 property list of attributes, like (:foreground \"blue\" :weight
847 (string :tag "Keyword")
848 (choice color (sexp :tag "Face")))))))
850 (eval-after-load 'org
852 (defun org-get-todo-face-from-color (color)
853 "Returns a specification for a face that inherits from org-todo
854 face and has the given color as foreground. Returns nil if
857 `(:inherit org-warning :foreground ,color)))
859 (defun org-get-todo-face (kwd)
860 "Get the right face for a TODO keyword KWD.
861 If KWD is a number, get the corresponding match group."
862 (if (numberp kwd) (setq kwd (match-string kwd)))
863 (or (let ((face (cdr (assoc kwd org-todo-keyword-faces))))
865 (org-get-todo-face-from-color face)
867 (and (member kwd org-done-keywords) 'org-done)
870 * Changelog support for org headers
873 Put the following in your =.emacs=, and =C-x 4 a= and other functions which
874 use =add-log-current-defun= like =magit-add-log= will pick up the nearest org
875 headline as the "current function" if you add a changelog entry from an org
878 #+BEGIN_SRC emacs-lisp
879 (defun org-log-current-defun ()
881 (org-back-to-heading)
882 (if (looking-at org-complex-heading-regexp)
885 (add-hook 'org-mode-hook
887 (make-variable-buffer-local 'add-log-current-defun-function)
888 (setq add-log-current-defun-function 'org-log-current-defun)))
891 * Using ido-completing-read to find attachments
894 Org-attach is great for quickly linking files to a project. But if you
895 use org-attach extensively you might find yourself wanting to browse
896 all the files you've attached to org headlines. This is not easy to do
897 manually, since the directories containing the files are not human
898 readable (i.e., they are based on automatically generated ids). Here's
899 some code to browse those files using ido (obviously, you need to be
902 #+begin_src emacs-lisp
903 (load-library "find-lisp")
905 ;; Adapted from http://www.emacswiki.org/emacs/RecentFiles
907 (defun my-ido-find-org-attach ()
908 "Find files in org-attachment directory"
910 (let* ((enable-recursive-minibuffers t)
911 (files (find-lisp-find-files org-attach-directory "."))
914 (cons (file-name-nondirectory x)
918 (remove-duplicates (mapcar #'car file-assoc-list)
920 (filename (ido-completing-read "Org attachments: " filename-list nil t))
921 (longname (cdr (assoc filename file-assoc-list))))
922 (ido-set-current-directory
923 (if (file-directory-p longname)
925 (file-name-directory longname)))
926 (setq ido-exit 'refresh
927 ido-text-init ido-text
931 (add-hook 'ido-setup-hook 'ido-my-keys)
933 (defun ido-my-keys ()
934 "Add my keybindings for ido."
935 (define-key ido-completion-map (kbd "C-;") 'my-ido-find-org-attach)
939 To browse your org attachments using ido fuzzy matching and/or the
940 completion buffer, invoke ido-find-file as usual (=C-x C-f=) and then
943 * Remove redundant tags of headlines
946 A small function that processes all headlines in current buffer and
947 removes tags that are local to a headline and inherited by a parent
948 headline or the #+FILETAGS: statement.
950 #+BEGIN_SRC emacs-lisp
951 (defun dmj/org-remove-redundant-tags ()
952 "Remove redundant tags of headlines in current buffer.
954 A tag is considered redundant if it is local to a headline and
955 inherited by a parent headline."
957 (when (eq major-mode 'org-mode)
961 (let ((alltags (split-string (or (org-entry-get (point) "ALLTAGS") "") ":"))
963 (dolist (tag alltags)
964 (if (get-text-property 0 'inherited tag)
965 (push tag inherited) (push tag local)))
967 (if (member tag inherited) (org-toggle-tag tag 'off)))))
971 * Different org-cycle-level behavior
974 In recent org versions, when your point (cursor) is at the end of an
975 empty header line (like after you first created the header), the TAB
976 key (=org-cycle=) has a special behavior: it cycles the headline through
977 all possible levels. However, I did not like the way it determined
978 "all possible levels," so I rewrote the whole function, along with a
979 couple of supporting functions.
981 The original function's definition of "all possible levels" was "every
982 level from 1 to one more than the initial level of the current
983 headline before you started cycling." My new definition is "every
984 level from 1 to one more than the previous headline's level." So, if
985 you have a headline at level 4 and you use ALT+RET to make a new
986 headline below it, it will cycle between levels 1 and 5, inclusive.
988 The main advantage of my custom =org-cycle-level= function is that it
989 is stateless: the next level in the cycle is determined entirely by
990 the contents of the buffer, and not what command you executed last.
991 This makes it more predictable, I hope.
993 #+BEGIN_SRC emacs-lisp
996 (defun org-point-at-end-of-empty-headline ()
997 "If point is at the end of an empty headline, return t, else nil."
998 (and (looking-at "[ \t]*$")
1000 (beginning-of-line 1)
1001 (looking-at (concat "^\\(\\*+\\)[ \t]+\\(" org-todo-regexp "\\)?[ \t]*")))))
1003 (defun org-level-increment ()
1004 "Return the number of stars that will be added or removed at a
1005 time to headlines when structure editing, based on the value of
1006 `org-odd-levels-only'."
1007 (if org-odd-levels-only 2 1))
1009 (defvar org-previous-line-level-cached nil)
1011 (defun org-recalculate-previous-line-level ()
1012 "Same as `org-get-previous-line-level', but does not use cached
1013 value. It does *set* the cached value, though."
1014 (set 'org-previous-line-level-cached
1015 (let ((current-level (org-current-level))
1016 (prev-level (when (> (line-number-at-pos) 1)
1019 (org-current-level)))))
1020 (cond ((null current-level) nil) ; Before first headline
1021 ((null prev-level) 0) ; At first headline
1024 (defun org-get-previous-line-level ()
1025 "Return the outline depth of the last headline before the
1026 current line. Returns 0 for the first headline in the buffer, and
1027 nil if before the first headline."
1028 ;; This calculation is quite expensive, with all the regex searching
1029 ;; and stuff. Since org-cycle-level won't change lines, we can reuse
1030 ;; the last value of this command.
1031 (or (and (eq last-command 'org-cycle-level)
1032 org-previous-line-level-cached)
1033 (org-recalculate-previous-line-level)))
1035 (defun org-cycle-level ()
1037 (let ((org-adapt-indentation nil))
1038 (when (org-point-at-end-of-empty-headline)
1039 (setq this-command 'org-cycle-level) ;Only needed for caching
1040 (let ((cur-level (org-current-level))
1041 (prev-level (org-get-previous-line-level)))
1043 ;; If first headline in file, promote to top-level.
1045 (loop repeat (/ (- cur-level 1) (org-level-increment))
1046 do (org-do-promote)))
1047 ;; If same level as prev, demote one.
1048 ((= prev-level cur-level)
1050 ;; If parent is top-level, promote to top level if not already.
1052 (loop repeat (/ (- cur-level 1) (org-level-increment))
1053 do (org-do-promote)))
1054 ;; If top-level, return to prev-level.
1056 (loop repeat (/ (- prev-level 1) (org-level-increment))
1057 do (org-do-demote)))
1058 ;; If less than prev-level, promote one.
1059 ((< cur-level prev-level)
1061 ;; If deeper than prev-level, promote until higher than
1063 ((> cur-level prev-level)
1064 (loop repeat (+ 1 (/ (- cur-level prev-level) (org-level-increment)))
1065 do (org-do-promote))))
1069 * Set org-agenda-files by filetag
1072 It is often helpful to limit yourself to a subset of your agenda
1073 files. For instance, at work, you might want to see only files related
1074 to work (e.g., bugs, clientA, projectxyz, etc.). The FAQ has helpful
1075 information on filtering tasks using [[file:org-faq.org::#limit-agenda-with-tag-filtering][filetags]] and [[file:org-faq.org::#limit-agenda-with-category-match][custom agenda
1076 commands]]. These solutions, however, require reapplying a filter each
1077 time you call the agenda or writing several new custom agenda commands
1078 for each context. Another solution is to use directories for different
1079 types of tasks and to change your agenda files with a function that
1080 sets org-agenda-files to the appropriate directory. But this relies on
1081 hard and static boundaries between files.
1083 The following functions allow for a more dynamic approach to selecting
1084 a subset of files based on filetags:
1086 #+begin_src emacs-lisp
1087 (defun my-org-agenda-files-by-filetag (&optional tag)
1088 "Limit org agenda files only to those containing filetag."
1090 (let* ((tagslist (my-org-get-all-filetags))
1092 (completing-read "Tag: "
1093 (mapcar 'car tagslist)))))
1094 (setq org-agenda-files (cdr (assoc ftag tagslist)))))
1096 (defun my-org-get-all-filetags ()
1097 "Get list of filetags from all default org-files."
1100 my-org-agenda-directories my-org-agenda-extensions))
1103 (save-window-excursion
1104 (while (setq x (pop files))
1105 (set-buffer (find-file-noselect x))
1108 (let ((tagfiles (assoc y tagslist)))
1110 (setcdr tagfiles (cons x (cdr tagfiles)))
1111 (add-to-list 'tagslist (list y x)))))
1112 (my-org-get-filetags)))
1115 (defun my-org-get-filetags ()
1116 "Get list of filetags for current buffer"
1117 (let ((ftags org-file-tags)
1121 (org-substring-no-properties x))
1125 Calling my-org-agenda-files-by-filetag results in a prompt with all
1126 filetags in your "normal" agenda files. When you select a tag,
1127 org-agenda-files will be set only to those files containing that
1130 This functionality relies on a few other functions that abstract the
1131 process of setting org-agenda-files:
1133 #+begin_src emacs-lisp
1134 (defun my-org-list-files (dirs ext)
1135 "Function to create list of org files in multiple subdirectories.
1136 This can be called to generate a list of files for
1137 org-agenda-files or org-refile-targets.
1139 DIRS is a list of directories.
1141 EXT is a list of the extensions of files to be included."
1142 (let ((dirs (if (listp dirs)
1145 (ext (if (listp ext)
1155 (file-expand-wildcards
1156 (concat (file-name-as-directory x) "*" y)))))
1161 (when (or (string-match "/.#" x)
1162 (string-match "#$" x))
1163 (setq files (delete x files))))
1167 (defvar my-org-agenda-directories '("~/org/")
1168 "List of directories containing org files.")
1169 (defvar my-org-agenda-extensions '(".org")
1170 "List of extensions of agenda files")
1172 (setq my-org-agenda-directories '("~/org/"))
1173 (setq my-org-agenda-extensions '(".org"))
1175 (defun my-org-set-agenda-files ()
1177 (setq org-agenda-files (my-org-list-files
1178 my-org-agenda-directories
1179 my-org-agenda-extensions)))
1181 (my-org-set-agenda-files)
1184 The code above will set your "default" agenda files to all files
1185 ending in ".org" in the directory "~/org/". You can change these values
1186 by setting the variables my-org-agenda-extensions and
1187 my-org-agenda-directories. The function my-org-agenda-files-by-filetag
1188 uses these two variables to determine which files to search for
1189 filetags (i.e., the larger set from which the subset will be drawn).
1191 You can also easily use my-org-list-files to "mix and match"
1192 directories and extensions to generate different lists of agenda
1196 Speed commands are described [[http://orgmode.org/manual/Speed-keys.html#Speed-keys][here]] in the manual. Add your own speed
1198 ** Show next/prev heading tidily
1200 These close the current heading and open the next/previous heading.
1201 #+begin_src emacs-lisp
1202 (defun ded/org-show-next-heading-tidily ()
1203 "Show next entry, keeping other entries closed."
1204 (if (save-excursion (end-of-line) (outline-invisible-p))
1205 (progn (org-show-entry) (show-children))
1206 (outline-next-heading)
1207 (unless (and (bolp) (org-on-heading-p))
1208 (org-up-heading-safe)
1210 (error "Boundary reached"))
1216 (defun ded/org-show-previous-heading-tidily ()
1217 "Show previous entry, keeping other entries closed."
1218 (let ((pos (point)))
1219 (outline-previous-heading)
1220 (unless (and (< (point) pos) (bolp) (org-on-heading-p))
1223 (error "Boundary reached"))
1229 (setq org-use-speed-commands t)
1230 (add-to-list 'org-speed-commands-user
1231 '("n" ded/org-show-next-heading-tidily))
1232 (add-to-list 'org-speed-commands-user
1233 '("p" ded/org-show-previous-heading-tidily))
1235 * Use idle timer for automatic agenda views
1237 From John Wiegley's mailing list post (March 18, 2010):
1240 I have the following snippet in my .emacs file, which I find very
1241 useful. Basically what it does is that if I don't touch my Emacs for 5
1242 minutes, it displays the current agenda. This keeps my tasks "always
1243 in mind" whenever I come back to Emacs after doing something else,
1244 whereas before I had a tendency to forget that it was there.
1247 - [[http://mid.gmane.org/55590EA7-C744-44E5-909F-755F0BBE452D@gmail.com][John Wiegley: Displaying your Org agenda after idle time]]
1249 #+begin_src emacs-lisp
1250 (defun jump-to-org-agenda ()
1252 (let ((buf (get-buffer "*Org Agenda*"))
1255 (if (setq wind (get-buffer-window buf))
1256 (select-window wind)
1257 (if (called-interactively-p)
1259 (select-window (display-buffer buf t t))
1260 (org-fit-window-to-buffer)
1261 ;; (org-agenda-redo)
1263 (with-selected-window (display-buffer buf)
1264 (org-fit-window-to-buffer)
1265 ;; (org-agenda-redo)
1267 (call-interactively 'org-agenda-list)))
1268 ;;(let ((buf (get-buffer "*Calendar*")))
1269 ;; (unless (get-buffer-window buf)
1270 ;; (org-agenda-goto-calendar)))
1273 (run-with-idle-timer 300 t 'jump-to-org-agenda)
1276 * Send html messages and attachments with Wanderlust
1278 *note*: [[file:org-contrib/org-mime.org][Org-mime]] has recently been added to the contrib directory of
1279 Org-mode implementing this functionality for both Wanderlust and
1282 ** non Org-mime approach
1283 These two hacks below add the capability of using Org to send out html
1284 via email. Both focus on Wanderlust but could be easily adopted for
1285 Gnus, I think. -- David Maus
1287 *** Send HTML message
1289 Putting the code below in your .emacs adds following four functions:
1291 - dmj/wl-send-html-message
1293 Function that does the job: Convert everything between "--text
1294 follows this line--" and first mime entity (read: attachment) or
1295 end of buffer into html markup using `org-export-region-as-html'
1296 and replaces original body with a multipart MIME entity with the
1297 plain text version of body and the html markup version. Thus a
1298 recipient that prefers html messages can see the html markup,
1299 recipients that prefer or depend on plain text can see the plain
1302 Cannot be called interactively: It is hooked into SEMI's
1303 `mime-edit-translate-hook' if message should be HTML message.
1305 - dmj/wl-send-html-message-draft-init
1307 Cannot be called interactively: It is hooked into WL's
1308 `wl-mail-setup-hook' and provides a buffer local variable to
1311 - dmj/wl-send-html-message-draft-maybe
1313 Cannot be called interactively: It is hooked into WL's
1314 `wl-draft-send-hook' and hooks `dmj/wl-send-html-message' into
1315 `mime-edit-translate-hook' depending on whether HTML message is
1318 - dmj/wl-send-html-message-toggle
1320 Toggles sending of HTML message. If toggled on, the letters
1321 "HTML" appear in the mode line.
1323 Call it interactively! Or bind it to a key in `wl-draft-mode'.
1325 If you have to send HTML messages regularly you can set a global
1326 variable `dmj/wl-send-html-message-toggled-p' to the string "HTML" to
1327 toggle on sending HTML message by default.
1329 The image [[http://s11.directupload.net/file/u/15851/48ru5wl3.png][here]] shows an example of how the HTML message looks like in
1330 Google's web front end. As you can see you have the whole markup of
1331 Org at your service: *bold*, /italics/, tables, lists...
1333 So even if you feel uncomfortable with sending HTML messages at least
1334 you send HTML that looks quite good.
1336 #+begin_src emacs-lisp
1337 (defun dmj/wl-send-html-message ()
1338 "Send message as html message.
1339 Convert body of message to html using
1340 `org-export-region-as-html'."
1343 (let (beg end html text)
1344 (goto-char (point-min))
1345 (re-search-forward "^--text follows this line--$")
1346 ;; move to beginning of next line
1347 (beginning-of-line 2)
1349 (if (not (re-search-forward "^--\\[\\[" nil t))
1350 (setq end (point-max))
1355 (setq text (buffer-substring-no-properties beg end))
1361 (when (re-search-backward "^-- \n" nil t)
1362 ;; preserve link breaks in signature
1363 (insert "\n#+BEGIN_VERSE\n")
1364 (goto-char (point-max))
1365 (insert "\n#+END_VERSE\n")
1367 (setq html (org-export-region-as-html
1368 (point-min) (point-max) t 'string))))
1369 (delete-region beg end)
1372 "--" "<<alternative>>-{\n"
1373 "--" "[[text/plain]]\n" text
1374 "--" "[[text/html]]\n" html
1375 "--" "}-<<alternative>>\n")))))
1377 (defun dmj/wl-send-html-message-toggle ()
1378 "Toggle sending of html message."
1380 (setq dmj/wl-send-html-message-toggled-p
1381 (if dmj/wl-send-html-message-toggled-p
1383 (message "Sending html message toggled %s"
1384 (if dmj/wl-send-html-message-toggled-p
1387 (defun dmj/wl-send-html-message-draft-init ()
1388 "Create buffer local settings for maybe sending html message."
1389 (unless (boundp 'dmj/wl-send-html-message-toggled-p)
1390 (setq dmj/wl-send-html-message-toggled-p nil))
1391 (make-variable-buffer-local 'dmj/wl-send-html-message-toggled-p)
1392 (add-to-list 'global-mode-string
1393 '(:eval (if (eq major-mode 'wl-draft-mode)
1394 dmj/wl-send-html-message-toggled-p))))
1396 (defun dmj/wl-send-html-message-maybe ()
1397 "Maybe send this message as html message.
1399 If buffer local variable `dmj/wl-send-html-message-toggled-p' is
1400 non-nil, add `dmj/wl-send-html-message' to
1401 `mime-edit-translate-hook'."
1402 (if dmj/wl-send-html-message-toggled-p
1403 (add-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)
1404 (remove-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)))
1406 (add-hook 'wl-draft-reedit-hook 'dmj/wl-send-html-message-draft-init)
1407 (add-hook 'wl-mail-setup-hook 'dmj/wl-send-html-message-draft-init)
1408 (add-hook 'wl-draft-send-hook 'dmj/wl-send-html-message-maybe)
1411 *** Attach HTML of region or subtree
1413 Instead of sending a complete HTML message you might only send parts
1414 of an Org file as HTML for the poor souls who are plagued with
1415 non-proportional fonts in their mail program that messes up pretty
1418 This short function does the trick: It exports region or subtree to
1419 HTML, prefixes it with a MIME entity delimiter and pushes to killring
1420 and clipboard. If a region is active, it uses the region, the
1421 complete subtree otherwise.
1423 #+begin_src emacs-lisp
1424 (defun dmj/org-export-region-as-html-attachment (beg end arg)
1425 "Export region between BEG and END as html attachment.
1426 If BEG and END are not set, use current subtree. Region or
1427 subtree is exported to html without header and footer, prefixed
1428 with a mime entity string and pushed to clipboard and killring.
1429 When called with prefix, mime entity is not marked as
1431 (interactive "r\nP")
1433 (let* ((beg (if (region-active-p) (region-beginning)
1435 (org-back-to-heading)
1437 (end (if (region-active-p) (region-end)
1439 (org-end-of-subtree)
1441 (html (concat "--[[text/html"
1442 (if arg "" "\nContent-Disposition: attachment")
1444 (org-export-region-as-html beg end t 'string))))
1445 (when (fboundp 'x-set-selection)
1446 (ignore-errors (x-set-selection 'PRIMARY html))
1447 (ignore-errors (x-set-selection 'CLIPBOARD html)))
1448 (message "html export done, pushed to kill ring and clipboard"))))
1451 *** Adopting for Gnus
1453 The whole magic lies in the special strings that mark a HTML
1454 attachment. So you might just have to find out what these special
1455 strings are in message-mode and modify the functions accordingly.