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: mdl AT imapmail 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 * Hacking Org: Working within Org-mode.
21 ** Building and Managing Org
22 *** Compiling Org without make
24 :CUSTOM_ID: compiling-org-without-make
27 This file is the result of [[http://article.gmane.org/gmane.emacs.orgmode/15264][one of our discussions]] on the mailing list.
30 To use this function, adjust the variables =my/org-lisp-directory= and
31 =my/org-compile-sources= to suite your needs.
33 #+BEGIN_SRC emacs-lisp
34 (defvar my/org-lisp-directory "~/.emacs.d/org/lisp"
35 "Directory where your org-mode files live.")
37 (defvar my/org-compile-sources t
38 "If `nil', never compile org-sources. `my/compile-org' will only create
39 the autoloads file `org-install.el' then. If `t', compile the sources, too.")
42 (setq my/org-lisp-directory "~/.emacs.d/org/lisp")
45 (setq my/org-compile-sources t)
47 (defun my/compile-org(&optional directory)
48 "Compile all *.el files that come with org-mode."
50 (setq directory (concat
52 (or directory my/org-lisp-directory)) "/"))
54 (add-to-list 'load-path directory)
56 (let ((list-of-org-files (file-expand-wildcards (concat directory "*.el"))))
58 ;; create the org-install file
60 (setq esf/org-install-file (concat directory "org-install.el"))
61 (find-file esf/org-install-file)
64 (generate-file-autoloads x))
66 (insert "\n(provide (quote org-install))\n")
69 (byte-compile-file esf/org-install-file t)
71 (dolist (f list-of-org-files)
72 (if (file-exists-p (concat f "c")) ; delete compiled files
73 (delete-file (concat f "c")))
74 (if my/org-compile-sources ; Compile, if `my/org-compile-sources' is t
75 (byte-compile-file f)))))
79 As of Org version 6.23b (released Sunday Feb 22, 2009) there is a new
80 function to reload org files.
82 Normally you want to use the compiled files since they are faster.
83 If you update your org files you can easily reload them with
87 If you run into a bug and want to generate a useful backtrace you can
88 reload the source files instead of the compiled files with
92 and turn on the "Enter Debugger On Error" option. Redo the action
93 that generates the error and cut and paste the resulting backtrace.
94 To switch back to the compiled version just reload again with
98 *** Check for possibly problematic old link escapes
100 :CUSTOM_ID: check-old-link-escapes
103 Starting with version 7.5 Org uses [[http://en.wikipedia.org/wiki/Percent-encoding][percent escaping]] more consistently
104 and with a modified algorithm to determine which characters to escape
107 As a side effect this modified behaviour might break existing links if
108 they contain a sequence of characters that look like a percent escape
109 (e.g. =[0-9A-Fa-f]{2}=) but are in fact not a percent escape.
111 The function below can be used to perform a preliminary check for such
112 links in an Org mode file. It will run through all links in the file
113 and issue a warning if it finds a percent escape sequence which is not
114 in old Org's list of known percent escapes.
116 #+begin_src emacs-lisp
117 (defun dmaus/org-check-percent-escapes ()
118 "*Check buffer for possibly problematic old link escapes."
120 (when (eq major-mode 'org-mode)
121 (let ((old-escapes '("%20" "%5B" "%5D" "%E0" "%E2" "%E7" "%E8" "%E9"
122 "%EA" "%EE" "%F4" "%F9" "%FB" "%3B" "%3D" "%2B")))
123 (unless (boundp 'warning-suppress-types)
124 (setq warning-suppress-types nil))
127 (goto-char (point-min))
128 (while (re-search-forward org-any-link-re nil t)
129 (let ((end (match-end 0)))
130 (goto-char (match-beginning 0))
131 (while (re-search-forward "%[0-9a-zA-Z]\\{2\\}" end t)
132 (let ((escape (match-string-no-properties 0)))
133 (unless (member (upcase escape) old-escapes)
134 (warn "Found unknown percent escape sequence %s at buffer %s, position %d"
141 ** Structure Movement and Editing
142 *** Show next/prev heading tidily
144 These close the current heading and open the next/previous heading.
146 #+begin_src emacs-lisp
147 (defun ded/org-show-next-heading-tidily ()
148 "Show next entry, keeping other entries closed."
149 (if (save-excursion (end-of-line) (outline-invisible-p))
150 (progn (org-show-entry) (show-children))
151 (outline-next-heading)
152 (unless (and (bolp) (org-on-heading-p))
153 (org-up-heading-safe)
155 (error "Boundary reached"))
161 (defun ded/org-show-previous-heading-tidily ()
162 "Show previous entry, keeping other entries closed."
164 (outline-previous-heading)
165 (unless (and (< (point) pos) (bolp) (org-on-heading-p))
168 (error "Boundary reached"))
174 (setq org-use-speed-commands t)
175 (add-to-list 'org-speed-commands-user
176 '("n" ded/org-show-next-heading-tidily))
177 (add-to-list 'org-speed-commands-user
178 '("p" ded/org-show-previous-heading-tidily))
181 *** Promote all items in subtree
184 This function will promote all items in a subtree. Since I use
185 subtrees primarily to organize projects, the function is somewhat
186 unimaginatively called my-org-un-project:
188 #+begin_src emacs-lisp
189 (defun my-org-un-project ()
191 (org-map-entries 'org-do-promote "LEVEL>1" 'tree)
195 *** Turn a heading into an Org link
197 :CUSTOM_ID: heading-to-link
202 #+begin_src emacs-lisp
203 (defun dmj:turn-headline-into-org-mode-link ()
204 "Replace word at point by an Org mode link."
206 (when (org-at-heading-p)
207 (let ((hl-text (nth 4 (org-heading-components))))
208 (unless (or (null hl-text)
209 (org-string-match-p "^[ \t]*:[^:]+:$" hl-text))
211 (search-forward hl-text (point-at-eol))
214 (format "[[file:%s.org][%s]]"
215 (org-link-escape hl-text)
216 (org-link-escape hl-text '((?\] . "%5D") (?\[ . "%5B"))))
217 nil (- (point) (length hl-text)) (point))))))
220 *** Using M-up and M-down to transpose paragraphs
222 From Paul Sexton: By default, if used within ordinary paragraphs in
223 org mode, =M-up= and =M-down= transpose *lines* (not sentences). The
224 following code makes these keys transpose paragraphs, keeping the
225 point at the start of the moved paragraph. Behavior in tables and
226 headings is unaffected. It would be easy to modify this to transpose
229 #+begin_src emacs-lisp
230 (defun org-transpose-paragraphs (arg)
232 (when (and (not (or (org-at-table-p) (org-on-heading-p) (org-at-item-p)))
233 (thing-at-point 'sentence))
234 (transpose-paragraphs arg)
236 (re-search-forward "[[:graph:]]")
237 (goto-char (match-beginning 0))
240 (add-to-list 'org-metaup-hook
241 (lambda () (interactive) (org-transpose-paragraphs -1)))
242 (add-to-list 'org-metadown-hook
243 (lambda () (interactive) (org-transpose-paragraphs 1)))
245 *** Changelog support for org headers
248 Put the following in your =.emacs=, and =C-x 4 a= and other functions which
249 use =add-log-current-defun= like =magit-add-log= will pick up the nearest org
250 headline as the "current function" if you add a changelog entry from an org
253 #+BEGIN_SRC emacs-lisp
254 (defun org-log-current-defun ()
256 (org-back-to-heading)
257 (if (looking-at org-complex-heading-regexp)
260 (add-hook 'org-mode-hook
262 (make-variable-buffer-local 'add-log-current-defun-function)
263 (setq add-log-current-defun-function 'org-log-current-defun)))
266 *** Different org-cycle-level behavior
269 In recent org versions, when your point (cursor) is at the end of an
270 empty header line (like after you first created the header), the TAB
271 key (=org-cycle=) has a special behavior: it cycles the headline through
272 all possible levels. However, I did not like the way it determined
273 "all possible levels," so I rewrote the whole function, along with a
274 couple of supporting functions.
276 The original function's definition of "all possible levels" was "every
277 level from 1 to one more than the initial level of the current
278 headline before you started cycling." My new definition is "every
279 level from 1 to one more than the previous headline's level." So, if
280 you have a headline at level 4 and you use ALT+RET to make a new
281 headline below it, it will cycle between levels 1 and 5, inclusive.
283 The main advantage of my custom =org-cycle-level= function is that it
284 is stateless: the next level in the cycle is determined entirely by
285 the contents of the buffer, and not what command you executed last.
286 This makes it more predictable, I hope.
288 #+BEGIN_SRC emacs-lisp
291 (defun org-point-at-end-of-empty-headline ()
292 "If point is at the end of an empty headline, return t, else nil."
293 (and (looking-at "[ \t]*$")
295 (beginning-of-line 1)
296 (looking-at (concat "^\\(\\*+\\)[ \t]+\\(" org-todo-regexp "\\)?[ \t]*")))))
298 (defun org-level-increment ()
299 "Return the number of stars that will be added or removed at a
300 time to headlines when structure editing, based on the value of
301 `org-odd-levels-only'."
302 (if org-odd-levels-only 2 1))
304 (defvar org-previous-line-level-cached nil)
306 (defun org-recalculate-previous-line-level ()
307 "Same as `org-get-previous-line-level', but does not use cached
308 value. It does *set* the cached value, though."
309 (set 'org-previous-line-level-cached
310 (let ((current-level (org-current-level))
311 (prev-level (when (> (line-number-at-pos) 1)
314 (org-current-level)))))
315 (cond ((null current-level) nil) ; Before first headline
316 ((null prev-level) 0) ; At first headline
319 (defun org-get-previous-line-level ()
320 "Return the outline depth of the last headline before the
321 current line. Returns 0 for the first headline in the buffer, and
322 nil if before the first headline."
323 ;; This calculation is quite expensive, with all the regex searching
324 ;; and stuff. Since org-cycle-level won't change lines, we can reuse
325 ;; the last value of this command.
326 (or (and (eq last-command 'org-cycle-level)
327 org-previous-line-level-cached)
328 (org-recalculate-previous-line-level)))
330 (defun org-cycle-level ()
332 (let ((org-adapt-indentation nil))
333 (when (org-point-at-end-of-empty-headline)
334 (setq this-command 'org-cycle-level) ;Only needed for caching
335 (let ((cur-level (org-current-level))
336 (prev-level (org-get-previous-line-level)))
338 ;; If first headline in file, promote to top-level.
340 (loop repeat (/ (- cur-level 1) (org-level-increment))
341 do (org-do-promote)))
342 ;; If same level as prev, demote one.
343 ((= prev-level cur-level)
345 ;; If parent is top-level, promote to top level if not already.
347 (loop repeat (/ (- cur-level 1) (org-level-increment))
348 do (org-do-promote)))
349 ;; If top-level, return to prev-level.
351 (loop repeat (/ (- prev-level 1) (org-level-increment))
353 ;; If less than prev-level, promote one.
354 ((< cur-level prev-level)
356 ;; If deeper than prev-level, promote until higher than
358 ((> cur-level prev-level)
359 (loop repeat (+ 1 (/ (- cur-level prev-level) (org-level-increment)))
360 do (org-do-promote))))
364 *** Count words in an Org buffer
365 #FIXME: Does not fit too well under Structure. Any idea where to put it?
366 Paul Sexton [[http://article.gmane.org/gmane.emacs.orgmode/38014][posted]] this function to count words in an Org buffer:
368 #+begin_src emacs-lisp
369 (defun org-word-count (beg end
370 &optional count-latex-macro-args?
372 "Report the number of words in the Org mode buffer or selected region.
376 - source code blocks (#+BEGIN_SRC ... #+END_SRC, and inline blocks)
377 - hyperlinks (but does count words in hyperlink descriptions)
378 - tags, priorities, and TODO keywords in headers
379 - sections tagged as 'not for export'.
381 The text of footnote definitions is ignored, unless the optional argument
382 COUNT-FOOTNOTES? is non-nil.
384 If the optional argument COUNT-LATEX-MACRO-ARGS? is non-nil, the word count
385 includes LaTeX macro arguments (the material between {curly braces}).
386 Otherwise, and by default, every LaTeX macro counts as 1 word regardless
390 (setf beg (point-min)
393 (latex-macro-regexp "\\\\[A-Za-z]+\\(\\[[^]]*\\]\\|\\){\\([^}]*\\)}"))
396 (while (< (point) end)
399 ((or (org-in-commented-line) (org-at-table-p))
401 ;; Ignore hyperlinks. But if link has a description, count
402 ;; the words within the description.
403 ((looking-at org-bracket-link-analytic-regexp)
404 (when (match-string-no-properties 5)
405 (let ((desc (match-string-no-properties 5)))
407 (incf wc (length (remove "" (org-split-string
409 (goto-char (match-end 0)))
410 ((looking-at org-any-link-re)
411 (goto-char (match-end 0)))
412 ;; Ignore source code blocks.
413 ((org-in-regexps-block-p "^#\\+BEGIN_SRC\\W" "^#\\+END_SRC\\W")
415 ;; Ignore inline source blocks, counting them as 1 word.
418 (looking-at org-babel-inline-src-block-regexp))
419 (goto-char (match-end 0))
421 ;; Count latex macros as 1 word, ignoring their arguments.
424 (looking-at latex-macro-regexp))
425 (goto-char (if count-latex-macro-args?
430 ((and (not count-footnotes?)
431 (or (org-footnote-at-definition-p)
432 (org-footnote-at-reference-p)))
435 (let ((contexts (org-context)))
437 ;; Ignore tags and TODO keywords, etc.
438 ((or (assoc :todo-keyword contexts)
439 (assoc :priority contexts)
440 (assoc :keyword contexts)
441 (assoc :checkbox contexts))
443 ;; Ignore sections marked with tags that are
444 ;; excluded from export.
445 ((assoc :tags contexts)
446 (if (intersection (org-get-tags-at) org-export-exclude-tags
448 (org-forward-same-level 1)
452 (re-search-forward "\\w+\\W*")))
453 (message (format "%d words in %s." wc
454 (if mark-active "region" "buffer")))))
458 *** Transpose tables (Juan Pechiar)
460 This function by Juan Pechiar will transpose a table:
462 #+begin_src emacs-lisp
463 (defun org-transpose-table-at-point ()
464 "Transpose orgmode table at point, eliminate hlines"
467 (apply #'mapcar* #'list
468 ;; remove 'hline from list
469 (remove-if-not 'listp
470 ;; signals error if not table
471 (org-table-to-lisp)))))
472 (delete-region (org-table-begin) (org-table-end))
473 (insert (mapconcat (lambda(x) (concat "| " (mapconcat 'identity x " | " ) " |\n" ))
485 will be transposed as
492 (Note that horizontal lines disappeared.)
494 *** Manipulate hours/minutes/seconds in table formulas
496 Both Bastien and Martin Halder have posted code ([[http://article.gmane.org/gmane.emacs.orgmode/39519][Bastien's code]] and
497 [[http://article.gmane.org/gmane.emacs.orgmode/39519][Martin's code]]) for interpreting =dd:dd= or =dd:dd:dd= strings (where
498 "=d=" is any digit) as time values in Org-mode table formula. These
499 functions have now been wrapped up into a =with-time= macro which can
500 be used in table formula to translate table cell values to and from
501 numerical values for algebraic manipulation.
503 Here is the code implementing this macro.
504 #+begin_src emacs-lisp :results silent
505 (defun org-time-string-to-seconds (s)
506 "Convert a string HH:MM:SS to a number of seconds."
509 (string-match "\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\)" s))
510 (let ((hour (string-to-number (match-string 1 s)))
511 (min (string-to-number (match-string 2 s)))
512 (sec (string-to-number (match-string 3 s))))
513 (+ (* hour 3600) (* min 60) sec)))
515 (string-match "\\([0-9]+\\):\\([0-9]+\\)" s))
516 (let ((min (string-to-number (match-string 1 s)))
517 (sec (string-to-number (match-string 2 s))))
519 ((stringp s) (string-to-number s))
522 (defun org-time-seconds-to-string (secs)
523 "Convert a number of seconds to a time string."
524 (cond ((>= secs 3600) (format-seconds "%h:%.2m:%.2s" secs))
525 ((>= secs 60) (format-seconds "%m:%.2s" secs))
526 (t (format-seconds "%s" secs))))
528 (defmacro with-time (time-output-p &rest exprs)
529 "Evaluate an org-table formula, converting all fields that look
530 like time data to integer seconds. If TIME-OUTPUT-P then return
531 the result as a time value."
533 (if time-output-p 'org-time-seconds-to-string 'identity)
541 (list 'with-time nil el)
542 (org-time-string-to-seconds el)))
547 Which allows the following forms of table manipulation such as adding
548 and subtracting time values.
549 : | Date | Start | Lunch | Back | End | Sum |
550 : |------------------+-------+-------+-------+-------+------|
551 : | [2011-03-01 Tue] | 8:00 | 12:00 | 12:30 | 18:15 | 9:45 |
552 : #+TBLFM: $6='(with-time t (+ (- $5 $4) (- $3 $2)))
554 and dividing time values by integers
555 : | time | miles | minutes/mile |
556 : |-------+-------+--------------|
557 : | 34:43 | 2.9 | 11:58 |
558 : | 32:15 | 2.77 | 11:38 |
559 : | 33:56 | 3.0 | 11:18 |
560 : | 52:22 | 4.62 | 11:20 |
561 : #+TBLFM: $3='(with-time t (/ $1 $2))
563 *Update*: As of Org version 7.6, you can use the =T= flag (both in Calc and
564 Elisp formulas) to compute time durations. For example:
566 : | Task 1 | Task 2 | Total |
567 : |--------+--------+---------|
568 : | 35:00 | 35:00 | 1:10:00 |
569 : #+TBLFM: @2$3=$1+$2;T
571 *** Dates computation
573 Xin Shi [[http://article.gmane.org/gmane.emacs.orgmode/15692][asked]] for a way to calculate the duration of
574 dates stored in an org table.
576 Nick Dokos [[http://article.gmane.org/gmane.emacs.orgmode/15694][suggested]]:
580 | Start Date | End Date | Duration |
581 |------------+------------+----------|
582 | 2004.08.07 | 2005.07.08 | 335 |
583 :#+TBLFM: $3=(date(<$2>)-date(<$1>))
585 See [[http://thread.gmane.org/gmane.emacs.orgmode/7741][this thread]] as well as [[http://article.gmane.org/gmane.emacs.orgmode/7753][this post]] (which is really a followup on the
586 above). The problem that this last article pointed out was solved in [[http://article.gmane.org/gmane.emacs.orgmode/8001][this
587 post]] and Chris Randle's original musings are [[http://article.gmane.org/gmane.emacs.orgmode/6536/][here]].
591 As with Times computation, the following code allows Computation with
592 Hex values in Org-mode tables using the =with-hex= macro.
594 Here is the code implementing this macro.
595 #+begin_src emacs-lisp
596 (defun org-hex-strip-lead (str)
597 (if (and (> (length str) 2) (string= (substring str 0 2) "0x"))
598 (substring str 2) str))
600 (defun org-hex-to-hex (int)
603 (defun org-hex-to-dec (str)
606 (string-match "\\([0-9a-f]+\\)" (setf str (org-hex-strip-lead str))))
610 (setf out (+ (* out 16)
611 (if (and (>= ch 48) (<= ch 57)) (- ch 48) (- ch 87)))))
612 (coerce (match-string 1 str) 'list))
614 ((stringp str) (string-to-number str))
617 (defmacro with-hex (hex-output-p &rest exprs)
618 "Evaluate an org-table formula, converting all fields that look
619 like hexadecimal to decimal integers. If HEX-OUTPUT-P then
620 return the result as a hex value."
622 (if hex-output-p 'org-hex-to-hex 'identity)
629 (list 'with-hex nil el)
630 (org-hex-to-dec el)))
635 Which allows the following forms of table manipulation such as adding
636 and subtracting hex values.
637 | 0x10 | 0x0 | 0x10 | 16 |
638 | 0x20 | 0x1 | 0x21 | 33 |
639 | 0x30 | 0x2 | 0x32 | 50 |
640 | 0xf0 | 0xf | 0xff | 255 |
641 #+TBLFM: $3='(with-hex 'hex (+ $2 $1))::$4='(with-hex nil (identity $3))
643 *** Field coordinates in formulas (=@#= and =$#=)
647 Following are some use cases that can be implemented with the
648 _field coordinates in formulas_ described in the corresponding
649 chapter in the [[http://orgmode.org/manual/References.html#References][Org manual]], available since =org-version= 6.35.
651 **** Copy a column from a remote table into a column
653 current column =$3= = remote column =$2=:
654 : #+TBLFM: $3 = remote(FOO, @@#$2)
656 **** Copy a row from a remote table transposed into a column
658 current column =$1= = transposed remote row =@1=:
659 : #+TBLFM: $1 = remote(FOO, @$#$@#)
661 **** Transpose a table
665 This is more like a demonstration of using _field coordinates in formulas_
666 to [[http://en.wikipedia.org/wiki/Transpose][transpose]] a table or to do it without using org-babel. The efficient
667 and simple solution for this with the help of org-babel and Emacs Lisp has
668 been provided by Thomas S. Dye on the [[http://thread.gmane.org/gmane.emacs.orgmode/23809/focus=23815][mailing list]].
670 To transpose this 4x7 table
673 : | year | 2004 | 2005 | 2006 | 2007 | 2008 | 2009 |
674 : |------+------+------+------+------+------+------|
675 : | min | 401 | 501 | 601 | 701 | 801 | 901 |
676 : | avg | 402 | 502 | 602 | 702 | 802 | 902 |
677 : | max | 403 | 503 | 603 | 703 | 803 | 903 |
679 start with a 7x4 table without any horizontal line (to have filled
680 also the column header) and yet empty:
690 Then add the =TBLFM= below with the same formula repeated for each column.
691 After recalculation this will end up with the transposed copy:
693 : | year | min | avg | max |
694 : | 2004 | 401 | 402 | 403 |
695 : | 2005 | 501 | 502 | 503 |
696 : | 2006 | 601 | 602 | 603 |
697 : | 2007 | 701 | 702 | 703 |
698 : | 2008 | 801 | 802 | 803 |
699 : | 2009 | 901 | 902 | 903 |
700 : #+TBLFM: $1 = remote(FOO, @$#$@#) :: $2 = remote(FOO, @$#$@#) :: $3 = remote(FOO, @$#$@#) :: $4 = remote(FOO, @$#$@#)
702 The formulas simply exchange row and column numbers by taking
703 - the absolute remote row number =@$#= from the current column number =$#=
704 - the absolute remote column number =$@#= from the current row number =@#=
706 Possible field formulas from the remote table will have to be transferred
707 manually. Since there are no row formulas yet there is no need to transfer
708 column formulas to row formulas or vice versa.
710 **** Dynamic variation of ranges
714 In this example all columns next to =quote= are calculated from the column
715 =quote= and show the average change of the time series =quote[year]=
716 during the period of the preceding =1=, =2=, =3= or =4= years:
718 : | year | quote | 1 a | 2 a | 3 a | 4 a |
719 : |------+-------+-------+-------+-------+-------|
720 : | 2005 | 10 | | | | |
721 : | 2006 | 12 | 0.200 | | | |
722 : | 2007 | 14 | 0.167 | 0.183 | | |
723 : | 2008 | 16 | 0.143 | 0.155 | 0.170 | |
724 : | 2009 | 18 | 0.125 | 0.134 | 0.145 | 0.158 |
725 : #+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
727 The formula is the same for each column =$3= through =$6=. This can easily
728 be seen with the great formula editor invoked by C-c ' on the
729 table. The important part of the formula without the field blanking is:
731 : ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1
733 which is the Emacs Calc implementation of the equation
735 /AvgChange(i, a) = (quote[i] / quote[i - a]) ^ 1 / n - 1/
737 where /i/ is the current time and /a/ is the length of the preceding period.
739 ** Capture and Remember
740 *** Customize the size of the frame for remember
741 (Note: this hack is likely out of date due to the development of
745 On emacs-orgmode, Ryan C. Thompson suggested this:
748 I am using org-remember set to open a new frame when used,
749 and the default frame size is much too large. To fix this, I have
750 designed some advice and a custom variable to implement custom
751 parameters for the remember frame:
754 #+begin_src emacs-lisp
755 (defcustom remember-frame-alist nil
756 "Additional frame parameters for dedicated remember frame."
760 (defadvice remember (around remember-frame-parameters activate)
761 "Set some frame parameters for the remember frame."
762 (let ((default-frame-alist (append remember-frame-alist
763 default-frame-alist)))
767 Setting remember-frame-alist to =((width . 80) (height . 15)))= give a
768 reasonable size for the frame.
770 *** [[#heading-to-link][Turn a heading into an org link]]
771 *** Quickaccess to the link part of hyperlinks
772 Christian Moe [[http://permalink.gmane.org/gmane.emacs.orgmode/43122][asked]], if there is a simpler way to copy the link part
773 of an org hyperling other than to use `C-c C-l C-a C-k C-g',
774 which is indeed kind of cumbersome.
776 The thread offered [[http://permalink.gmane.org/gmane.emacs.orgmode/43606][two ways]]:
778 Using a [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Keyboard-Macros.html][keyboard macro]]:
779 #+begin_src emacs-lisp
781 (lambda (&optional arg)
784 (kmacro-exec-ring-item (quote ("\C-c\C-l\C-a\C-k\C-g" 0 "%d")) arg)))
788 #+begin_src emacs-lisp
789 (defun my-org-extract-link ()
790 "Extract the link location at point and put it on the killring."
792 (when (org-in-regexp org-bracket-link-regexp 1)
793 (kill-new (org-link-unescape (org-match-string-no-properties 1)))))
796 They put the link destination on the killring and can be easily bound to a key.
798 ** Archiving Content in Org-Mode
799 *** Preserve top level headings when archiving to a file
802 To preserve (somewhat) the integrity of your archive structure while
803 archiving lower level items to a file, you can use the following
806 #+begin_src emacs-lisp
807 (defadvice org-archive-subtree (around my-org-archive-subtree activate)
808 (let ((org-archive-location
809 (if (save-excursion (org-back-to-heading)
810 (> (org-outline-level) 1))
811 (concat (car (split-string org-archive-location "::"))
813 (car (org-get-outline-path)))
814 org-archive-location)))
818 Thus, if you have an outline structure such as...
826 ...archiving "Subsubheading" to a new file will set the location in
827 the new file to the top level heading:
834 While this hack obviously destroys the outline hierarchy somewhat, it
835 at least preserves the logic of level one groupings.
837 A slightly more complex version of this hack will not only keep the
838 archive organized by top-level headings, but will also preserve the
839 tags found on those headings:
841 #+begin_src emacs-lisp
842 (defun my-org-inherited-no-file-tags ()
843 (let ((tags (org-entry-get nil "ALLTAGS" 'selective))
844 (ltags (org-entry-get nil "TAGS")))
847 (replace-regexp-in-string (concat tag ":") "" tags)))
848 (append org-file-tags (when ltags (split-string ltags ":" t))))
849 (if (string= ":" tags) nil tags)))
851 (defadvice org-archive-subtree (around my-org-archive-subtree-low-level activate)
852 (let ((tags (my-org-inherited-no-file-tags))
853 (org-archive-location
854 (if (save-excursion (org-back-to-heading)
855 (> (org-outline-level) 1))
856 (concat (car (split-string org-archive-location "::"))
858 (car (org-get-outline-path)))
859 org-archive-location)))
861 (with-current-buffer (find-file-noselect (org-extract-archive-file))
863 (while (org-up-heading-safe))
864 (org-set-tags-to tags)))))
867 *** Archive in a date tree
869 Posted to Org-mode mailing list by Osamu Okano [2010-04-21 Wed].
871 (Make sure org-datetree.el is loaded for this to work.)
873 #+begin_src emacs-lisp
874 ;; (setq org-archive-location "%s_archive::date-tree")
875 (defadvice org-archive-subtree
876 (around org-archive-subtree-to-data-tree activate)
877 "org-archive-subtree to date-tree"
880 (org-extract-archive-heading
881 (org-get-local-archive-location)))
882 (let* ((dct (decode-time (org-current-time)))
886 (this-buffer (current-buffer))
887 (location (org-get-local-archive-location))
888 (afile (org-extract-archive-file location))
889 (org-archive-location
890 (format "%s::*** %04d-%02d-%02d %s" afile y m d
891 (format-time-string "%A" (encode-time 0 0 0 d m y)))))
892 (message "afile=%s" afile)
894 (error "Invalid `org-archive-location'"))
896 (switch-to-buffer (find-file-noselect afile))
897 (org-datetree-find-year-create y)
898 (org-datetree-find-month-create y m)
899 (org-datetree-find-day-create y m d)
901 (switch-to-buffer this-buffer))
906 *** Add inherited tags to archived entries
908 To make =org-archive-subtree= keep inherited tags, Osamu OKANO suggests to
909 advise the function like this:
912 (defadvice org-archive-subtree
913 (before add-inherited-tags-before-org-archive-subtree activate)
914 "add inherited tags before org-archive-subtree"
915 (org-set-tags-to (org-get-tags-at)))
918 ** Using and Managing Org-Metadata
919 *** Remove redundant tags of headlines
922 A small function that processes all headlines in current buffer and
923 removes tags that are local to a headline and inherited by a parent
924 headline or the #+FILETAGS: statement.
926 #+BEGIN_SRC emacs-lisp
927 (defun dmj/org-remove-redundant-tags ()
928 "Remove redundant tags of headlines in current buffer.
930 A tag is considered redundant if it is local to a headline and
931 inherited by a parent headline."
933 (when (eq major-mode 'org-mode)
937 (let ((alltags (split-string (or (org-entry-get (point) "ALLTAGS") "") ":"))
939 (dolist (tag alltags)
940 (if (get-text-property 0 'inherited tag)
941 (push tag inherited) (push tag local)))
943 (if (member tag inherited) (org-toggle-tag tag 'off)))))
947 *** Remove empty property drawers
949 David Maus proposed this:
951 #+begin_src emacs-lisp
952 (defun dmj:org:remove-empty-propert-drawers ()
953 "*Remove all empty property drawers in current file."
955 (unless (eq major-mode 'org-mode)
956 (error "You need to turn on Org mode for this function."))
958 (goto-char (point-min))
959 (while (re-search-forward ":PROPERTIES:" nil t)
961 (org-remove-empty-drawer-at "PROPERTIES" (match-beginning 0))))))
964 *** Group task list by a property
966 This advice allows you to group a task list in Org-Mode. To use it,
967 set the variable =org-agenda-group-by-property= to the name of a
968 property in the option list for a TODO or TAGS search. The resulting
969 agenda view will group tasks by that property prior to searching.
971 #+begin_src emacs-lisp
972 (defvar org-agenda-group-by-property nil
973 "Set this in org-mode agenda views to group tasks by property")
975 (defun org-group-bucket-items (prop items)
978 (let* ((marker (get-text-property 0 'org-marker item))
979 (pvalue (org-entry-get marker prop t))
980 (cell (assoc pvalue buckets)))
982 (setcdr cell (cons item (cdr cell)))
983 (setq buckets (cons (cons pvalue (list item))
985 (setq buckets (mapcar (lambda (bucket)
987 (reverse (cdr bucket))))
989 (sort buckets (lambda (i1 i2)
990 (string< (car i1) (car i2))))))
992 (defadvice org-finalize-agenda-entries (around org-group-agenda-finalize
993 (list &optional nosort))
994 "Prepare bucketed agenda entry lists"
995 (if org-agenda-group-by-property
996 ;; bucketed, handle appropriately
998 (dolist (bucket (org-group-bucket-items
999 org-agenda-group-by-property
1001 (let ((header (concat "Property "
1002 org-agenda-group-by-property
1004 (or (car bucket) "<nil>") ":\n")))
1005 (add-text-properties 0 (1- (length header))
1006 (list 'face 'org-agenda-structure)
1010 ;; recursively process
1011 (let ((org-agenda-group-by-property nil))
1012 (org-finalize-agenda-entries
1013 (cdr bucket) nosort))
1015 (setq ad-return-value text))
1017 (ad-activate 'org-finalize-agenda-entries)
1019 *** A way to tag a task so that when clocking-out user is prompted to take a note.
1020 Thanks to Richard Riley (see [[http://permalink.gmane.org/gmane.emacs.orgmode/40896][this post on the mailing list]]).
1022 A small hook run when clocking out of a task that prompts for a note
1023 when the tag "=clockout_note=" is found in a headline. It uses the tag
1024 ("=clockout_note=") so inheritance can also be used...
1026 #+begin_src emacs-lisp
1027 (defun rgr/check-for-clock-out-note()
1030 (org-back-to-heading)
1031 (let ((tags (org-get-tags)))
1032 (and tags (message "tags: %s " tags)
1033 (when (member "clocknote" tags)
1036 (add-hook 'org-clock-out-hook 'rgr/check-for-clock-out-note)
1038 *** Dynamically adjust tag position
1039 Here is a bit of code that allows you to have the tags always
1040 right-adjusted in the buffer.
1042 This is useful when you have bigger window than default window-size
1043 and you dislike the aesthetics of having the tag in the middle of the
1046 This hack solves the problem of adjusting it whenever you change the
1048 Before saving it will revert the file to having the tag position be
1049 left-adjusted so that if you track your files with version control,
1050 you won't run into artificial diffs just because the window-size
1053 *IMPORTANT*: This is probably slow on very big files.
1055 #+begin_src emacs-lisp
1056 (setq ba/org-adjust-tags-column t)
1058 (defun ba/org-adjust-tags-column-reset-tags ()
1059 "In org-mode buffers it will reset tag position according to
1062 (not (string= (buffer-name) "*Remember*"))
1063 (eql major-mode 'org-mode))
1064 (let ((b-m-p (buffer-modified-p)))
1067 (goto-char (point-min))
1068 (command-execute 'outline-next-visible-heading)
1069 ;; disable (message) that org-set-tags generates
1070 (flet ((message (&rest ignored) nil))
1072 (set-buffer-modified-p b-m-p))
1075 (defun ba/org-adjust-tags-column-now ()
1076 "Right-adjust `org-tags-column' value, then reset tag position."
1077 (set (make-local-variable 'org-tags-column)
1078 (- (- (window-width) (length org-ellipsis))))
1079 (ba/org-adjust-tags-column-reset-tags))
1081 (defun ba/org-adjust-tags-column-maybe ()
1082 "If `ba/org-adjust-tags-column' is set to non-nil, adjust tags."
1083 (when ba/org-adjust-tags-column
1084 (ba/org-adjust-tags-column-now)))
1086 (defun ba/org-adjust-tags-column-before-save ()
1087 "Tags need to be left-adjusted when saving."
1088 (when ba/org-adjust-tags-column
1089 (setq org-tags-column 1)
1090 (ba/org-adjust-tags-column-reset-tags)))
1092 (defun ba/org-adjust-tags-column-after-save ()
1093 "Revert left-adjusted tag position done by before-save hook."
1094 (ba/org-adjust-tags-column-maybe)
1095 (set-buffer-modified-p nil))
1097 ; automatically align tags on right-hand side
1098 (add-hook 'window-configuration-change-hook
1099 'ba/org-adjust-tags-column-maybe)
1100 (add-hook 'before-save-hook 'ba/org-adjust-tags-column-before-save)
1101 (add-hook 'after-save-hook 'ba/org-adjust-tags-column-after-save)
1102 (add-hook 'org-agenda-mode-hook '(lambda ()
1103 (setq org-agenda-tags-column (- (window-width)))))
1105 ; between invoking org-refile and displaying the prompt (which
1106 ; triggers window-configuration-change-hook) tags might adjust,
1107 ; which invalidates the org-refile cache
1108 (defadvice org-refile (around org-refile-disable-adjust-tags)
1109 "Disable dynamically adjusting tags"
1110 (let ((ba/org-adjust-tags-column nil))
1112 (ad-activate 'org-refile)
1114 *** Use an "attach" link type to open files without worrying about their location
1116 -- Darlan Cavalcante Moreira
1118 In the setup part in my org-files I put:
1121 ,#+LINK: attach elisp:(org-open-file (org-attach-expand "%s"))
1124 Now I can use the "attach" link type, but org will ask me if I want to
1125 allow executing the elisp code. To avoid this you can even set
1126 org-confirm-elisp-link-function to nil (I don't like this because it allows
1127 any elisp code in links) or you can set org-confirm-elisp-link-not-regexp
1132 : (setq org-confirm-elisp-link-not-regexp "org-open-file")
1134 This works very well.
1136 ** Org Agenda and Task Management
1137 *** Make it easier to set org-agenda-files from multiple directories
1140 #+begin_src emacs-lisp
1141 (defun my-org-list-files (dirs ext)
1142 "Function to create list of org files in multiple subdirectories.
1143 This can be called to generate a list of files for
1144 org-agenda-files or org-refile-targets.
1146 DIRS is a list of directories.
1148 EXT is a list of the extensions of files to be included."
1149 (let ((dirs (if (listp dirs)
1152 (ext (if (listp ext)
1162 (file-expand-wildcards
1163 (concat (file-name-as-directory x) "*" y)))))
1168 (when (or (string-match "/.#" x)
1169 (string-match "#$" x))
1170 (setq files (delete x files))))
1174 (defvar my-org-agenda-directories '("~/org/")
1175 "List of directories containing org files.")
1176 (defvar my-org-agenda-extensions '(".org")
1177 "List of extensions of agenda files")
1179 (setq my-org-agenda-directories '("~/org/" "~/work/"))
1180 (setq my-org-agenda-extensions '(".org" ".ref"))
1182 (defun my-org-set-agenda-files ()
1184 (setq org-agenda-files (my-org-list-files
1185 my-org-agenda-directories
1186 my-org-agenda-extensions)))
1188 (my-org-set-agenda-files)
1191 The code above will set your "default" agenda files to all files
1192 ending in ".org" and ".ref" in the directories "~/org/" and "~/work/".
1193 You can change these values by setting the variables
1194 my-org-agenda-extensions and my-org-agenda-directories. The function
1195 my-org-agenda-files-by-filetag uses these two variables to determine
1196 which files to search for filetags (i.e., the larger set from which
1197 the subset will be drawn).
1199 You can also easily use my-org-list-files to "mix and match"
1200 directories and extensions to generate different lists of agenda
1203 *** Restrict org-agenda-files by filetag
1205 :CUSTOM_ID: set-agenda-files-by-filetag
1209 It is often helpful to limit yourself to a subset of your agenda
1210 files. For instance, at work, you might want to see only files related
1211 to work (e.g., bugs, clientA, projectxyz, etc.). The FAQ has helpful
1212 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
1213 commands]]. These solutions, however, require reapplying a filter each
1214 time you call the agenda or writing several new custom agenda commands
1215 for each context. Another solution is to use directories for different
1216 types of tasks and to change your agenda files with a function that
1217 sets org-agenda-files to the appropriate directory. But this relies on
1218 hard and static boundaries between files.
1220 The following functions allow for a more dynamic approach to selecting
1221 a subset of files based on filetags:
1223 #+begin_src emacs-lisp
1224 (defun my-org-agenda-restrict-files-by-filetag (&optional tag)
1225 "Restrict org agenda files only to those containing filetag."
1227 (let* ((tagslist (my-org-get-all-filetags))
1229 (completing-read "Tag: "
1230 (mapcar 'car tagslist)))))
1231 (org-agenda-remove-restriction-lock 'noupdate)
1232 (put 'org-agenda-files 'org-restrict (cdr (assoc ftag tagslist)))
1233 (setq org-agenda-overriding-restriction 'files)))
1235 (defun my-org-get-all-filetags ()
1236 "Get list of filetags from all default org-files."
1237 (let ((files org-agenda-files)
1239 (save-window-excursion
1240 (while (setq x (pop files))
1241 (set-buffer (find-file-noselect x))
1244 (let ((tagfiles (assoc y tagslist)))
1246 (setcdr tagfiles (cons x (cdr tagfiles)))
1247 (add-to-list 'tagslist (list y x)))))
1248 (my-org-get-filetags)))
1251 (defun my-org-get-filetags ()
1252 "Get list of filetags for current buffer"
1253 (let ((ftags org-file-tags)
1257 (org-substring-no-properties x))
1261 Calling my-org-agenda-restrict-files-by-filetag results in a prompt
1262 with all filetags in your "normal" agenda files. When you select a
1263 tag, org-agenda-files will be restricted to only those files
1264 containing the filetag. To release the restriction, type C-c C-x >
1265 (org-agenda-remove-restriction-lock).
1267 *** Highlight the agenda line under cursor
1269 This is useful to make sure what task you are operating on.
1271 #+BEGIN_SRC emacs-lisp
1272 (add-hook 'org-agenda-mode-hook '(lambda () (hl-line-mode 1)))
1277 #+BEGIN_SRC emacs-lisp
1278 ;; hl-line seems to be only for emacs
1280 (add-hook 'org-agenda-mode-hook '(lambda () (highline-mode 1)))
1282 ;; highline-mode does not work straightaway in tty mode.
1283 ;; I use a black background
1285 '(highline-face ((((type tty) (class color))
1286 (:background "white" :foreground "black")))))
1289 *** Split horizontally for agenda
1291 If you would like to split the frame into two side-by-side windows when
1292 displaying the agenda, try this hack from Jan Rehders, which uses the
1293 `toggle-window-split' from
1295 http://www.emacswiki.org/cgi-bin/wiki/ToggleWindowSplit
1297 #+BEGIN_SRC emacs-lisp
1298 ;; Patch org-mode to use vertical splitting
1299 (defadvice org-prepare-agenda (after org-fix-split)
1300 (toggle-window-split))
1301 (ad-activate 'org-prepare-agenda)
1304 *** Automatically add an appointment when clocking in a task
1306 #+BEGIN_SRC emacs-lisp
1307 ;; Make sure you have a sensible value for `appt-message-warning-time'
1308 (defvar bzg-org-clock-in-appt-delay 100
1309 "Number of minutes for setting an appointment by clocking-in")
1312 This function let's you add an appointment for the current entry.
1313 This can be useful when you need a reminder.
1315 #+BEGIN_SRC emacs-lisp
1316 (defun bzg-org-clock-in-add-appt (&optional n)
1317 "Add an appointment for the Org entry at point in N minutes."
1320 (org-back-to-heading t)
1321 (looking-at org-complex-heading-regexp)
1322 (let* ((msg (match-string-no-properties 4))
1323 (ct-time (decode-time))
1324 (appt-min (+ (cadr ct-time)
1325 (or n bzg-org-clock-in-appt-delay)))
1326 (appt-time ; define the time for the appointment
1327 (progn (setf (cadr ct-time) appt-min) ct-time)))
1328 (appt-add (format-time-string
1329 "%H:%M" (apply 'encode-time appt-time)) msg)
1330 (if (interactive-p) (message "New appointment for %s" msg)))))
1333 You can advise =org-clock-in= so that =C-c C-x C-i= will automatically
1336 #+BEGIN_SRC emacs-lisp
1337 (defadvice org-clock-in (after org-clock-in-add-appt activate)
1338 "Add an appointment when clocking a task in."
1339 (bzg-org-clock-in-add-appt))
1342 You may also want to delete the associated appointment when clocking
1343 out. This function does this:
1345 #+BEGIN_SRC emacs-lisp
1346 (defun bzg-org-clock-out-delete-appt nil
1347 "When clocking out, delete any associated appointment."
1350 (org-back-to-heading t)
1351 (looking-at org-complex-heading-regexp)
1352 (let* ((msg (match-string-no-properties 4)))
1353 (setq appt-time-msg-list
1357 (if (not (string-match (regexp-quote msg)
1358 (cadr appt))) appt))
1359 appt-time-msg-list)))
1363 And here is the advice for =org-clock-out= (=C-c C-x C-o=)
1365 #+BEGIN_SRC emacs-lisp
1366 (defadvice org-clock-out (before org-clock-out-delete-appt activate)
1367 "Delete an appointment when clocking a task out."
1368 (bzg-org-clock-out-delete-appt))
1371 *IMPORTANT*: You can add appointment by clocking in in both an
1372 =org-mode= and an =org-agenda-mode= buffer. But clocking out from
1373 agenda buffer with the advice above will bring an error.
1375 *** Remove time grid lines that are in an appointment
1377 The agenda shows lines for the time grid. Some people think that
1378 these lines are a distraction when there are appointments at those
1379 times. You can get rid of the lines which coincide exactly with the
1380 beginning of an appointment. Michael Ekstrand has written a piece of
1381 advice that also removes lines that are somewhere inside an
1384 #+begin_src emacs-lisp
1385 (defun org-time-to-minutes (time)
1386 "Convert an HHMM time to minutes"
1387 (+ (* (/ time 100) 60) (% time 100)))
1389 (defun org-time-from-minutes (minutes)
1390 "Convert a number of minutes to an HHMM time"
1391 (+ (* (/ minutes 60) 100) (% minutes 60)))
1393 (defadvice org-agenda-add-time-grid-maybe (around mde-org-agenda-grid-tweakify
1394 (list ndays todayp))
1395 (if (member 'remove-match (car org-agenda-time-grid))
1396 (flet ((extract-window
1398 (let ((start (get-text-property 1 'time-of-day line))
1399 (dur (get-text-property 1 'duration line)))
1403 (org-time-from-minutes
1404 (+ dur (org-time-to-minutes start)))))
1407 (let* ((windows (delq nil (mapcar 'extract-window list)))
1408 (org-agenda-time-grid
1409 (list (car org-agenda-time-grid)
1410 (cadr org-agenda-time-grid)
1413 (find-if (lambda (w)
1416 (and (>= time (car w))
1419 (caddr org-agenda-time-grid)))))
1422 (ad-activate 'org-agenda-add-time-grid-maybe)
1424 *** Disable vc for Org mode agenda files
1427 Even if you use Git to track your agenda files you might not need
1428 vc-mode to be enabled for these files.
1430 #+begin_src emacs-lisp
1431 (add-hook 'find-file-hook 'dmj/disable-vc-for-agenda-files-hook)
1432 (defun dmj/disable-vc-for-agenda-files-hook ()
1433 "Disable vc-mode for Org agenda files."
1434 (if (and (fboundp 'org-agenda-file-p)
1435 (org-agenda-file-p (buffer-file-name)))
1436 (remove-hook 'find-file-hook 'vc-find-file-hook)
1437 (add-hook 'find-file-hook 'vc-find-file-hook)))
1440 *** Easy customization of TODO colors
1443 Here is some code I came up with some code to make it easier to
1444 customize the colors of various TODO keywords. As long as you just
1445 want a different color and nothing else, you can customize the
1446 variable org-todo-keyword-faces and use just a string color (i.e. a
1447 string of the color name) as the face, and then org-get-todo-face
1448 will convert the color to a face, inheriting everything else from
1449 the standard org-todo face.
1451 To demonstrate, I currently have org-todo-keyword-faces set to
1453 #+BEGIN_SRC emacs-lisp
1454 (("IN PROGRESS" . "dark orange")
1455 ("WAITING" . "red4")
1456 ("CANCELED" . "saddle brown"))
1459 Here's the code, in a form you can put in your =.emacs=
1461 #+BEGIN_SRC emacs-lisp
1462 (eval-after-load 'org-faces
1464 (defcustom org-todo-keyword-faces nil
1465 "Faces for specific TODO keywords.
1466 This is a list of cons cells, with TODO keywords in the car and
1467 faces in the cdr. The face can be a symbol, a color, or a
1468 property list of attributes, like (:foreground \"blue\" :weight
1469 bold :underline t)."
1474 (string :tag "Keyword")
1475 (choice color (sexp :tag "Face")))))))
1477 (eval-after-load 'org
1479 (defun org-get-todo-face-from-color (color)
1480 "Returns a specification for a face that inherits from org-todo
1481 face and has the given color as foreground. Returns nil if
1484 `(:inherit org-warning :foreground ,color)))
1486 (defun org-get-todo-face (kwd)
1487 "Get the right face for a TODO keyword KWD.
1488 If KWD is a number, get the corresponding match group."
1489 (if (numberp kwd) (setq kwd (match-string kwd)))
1490 (or (let ((face (cdr (assoc kwd org-todo-keyword-faces))))
1492 (org-get-todo-face-from-color face)
1494 (and (member kwd org-done-keywords) 'org-done)
1498 *** Add an effort estimate on the fly when clocking in
1500 You can use =org-clock-in-prepare-hook= to add an effort estimate.
1501 This way you can easily have a "tea-timer" for your tasks when they
1502 don't already have an effort estimate.
1504 #+begin_src emacs-lisp
1505 (add-hook 'org-clock-in-prepare-hook
1506 'my-org-mode-ask-effort)
1508 (defun my-org-mode-ask-effort ()
1509 "Ask for an effort estimate when clocking in."
1510 (unless (org-entry-get (point) "Effort")
1514 (org-entry-get-multivalued-property (point) "Effort"))))
1515 (unless (equal effort "")
1516 (org-set-property "Effort" effort)))))
1519 Or you can use a default effort for such a timer:
1521 #+begin_src emacs-lisp
1522 (add-hook 'org-clock-in-prepare-hook
1523 'my-org-mode-add-default-effort)
1525 (defvar org-clock-default-effort "1:00")
1527 (defun my-org-mode-add-default-effort ()
1528 "Add a default effort estimation."
1529 (unless (org-entry-get (point) "Effort")
1530 (org-set-property "Effort" org-clock-default-effort)))
1533 *** Refresh the agenda view regurally
1535 Hack sent by Kiwon Um:
1537 #+begin_src emacs-lisp
1538 (defun kiwon/org-agenda-redo-in-other-window ()
1539 "Call org-agenda-redo function even in the non-agenda buffer."
1541 (let ((agenda-window (get-buffer-window org-agenda-buffer-name t)))
1543 (with-selected-window agenda-window (org-agenda-redo)))))
1544 (run-at-time nil 300 'kiwon/org-agenda-redo-in-other-window)
1547 *** Reschedule agenda items to today with a single command
1549 This was suggested by Carsten in reply to David Abrahams:
1551 #+begin_example emacs-lisp
1552 (defun org-agenda-reschedule-to-today ()
1554 (flet ((org-read-date (&rest rest) (current-time)))
1555 (call-interactively 'org-agenda-schedule)))
1558 *** Mark subtree DONE along with all subheadings
1560 Bernt Hansen [[http://permalink.gmane.org/gmane.emacs.orgmode/44693][suggested]] this command:
1562 #+begin_src emacs-lisp
1563 (defun bh/mark-subtree-done ()
1566 (let ((limit (point)))
1568 (exchange-point-and-mark)
1569 (while (> (point) limit)
1571 (outline-previous-visible-heading 1))
1572 (org-todo "DONE"))))
1575 Then M-x bh/mark-subtree-done.
1577 ** Exporting org files
1578 *** Specifying LaTeX commands to floating environments
1580 :CUSTOM_ID: latex-command-for-floats
1583 The keyword ~placement~ can be used to specify placement options to
1584 floating environments (like =\begin{figure}= and =\begin{table}=}) in
1585 LaTeX export. Org passes along everything passed in options as long as
1586 there are no spaces. One can take advantage of this to pass other
1587 LaTeX commands and have their scope limited to the floating
1590 For example one can set the fontsize of a table different from the
1591 default normal size by putting something like =\footnotesize= right
1592 after the placement options. During LaTeX export using the
1593 ~#+ATTR_LaTeX:~ line below:
1596 ,#+ATTR_LaTeX: placement=[<options>]\footnotesize
1599 exports the associated floating environment as shown in the following
1603 \begin{table}[<options>]\footnotesize
1608 It should be noted that this hack does not work for beamer export of
1609 tables since the =table= environment is not used. As an ugly
1610 workaround, one can use the following:
1613 ,#+LATEX: {\footnotesize
1614 ,#+ATTR_LaTeX: align=rr
1621 * Hacking Org: Working with Org-mode and other Emacs Packages.
1622 ** org-remember-anything
1624 [[http://www.emacswiki.org/cgi-bin/wiki/Anything][Anything]] users may find the snippet below interesting:
1626 #+BEGIN_SRC emacs-lisp
1627 (defvar org-remember-anything
1628 '((name . "Org Remember")
1629 (candidates . (lambda () (mapcar 'car org-remember-templates)))
1630 (action . (lambda (name)
1631 (let* ((orig-template org-remember-templates)
1632 (org-remember-templates
1633 (list (assoc name orig-template))))
1634 (call-interactively 'org-remember))))))
1637 You can add it to your 'anything-sources' variable and open remember directly
1638 from anything. I imagine this would be more interesting for people with many
1639 remember templates, so that you are out of keys to assign those to.
1641 ** Org-mode and saveplace.el
1643 Fix a problem with saveplace.el putting you back in a folded position:
1645 #+begin_src emacs-lisp
1646 (add-hook 'org-mode-hook
1648 (when (outline-invisible-p)
1650 (outline-previous-visible-heading 1)
1651 (org-show-subtree)))))
1654 ** Using ido-completing-read to find attachments
1657 Org-attach is great for quickly linking files to a project. But if you
1658 use org-attach extensively you might find yourself wanting to browse
1659 all the files you've attached to org headlines. This is not easy to do
1660 manually, since the directories containing the files are not human
1661 readable (i.e., they are based on automatically generated ids). Here's
1662 some code to browse those files using ido (obviously, you need to be
1665 #+begin_src emacs-lisp
1666 (load-library "find-lisp")
1668 ;; Adapted from http://www.emacswiki.org/emacs/RecentFiles
1670 (defun my-ido-find-org-attach ()
1671 "Find files in org-attachment directory"
1673 (let* ((enable-recursive-minibuffers t)
1674 (files (find-lisp-find-files org-attach-directory "."))
1677 (cons (file-name-nondirectory x)
1681 (remove-duplicates (mapcar #'car file-assoc-list)
1683 (filename (ido-completing-read "Org attachments: " filename-list nil t))
1684 (longname (cdr (assoc filename file-assoc-list))))
1685 (ido-set-current-directory
1686 (if (file-directory-p longname)
1688 (file-name-directory longname)))
1689 (setq ido-exit 'refresh
1690 ido-text-init ido-text
1694 (add-hook 'ido-setup-hook 'ido-my-keys)
1696 (defun ido-my-keys ()
1697 "Add my keybindings for ido."
1698 (define-key ido-completion-map (kbd "C-;") 'my-ido-find-org-attach))
1701 To browse your org attachments using ido fuzzy matching and/or the
1702 completion buffer, invoke ido-find-file as usual (=C-x C-f=) and then
1705 ** Use idle timer for automatic agenda views
1707 From John Wiegley's mailing list post (March 18, 2010):
1710 I have the following snippet in my .emacs file, which I find very
1711 useful. Basically what it does is that if I don't touch my Emacs for 5
1712 minutes, it displays the current agenda. This keeps my tasks "always
1713 in mind" whenever I come back to Emacs after doing something else,
1714 whereas before I had a tendency to forget that it was there.
1717 - [[http://mid.gmane.org/55590EA7-C744-44E5-909F-755F0BBE452D@gmail.com][John Wiegley: Displaying your Org agenda after idle time]]
1719 #+begin_src emacs-lisp
1720 (defun jump-to-org-agenda ()
1722 (let ((buf (get-buffer "*Org Agenda*"))
1725 (if (setq wind (get-buffer-window buf))
1726 (select-window wind)
1727 (if (called-interactively-p)
1729 (select-window (display-buffer buf t t))
1730 (org-fit-window-to-buffer)
1731 ;; (org-agenda-redo)
1733 (with-selected-window (display-buffer buf)
1734 (org-fit-window-to-buffer)
1735 ;; (org-agenda-redo)
1737 (call-interactively 'org-agenda-list)))
1738 ;;(let ((buf (get-buffer "*Calendar*")))
1739 ;; (unless (get-buffer-window buf)
1740 ;; (org-agenda-goto-calendar)))
1743 (run-with-idle-timer 300 t 'jump-to-org-agenda)
1747 : [nil 0 300 0 t jump-to-org-agenda nil idle]
1749 ** Link to Gnus messages by Message-Id
1751 In a [[http://thread.gmane.org/gmane.emacs.orgmode/8860][recent thread]] on the Org-Mode mailing list, there was some
1752 discussion about linking to Gnus messages without encoding the folder
1753 name in the link. The following code hooks in to the store-link
1754 function in Gnus to capture links by Message-Id when in nnml folders,
1755 and then provides a link type "mid" which can open this link. The
1756 =mde-org-gnus-open-message-link= function uses the
1757 =mde-mid-resolve-methods= variable to determine what Gnus backends to
1758 scan. It will go through them, in order, asking each to locate the
1759 message and opening it from the first one that reports success.
1761 It has only been tested with a single nnml backend, so there may be
1762 bugs lurking here and there.
1764 The logic for finding the message was adapted from [[http://www.emacswiki.org/cgi-bin/wiki/FindMailByMessageId][an Emacs Wiki
1767 #+begin_src emacs-lisp
1768 ;; Support for saving Gnus messages by Message-ID
1769 (defun mde-org-gnus-save-by-mid ()
1770 (when (memq major-mode '(gnus-summary-mode gnus-article-mode))
1771 (when (eq major-mode 'gnus-article-mode)
1772 (gnus-article-show-summary))
1773 (let* ((group gnus-newsgroup-name)
1774 (method (gnus-find-method-for-group group)))
1775 (when (eq 'nnml (car method))
1776 (let* ((article (gnus-summary-article-number))
1777 (header (gnus-summary-article-header article))
1778 (from (mail-header-from header))
1781 (let ((mid (mail-header-id header)))
1782 (if (string-match "<\\(.*\\)>" mid)
1783 (match-string 1 mid)
1784 (error "Malformed message ID header %s" mid)))))
1785 (date (mail-header-date header))
1786 (subject (gnus-summary-subject-string)))
1787 (org-store-link-props :type "mid" :from from :subject subject
1788 :message-id message-id :group group
1789 :link (org-make-link "mid:" message-id))
1790 (apply 'org-store-link-props
1791 :description (org-email-link-description)
1792 org-store-link-plist)
1795 (defvar mde-mid-resolve-methods '()
1796 "List of methods to try when resolving message ID's. For Gnus,
1797 it is a cons of 'gnus and the select (type and name).")
1798 (setq mde-mid-resolve-methods
1801 (defvar mde-org-gnus-open-level 1
1802 "Level at which Gnus is started when opening a link")
1803 (defun mde-org-gnus-open-message-link (msgid)
1804 "Open a message link with Gnus"
1806 (require 'org-table)
1807 (catch 'method-found
1808 (message "[MID linker] Resolving %s" msgid)
1809 (dolist (method mde-mid-resolve-methods)
1811 ((and (eq (car method) 'gnus)
1812 (eq (cadr method) 'nnml))
1813 (funcall (cdr (assq 'gnus org-link-frame-setup))
1814 mde-org-gnus-open-level)
1815 (when gnus-other-frame-object
1816 (select-frame gnus-other-frame-object))
1817 (let* ((msg-info (nnml-find-group-number
1818 (concat "<" msgid ">")
1820 (group (and msg-info (car msg-info)))
1821 (message (and msg-info (cdr msg-info)))
1823 (if (gnus-methods-equal-p
1827 (gnus-group-full-name group (cdr method))))))
1829 (gnus-summary-read-group qname nil t)
1830 (gnus-summary-goto-article message nil t))
1831 (throw 'method-found t)))
1832 (t (error "Unknown link type"))))))
1834 (eval-after-load 'org-gnus
1836 (add-to-list 'org-store-link-functions 'mde-org-gnus-save-by-mid)
1837 (org-add-link-type "mid" 'mde-org-gnus-open-message-link)))
1840 ** Store link upon sending a message in Gnus
1842 Ulf Stegemann came up with this solution (see his [[http://www.mail-archive.com/emacs-orgmode@gnu.org/msg33278.html][original message]]):
1844 #+begin_src emacs-lisp
1845 (defun ulf-message-send-and-org-gnus-store-link (&optional arg)
1846 "Send message with `message-send-and-exit' and store org link to message copy.
1847 If multiple groups appear in the Gcc header, the link refers to
1848 the copy in the last group."
1852 (message-narrow-to-headers)
1853 (let ((gcc (car (last
1854 (message-unquote-tokens
1855 (message-tokenize-header
1856 (mail-fetch-field "gcc" nil t) " ,")))))
1857 (buf (current-buffer))
1858 (message-kill-buffer-on-exit nil)
1859 id to from subject desc link newsgroup xarchive)
1860 (message-send-and-exit arg)
1862 ;; gcc group found ...
1864 (save-current-buffer
1865 (progn (set-buffer buf)
1866 (setq id (org-remove-angle-brackets
1867 (mail-fetch-field "Message-ID")))
1868 (setq to (mail-fetch-field "To"))
1869 (setq from (mail-fetch-field "From"))
1870 (setq subject (mail-fetch-field "Subject"))))
1871 (org-store-link-props :type "gnus" :from from :subject subject
1872 :message-id id :group gcc :to to)
1873 (setq desc (org-email-link-description))
1874 (setq link (org-gnus-article-link
1875 gcc newsgroup id xarchive))
1876 (setq org-stored-links
1877 (cons (list link desc) org-stored-links)))
1878 ;; no gcc group found ...
1879 (message "Can not create Org link: No Gcc header found."))))))
1881 (define-key message-mode-map [(control c) (control meta c)]
1882 'ulf-message-send-and-org-gnus-store-link)
1885 ** Send html messages and attachments with Wanderlust
1888 /Note/: The module [[file:org-contrib/org-mime.org][Org-mime]] in Org's contrib directory provides
1889 similar functionality for both Wanderlust and Gnus. The hack below is
1890 still somewhat different: It allows you to toggle sending of html
1891 messages within Wanderlust transparently. I.e. html markup of the
1892 message body is created right before sending starts.
1894 *** Send HTML message
1896 Putting the code below in your .emacs adds following four functions:
1898 - dmj/wl-send-html-message
1900 Function that does the job: Convert everything between "--text
1901 follows this line--" and first mime entity (read: attachment) or
1902 end of buffer into html markup using `org-export-region-as-html'
1903 and replaces original body with a multipart MIME entity with the
1904 plain text version of body and the html markup version. Thus a
1905 recipient that prefers html messages can see the html markup,
1906 recipients that prefer or depend on plain text can see the plain
1909 Cannot be called interactively: It is hooked into SEMI's
1910 `mime-edit-translate-hook' if message should be HTML message.
1912 - dmj/wl-send-html-message-draft-init
1914 Cannot be called interactively: It is hooked into WL's
1915 `wl-mail-setup-hook' and provides a buffer local variable to
1918 - dmj/wl-send-html-message-draft-maybe
1920 Cannot be called interactively: It is hooked into WL's
1921 `wl-draft-send-hook' and hooks `dmj/wl-send-html-message' into
1922 `mime-edit-translate-hook' depending on whether HTML message is
1925 - dmj/wl-send-html-message-toggle
1927 Toggles sending of HTML message. If toggled on, the letters
1928 "HTML" appear in the mode line.
1930 Call it interactively! Or bind it to a key in `wl-draft-mode'.
1932 If you have to send HTML messages regularly you can set a global
1933 variable `dmj/wl-send-html-message-toggled-p' to the string "HTML" to
1934 toggle on sending HTML message by default.
1936 The image [[http://s11.directupload.net/file/u/15851/48ru5wl3.png][here]] shows an example of how the HTML message looks like in
1937 Google's web front end. As you can see you have the whole markup of
1938 Org at your service: *bold*, /italics/, tables, lists...
1940 So even if you feel uncomfortable with sending HTML messages at least
1941 you send HTML that looks quite good.
1943 #+begin_src emacs-lisp
1944 (defun dmj/wl-send-html-message ()
1945 "Send message as html message.
1946 Convert body of message to html using
1947 `org-export-region-as-html'."
1950 (let (beg end html text)
1951 (goto-char (point-min))
1952 (re-search-forward "^--text follows this line--$")
1953 ;; move to beginning of next line
1954 (beginning-of-line 2)
1956 (if (not (re-search-forward "^--\\[\\[" nil t))
1957 (setq end (point-max))
1962 (setq text (buffer-substring-no-properties beg end))
1968 (when (re-search-backward "^-- \n" nil t)
1969 ;; preserve link breaks in signature
1970 (insert "\n#+BEGIN_VERSE\n")
1971 (goto-char (point-max))
1972 (insert "\n#+END_VERSE\n")
1974 (setq html (org-export-region-as-html
1975 (point-min) (point-max) t 'string))))
1976 (delete-region beg end)
1979 "--" "<<alternative>>-{\n"
1980 "--" "[[text/plain]]\n" text
1981 "--" "[[text/html]]\n" html
1982 "--" "}-<<alternative>>\n")))))
1984 (defun dmj/wl-send-html-message-toggle ()
1985 "Toggle sending of html message."
1987 (setq dmj/wl-send-html-message-toggled-p
1988 (if dmj/wl-send-html-message-toggled-p
1990 (message "Sending html message toggled %s"
1991 (if dmj/wl-send-html-message-toggled-p
1994 (defun dmj/wl-send-html-message-draft-init ()
1995 "Create buffer local settings for maybe sending html message."
1996 (unless (boundp 'dmj/wl-send-html-message-toggled-p)
1997 (setq dmj/wl-send-html-message-toggled-p nil))
1998 (make-variable-buffer-local 'dmj/wl-send-html-message-toggled-p)
1999 (add-to-list 'global-mode-string
2000 '(:eval (if (eq major-mode 'wl-draft-mode)
2001 dmj/wl-send-html-message-toggled-p))))
2003 (defun dmj/wl-send-html-message-maybe ()
2004 "Maybe send this message as html message.
2006 If buffer local variable `dmj/wl-send-html-message-toggled-p' is
2007 non-nil, add `dmj/wl-send-html-message' to
2008 `mime-edit-translate-hook'."
2009 (if dmj/wl-send-html-message-toggled-p
2010 (add-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)
2011 (remove-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)))
2013 (add-hook 'wl-draft-reedit-hook 'dmj/wl-send-html-message-draft-init)
2014 (add-hook 'wl-mail-setup-hook 'dmj/wl-send-html-message-draft-init)
2015 (add-hook 'wl-draft-send-hook 'dmj/wl-send-html-message-maybe)
2018 *** Attach HTML of region or subtree
2020 Instead of sending a complete HTML message you might only send parts
2021 of an Org file as HTML for the poor souls who are plagued with
2022 non-proportional fonts in their mail program that messes up pretty
2025 This short function does the trick: It exports region or subtree to
2026 HTML, prefixes it with a MIME entity delimiter and pushes to killring
2027 and clipboard. If a region is active, it uses the region, the
2028 complete subtree otherwise.
2030 #+begin_src emacs-lisp
2031 (defun dmj/org-export-region-as-html-attachment (beg end arg)
2032 "Export region between BEG and END as html attachment.
2033 If BEG and END are not set, use current subtree. Region or
2034 subtree is exported to html without header and footer, prefixed
2035 with a mime entity string and pushed to clipboard and killring.
2036 When called with prefix, mime entity is not marked as
2038 (interactive "r\nP")
2040 (let* ((beg (if (region-active-p) (region-beginning)
2042 (org-back-to-heading)
2044 (end (if (region-active-p) (region-end)
2046 (org-end-of-subtree)
2048 (html (concat "--[[text/html"
2049 (if arg "" "\nContent-Disposition: attachment")
2051 (org-export-region-as-html beg end t 'string))))
2052 (when (fboundp 'x-set-selection)
2053 (ignore-errors (x-set-selection 'PRIMARY html))
2054 (ignore-errors (x-set-selection 'CLIPBOARD html)))
2055 (message "html export done, pushed to kill ring and clipboard"))))
2058 *** Adopting for Gnus
2060 The whole magic lies in the special strings that mark a HTML
2061 attachment. So you might just have to find out what these special
2062 strings are in message-mode and modify the functions accordingly.
2063 ** Add sunrise/sunset times to the agenda.
2066 The diary package provides the function =diary-sunrise-sunset= which can be used
2067 in a diary s-expression in some agenda file like this:
2069 #+begin_src org-mode
2070 %%(diary-sunrise-sunset)
2073 Seb Vauban asked if it is possible to put sunrise and sunset in
2074 separate lines. Here is a hack to do that. It adds two functions (they
2075 have to be available before the agenda is shown, so I add them early
2076 in my org-config file which is sourced from .emacs, but you'll have to
2077 suit yourself here) that just parse the output of
2078 diary-sunrise-sunset, instead of doing the right thing which would be
2079 to take advantage of the data structures that diary/solar.el provides.
2080 In short, a hack - so perfectly suited for inclusion here :-)
2082 The functions (and latitude/longitude settings which you have to modify for
2083 your location) are as follows:
2085 #+begin_src emacs-lisp
2086 (setq calendar-latitude 40.3)
2087 (setq calendar-longitude -71.0)
2088 (defun diary-sunrise ()
2089 (let ((dss (diary-sunrise-sunset)))
2092 (goto-char (point-min))
2093 (while (re-search-forward " ([^)]*)" nil t)
2094 (replace-match "" nil nil))
2095 (goto-char (point-min))
2096 (search-forward ",")
2097 (buffer-substring (point-min) (match-beginning 0)))))
2099 (defun diary-sunset ()
2100 (let ((dss (diary-sunrise-sunset))
2104 (goto-char (point-min))
2105 (while (re-search-forward " ([^)]*)" nil t)
2106 (replace-match "" nil nil))
2107 (goto-char (point-min))
2108 (search-forward ", ")
2109 (setq start (match-end 0))
2110 (search-forward " at")
2111 (setq end (match-beginning 0))
2114 (buffer-substring start end))))
2117 You also need to add a couple of diary s-expressions in one of your agenda
2120 #+begin_src org-mode
2125 The thread on the mailing list that started this can be found [[http://thread.gmane.org/gmane.emacs.orgmode/38723Here%20is%20a%20pointer%20to%20the%20thread%20on%20the%20mailing%20list][here]].
2126 In comparison to the version posted on the mailing list, this one
2127 gets rid of the timezone information.
2128 * Hacking Org: Working with Org-mode and External Programs.
2132 : I've [...] created some procmail and shell glue that takes emails and
2133 : inserts them into an org-file so that I can capture stuff on the go using
2134 : the email program.
2136 That's [[http://tychoish.com/code/org-mail/][here]].
2138 ** Use Org-mode with Screen [Andrew Hyatt]
2140 "The general idea is that you start a task in which all the work will
2141 take place in a shell. This usually is not a leaf-task for me, but
2142 usually the parent of a leaf task. From a task in your org-file, M-x
2143 ash-org-screen will prompt for the name of a session. Give it a name,
2144 and it will insert a link. Open the link at any time to go the screen
2145 session containing your work!"
2147 http://article.gmane.org/gmane.emacs.orgmode/5276
2149 #+BEGIN_SRC emacs-lisp
2152 (defun ash-org-goto-screen (name)
2153 "Open the screen with the specified name in the window"
2154 (interactive "MScreen name: ")
2155 (let ((screen-buffer-name (ash-org-screen-buffer-name name)))
2156 (if (member screen-buffer-name
2157 (mapcar 'buffer-name (buffer-list)))
2158 (switch-to-buffer screen-buffer-name)
2159 (switch-to-buffer (ash-org-screen-helper name "-dr")))))
2161 (defun ash-org-screen-buffer-name (name)
2162 "Returns the buffer name corresponding to the screen name given."
2163 (concat "*screen " name "*"))
2165 (defun ash-org-screen-helper (name arg)
2166 ;; Pick the name of the new buffer.
2167 (let ((term-ansi-buffer-name
2168 (generate-new-buffer-name
2169 (ash-org-screen-buffer-name name))))
2170 (setq term-ansi-buffer-name
2171 (term-ansi-make-term
2172 term-ansi-buffer-name "/usr/bin/screen" nil arg name))
2173 (set-buffer term-ansi-buffer-name)
2176 (term-set-escape-char ?\C-x)
2177 term-ansi-buffer-name))
2179 (defun ash-org-screen (name)
2180 "Start a screen session with name"
2181 (interactive "MScreen name: ")
2183 (ash-org-screen-helper name "-S"))
2184 (insert-string (concat "[[screen:" name "]]")))
2186 ;; And don't forget to add ("screen" . "elisp:(ash-org-goto-screen
2187 ;; \"%s\")") to org-link-abbrev-alist.
2190 ** Org Agenda + Appt + Zenity
2192 <a name="agenda-appt-zenity"></a>
2194 Russell Adams posted this setup [[http://article.gmane.org/gmane.emacs.orgmode/5806][on the list]]. It makes sure your agenda
2195 appointments are known by Emacs, and it displays warnings in a [[http://live.gnome.org/Zenity][zenity]]
2198 #+BEGIN_SRC emacs-lisp
2199 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2200 ; For org appointment reminders
2202 ;; Get appointments for today
2203 (defun my-org-agenda-to-appt ()
2205 (setq appt-time-msg-list nil)
2206 (let ((org-deadline-warning-days 0)) ;; will be automatic in org 5.23
2207 (org-agenda-to-appt)))
2209 ;; Run once, activate and schedule refresh
2210 (my-org-agenda-to-appt)
2212 (run-at-time "24:01" nil 'my-org-agenda-to-appt)
2215 (setq appt-message-warning-time 15)
2216 (setq appt-display-interval 5)
2218 ; Update appt each time agenda opened.
2219 (add-hook 'org-finalize-agenda-hook 'my-org-agenda-to-appt)
2221 ; Setup zenify, we tell appt to use window, and replace default function
2222 (setq appt-display-format 'window)
2223 (setq appt-disp-window-function (function my-appt-disp-window))
2225 (defun my-appt-disp-window (min-to-app new-time msg)
2226 (save-window-excursion (shell-command (concat
2227 "/usr/bin/zenity --info --title='Appointment' --text='"
2228 msg "' &") nil nil)))
2231 ** Org-Mode + gnome-osd
2233 Richard Riley uses gnome-osd in interaction with Org-Mode to display
2234 appointments. You can look at the code on the [[http://www.emacswiki.org/emacs-en/OrgMode-OSD][emacswiki]].
2240 http://article.gmane.org/gmane.emacs.orgmode/5073
2243 Remind (http://www.roaringpenguin.com/products/remind) is a very powerful
2244 command line calendaring program. Its features superseed the possibilities
2245 of orgmode in the area of date specifying, so that I want to use it
2246 combined with orgmode.
2248 Using the script below I'm able use remind and incorporate its output in my
2249 agenda views. The default of using 13 months look ahead is easily
2250 changed. It just happens I sometimes like to look a year into the
2254 ** Useful webjumps for conkeror
2256 If you are using the [[http://conkeror.org][conkeror browser]], maybe you want to put this into
2257 your =~/.conkerorrc= file:
2260 define_webjump("orglist", "http://search.gmane.org/?query=%s&group=gmane.emacs.orgmode");
2261 define_webjump("worg", "http://www.google.com/cse?cx=002987994228320350715%3Az4glpcrritm&ie=UTF-8&q=%s&sa=Search&siteurl=orgmode.org%2Fworg%2F");
2264 It creates two [[http://conkeror.org/Webjumps][webjumps]] for easily searching the Worg website and the
2265 Org-mode mailing list.
2267 ** Use MathJax for HTML export without requiring JavaScript
2268 As of 2010-08-14, MathJax is the default method used to export math to HTML.
2270 If you like the results but do not want JavaScript in the exported pages,
2271 check out [[http://www.jboecker.de/2010/08/15/staticmathjax.html][Static MathJax]], a XULRunner application which generates a static
2272 HTML file from the exported version. It can also embed all referenced fonts
2273 within the HTML file itself, so there are no dependencies to external files.
2275 The download archive contains an elisp file which integrates it into the Org
2276 export process (configurable per file with a "#+StaticMathJax:" line).
2278 Read README.org and the comments in org-static-mathjax.el for usage instructions.
2279 ** Search Org files using lgrep
2281 Matt Lundin suggests this:
2283 #+begin_src emacs-lisp
2284 (defun my-org-grep (search &optional context)
2285 "Search for word in org files.
2287 Prefix argument determines number of lines."
2288 (interactive "sSearch for: \nP")
2289 (let ((grep-find-ignored-files '("#*" ".#*"))
2290 (grep-template (concat "grep <X> -i -nH "
2292 (concat "-C" (number-to-string context)))
2294 (lgrep search "*org*" "/home/matt/org/")))
2296 (global-set-key (kbd "<f8>") 'my-org-grep)
2299 ** Automatic screenshot insertion
2301 Suggested by Russell Adams
2303 #+begin_src emacs-lisp
2304 (defun my-org-screenshot ()
2305 "Take a screenshot into a time stamped unique-named file in the
2306 same directory as the org-buffer and insert a link to this file."
2311 (concat (buffer-file-name)
2313 (format-time-string "%Y%m%d_%H%M%S_")) ) ".png"))
2314 (call-process "import" nil nil nil filename)
2315 (insert (concat "[[" filename "]]"))
2316 (org-display-inline-images))
2319 ** Capture invitations/appointments from MS Exchange emails
2321 Dirk-Jan C.Binnema [[http://article.gmane.org/gmane.emacs.orgmode/27684/][provided]] code to do this. Please check
2322 [[file:code/elisp/org-exchange-capture.el][org-exchange-capture.el]]
2324 ** Audio/video file playback within org mode
2326 Paul Sexton provided code that makes =file:= links to audio or video files
2327 (MP3, WAV, OGG, AVI, MPG, et cetera) play those files using the [[https://github.com/dbrock/bongo][Bongo]] Emacs
2328 media player library. The user can pause, skip forward and backward in the
2329 track, and so on from without leaving Emacs. Links can also contain a time
2330 after a double colon -- when this is present, playback will begin at that
2331 position in the track.
2333 See the file [[file:code/elisp/org-player.el][org-player.el]]
2335 ** Under X11 Keep a window with the current agenda items at all time
2337 I struggle to keep (in emacs) a window with the agenda at all times.
2338 For a long time I have wanted a sticky window that keeps this
2339 information, and then use my window manager to place it and remove its
2340 decorations (I can also force its placement in the stack: top always,
2343 I wrote a small program in qt that simply monitors an HTML file and
2344 displays it. Nothing more. It does the work for me, and maybe somebody
2345 else will find it useful. It relies on exporting the agenda as HTML
2346 every time the org file is saved, and then this little program
2347 displays the html file. The window manager is responsible of removing
2348 decorations, making it sticky, and placing it in same place always.
2350 Here is a screenshot (see window to the bottom right). The decorations
2351 are removed by the window manager:
2353 http://turingmachine.org/hacking/org-mode/orgdisplay.png
2355 Here is the code. As I said, very, very simple, but maybe somebody will
2358 http://turingmachine.org/hacking/org-mode/
2362 ** Script (thru procmail) to output emails to an Org file
2364 Tycho Garen sent [[http://comments.gmane.org/gmane.emacs.orgmode/44773][this]]:
2367 ** Cooking? Brewing?
2369 See [[http://article.gmane.org/gmane.emacs.orgmode/44981][this message]] from Erik Hetzner:
2371 It currently does metric/english conversion, and a few other tricks.
2372 Basically I just use calc’s units code. I think scaling recipes, or
2373 turning percentages into weights would be pretty easy.
2375 https://gitorious.org/org-cook/org-cook
2377 There is also, for those interested:
2379 https://gitorious.org/org-brew/org-brew
2381 for brewing beer. This is again, mostly just calc functions, including
2382 hydrometer correction, abv calculation, priming sugar for a given CO_2
2383 volume, etc. More integration with org-mode should be possible: for
2384 instance it would be nice to be able to use a lookup table (of ingredients)
2385 to calculate target original gravity, IBUs, etc.