| blob | 1bfbf89423574bf90fdfeb4032808e1b2197a6b8 |
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
6 #+AUTHOR: Worg people
7 #+EMAIL: mdl AT imapmail DOT org
8 #+LANGUAGE: en
9 #+PRIORITIES: A C B
10 #+CATEGORY: worg
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
18 workaround. Go crazy.
20 * Hacking Org: Working within Org-mode.
21 ** Building and Managing Org
22 *** Compiling Org without make
23 :PROPERTIES:
24 :CUSTOM_ID: compiling-org-without-make
25 :END:
27 This file is the result of [[http://article.gmane.org/gmane.emacs.orgmode/15264][one of our discussions]] on the mailing list.
28 Enhancements welcome.
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.")
41 ;; Customize:
42 (setq my/org-lisp-directory "~/.emacs.d/org/lisp")
44 ;; Customize:
45 (setq my/org-compile-sources t)
47 (defun my/compile-org(&optional directory)
48 "Compile all *.el files that come with org-mode."
49 (interactive)
50 (setq directory (concat
51 (file-truename
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
59 (require 'autoload)
60 (setq esf/org-install-file (concat directory "org-install.el"))
61 (find-file esf/org-install-file)
62 (erase-buffer)
63 (mapc (lambda (x)
64 (generate-file-autoloads x))
65 list-of-org-files)
66 (insert "\n(provide (quote org-install))\n")
67 (save-buffer)
68 (kill-buffer)
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)))))
76 #+END_SRC
77 *** Reload Org
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
85 : M-x org-reload
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
90 : C-u M-x org-reload
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
96 : M-x org-reload
98 *** Check for possibly problematic old link escapes
99 :PROPERTIES:
100 :CUSTOM_ID: check-old-link-escapes
101 :END:
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
105 and how.
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."
119 (interactive)
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))
125 (widen)
126 (show-all)
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"
135 escape
136 (buffer-name)
137 (- (point) 3)))))
138 (goto-char end))))))
139 #+end_src
141 ** Structure Movement and Editing
142 *** Show next/prev heading tidily
143 - Dan Davison
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)
154 (hide-subtree)
155 (error "Boundary reached"))
156 (org-overview)
157 (org-reveal t)
158 (org-show-entry)
159 (show-children)))
161 (defun ded/org-show-previous-heading-tidily ()
162 "Show previous entry, keeping other entries closed."
163 (let ((pos (point)))
164 (outline-previous-heading)
165 (unless (and (< (point) pos) (bolp) (org-on-heading-p))
166 (goto-char pos)
167 (hide-subtree)
168 (error "Boundary reached"))
169 (org-overview)
170 (org-reveal t)
171 (org-show-entry)
172 (show-children)))
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))
179 #+end_src
181 *** Promote all items in subtree
182 - Matt Lundin
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 ()
190 (interactive)
191 (org-map-entries 'org-do-promote "LEVEL>1" 'tree)
192 (org-cycle t))
193 #+end_src
195 *** Turn a heading into an Org link
196 :PROPERTIES:
197 :CUSTOM_ID: heading-to-link
198 :END:
200 From David Maus:
202 #+begin_src emacs-lisp
203 (defun dmj:turn-headline-into-org-mode-link ()
204 "Replace word at point by an Org mode link."
205 (interactive)
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))
210 (beginning-of-line)
211 (search-forward hl-text (point-at-eol))
212 (replace-string
213 hl-text
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))))))
218 #+end_src
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
227 sentences.
229 #+begin_src emacs-lisp
230 (defun org-transpose-paragraphs (arg)
231 (interactive)
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)
235 (backward-paragraph)
236 (re-search-forward "[[:graph:]]")
237 (goto-char (match-beginning 0))
238 t))
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)))
244 #+end_src
245 *** Changelog support for org headers
246 -- James TD Smith
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
251 buffer.
253 #+BEGIN_SRC emacs-lisp
254 (defun org-log-current-defun ()
255 (save-excursion
256 (org-back-to-heading)
257 (if (looking-at org-complex-heading-regexp)
258 (match-string 4))))
260 (add-hook 'org-mode-hook
261 (lambda ()
262 (make-variable-buffer-local 'add-log-current-defun-function)
263 (setq add-log-current-defun-function 'org-log-current-defun)))
264 #+END_SRC
266 *** Different org-cycle-level behavior
267 -- Ryan Thompson
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
289 (require 'cl)
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]*$")
294 (save-excursion
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)
312 (save-excursion
313 (previous-line)
314 (org-current-level)))))
315 (cond ((null current-level) nil) ; Before first headline
316 ((null prev-level) 0) ; At first headline
317 (prev-level)))))
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 ()
331 (interactive)
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)))
337 (cond
338 ;; If first headline in file, promote to top-level.
339 ((= prev-level 0)
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)
344 (org-do-demote))
345 ;; If parent is top-level, promote to top level if not already.
346 ((= prev-level 1)
347 (loop repeat (/ (- cur-level 1) (org-level-increment))
348 do (org-do-promote)))
349 ;; If top-level, return to prev-level.
350 ((= cur-level 1)
351 (loop repeat (/ (- prev-level 1) (org-level-increment))
352 do (org-do-demote)))
353 ;; If less than prev-level, promote one.
354 ((< cur-level prev-level)
355 (org-do-promote))
356 ;; If deeper than prev-level, promote until higher than
357 ;; prev-level.
358 ((> cur-level prev-level)
359 (loop repeat (+ 1 (/ (- cur-level prev-level) (org-level-increment)))
360 do (org-do-promote))))
361 t))))
362 #+END_SRC
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?
371 count-footnotes?)
372 "Report the number of words in the Org mode buffer or selected region.
373 Ignores:
374 - comments
375 - tables
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
387 of its arguments."
388 (interactive "r")
389 (unless mark-active
390 (setf beg (point-min)
391 end (point-max)))
392 (let ((wc 0)
393 (latex-macro-regexp "\\\\[A-Za-z]+\\(\\[[^]]*\\]\\|\\){\\([^}]*\\)}"))
394 (save-excursion
395 (goto-char beg)
396 (while (< (point) end)
397 (cond
398 ;; Ignore comments.
399 ((or (org-in-commented-line) (org-at-table-p))
400 nil)
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)))
406 (save-match-data
407 (incf wc (length (remove "" (org-split-string
408 desc "\\W")))))))
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")
414 nil)
415 ;; Ignore inline source blocks, counting them as 1 word.
416 ((save-excursion
417 (backward-char)
418 (looking-at org-babel-inline-src-block-regexp))
419 (goto-char (match-end 0))
420 (setf wc (+ 2 wc)))
421 ;; Count latex macros as 1 word, ignoring their arguments.
422 ((save-excursion
423 (backward-char)
424 (looking-at latex-macro-regexp))
425 (goto-char (if count-latex-macro-args?
426 (match-beginning 2)
427 (match-end 0)))
428 (setf wc (+ 2 wc)))
429 ;; Ignore footnotes.
430 ((and (not count-footnotes?)
431 (or (org-footnote-at-definition-p)
432 (org-footnote-at-reference-p)))
433 nil)
434 (t
435 (let ((contexts (org-context)))
436 (cond
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))
442 nil)
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
447 :test 'equal)
448 (org-forward-same-level 1)
449 nil))
450 (t
451 (incf wc))))))
452 (re-search-forward "\\w+\\W*")))
453 (message (format "%d words in %s." wc
454 (if mark-active "region" "buffer")))))
455 #+end_src
457 ** Org Table
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"
465 (interactive)
466 (let ((contents
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" ))
474 contents ""))
475 (org-table-align)))
476 #+end_src
478 So a table like
480 : | 1 | 2 | 4 | 5 |
481 : |---+---+---+---|
482 : | a | b | c | d |
483 : | e | f | g | h |
485 will be transposed as
487 : | 1 | a | e |
488 : | 2 | b | f |
489 : | 4 | c | g |
490 : | 5 | d | h |
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."
507 (cond
508 ((and (stringp s)
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)))
514 ((and (stringp s)
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))))
518 (+ (* min 60) sec)))
519 ((stringp s) (string-to-number s))
520 (t 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."
532 (list
533 (if time-output-p 'org-time-seconds-to-string 'identity)
534 (cons 'progn
535 (mapcar
536 (lambda (expr)
537 `,(cons (car expr)
538 (mapcar
539 (lambda (el)
540 (if (listp el)
541 (list 'with-time nil el)
542 (org-time-string-to-seconds el)))
543 (cdr expr))))
544 `,@exprs))))
545 #+end_src
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]]:
578 Try the following:
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]].
589 *** Hex computation
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)
601 (format "0x%x" int))
603 (defun org-hex-to-dec (str)
604 (cond
605 ((and (stringp str)
606 (string-match "\\([0-9a-f]+\\)" (setf str (org-hex-strip-lead str))))
607 (let ((out 0))
608 (mapc
609 (lambda (ch)
610 (setf out (+ (* out 16)
611 (if (and (>= ch 48) (<= ch 57)) (- ch 48) (- ch 87)))))
612 (coerce (match-string 1 str) 'list))
613 out))
614 ((stringp str) (string-to-number str))
615 (t 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."
621 (list
622 (if hex-output-p 'org-hex-to-hex 'identity)
623 (cons 'progn
624 (mapcar
625 (lambda (expr)
626 `,(cons (car expr)
627 (mapcar (lambda (el)
628 (if (listp el)
629 (list 'with-hex nil el)
630 (org-hex-to-dec el)))
631 (cdr expr))))
632 `,@exprs))))
633 #+end_src
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 =$#=)
645 -- Michael Brand
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
663 -- Michael Brand
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
672 : #+TBLNAME: FOO
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:
682 : | | | | |
683 : | | | | |
684 : | | | | |
685 : | | | | |
686 : | | | | |
687 : | | | | |
688 : | | | | |
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 -- Note added 2011-11-12 Sat
712 Now that org allows ranges on the LHS of table formulas, the multiple formulas
713 can be condensed down to a single formula:
715 : #+TBLFM: @1$1..@>$> = remote(FOO, @$#$@#)
717 Note however that this is bound to be slow for large tables. See the discussion
718 in the [[http://thread.gmane.org/gmane.emacs.orgmode/22610/focus=23662][mailing list]].
720 **** Dynamic variation of ranges
722 -- Michael Brand
724 In this example all columns next to =quote= are calculated from the column
725 =quote= and show the average change of the time series =quote[year]=
726 during the period of the preceding =1=, =2=, =3= or =4= years:
728 : | year | quote | 1 a | 2 a | 3 a | 4 a |
729 : |------+-------+-------+-------+-------+-------|
730 : | 2005 | 10 | | | | |
731 : | 2006 | 12 | 0.200 | | | |
732 : | 2007 | 14 | 0.167 | 0.183 | | |
733 : | 2008 | 16 | 0.143 | 0.155 | 0.170 | |
734 : | 2009 | 18 | 0.125 | 0.134 | 0.145 | 0.158 |
735 : #+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
737 The formula is the same for each column =$3= through =$6=. This can easily
738 be seen with the great formula editor invoked by C-c ' on the
739 table. The important part of the formula without the field blanking is:
741 : ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1
743 which is the Emacs Calc implementation of the equation
745 /AvgChange(i, a) = (quote[i] / quote[i - a]) ^ 1 / n - 1/
747 where /i/ is the current time and /a/ is the length of the preceding period.
749 ** Capture and Remember
750 *** Customize the size of the frame for remember
751 (Note: this hack is likely out of date due to the development of
752 [[org-capture]].)
754 #FIXME: gmane link?
755 On emacs-orgmode, Ryan C. Thompson suggested this:
757 #+begin_quote
758 I am using org-remember set to open a new frame when used,
759 and the default frame size is much too large. To fix this, I have
760 designed some advice and a custom variable to implement custom
761 parameters for the remember frame:
762 #+end_quote
764 #+begin_src emacs-lisp
765 (defcustom remember-frame-alist nil
766 "Additional frame parameters for dedicated remember frame."
767 :type 'alist
768 :group 'remember)
770 (defadvice remember (around remember-frame-parameters activate)
771 "Set some frame parameters for the remember frame."
772 (let ((default-frame-alist (append remember-frame-alist
773 default-frame-alist)))
774 ad-do-it))
775 #+end_src
777 Setting remember-frame-alist to =((width . 80) (height . 15)))= give a
778 reasonable size for the frame.
779 ** Handling Links
780 *** [[#heading-to-link][Turn a heading into an org link]]
781 *** Quickaccess to the link part of hyperlinks
782 Christian Moe [[http://permalink.gmane.org/gmane.emacs.orgmode/43122][asked]], if there is a simpler way to copy the link part
783 of an org hyperling other than to use `C-c C-l C-a C-k C-g',
784 which is indeed kind of cumbersome.
786 The thread offered [[http://permalink.gmane.org/gmane.emacs.orgmode/43606][two ways]]:
788 Using a [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Keyboard-Macros.html][keyboard macro]]:
789 #+begin_src emacs-lisp
790 (fset 'getlink
791 (lambda (&optional arg)
792 "Keyboard macro."
793 (interactive "p")
794 (kmacro-exec-ring-item (quote ("\C-c\C-l\C-a\C-k\C-g" 0 "%d")) arg)))
795 #+end_src
797 or a function:
798 #+begin_src emacs-lisp
799 (defun my-org-extract-link ()
800 "Extract the link location at point and put it on the killring."
801 (interactive)
802 (when (org-in-regexp org-bracket-link-regexp 1)
803 (kill-new (org-link-unescape (org-match-string-no-properties 1)))))
804 #+end_src
806 They put the link destination on the killring and can be easily bound to a key.
808 ** Archiving Content in Org-Mode
809 *** Preserve top level headings when archiving to a file
810 - Matt Lundin
812 To preserve (somewhat) the integrity of your archive structure while
813 archiving lower level items to a file, you can use the following
814 defadvice:
816 #+begin_src emacs-lisp
817 (defadvice org-archive-subtree (around my-org-archive-subtree activate)
818 (let ((org-archive-location
819 (if (save-excursion (org-back-to-heading)
820 (> (org-outline-level) 1))
821 (concat (car (split-string org-archive-location "::"))
822 "::* "
823 (car (org-get-outline-path)))
824 org-archive-location)))
825 ad-do-it))
826 #+end_src
828 Thus, if you have an outline structure such as...
830 #+begin_src org
831 ,* Heading
832 ,** Subheading
833 ,*** Subsubheading
834 #+end_src
836 ...archiving "Subsubheading" to a new file will set the location in
837 the new file to the top level heading:
839 #+begin_src org
840 ,* Heading
841 ,** Subsubheading
842 #+end_src
844 While this hack obviously destroys the outline hierarchy somewhat, it
845 at least preserves the logic of level one groupings.
847 A slightly more complex version of this hack will not only keep the
848 archive organized by top-level headings, but will also preserve the
849 tags found on those headings:
851 #+begin_src emacs-lisp
852 (defun my-org-inherited-no-file-tags ()
853 (let ((tags (org-entry-get nil "ALLTAGS" 'selective))
854 (ltags (org-entry-get nil "TAGS")))
855 (mapc (lambda (tag)
856 (setq tags
857 (replace-regexp-in-string (concat tag ":") "" tags)))
858 (append org-file-tags (when ltags (split-string ltags ":" t))))
859 (if (string= ":" tags) nil tags)))
861 (defadvice org-archive-subtree (around my-org-archive-subtree-low-level activate)
862 (let ((tags (my-org-inherited-no-file-tags))
863 (org-archive-location
864 (if (save-excursion (org-back-to-heading)
865 (> (org-outline-level) 1))
866 (concat (car (split-string org-archive-location "::"))
867 "::* "
868 (car (org-get-outline-path)))
869 org-archive-location)))
870 ad-do-it
871 (with-current-buffer (find-file-noselect (org-extract-archive-file))
872 (save-excursion
873 (while (org-up-heading-safe))
874 (org-set-tags-to tags)))))
875 #+end_src
877 *** Archive in a date tree
879 Posted to Org-mode mailing list by Osamu Okano [2010-04-21 Wed].
881 (Make sure org-datetree.el is loaded for this to work.)
883 #+begin_src emacs-lisp
884 ;; (setq org-archive-location "%s_archive::date-tree")
885 (defadvice org-archive-subtree
886 (around org-archive-subtree-to-data-tree activate)
887 "org-archive-subtree to date-tree"
888 (if
889 (string= "date-tree"
890 (org-extract-archive-heading
891 (org-get-local-archive-location)))
892 (let* ((dct (decode-time (org-current-time)))
893 (y (nth 5 dct))
894 (m (nth 4 dct))
895 (d (nth 3 dct))
896 (this-buffer (current-buffer))
897 (location (org-get-local-archive-location))
898 (afile (org-extract-archive-file location))
899 (org-archive-location
900 (format "%s::*** %04d-%02d-%02d %s" afile y m d
901 (format-time-string "%A" (encode-time 0 0 0 d m y)))))
902 (message "afile=%s" afile)
903 (unless afile
904 (error "Invalid `org-archive-location'"))
905 (save-excursion
906 (switch-to-buffer (find-file-noselect afile))
907 (org-datetree-find-year-create y)
908 (org-datetree-find-month-create y m)
909 (org-datetree-find-day-create y m d)
910 (widen)
911 (switch-to-buffer this-buffer))
912 ad-do-it)
913 ad-do-it))
914 #+end_src
916 *** Add inherited tags to archived entries
918 To make =org-archive-subtree= keep inherited tags, Osamu OKANO suggests to
919 advise the function like this:
921 #+begin_example
922 (defadvice org-archive-subtree
923 (before add-inherited-tags-before-org-archive-subtree activate)
924 "add inherited tags before org-archive-subtree"
925 (org-set-tags-to (org-get-tags-at)))
926 #+end_example
928 ** Using and Managing Org-Metadata
929 *** Remove redundant tags of headlines
930 -- David Maus
932 A small function that processes all headlines in current buffer and
933 removes tags that are local to a headline and inherited by a parent
934 headline or the #+FILETAGS: statement.
936 #+BEGIN_SRC emacs-lisp
937 (defun dmj/org-remove-redundant-tags ()
938 "Remove redundant tags of headlines in current buffer.
940 A tag is considered redundant if it is local to a headline and
941 inherited by a parent headline."
942 (interactive)
943 (when (eq major-mode 'org-mode)
944 (save-excursion
945 (org-map-entries
946 '(lambda ()
947 (let ((alltags (split-string (or (org-entry-get (point) "ALLTAGS") "") ":"))
948 local inherited tag)
949 (dolist (tag alltags)
950 (if (get-text-property 0 'inherited tag)
951 (push tag inherited) (push tag local)))
952 (dolist (tag local)
953 (if (member tag inherited) (org-toggle-tag tag 'off)))))
954 t nil))))
955 #+END_SRC
957 *** Remove empty property drawers
959 David Maus proposed this:
961 #+begin_src emacs-lisp
962 (defun dmj:org:remove-empty-propert-drawers ()
963 "*Remove all empty property drawers in current file."
964 (interactive)
965 (unless (eq major-mode 'org-mode)
966 (error "You need to turn on Org mode for this function."))
967 (save-excursion
968 (goto-char (point-min))
969 (while (re-search-forward ":PROPERTIES:" nil t)
970 (save-excursion
971 (org-remove-empty-drawer-at "PROPERTIES" (match-beginning 0))))))
972 #+end_src
974 *** Group task list by a property
976 This advice allows you to group a task list in Org-Mode. To use it,
977 set the variable =org-agenda-group-by-property= to the name of a
978 property in the option list for a TODO or TAGS search. The resulting
979 agenda view will group tasks by that property prior to searching.
981 #+begin_src emacs-lisp
982 (defvar org-agenda-group-by-property nil
983 "Set this in org-mode agenda views to group tasks by property")
985 (defun org-group-bucket-items (prop items)
986 (let ((buckets ()))
987 (dolist (item items)
988 (let* ((marker (get-text-property 0 'org-marker item))
989 (pvalue (org-entry-get marker prop t))
990 (cell (assoc pvalue buckets)))
991 (if cell
992 (setcdr cell (cons item (cdr cell)))
993 (setq buckets (cons (cons pvalue (list item))
994 buckets)))))
995 (setq buckets (mapcar (lambda (bucket)
996 (cons (car bucket)
997 (reverse (cdr bucket))))
998 buckets))
999 (sort buckets (lambda (i1 i2)
1000 (string< (car i1) (car i2))))))
1002 (defadvice org-finalize-agenda-entries (around org-group-agenda-finalize
1003 (list &optional nosort))
1004 "Prepare bucketed agenda entry lists"
1005 (if org-agenda-group-by-property
1006 ;; bucketed, handle appropriately
1007 (let ((text ""))
1008 (dolist (bucket (org-group-bucket-items
1009 org-agenda-group-by-property
1010 list))
1011 (let ((header (concat "Property "
1012 org-agenda-group-by-property
1013 " is "
1014 (or (car bucket) "<nil>") ":\n")))
1015 (add-text-properties 0 (1- (length header))
1016 (list 'face 'org-agenda-structure)
1017 header)
1018 (setq text
1019 (concat text header
1020 ;; recursively process
1021 (let ((org-agenda-group-by-property nil))
1022 (org-finalize-agenda-entries
1023 (cdr bucket) nosort))
1024 "\n\n"))))
1025 (setq ad-return-value text))
1026 ad-do-it))
1027 (ad-activate 'org-finalize-agenda-entries)
1028 #+end_src
1029 *** A way to tag a task so that when clocking-out user is prompted to take a note.
1030 Thanks to Richard Riley (see [[http://permalink.gmane.org/gmane.emacs.orgmode/40896][this post on the mailing list]]).
1032 A small hook run when clocking out of a task that prompts for a note
1033 when the tag "=clockout_note=" is found in a headline. It uses the tag
1034 ("=clockout_note=") so inheritance can also be used...
1036 #+begin_src emacs-lisp
1037 (defun rgr/check-for-clock-out-note()
1038 (interactive)
1039 (save-excursion
1040 (org-back-to-heading)
1041 (let ((tags (org-get-tags)))
1042 (and tags (message "tags: %s " tags)
1043 (when (member "clocknote" tags)
1044 (org-add-note))))))
1046 (add-hook 'org-clock-out-hook 'rgr/check-for-clock-out-note)
1047 #+end_src
1048 *** Dynamically adjust tag position
1049 Here is a bit of code that allows you to have the tags always
1050 right-adjusted in the buffer.
1052 This is useful when you have bigger window than default window-size
1053 and you dislike the aesthetics of having the tag in the middle of the
1054 line.
1056 This hack solves the problem of adjusting it whenever you change the
1057 window size.
1058 Before saving it will revert the file to having the tag position be
1059 left-adjusted so that if you track your files with version control,
1060 you won't run into artificial diffs just because the window-size
1061 changed.
1063 *IMPORTANT*: This is probably slow on very big files.
1065 #+begin_src emacs-lisp
1066 (setq ba/org-adjust-tags-column t)
1068 (defun ba/org-adjust-tags-column-reset-tags ()
1069 "In org-mode buffers it will reset tag position according to
1070 `org-tags-column'."
1071 (when (and
1072 (not (string= (buffer-name) "*Remember*"))
1073 (eql major-mode 'org-mode))
1074 (let ((b-m-p (buffer-modified-p)))
1075 (condition-case nil
1076 (save-excursion
1077 (goto-char (point-min))
1078 (command-execute 'outline-next-visible-heading)
1079 ;; disable (message) that org-set-tags generates
1080 (flet ((message (&rest ignored) nil))
1081 (org-set-tags 1 t))
1082 (set-buffer-modified-p b-m-p))
1083 (error nil)))))
1085 (defun ba/org-adjust-tags-column-now ()
1086 "Right-adjust `org-tags-column' value, then reset tag position."
1087 (set (make-local-variable 'org-tags-column)
1088 (- (- (window-width) (length org-ellipsis))))
1089 (ba/org-adjust-tags-column-reset-tags))
1091 (defun ba/org-adjust-tags-column-maybe ()
1092 "If `ba/org-adjust-tags-column' is set to non-nil, adjust tags."
1093 (when ba/org-adjust-tags-column
1094 (ba/org-adjust-tags-column-now)))
1096 (defun ba/org-adjust-tags-column-before-save ()
1097 "Tags need to be left-adjusted when saving."
1098 (when ba/org-adjust-tags-column
1099 (setq org-tags-column 1)
1100 (ba/org-adjust-tags-column-reset-tags)))
1102 (defun ba/org-adjust-tags-column-after-save ()
1103 "Revert left-adjusted tag position done by before-save hook."
1104 (ba/org-adjust-tags-column-maybe)
1105 (set-buffer-modified-p nil))
1107 ; automatically align tags on right-hand side
1108 (add-hook 'window-configuration-change-hook
1109 'ba/org-adjust-tags-column-maybe)
1110 (add-hook 'before-save-hook 'ba/org-adjust-tags-column-before-save)
1111 (add-hook 'after-save-hook 'ba/org-adjust-tags-column-after-save)
1112 (add-hook 'org-agenda-mode-hook '(lambda ()
1113 (setq org-agenda-tags-column (- (window-width)))))
1115 ; between invoking org-refile and displaying the prompt (which
1116 ; triggers window-configuration-change-hook) tags might adjust,
1117 ; which invalidates the org-refile cache
1118 (defadvice org-refile (around org-refile-disable-adjust-tags)
1119 "Disable dynamically adjusting tags"
1120 (let ((ba/org-adjust-tags-column nil))
1121 ad-do-it))
1122 (ad-activate 'org-refile)
1123 #+end_src
1124 *** Use an "attach" link type to open files without worrying about their location
1126 -- Darlan Cavalcante Moreira
1128 In the setup part in my org-files I put:
1130 #+begin_src org
1131 ,#+LINK: attach elisp:(org-open-file (org-attach-expand "%s"))
1132 #+end_src org
1134 Now I can use the "attach" link type, but org will ask me if I want to
1135 allow executing the elisp code. To avoid this you can even set
1136 org-confirm-elisp-link-function to nil (I don't like this because it allows
1137 any elisp code in links) or you can set org-confirm-elisp-link-not-regexp
1138 appropriately.
1140 In my case I use
1142 : (setq org-confirm-elisp-link-not-regexp "org-open-file")
1144 This works very well.
1146 ** Org Agenda and Task Management
1147 *** Make it easier to set org-agenda-files from multiple directories
1148 - Matt Lundin
1150 #+begin_src emacs-lisp
1151 (defun my-org-list-files (dirs ext)
1152 "Function to create list of org files in multiple subdirectories.
1153 This can be called to generate a list of files for
1154 org-agenda-files or org-refile-targets.
1156 DIRS is a list of directories.
1158 EXT is a list of the extensions of files to be included."
1159 (let ((dirs (if (listp dirs)
1160 dirs
1161 (list dirs)))
1162 (ext (if (listp ext)
1163 ext
1164 (list ext)))
1165 files)
1166 (mapc
1167 (lambda (x)
1168 (mapc
1169 (lambda (y)
1170 (setq files
1171 (append files
1172 (file-expand-wildcards
1173 (concat (file-name-as-directory x) "*" y)))))
1174 ext))
1175 dirs)
1176 (mapc
1177 (lambda (x)
1178 (when (or (string-match "/.#" x)
1179 (string-match "#$" x))
1180 (setq files (delete x files))))
1181 files)
1182 files))
1184 (defvar my-org-agenda-directories '("~/org/")
1185 "List of directories containing org files.")
1186 (defvar my-org-agenda-extensions '(".org")
1187 "List of extensions of agenda files")
1189 (setq my-org-agenda-directories '("~/org/" "~/work/"))
1190 (setq my-org-agenda-extensions '(".org" ".ref"))
1192 (defun my-org-set-agenda-files ()
1193 (interactive)
1194 (setq org-agenda-files (my-org-list-files
1195 my-org-agenda-directories
1196 my-org-agenda-extensions)))
1198 (my-org-set-agenda-files)
1199 #+end_src
1201 The code above will set your "default" agenda files to all files
1202 ending in ".org" and ".ref" in the directories "~/org/" and "~/work/".
1203 You can change these values by setting the variables
1204 my-org-agenda-extensions and my-org-agenda-directories. The function
1205 my-org-agenda-files-by-filetag uses these two variables to determine
1206 which files to search for filetags (i.e., the larger set from which
1207 the subset will be drawn).
1209 You can also easily use my-org-list-files to "mix and match"
1210 directories and extensions to generate different lists of agenda
1211 files.
1213 *** Restrict org-agenda-files by filetag
1214 :PROPERTIES:
1215 :CUSTOM_ID: set-agenda-files-by-filetag
1216 :END:
1217 - Matt Lundin
1219 It is often helpful to limit yourself to a subset of your agenda
1220 files. For instance, at work, you might want to see only files related
1221 to work (e.g., bugs, clientA, projectxyz, etc.). The FAQ has helpful
1222 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
1223 commands]]. These solutions, however, require reapplying a filter each
1224 time you call the agenda or writing several new custom agenda commands
1225 for each context. Another solution is to use directories for different
1226 types of tasks and to change your agenda files with a function that
1227 sets org-agenda-files to the appropriate directory. But this relies on
1228 hard and static boundaries between files.
1230 The following functions allow for a more dynamic approach to selecting
1231 a subset of files based on filetags:
1233 #+begin_src emacs-lisp
1234 (defun my-org-agenda-restrict-files-by-filetag (&optional tag)
1235 "Restrict org agenda files only to those containing filetag."
1236 (interactive)
1237 (let* ((tagslist (my-org-get-all-filetags))
1238 (ftag (or tag
1239 (completing-read "Tag: "
1240 (mapcar 'car tagslist)))))
1241 (org-agenda-remove-restriction-lock 'noupdate)
1242 (put 'org-agenda-files 'org-restrict (cdr (assoc ftag tagslist)))
1243 (setq org-agenda-overriding-restriction 'files)))
1245 (defun my-org-get-all-filetags ()
1246 "Get list of filetags from all default org-files."
1247 (let ((files org-agenda-files)
1248 tagslist x)
1249 (save-window-excursion
1250 (while (setq x (pop files))
1251 (set-buffer (find-file-noselect x))
1252 (mapc
1253 (lambda (y)
1254 (let ((tagfiles (assoc y tagslist)))
1255 (if tagfiles
1256 (setcdr tagfiles (cons x (cdr tagfiles)))
1257 (add-to-list 'tagslist (list y x)))))
1258 (my-org-get-filetags)))
1259 tagslist)))
1261 (defun my-org-get-filetags ()
1262 "Get list of filetags for current buffer"
1263 (let ((ftags org-file-tags)
1264 x)
1265 (mapcar
1266 (lambda (x)
1267 (org-substring-no-properties x))
1268 ftags)))
1269 #+end_src
1271 Calling my-org-agenda-restrict-files-by-filetag results in a prompt
1272 with all filetags in your "normal" agenda files. When you select a
1273 tag, org-agenda-files will be restricted to only those files
1274 containing the filetag. To release the restriction, type C-c C-x >
1275 (org-agenda-remove-restriction-lock).
1277 *** Highlight the agenda line under cursor
1279 This is useful to make sure what task you are operating on.
1281 #+BEGIN_SRC emacs-lisp
1282 (add-hook 'org-agenda-mode-hook '(lambda () (hl-line-mode 1)))
1283 #+END_SRC
1285 Under XEmacs:
1287 #+BEGIN_SRC emacs-lisp
1288 ;; hl-line seems to be only for emacs
1289 (require 'highline)
1290 (add-hook 'org-agenda-mode-hook '(lambda () (highline-mode 1)))
1292 ;; highline-mode does not work straightaway in tty mode.
1293 ;; I use a black background
1294 (custom-set-faces
1295 '(highline-face ((((type tty) (class color))
1296 (:background "white" :foreground "black")))))
1297 #+END_SRC
1299 *** Split horizontally for agenda
1301 If you would like to split the frame into two side-by-side windows when
1302 displaying the agenda, try this hack from Jan Rehders, which uses the
1303 `toggle-window-split' from
1305 http://www.emacswiki.org/cgi-bin/wiki/ToggleWindowSplit
1307 #+BEGIN_SRC emacs-lisp
1308 ;; Patch org-mode to use vertical splitting
1309 (defadvice org-prepare-agenda (after org-fix-split)
1310 (toggle-window-split))
1311 (ad-activate 'org-prepare-agenda)
1312 #+END_SRC
1314 *** Automatically add an appointment when clocking in a task
1316 #+BEGIN_SRC emacs-lisp
1317 ;; Make sure you have a sensible value for `appt-message-warning-time'
1318 (defvar bzg-org-clock-in-appt-delay 100
1319 "Number of minutes for setting an appointment by clocking-in")
1320 #+END_SRC
1322 This function let's you add an appointment for the current entry.
1323 This can be useful when you need a reminder.
1325 #+BEGIN_SRC emacs-lisp
1326 (defun bzg-org-clock-in-add-appt (&optional n)
1327 "Add an appointment for the Org entry at point in N minutes."
1328 (interactive)
1329 (save-excursion
1330 (org-back-to-heading t)
1331 (looking-at org-complex-heading-regexp)
1332 (let* ((msg (match-string-no-properties 4))
1333 (ct-time (decode-time))
1334 (appt-min (+ (cadr ct-time)
1335 (or n bzg-org-clock-in-appt-delay)))
1336 (appt-time ; define the time for the appointment
1337 (progn (setf (cadr ct-time) appt-min) ct-time)))
1338 (appt-add (format-time-string
1339 "%H:%M" (apply 'encode-time appt-time)) msg)
1340 (if (interactive-p) (message "New appointment for %s" msg)))))
1341 #+END_SRC
1343 You can advise =org-clock-in= so that =C-c C-x C-i= will automatically
1344 add an appointment:
1346 #+BEGIN_SRC emacs-lisp
1347 (defadvice org-clock-in (after org-clock-in-add-appt activate)
1348 "Add an appointment when clocking a task in."
1349 (bzg-org-clock-in-add-appt))
1350 #+END_SRC
1352 You may also want to delete the associated appointment when clocking
1353 out. This function does this:
1355 #+BEGIN_SRC emacs-lisp
1356 (defun bzg-org-clock-out-delete-appt nil
1357 "When clocking out, delete any associated appointment."
1358 (interactive)
1359 (save-excursion
1360 (org-back-to-heading t)
1361 (looking-at org-complex-heading-regexp)
1362 (let* ((msg (match-string-no-properties 4)))
1363 (setq appt-time-msg-list
1364 (delete nil
1365 (mapcar
1366 (lambda (appt)
1367 (if (not (string-match (regexp-quote msg)
1368 (cadr appt))) appt))
1369 appt-time-msg-list)))
1370 (appt-check))))
1371 #+END_SRC
1373 And here is the advice for =org-clock-out= (=C-c C-x C-o=)
1375 #+BEGIN_SRC emacs-lisp
1376 (defadvice org-clock-out (before org-clock-out-delete-appt activate)
1377 "Delete an appointment when clocking a task out."
1378 (bzg-org-clock-out-delete-appt))
1379 #+END_SRC
1381 *IMPORTANT*: You can add appointment by clocking in in both an
1382 =org-mode= and an =org-agenda-mode= buffer. But clocking out from
1383 agenda buffer with the advice above will bring an error.
1385 *** Using external programs for appointments reminders
1387 Read this rich [[http://comments.gmane.org/gmane.emacs.orgmode/46641][thread]] from the org-mode list.
1389 *** Remove time grid lines that are in an appointment
1391 The agenda shows lines for the time grid. Some people think that
1392 these lines are a distraction when there are appointments at those
1393 times. You can get rid of the lines which coincide exactly with the
1394 beginning of an appointment. Michael Ekstrand has written a piece of
1395 advice that also removes lines that are somewhere inside an
1396 appointment:
1398 #+begin_src emacs-lisp
1399 (defun org-time-to-minutes (time)
1400 "Convert an HHMM time to minutes"
1401 (+ (* (/ time 100) 60) (% time 100)))
1403 (defun org-time-from-minutes (minutes)
1404 "Convert a number of minutes to an HHMM time"
1405 (+ (* (/ minutes 60) 100) (% minutes 60)))
1407 (defadvice org-agenda-add-time-grid-maybe (around mde-org-agenda-grid-tweakify
1408 (list ndays todayp))
1409 (if (member 'remove-match (car org-agenda-time-grid))
1410 (flet ((extract-window
1411 (line)
1412 (let ((start (get-text-property 1 'time-of-day line))
1413 (dur (get-text-property 1 'duration line)))
1414 (cond
1415 ((and start dur)
1416 (cons start
1417 (org-time-from-minutes
1418 (+ dur (org-time-to-minutes start)))))
1419 (start start)
1420 (t nil)))))
1421 (let* ((windows (delq nil (mapcar 'extract-window list)))
1422 (org-agenda-time-grid
1423 (list (car org-agenda-time-grid)
1424 (cadr org-agenda-time-grid)
1425 (remove-if
1426 (lambda (time)
1427 (find-if (lambda (w)
1428 (if (numberp w)
1429 (equal w time)
1430 (and (>= time (car w))
1431 (< time (cdr w)))))
1432 windows))
1433 (caddr org-agenda-time-grid)))))
1434 ad-do-it))
1435 ad-do-it))
1436 (ad-activate 'org-agenda-add-time-grid-maybe)
1437 #+end_src
1438 *** Disable vc for Org mode agenda files
1439 -- David Maus
1441 Even if you use Git to track your agenda files you might not need
1442 vc-mode to be enabled for these files.
1444 #+begin_src emacs-lisp
1445 (add-hook 'find-file-hook 'dmj/disable-vc-for-agenda-files-hook)
1446 (defun dmj/disable-vc-for-agenda-files-hook ()
1447 "Disable vc-mode for Org agenda files."
1448 (if (and (fboundp 'org-agenda-file-p)
1449 (org-agenda-file-p (buffer-file-name)))
1450 (remove-hook 'find-file-hook 'vc-find-file-hook)
1451 (add-hook 'find-file-hook 'vc-find-file-hook)))
1452 #+end_src
1454 *** Easy customization of TODO colors
1455 -- Ryan C. Thompson
1457 Here is some code I came up with some code to make it easier to
1458 customize the colors of various TODO keywords. As long as you just
1459 want a different color and nothing else, you can customize the
1460 variable org-todo-keyword-faces and use just a string color (i.e. a
1461 string of the color name) as the face, and then org-get-todo-face
1462 will convert the color to a face, inheriting everything else from
1463 the standard org-todo face.
1465 To demonstrate, I currently have org-todo-keyword-faces set to
1467 #+BEGIN_SRC emacs-lisp
1468 (("IN PROGRESS" . "dark orange")
1469 ("WAITING" . "red4")
1470 ("CANCELED" . "saddle brown"))
1471 #+END_SRC
1473 Here's the code, in a form you can put in your =.emacs=
1475 #+BEGIN_SRC emacs-lisp
1476 (eval-after-load 'org-faces
1477 '(progn
1478 (defcustom org-todo-keyword-faces nil
1479 "Faces for specific TODO keywords.
1480 This is a list of cons cells, with TODO keywords in the car and
1481 faces in the cdr. The face can be a symbol, a color, or a
1482 property list of attributes, like (:foreground \"blue\" :weight
1483 bold :underline t)."
1484 :group 'org-faces
1485 :group 'org-todo
1486 :type '(repeat
1487 (cons
1488 (string :tag "Keyword")
1489 (choice color (sexp :tag "Face")))))))
1491 (eval-after-load 'org
1492 '(progn
1493 (defun org-get-todo-face-from-color (color)
1494 "Returns a specification for a face that inherits from org-todo
1495 face and has the given color as foreground. Returns nil if
1496 color is nil."
1497 (when color
1498 `(:inherit org-warning :foreground ,color)))
1500 (defun org-get-todo-face (kwd)
1501 "Get the right face for a TODO keyword KWD.
1502 If KWD is a number, get the corresponding match group."
1503 (if (numberp kwd) (setq kwd (match-string kwd)))
1504 (or (let ((face (cdr (assoc kwd org-todo-keyword-faces))))
1505 (if (stringp face)
1506 (org-get-todo-face-from-color face)
1507 face))
1508 (and (member kwd org-done-keywords) 'org-done)
1509 'org-todo))))
1510 #+END_SRC
1512 *** Add an effort estimate on the fly when clocking in
1514 You can use =org-clock-in-prepare-hook= to add an effort estimate.
1515 This way you can easily have a "tea-timer" for your tasks when they
1516 don't already have an effort estimate.
1518 #+begin_src emacs-lisp
1519 (add-hook 'org-clock-in-prepare-hook
1520 'my-org-mode-ask-effort)
1522 (defun my-org-mode-ask-effort ()
1523 "Ask for an effort estimate when clocking in."
1524 (unless (org-entry-get (point) "Effort")
1525 (let ((effort
1526 (completing-read
1527 "Effort: "
1528 (org-entry-get-multivalued-property (point) "Effort"))))
1529 (unless (equal effort "")
1530 (org-set-property "Effort" effort)))))
1531 #+end_src
1533 Or you can use a default effort for such a timer:
1535 #+begin_src emacs-lisp
1536 (add-hook 'org-clock-in-prepare-hook
1537 'my-org-mode-add-default-effort)
1539 (defvar org-clock-default-effort "1:00")
1541 (defun my-org-mode-add-default-effort ()
1542 "Add a default effort estimation."
1543 (unless (org-entry-get (point) "Effort")
1544 (org-set-property "Effort" org-clock-default-effort)))
1545 #+end_src
1547 *** Refresh the agenda view regurally
1549 Hack sent by Kiwon Um:
1551 #+begin_src emacs-lisp
1552 (defun kiwon/org-agenda-redo-in-other-window ()
1553 "Call org-agenda-redo function even in the non-agenda buffer."
1554 (interactive)
1555 (let ((agenda-window (get-buffer-window org-agenda-buffer-name t)))
1556 (when agenda-window
1557 (with-selected-window agenda-window (org-agenda-redo)))))
1558 (run-at-time nil 300 'kiwon/org-agenda-redo-in-other-window)
1559 #+end_src
1561 *** Reschedule agenda items to today with a single command
1563 This was suggested by Carsten in reply to David Abrahams:
1565 #+begin_example emacs-lisp
1566 (defun org-agenda-reschedule-to-today ()
1567 (interactive)
1568 (flet ((org-read-date (&rest rest) (current-time)))
1569 (call-interactively 'org-agenda-schedule)))
1570 #+end_example
1572 *** Mark subtree DONE along with all subheadings
1574 Bernt Hansen [[http://permalink.gmane.org/gmane.emacs.orgmode/44693][suggested]] this command:
1576 #+begin_src emacs-lisp
1577 (defun bh/mark-subtree-done ()
1578 (interactive)
1579 (org-mark-subtree)
1580 (let ((limit (point)))
1581 (save-excursion
1582 (exchange-point-and-mark)
1583 (while (> (point) limit)
1584 (org-todo "DONE")
1585 (outline-previous-visible-heading 1))
1586 (org-todo "DONE"))))
1587 #+end_src
1589 Then M-x bh/mark-subtree-done.
1591 ** Exporting org files
1592 *** Export Org to Org and handle includes.
1594 Nick Dokos came up with this useful function:
1596 #+begin_src emacs-lisp
1597 (defun org-to-org-handle-includes ()
1598 "Copy the contents of the current buffer to OUTFILE,
1599 recursively processing #+INCLUDEs."
1600 (let* ((s (buffer-string))
1601 (fname (buffer-file-name))
1602 (ofname (format "%s.I.org" (file-name-sans-extension fname))))
1603 (setq result
1604 (with-temp-buffer
1605 (insert s)
1606 (org-export-handle-include-files-recurse)
1607 (buffer-string)))
1608 (find-file ofname)
1609 (delete-region (point-min) (point-max))
1610 (insert result)
1611 (save-buffer)))
1612 #+end_src
1614 *** Specifying LaTeX commands to floating environments
1615 :PROPERTIES:
1616 :CUSTOM_ID: latex-command-for-floats
1617 :END:
1619 The keyword ~placement~ can be used to specify placement options to
1620 floating environments (like =\begin{figure}= and =\begin{table}=}) in
1621 LaTeX export. Org passes along everything passed in options as long as
1622 there are no spaces. One can take advantage of this to pass other
1623 LaTeX commands and have their scope limited to the floating
1624 environment.
1626 For example one can set the fontsize of a table different from the
1627 default normal size by putting something like =\footnotesize= right
1628 after the placement options. During LaTeX export using the
1629 ~#+ATTR_LaTeX:~ line below:
1631 #+begin_src org
1632 ,#+ATTR_LaTeX: placement=[<options>]\footnotesize
1633 #+end_src
1635 exports the associated floating environment as shown in the following
1636 block.
1638 #+begin_src latex
1639 \begin{table}[<options>]\footnotesize
1640 ...
1641 \end{table}
1642 #+end_src
1644 It should be noted that this hack does not work for beamer export of
1645 tables since the =table= environment is not used. As an ugly
1646 workaround, one can use the following:
1648 #+begin_src org
1649 ,#+LATEX: {\footnotesize
1650 ,#+ATTR_LaTeX: align=rr
1651 ,| some | table |
1652 ,|------+-------|
1653 ,| .. | .. |
1654 ,#+LATEX: }
1655 #+end_src
1657 *** Styling code sections with CSS
1659 Code sections (marked with =#+begin_src= and =#+end_src=) are exported
1660 to HTML using =<pre>= tags, and assigned CSS classes by their content
1661 type. For example, Perl content will have an opening tag like
1662 =<pre class="src src-perl">=. You can use those classes to add styling
1663 to the output, such as here where a small language tag is added at the
1664 top of each kind of code box:
1666 #+begin_src lisp
1667 (setq org-export-html-style
1668 "<style type=\"text/css\">
1669 <!--/*--><![CDATA[/*><!--*/
1670 .src { background-color: #F5FFF5; position: relative; overflow: visible; }
1671 .src:before { position: absolute; top: -15px; background: #ffffff; padding: 1px; border: 1px solid #000000; font-size: small; }
1672 .src-sh:before { content: 'sh'; }
1673 .src-bash:before { content: 'sh'; }
1674 .src-R:before { content: 'R'; }
1675 .src-perl:before { content: 'Perl'; }
1676 .src-sql:before { content: 'SQL'; }
1677 .example { background-color: #FFF5F5; }
1678 /*]]>*/-->
1679 </style>")
1680 #+end_src
1682 Additionally, we use color to distinguish code output (the =.example=
1683 class) from input (all the =.src-*= classes).
1685 * Hacking Org: Working with Org-mode and other Emacs Packages.
1686 ** org-remember-anything
1688 [[http://www.emacswiki.org/cgi-bin/wiki/Anything][Anything]] users may find the snippet below interesting:
1690 #+BEGIN_SRC emacs-lisp
1691 (defvar org-remember-anything
1692 '((name . "Org Remember")
1693 (candidates . (lambda () (mapcar 'car org-remember-templates)))
1694 (action . (lambda (name)
1695 (let* ((orig-template org-remember-templates)
1696 (org-remember-templates
1697 (list (assoc name orig-template))))
1698 (call-interactively 'org-remember))))))
1699 #+END_SRC
1701 You can add it to your 'anything-sources' variable and open remember directly
1702 from anything. I imagine this would be more interesting for people with many
1703 remember templates, so that you are out of keys to assign those to.
1705 ** Org-mode and saveplace.el
1707 Fix a problem with saveplace.el putting you back in a folded position:
1709 #+begin_src emacs-lisp
1710 (add-hook 'org-mode-hook
1711 (lambda ()
1712 (when (outline-invisible-p)
1713 (save-excursion
1714 (outline-previous-visible-heading 1)
1715 (org-show-subtree)))))
1716 #+end_src
1718 ** Using ido-completing-read to find attachments
1719 -- Matt Lundin.
1721 Org-attach is great for quickly linking files to a project. But if you
1722 use org-attach extensively you might find yourself wanting to browse
1723 all the files you've attached to org headlines. This is not easy to do
1724 manually, since the directories containing the files are not human
1725 readable (i.e., they are based on automatically generated ids). Here's
1726 some code to browse those files using ido (obviously, you need to be
1727 using ido):
1729 #+begin_src emacs-lisp
1730 (load-library "find-lisp")
1732 ;; Adapted from http://www.emacswiki.org/emacs/RecentFiles
1734 (defun my-ido-find-org-attach ()
1735 "Find files in org-attachment directory"
1736 (interactive)
1737 (let* ((enable-recursive-minibuffers t)
1738 (files (find-lisp-find-files org-attach-directory "."))
1739 (file-assoc-list
1740 (mapcar (lambda (x)
1741 (cons (file-name-nondirectory x)
1742 x))
1743 files))
1744 (filename-list
1745 (remove-duplicates (mapcar #'car file-assoc-list)
1746 :test #'string=))
1747 (filename (ido-completing-read "Org attachments: " filename-list nil t))
1748 (longname (cdr (assoc filename file-assoc-list))))
1749 (ido-set-current-directory
1750 (if (file-directory-p longname)
1751 longname
1752 (file-name-directory longname)))
1753 (setq ido-exit 'refresh
1754 ido-text-init ido-text
1755 ido-rotate-temp t)
1756 (exit-minibuffer)))
1758 (add-hook 'ido-setup-hook 'ido-my-keys)
1760 (defun ido-my-keys ()
1761 "Add my keybindings for ido."
1762 (define-key ido-completion-map (kbd "C-;") 'my-ido-find-org-attach))
1763 #+end_src
1765 To browse your org attachments using ido fuzzy matching and/or the
1766 completion buffer, invoke ido-find-file as usual (=C-x C-f=) and then
1767 press =C-;=.
1769 ** Use idle timer for automatic agenda views
1771 From John Wiegley's mailing list post (March 18, 2010):
1773 #+begin_quote
1774 I have the following snippet in my .emacs file, which I find very
1775 useful. Basically what it does is that if I don't touch my Emacs for 5
1776 minutes, it displays the current agenda. This keeps my tasks "always
1777 in mind" whenever I come back to Emacs after doing something else,
1778 whereas before I had a tendency to forget that it was there.
1779 #+end_quote
1781 - [[http://mid.gmane.org/55590EA7-C744-44E5-909F-755F0BBE452D@gmail.com][John Wiegley: Displaying your Org agenda after idle time]]
1783 #+begin_src emacs-lisp
1784 (defun jump-to-org-agenda ()
1785 (interactive)
1786 (let ((buf (get-buffer "*Org Agenda*"))
1787 wind)
1788 (if buf
1789 (if (setq wind (get-buffer-window buf))
1790 (select-window wind)
1791 (if (called-interactively-p)
1792 (progn
1793 (select-window (display-buffer buf t t))
1794 (org-fit-window-to-buffer)
1795 ;; (org-agenda-redo)
1796 )
1797 (with-selected-window (display-buffer buf)
1798 (org-fit-window-to-buffer)
1799 ;; (org-agenda-redo)
1800 )))
1801 (call-interactively 'org-agenda-list)))
1802 ;;(let ((buf (get-buffer "*Calendar*")))
1803 ;; (unless (get-buffer-window buf)
1804 ;; (org-agenda-goto-calendar)))
1805 )
1807 (run-with-idle-timer 300 t 'jump-to-org-agenda)
1808 #+end_src
1810 #+results:
1811 : [nil 0 300 0 t jump-to-org-agenda nil idle]
1813 ** Link to Gnus messages by Message-Id
1815 In a [[http://thread.gmane.org/gmane.emacs.orgmode/8860][recent thread]] on the Org-Mode mailing list, there was some
1816 discussion about linking to Gnus messages without encoding the folder
1817 name in the link. The following code hooks in to the store-link
1818 function in Gnus to capture links by Message-Id when in nnml folders,
1819 and then provides a link type "mid" which can open this link. The
1820 =mde-org-gnus-open-message-link= function uses the
1821 =mde-mid-resolve-methods= variable to determine what Gnus backends to
1822 scan. It will go through them, in order, asking each to locate the
1823 message and opening it from the first one that reports success.
1825 It has only been tested with a single nnml backend, so there may be
1826 bugs lurking here and there.
1828 The logic for finding the message was adapted from [[http://www.emacswiki.org/cgi-bin/wiki/FindMailByMessageId][an Emacs Wiki
1829 article]].
1831 #+begin_src emacs-lisp
1832 ;; Support for saving Gnus messages by Message-ID
1833 (defun mde-org-gnus-save-by-mid ()
1834 (when (memq major-mode '(gnus-summary-mode gnus-article-mode))
1835 (when (eq major-mode 'gnus-article-mode)
1836 (gnus-article-show-summary))
1837 (let* ((group gnus-newsgroup-name)
1838 (method (gnus-find-method-for-group group)))
1839 (when (eq 'nnml (car method))
1840 (let* ((article (gnus-summary-article-number))
1841 (header (gnus-summary-article-header article))
1842 (from (mail-header-from header))
1843 (message-id
1844 (save-match-data
1845 (let ((mid (mail-header-id header)))
1846 (if (string-match "<\\(.*\\)>" mid)
1847 (match-string 1 mid)
1848 (error "Malformed message ID header %s" mid)))))
1849 (date (mail-header-date header))
1850 (subject (gnus-summary-subject-string)))
1851 (org-store-link-props :type "mid" :from from :subject subject
1852 :message-id message-id :group group
1853 :link (org-make-link "mid:" message-id))
1854 (apply 'org-store-link-props
1855 :description (org-email-link-description)
1856 org-store-link-plist)
1857 t)))))
1859 (defvar mde-mid-resolve-methods '()
1860 "List of methods to try when resolving message ID's. For Gnus,
1861 it is a cons of 'gnus and the select (type and name).")
1862 (setq mde-mid-resolve-methods
1863 '((gnus nnml "")))
1865 (defvar mde-org-gnus-open-level 1
1866 "Level at which Gnus is started when opening a link")
1867 (defun mde-org-gnus-open-message-link (msgid)
1868 "Open a message link with Gnus"
1869 (require 'gnus)
1870 (require 'org-table)
1871 (catch 'method-found
1872 (message "[MID linker] Resolving %s" msgid)
1873 (dolist (method mde-mid-resolve-methods)
1874 (cond
1875 ((and (eq (car method) 'gnus)
1876 (eq (cadr method) 'nnml))
1877 (funcall (cdr (assq 'gnus org-link-frame-setup))
1878 mde-org-gnus-open-level)
1879 (when gnus-other-frame-object
1880 (select-frame gnus-other-frame-object))
1881 (let* ((msg-info (nnml-find-group-number
1882 (concat "<" msgid ">")
1883 (cdr method)))
1884 (group (and msg-info (car msg-info)))
1885 (message (and msg-info (cdr msg-info)))
1886 (qname (and group
1887 (if (gnus-methods-equal-p
1888 (cdr method)
1889 gnus-select-method)
1890 group
1891 (gnus-group-full-name group (cdr method))))))
1892 (when msg-info
1893 (gnus-summary-read-group qname nil t)
1894 (gnus-summary-goto-article message nil t))
1895 (throw 'method-found t)))
1896 (t (error "Unknown link type"))))))
1898 (eval-after-load 'org-gnus
1899 '(progn
1900 (add-to-list 'org-store-link-functions 'mde-org-gnus-save-by-mid)
1901 (org-add-link-type "mid" 'mde-org-gnus-open-message-link)))
1902 #+end_src
1904 ** Store link upon sending a message in Gnus
1906 Ulf Stegemann came up with this solution (see his [[http://www.mail-archive.com/emacs-orgmode@gnu.org/msg33278.html][original message]]):
1908 #+begin_src emacs-lisp
1909 (defun ulf-message-send-and-org-gnus-store-link (&optional arg)
1910 "Send message with `message-send-and-exit' and store org link to message copy.
1911 If multiple groups appear in the Gcc header, the link refers to
1912 the copy in the last group."
1913 (interactive "P")
1914 (save-excursion
1915 (save-restriction
1916 (message-narrow-to-headers)
1917 (let ((gcc (car (last
1918 (message-unquote-tokens
1919 (message-tokenize-header
1920 (mail-fetch-field "gcc" nil t) " ,")))))
1921 (buf (current-buffer))
1922 (message-kill-buffer-on-exit nil)
1923 id to from subject desc link newsgroup xarchive)
1924 (message-send-and-exit arg)
1925 (or
1926 ;; gcc group found ...
1927 (and gcc
1928 (save-current-buffer
1929 (progn (set-buffer buf)
1930 (setq id (org-remove-angle-brackets
1931 (mail-fetch-field "Message-ID")))
1932 (setq to (mail-fetch-field "To"))
1933 (setq from (mail-fetch-field "From"))
1934 (setq subject (mail-fetch-field "Subject"))))
1935 (org-store-link-props :type "gnus" :from from :subject subject
1936 :message-id id :group gcc :to to)
1937 (setq desc (org-email-link-description))
1938 (setq link (org-gnus-article-link
1939 gcc newsgroup id xarchive))
1940 (setq org-stored-links
1941 (cons (list link desc) org-stored-links)))
1942 ;; no gcc group found ...
1943 (message "Can not create Org link: No Gcc header found."))))))
1945 (define-key message-mode-map [(control c) (control meta c)]
1946 'ulf-message-send-and-org-gnus-store-link)
1947 #+end_src
1949 ** Send html messages and attachments with Wanderlust
1950 -- David Maus
1952 /Note/: The module [[file:org-contrib/org-mime.org][Org-mime]] in Org's contrib directory provides
1953 similar functionality for both Wanderlust and Gnus. The hack below is
1954 still somewhat different: It allows you to toggle sending of html
1955 messages within Wanderlust transparently. I.e. html markup of the
1956 message body is created right before sending starts.
1958 *** Send HTML message
1960 Putting the code below in your .emacs adds following four functions:
1962 - dmj/wl-send-html-message
1964 Function that does the job: Convert everything between "--text
1965 follows this line--" and first mime entity (read: attachment) or
1966 end of buffer into html markup using `org-export-region-as-html'
1967 and replaces original body with a multipart MIME entity with the
1968 plain text version of body and the html markup version. Thus a
1969 recipient that prefers html messages can see the html markup,
1970 recipients that prefer or depend on plain text can see the plain
1971 text.
1973 Cannot be called interactively: It is hooked into SEMI's
1974 `mime-edit-translate-hook' if message should be HTML message.
1976 - dmj/wl-send-html-message-draft-init
1978 Cannot be called interactively: It is hooked into WL's
1979 `wl-mail-setup-hook' and provides a buffer local variable to
1980 toggle.
1982 - dmj/wl-send-html-message-draft-maybe
1984 Cannot be called interactively: It is hooked into WL's
1985 `wl-draft-send-hook' and hooks `dmj/wl-send-html-message' into
1986 `mime-edit-translate-hook' depending on whether HTML message is
1987 toggled on or off
1989 - dmj/wl-send-html-message-toggle
1991 Toggles sending of HTML message. If toggled on, the letters
1992 "HTML" appear in the mode line.
1994 Call it interactively! Or bind it to a key in `wl-draft-mode'.
1996 If you have to send HTML messages regularly you can set a global
1997 variable `dmj/wl-send-html-message-toggled-p' to the string "HTML" to
1998 toggle on sending HTML message by default.
2000 The image [[http://s11.directupload.net/file/u/15851/48ru5wl3.png][here]] shows an example of how the HTML message looks like in
2001 Google's web front end. As you can see you have the whole markup of
2002 Org at your service: *bold*, /italics/, tables, lists...
2004 So even if you feel uncomfortable with sending HTML messages at least
2005 you send HTML that looks quite good.
2007 #+begin_src emacs-lisp
2008 (defun dmj/wl-send-html-message ()
2009 "Send message as html message.
2010 Convert body of message to html using
2011 `org-export-region-as-html'."
2012 (require 'org)
2013 (save-excursion
2014 (let (beg end html text)
2015 (goto-char (point-min))
2016 (re-search-forward "^--text follows this line--$")
2017 ;; move to beginning of next line
2018 (beginning-of-line 2)
2019 (setq beg (point))
2020 (if (not (re-search-forward "^--\\[\\[" nil t))
2021 (setq end (point-max))
2022 ;; line up
2023 (end-of-line 0)
2024 (setq end (point)))
2025 ;; grab body
2026 (setq text (buffer-substring-no-properties beg end))
2027 ;; convert to html
2028 (with-temp-buffer
2029 (org-mode)
2030 (insert text)
2031 ;; handle signature
2032 (when (re-search-backward "^-- \n" nil t)
2033 ;; preserve link breaks in signature
2034 (insert "\n#+BEGIN_VERSE\n")
2035 (goto-char (point-max))
2036 (insert "\n#+END_VERSE\n")
2037 ;; grab html
2038 (setq html (org-export-region-as-html
2039 (point-min) (point-max) t 'string))))
2040 (delete-region beg end)
2041 (insert
2042 (concat
2043 "--" "<<alternative>>-{\n"
2044 "--" "[[text/plain]]\n" text
2045 "--" "[[text/html]]\n" html
2046 "--" "}-<<alternative>>\n")))))
2048 (defun dmj/wl-send-html-message-toggle ()
2049 "Toggle sending of html message."
2050 (interactive)
2051 (setq dmj/wl-send-html-message-toggled-p
2052 (if dmj/wl-send-html-message-toggled-p
2053 nil "HTML"))
2054 (message "Sending html message toggled %s"
2055 (if dmj/wl-send-html-message-toggled-p
2056 "on" "off")))
2058 (defun dmj/wl-send-html-message-draft-init ()
2059 "Create buffer local settings for maybe sending html message."
2060 (unless (boundp 'dmj/wl-send-html-message-toggled-p)
2061 (setq dmj/wl-send-html-message-toggled-p nil))
2062 (make-variable-buffer-local 'dmj/wl-send-html-message-toggled-p)
2063 (add-to-list 'global-mode-string
2064 '(:eval (if (eq major-mode 'wl-draft-mode)
2065 dmj/wl-send-html-message-toggled-p))))
2067 (defun dmj/wl-send-html-message-maybe ()
2068 "Maybe send this message as html message.
2070 If buffer local variable `dmj/wl-send-html-message-toggled-p' is
2071 non-nil, add `dmj/wl-send-html-message' to
2072 `mime-edit-translate-hook'."
2073 (if dmj/wl-send-html-message-toggled-p
2074 (add-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)
2075 (remove-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)))
2077 (add-hook 'wl-draft-reedit-hook 'dmj/wl-send-html-message-draft-init)
2078 (add-hook 'wl-mail-setup-hook 'dmj/wl-send-html-message-draft-init)
2079 (add-hook 'wl-draft-send-hook 'dmj/wl-send-html-message-maybe)
2080 #+end_src
2082 *** Attach HTML of region or subtree
2084 Instead of sending a complete HTML message you might only send parts
2085 of an Org file as HTML for the poor souls who are plagued with
2086 non-proportional fonts in their mail program that messes up pretty
2087 ASCII tables.
2089 This short function does the trick: It exports region or subtree to
2090 HTML, prefixes it with a MIME entity delimiter and pushes to killring
2091 and clipboard. If a region is active, it uses the region, the
2092 complete subtree otherwise.
2094 #+begin_src emacs-lisp
2095 (defun dmj/org-export-region-as-html-attachment (beg end arg)
2096 "Export region between BEG and END as html attachment.
2097 If BEG and END are not set, use current subtree. Region or
2098 subtree is exported to html without header and footer, prefixed
2099 with a mime entity string and pushed to clipboard and killring.
2100 When called with prefix, mime entity is not marked as
2101 attachment."
2102 (interactive "r\nP")
2103 (save-excursion
2104 (let* ((beg (if (region-active-p) (region-beginning)
2105 (progn
2106 (org-back-to-heading)
2107 (point))))
2108 (end (if (region-active-p) (region-end)
2109 (progn
2110 (org-end-of-subtree)
2111 (point))))
2112 (html (concat "--[[text/html"
2113 (if arg "" "\nContent-Disposition: attachment")
2114 "]]\n"
2115 (org-export-region-as-html beg end t 'string))))
2116 (when (fboundp 'x-set-selection)
2117 (ignore-errors (x-set-selection 'PRIMARY html))
2118 (ignore-errors (x-set-selection 'CLIPBOARD html)))
2119 (message "html export done, pushed to kill ring and clipboard"))))
2120 #+end_src
2122 *** Adopting for Gnus
2124 The whole magic lies in the special strings that mark a HTML
2125 attachment. So you might just have to find out what these special
2126 strings are in message-mode and modify the functions accordingly.
2127 ** Add sunrise/sunset times to the agenda.
2128 -- Nick Dokos
2130 The diary package provides the function =diary-sunrise-sunset= which can be used
2131 in a diary s-expression in some agenda file like this:
2133 #+begin_src org-mode
2134 %%(diary-sunrise-sunset)
2135 #+end_src
2137 Seb Vauban asked if it is possible to put sunrise and sunset in
2138 separate lines. Here is a hack to do that. It adds two functions (they
2139 have to be available before the agenda is shown, so I add them early
2140 in my org-config file which is sourced from .emacs, but you'll have to
2141 suit yourself here) that just parse the output of
2142 diary-sunrise-sunset, instead of doing the right thing which would be
2143 to take advantage of the data structures that diary/solar.el provides.
2144 In short, a hack - so perfectly suited for inclusion here :-)
2146 The functions (and latitude/longitude settings which you have to modify for
2147 your location) are as follows:
2149 #+begin_src emacs-lisp
2150 (setq calendar-latitude 40.3)
2151 (setq calendar-longitude -71.0)
2152 (defun diary-sunrise ()
2153 (let ((dss (diary-sunrise-sunset)))
2154 (with-temp-buffer
2155 (insert dss)
2156 (goto-char (point-min))
2157 (while (re-search-forward " ([^)]*)" nil t)
2158 (replace-match "" nil nil))
2159 (goto-char (point-min))
2160 (search-forward ",")
2161 (buffer-substring (point-min) (match-beginning 0)))))
2163 (defun diary-sunset ()
2164 (let ((dss (diary-sunrise-sunset))
2165 start end)
2166 (with-temp-buffer
2167 (insert dss)
2168 (goto-char (point-min))
2169 (while (re-search-forward " ([^)]*)" nil t)
2170 (replace-match "" nil nil))
2171 (goto-char (point-min))
2172 (search-forward ", ")
2173 (setq start (match-end 0))
2174 (search-forward " at")
2175 (setq end (match-beginning 0))
2176 (goto-char start)
2177 (capitalize-word 1)
2178 (buffer-substring start end))))
2179 #+end_src
2181 You also need to add a couple of diary s-expressions in one of your agenda
2182 files:
2184 #+begin_src org-mode
2185 %%(diary-sunrise)
2186 %%(diary-sunset)
2187 #+end_src
2189 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]].
2190 In comparison to the version posted on the mailing list, this one
2191 gets rid of the timezone information.
2192 ** Export BBDB contacts to org-contacts.el
2194 Try this tool by Wes Hardaker:
2196 http://www.hardakers.net/code/bbdb-to-org-contacts/
2198 ** Calculating date differences - how to write a simple elisp function
2200 Alexander Wingård asked how to calculate the number of days between a
2201 time stamp in his org file and today (see
2202 http://thread.gmane.org/gmane.emacs.orgmode/46881). Although the
2203 resulting answer is probably not of general interest, the method might
2204 be useful to a budding Elisp programmer.
2206 Alexander started from an already existing org function,
2207 =org-evaluate-time-range=. When this function is called in the context
2208 of a time range (two time stamps separated by "=--="), it calculates the
2209 number of days between the two dates and outputs the result in Emacs's
2210 echo area. What he wanted was a similar function that, when called from
2211 the context of a single time stamp, would calculate the number of days
2212 between the date in the time stamp and today. The result should go to
2213 the same place: Emacs's echo area.
2215 The solution presented in the mail thread is as follows:
2217 #+begin_src emacs-lisp
2218 (defun aw/org-evaluate-time-range (&optional to-buffer)
2219 (interactive)
2220 (if (org-at-date-range-p t)
2221 (org-evaluate-time-range to-buffer)
2222 ;; otherwise, make a time range in a temp buffer and run o-e-t-r there
2223 (let ((headline (buffer-substring (point-at-bol) (point-at-eol))))
2224 (with-temp-buffer
2225 (insert headline)
2226 (goto-char (point-at-bol))
2227 (re-search-forward org-ts-regexp (point-at-eol) t)
2228 (if (not (org-at-timestamp-p t))
2229 (error "No timestamp here"))
2230 (goto-char (match-beginning 0))
2231 (org-insert-time-stamp (current-time) nil nil)
2232 (insert "--")
2233 (org-evaluate-time-range to-buffer)))))
2234 #+end_src
2236 The function assumes that point is on some line with some time stamp
2237 (or a date range) in it. Note that =org-evaluate-time-range= does not care
2238 whether the first date is earlier than the second: it will always output
2239 the number of days between the earlier date and the later date.
2241 As stated before, the function itself is of limited interest (although
2242 it satisfied Alexander's need).The *method* used might be of wider
2243 interest however, so here is a short explanation.
2245 The idea is that we want =org-evaluate-time-range= to do all the
2246 heavy lifting, but that function requires that it be in a date-range
2247 context. So the function first checks whether it's in a date range
2248 context already: if so, it calls =org-evaluate-time-range= directly
2249 to do the work. The trick now is to arrange things so we can call this
2250 same function in the case where we do *not* have a date range
2251 context. In that case, we manufacture one: we create a temporary
2252 buffer, copy the line with the purported time stamp to the temp
2253 buffer, find the time stamp (signal an error if no time stamp is
2254 found) and insert a new time stamp with the current time before the
2255 existing time stamp, followed by "=--=": voilà, we now have a time range
2256 on which we can apply our old friend =org-evaluate-time-range= to
2257 produce the answer. Because of the above-mentioned property
2258 of =org-evaluate-time-range=, it does not matter if the existing
2259 time stamp is earlier or later than the current time: the correct
2260 number of days is output.
2262 Note that at the end of the call to =with-temp-buffer=, the temporary
2263 buffer goes away. It was just used as a scratch pad for the function
2264 to do some figuring.
2266 The idea of using a temp buffer as a scratch pad has wide
2267 applicability in Emacs programming. The rest of the work is knowing
2268 enough about facilities provided by Emacs (e.g. regexp searching) and
2269 by Org (e.g. checking for time stamps and generating a time stamp) so
2270 that you don't reinvent the wheel, and impedance-matching between the
2271 various pieces.
2273 * Hacking Org: Working with Org-mode and External Programs.
2274 ** Use Org-mode with Screen [Andrew Hyatt]
2276 "The general idea is that you start a task in which all the work will
2277 take place in a shell. This usually is not a leaf-task for me, but
2278 usually the parent of a leaf task. From a task in your org-file, M-x
2279 ash-org-screen will prompt for the name of a session. Give it a name,
2280 and it will insert a link. Open the link at any time to go the screen
2281 session containing your work!"
2283 http://article.gmane.org/gmane.emacs.orgmode/5276
2285 #+BEGIN_SRC emacs-lisp
2286 (require 'term)
2288 (defun ash-org-goto-screen (name)
2289 "Open the screen with the specified name in the window"
2290 (interactive "MScreen name: ")
2291 (let ((screen-buffer-name (ash-org-screen-buffer-name name)))
2292 (if (member screen-buffer-name
2293 (mapcar 'buffer-name (buffer-list)))
2294 (switch-to-buffer screen-buffer-name)
2295 (switch-to-buffer (ash-org-screen-helper name "-dr")))))
2297 (defun ash-org-screen-buffer-name (name)
2298 "Returns the buffer name corresponding to the screen name given."
2299 (concat "*screen " name "*"))
2301 (defun ash-org-screen-helper (name arg)
2302 ;; Pick the name of the new buffer.
2303 (let ((term-ansi-buffer-name
2304 (generate-new-buffer-name
2305 (ash-org-screen-buffer-name name))))
2306 (setq term-ansi-buffer-name
2307 (term-ansi-make-term
2308 term-ansi-buffer-name "/usr/bin/screen" nil arg name))
2309 (set-buffer term-ansi-buffer-name)
2310 (term-mode)
2311 (term-char-mode)
2312 (term-set-escape-char ?\C-x)
2313 term-ansi-buffer-name))
2315 (defun ash-org-screen (name)
2316 "Start a screen session with name"
2317 (interactive "MScreen name: ")
2318 (save-excursion
2319 (ash-org-screen-helper name "-S"))
2320 (insert-string (concat "[[screen:" name "]]")))
2322 ;; And don't forget to add ("screen" . "elisp:(ash-org-goto-screen
2323 ;; \"%s\")") to org-link-abbrev-alist.
2324 #+END_SRC
2326 ** Org Agenda + Appt + Zenity
2327 #+BEGIN_HTML
2328 <a name="agenda-appt-zenity"></a>
2329 #+END_HTML
2330 Russell Adams posted this setup [[http://article.gmane.org/gmane.emacs.orgmode/5806][on the list]]. It makes sure your agenda
2331 appointments are known by Emacs, and it displays warnings in a [[http://live.gnome.org/Zenity][zenity]]
2332 popup window.
2334 #+BEGIN_SRC emacs-lisp
2335 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2336 ; For org appointment reminders
2338 ;; Get appointments for today
2339 (defun my-org-agenda-to-appt ()
2340 (interactive)
2341 (setq appt-time-msg-list nil)
2342 (let ((org-deadline-warning-days 0)) ;; will be automatic in org 5.23
2343 (org-agenda-to-appt)))
2345 ;; Run once, activate and schedule refresh
2346 (my-org-agenda-to-appt)
2347 (appt-activate t)
2348 (run-at-time "24:01" nil 'my-org-agenda-to-appt)
2350 ; 5 minute warnings
2351 (setq appt-message-warning-time 15)
2352 (setq appt-display-interval 5)
2354 ; Update appt each time agenda opened.
2355 (add-hook 'org-finalize-agenda-hook 'my-org-agenda-to-appt)
2357 ; Setup zenify, we tell appt to use window, and replace default function
2358 (setq appt-display-format 'window)
2359 (setq appt-disp-window-function (function my-appt-disp-window))
2361 (defun my-appt-disp-window (min-to-app new-time msg)
2362 (save-window-excursion (shell-command (concat
2363 "/usr/bin/zenity --info --title='Appointment' --text='"
2364 msg "' &") nil nil)))
2365 #+END_SRC
2367 ** Org-Mode + gnome-osd
2369 Richard Riley uses gnome-osd in interaction with Org-Mode to display
2370 appointments. You can look at the code on the [[http://www.emacswiki.org/emacs-en/OrgMode-OSD][emacswiki]].
2372 ** remind2org
2374 From Detlef Steuer
2376 http://article.gmane.org/gmane.emacs.orgmode/5073
2378 #+BEGIN_QUOTE
2379 Remind (http://www.roaringpenguin.com/products/remind) is a very powerful
2380 command line calendaring program. Its features superseed the possibilities
2381 of orgmode in the area of date specifying, so that I want to use it
2382 combined with orgmode.
2384 Using the script below I'm able use remind and incorporate its output in my
2385 agenda views. The default of using 13 months look ahead is easily
2386 changed. It just happens I sometimes like to look a year into the
2387 future. :-)
2388 #+END_QUOTE
2390 ** Useful webjumps for conkeror
2392 If you are using the [[http://conkeror.org][conkeror browser]], maybe you want to put this into
2393 your =~/.conkerorrc= file:
2395 #+begin_example
2396 define_webjump("orglist", "http://search.gmane.org/?query=%s&group=gmane.emacs.orgmode");
2397 define_webjump("worg", "http://www.google.com/cse?cx=002987994228320350715%3Az4glpcrritm&ie=UTF-8&q=%s&sa=Search&siteurl=orgmode.org%2Fworg%2F");
2398 #+end_example
2400 It creates two [[http://conkeror.org/Webjumps][webjumps]] for easily searching the Worg website and the
2401 Org-mode mailing list.
2403 ** Use MathJax for HTML export without requiring JavaScript
2404 As of 2010-08-14, MathJax is the default method used to export math to HTML.
2406 If you like the results but do not want JavaScript in the exported pages,
2407 check out [[http://www.jboecker.de/2010/08/15/staticmathjax.html][Static MathJax]], a XULRunner application which generates a static
2408 HTML file from the exported version. It can also embed all referenced fonts
2409 within the HTML file itself, so there are no dependencies to external files.
2411 The download archive contains an elisp file which integrates it into the Org
2412 export process (configurable per file with a "#+StaticMathJax:" line).
2414 Read README.org and the comments in org-static-mathjax.el for usage instructions.
2415 ** Search Org files using lgrep
2417 Matt Lundin suggests this:
2419 #+begin_src emacs-lisp
2420 (defun my-org-grep (search &optional context)
2421 "Search for word in org files.
2423 Prefix argument determines number of lines."
2424 (interactive "sSearch for: \nP")
2425 (let ((grep-find-ignored-files '("#*" ".#*"))
2426 (grep-template (concat "grep <X> -i -nH "
2427 (when context
2428 (concat "-C" (number-to-string context)))
2429 " -e <R> <F>")))
2430 (lgrep search "*org*" "/home/matt/org/")))
2432 (global-set-key (kbd "<f8>") 'my-org-grep)
2433 #+end_src
2435 ** Automatic screenshot insertion
2437 Suggested by Russell Adams
2439 #+begin_src emacs-lisp
2440 (defun my-org-screenshot ()
2441 "Take a screenshot into a time stamped unique-named file in the
2442 same directory as the org-buffer and insert a link to this file."
2443 (interactive)
2444 (setq filename
2445 (concat
2446 (make-temp-name
2447 (concat (buffer-file-name)
2448 "_"
2449 (format-time-string "%Y%m%d_%H%M%S_")) ) ".png"))
2450 (call-process "import" nil nil nil filename)
2451 (insert (concat "[[" filename "]]"))
2452 (org-display-inline-images))
2453 #+end_src
2455 ** Capture invitations/appointments from MS Exchange emails
2457 Dirk-Jan C.Binnema [[http://article.gmane.org/gmane.emacs.orgmode/27684/][provided]] code to do this. Please check
2458 [[file:code/elisp/org-exchange-capture.el][org-exchange-capture.el]]
2460 ** Audio/video file playback within org mode
2462 Paul Sexton provided code that makes =file:= links to audio or video files
2463 (MP3, WAV, OGG, AVI, MPG, et cetera) play those files using the [[https://github.com/dbrock/bongo][Bongo]] Emacs
2464 media player library. The user can pause, skip forward and backward in the
2465 track, and so on from without leaving Emacs. Links can also contain a time
2466 after a double colon -- when this is present, playback will begin at that
2467 position in the track.
2469 See the file [[file:code/elisp/org-player.el][org-player.el]]
2471 ** Under X11 Keep a window with the current agenda items at all time
2473 I struggle to keep (in emacs) a window with the agenda at all times.
2474 For a long time I have wanted a sticky window that keeps this
2475 information, and then use my window manager to place it and remove its
2476 decorations (I can also force its placement in the stack: top always,
2477 for example).
2479 I wrote a small program in qt that simply monitors an HTML file and
2480 displays it. Nothing more. It does the work for me, and maybe somebody
2481 else will find it useful. It relies on exporting the agenda as HTML
2482 every time the org file is saved, and then this little program
2483 displays the html file. The window manager is responsible of removing
2484 decorations, making it sticky, and placing it in same place always.
2486 Here is a screenshot (see window to the bottom right). The decorations
2487 are removed by the window manager:
2489 http://turingmachine.org/hacking/org-mode/orgdisplay.png
2491 Here is the code. As I said, very, very simple, but maybe somebody will
2492 find if useful.
2494 http://turingmachine.org/hacking/org-mode/
2496 --daniel german
2498 ** Script (thru procmail) to output emails to an Org file
2500 Tycho Garen sent [[http://comments.gmane.org/gmane.emacs.orgmode/44773][this]]:
2502 : I've [...] created some procmail and shell glue that takes emails and
2503 : inserts them into an org-file so that I can capture stuff on the go using
2504 : the email program.
2506 Everything is documented [[http://tychoish.com/code/org-mail/][here]].
2508 ** Meaningful diff for org files in a git repository
2510 Since most diff utilities are primarily meant for source code, it is
2511 difficult to read diffs of text files like ~.org~ files easily. If you
2512 version your org directory with a SCM like git you will know what I
2513 mean. However for git, there is a way around. You can use
2514 =gitattributes= to define a custom diff driver for org files. Then a
2515 regular expression can be used to configure how the diff driver
2516 recognises a "function".
2518 Put the following in your =<org_dir>/.gitattributes=.
2519 : *.org diff=org
2520 Then put the following lines in =<org_dir>/.git/config=
2521 : [diff "org"]
2522 : xfuncname = "^(\\*+ [a-zA-Z0-9]+.+)$"
2524 This will let you see diffs for org files with each hunk identified by
2525 the unmodified headline closest to the changes. After the
2526 configuration a diff should look something like the example below.
2528 #+begin_example
2529 diff --git a/org-hacks.org b/org-hacks.org
2530 index a0672ea..92a08f7 100644
2531 --- a/org-hacks.org
2532 +++ b/org-hacks.org
2533 @@ -2495,6 +2495,22 @@ ** Script (thru procmail) to output emails to an Org file
2535 Everything is documented [[http://tychoish.com/code/org-mail/][here]].
2537 +** Meaningful diff for org files in a git repository
2538 +
2539 +Since most diff utilities are primarily meant for source code, it is
2540 +difficult to read diffs of text files like ~.org~ files easily. If you
2541 +version your org directory with a SCM like git you will know what I
2542 +mean. However for git, there is a way around. You can use
2543 +=gitattributes= to define a custom diff driver for org files. Then a
2544 +regular expression can be used to configure how the diff driver
2545 +recognises a "function".
2546 +
2547 +Put the following in your =<org_dir>/.gitattributes=.
2548 +: *.org diff=org
2549 +Then put the following lines in =<org_dir>/.git/config=
2550 +: [diff "org"]
2551 +: xfuncname = "^(\\*+ [a-zA-Z0-9]+.+)$"
2552 +
2553 * Musings
2555 ** Cooking? Brewing?
2556 #+end_example
2558 * Musings
2560 ** Cooking? Brewing?
2562 See [[http://article.gmane.org/gmane.emacs.orgmode/44981][this message]] from Erik Hetzner:
2564 It currently does metric/english conversion, and a few other tricks.
2565 Basically I just use calc’s units code. I think scaling recipes, or
2566 turning percentages into weights would be pretty easy.
2568 https://gitorious.org/org-cook/org-cook
2570 There is also, for those interested:
2572 https://gitorious.org/org-brew/org-brew
2574 for brewing beer. This is again, mostly just calc functions, including
2575 hydrometer correction, abv calculation, priming sugar for a given CO_2
2576 volume, etc. More integration with org-mode should be possible: for
2577 instance it would be nice to be able to use a lookup table (of ingredients)
2578 to calculate target original gravity, IBUs, etc.