org-hacks.org

   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
  11
  12 # This file is the default header for new Org files in Worg.  Feel free
  13 # to tailor it to your needs.
  14
  15 [[file:index.org][{Back to Worg's index}]]
  16
  17 This page is for ad hoc bits of code. Feel free to add quick hacks and
  18 workaround. Go crazy.
  19
  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:
  26
  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.
  29
  30 To use this function, adjust the variables =my/org-lisp-directory= and
  31 =my/org-compile-sources= to suite your needs.
  32
  33 #+BEGIN_SRC emacs-lisp
  34 (defvar my/org-lisp-directory "~/.emacs.d/org/lisp"
  35   "Directory where your org-mode files live.")
  36
  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.")
  40
  41 ;; Customize:
  42 (setq my/org-lisp-directory "~/.emacs.d/org/lisp")
  43
  44 ;; Customize:
  45 (setq  my/org-compile-sources t)
  46
  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)) "/"))
  53
  54   (add-to-list 'load-path directory)
  55
  56   (let ((list-of-org-files (file-expand-wildcards (concat directory "*.el"))))
  57
  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)
  70
  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
  78
  79 As of Org version 6.23b (released Sunday Feb 22, 2009) there is a new
  80 function to reload org files.
  81
  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
  84
  85 : M-x org-reload
  86
  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
  89
  90 : C-u M-x org-reload
  91
  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
  95
  96 : M-x org-reload
  97
  98 *** Check for possibly problematic old link escapes
  99 :PROPERTIES:
 100 :CUSTOM_ID: check-old-link-escapes
 101 :END:
 102
 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.
 106
 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.
 110
 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.
 115
 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
 140
 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.
 145
 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)))
 160
 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)))
 173
 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
 180
 181 *** Promote all items in subtree
 182 - Matt Lundin
 183
 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:
 187
 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
 194
 195 *** Turn a heading into an Org link
 196     :PROPERTIES:
 197     :CUSTOM_ID: heading-to-link
 198     :END:
 199
 200 From David Maus:
 201
 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
 219
 220 *** Using M-up and M-down to transpose paragraphs
 221
 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.
 228
 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))
 239
 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
 247
 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.
 252
 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))))
 259
 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
 265
 266 *** Different org-cycle-level behavior
 267 -- Ryan Thompson
 268
 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.
 275
 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.
 282
 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.
 287
 288 #+BEGIN_SRC emacs-lisp
 289 (require 'cl)
 290
 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]*")))))
 297
 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))
 303
 304 (defvar org-previous-line-level-cached nil)
 305
 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)))))
 318
 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)))
 329
 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
 363
 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:
 367
 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'.
 380
 381 The text of footnote definitions is ignored, unless the optional argument
 382 COUNT-FOOTNOTES? is non-nil.
 383
 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
 456
 457 ** Org Table
 458 *** Transpose tables (Juan Pechiar)
 459
 460 This function by Juan Pechiar will transpose a table:
 461
 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
 477
 478 So a table like
 479
 480 : | 1 | 2 | 4 | 5 |
 481 : |---+---+---+---|
 482 : | a | b | c | d |
 483 : | e | f | g | h |
 484
 485 will be transposed as
 486
 487 : | 1 | a | e |
 488 : | 2 | b | f |
 489 : | 4 | c | g |
 490 : | 5 | d | h |
 491
 492 (Note that horizontal lines disappeared.)
 493
 494 *** Manipulate hours/minutes/seconds in table formulas
 495
 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.
 502
 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)))
 521
 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))))
 527
 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
 546
 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)))
 553
 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))
 562
 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:
 565
 566 : | Task 1 | Task 2 |   Total |
 567 : |--------+--------+---------|
 568 : |  35:00 |  35:00 | 1:10:00 |
 569 : #+TBLFM: @2$3=$1+$2;T
 570
 571 *** Dates computation
 572
 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.
 575
 576 Nick Dokos [[http://article.gmane.org/gmane.emacs.orgmode/15694][suggested]]:
 577
 578 Try the following:
 579
 580 | Start Date |   End Date | Duration |
 581 |------------+------------+----------|
 582 | 2004.08.07 | 2005.07.08 |      335 |
 583 :#+TBLFM: $3=(date(<$2>)-date(<$1>))
 584
 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]].
 588
 589 *** Hex computation
 590
 591 As with Times computation, the following code allows Computation with
 592 Hex values in Org-mode tables using the =with-hex= macro.
 593
 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))
 599
 600   (defun org-hex-to-hex (int)
 601     (format "0x%x" int))
 602
 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)))
 616
 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
 634
 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))
 642
 643 *** Field coordinates in formulas (=@#= and =$#=)
 644
 645 -- Michael Brand
 646
 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.
 650
 651 **** Copy a column from a remote table into a column
 652
 653 current column =$3= = remote column =$2=:
 654 : #+TBLFM: $3 = remote(FOO, @@#$2)
 655
 656 **** Copy a row from a remote table transposed into a column
 657
 658 current column =$1= = transposed remote row =@1=:
 659 : #+TBLFM: $1 = remote(FOO, @$#$@#)
 660
 661 **** Transpose a table
 662
 663 -- Michael Brand
 664
 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]].
 669
 670 To transpose this 4x7 table
 671
 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 |
 678
 679 start with a 7x4 table without any horizontal line (to have filled
 680 also the column header) and yet empty:
 681
 682 : |   |   |   |   |
 683 : |   |   |   |   |
 684 : |   |   |   |   |
 685 : |   |   |   |   |
 686 : |   |   |   |   |
 687 : |   |   |   |   |
 688 : |   |   |   |   |
 689
 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:
 692
 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, @$#$@#)
 701
 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 =@#=
 705
 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.
 709
 710 **** Dynamic variation of ranges
 711
 712 -- Michael Brand
 713
 714 In this example all columns next to =quote= are calculated from the column
 715 =quote= and show the average change of the time series =quote[year]=
 716 during the period of the preceding =1=, =2=, =3= or =4= years:
 717
 718 : | year | quote |   1 a |   2 a |   3 a |   4 a |
 719 : |------+-------+-------+-------+-------+-------|
 720 : | 2005 |    10 |       |       |       |       |
 721 : | 2006 |    12 | 0.200 |       |       |       |
 722 : | 2007 |    14 | 0.167 | 0.183 |       |       |
 723 : | 2008 |    16 | 0.143 | 0.155 | 0.170 |       |
 724 : | 2009 |    18 | 0.125 | 0.134 | 0.145 | 0.158 |
 725 : #+TBLFM: $3=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$4=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$5=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3::$6=if(@# >= $#, ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1, string("")); f3
 726
 727 The formula is the same for each column =$3= through =$6=.  This can easily
 728 be seen with the great formula editor invoked by C-c ' on the
 729 table. The important part of the formula without the field blanking is:
 730
 731 : ($2 / subscr(@-I$2..@+I$2, @# + 1 - $#)) ^ (1 / ($# - 2)) - 1
 732
 733 which is the Emacs Calc implementation of the equation
 734
 735 /AvgChange(i, a) = (quote[i] / quote[i - a]) ^ 1 / n - 1/
 736
 737 where /i/ is the current time and /a/ is the length of the preceding period.
 738
 739 ** Capture and Remember
 740 *** Customize the size of the frame for remember
 741 (Note: this hack is likely out of date due to the development of
 742 [[org-capture]].)
 743
 744 #FIXME: gmane link?
 745 On emacs-orgmode, Ryan C. Thompson suggested this:
 746
 747 #+begin_quote
 748 I am using org-remember set to open a new frame when used,
 749 and the default frame size is much too large. To fix this, I have
 750 designed some advice and a custom variable to implement custom
 751 parameters for the remember frame:
 752 #+end_quote
 753
 754 #+begin_src emacs-lisp
 755 (defcustom remember-frame-alist nil
 756   "Additional frame parameters for dedicated remember frame."
 757   :type 'alist
 758   :group 'remember)
 759
 760 (defadvice remember (around remember-frame-parameters activate)
 761   "Set some frame parameters for the remember frame."
 762   (let ((default-frame-alist (append remember-frame-alist
 763                                      default-frame-alist)))
 764     ad-do-it))
 765 #+end_src
 766
 767 Setting remember-frame-alist to =((width . 80) (height . 15)))= give a
 768 reasonable size for the frame.
 769 ** Handling Links
 770 *** [[#heading-to-link][Turn a heading into an org link]]
 771 *** Quickaccess to the link part of hyperlinks
 772 Christian Moe [[http://permalink.gmane.org/gmane.emacs.orgmode/43122][asked]], if there is a simpler way to copy the link part
 773 of an org hyperling other than to use `C-c C-l C-a C-k C-g',
 774 which is indeed kind of cumbersome.
 775
 776 The thread offered [[http://permalink.gmane.org/gmane.emacs.orgmode/43606][two ways]]:
 777
 778 Using a [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Keyboard-Macros.html][keyboard macro]]:
 779 #+begin_src emacs-lisp
 780 (fset 'getlink
 781       (lambda (&optional arg)
 782         "Keyboard macro."
 783         (interactive "p")
 784         (kmacro-exec-ring-item (quote ("\C-c\C-l\C-a\C-k\C-g" 0 "%d")) arg)))
 785 #+end_src
 786
 787 or a function:
 788 #+begin_src emacs-lisp
 789 (defun my-org-extract-link ()
 790   "Extract the link location at point and put it on the killring."
 791   (interactive)
 792   (when (org-in-regexp org-bracket-link-regexp 1)
 793     (kill-new (org-link-unescape (org-match-string-no-properties 1)))))
 794 #+end_src
 795
 796 They put the link destination on the killring and can be easily bound to a key.
 797
 798 ** Archiving Content in Org-Mode
 799 *** Preserve top level headings when archiving to a file
 800 - Matt Lundin
 801
 802 To preserve (somewhat) the integrity of your archive structure while
 803 archiving lower level items to a file, you can use the following
 804 defadvice:
 805
 806 #+begin_src emacs-lisp
 807 (defadvice org-archive-subtree (around my-org-archive-subtree activate)
 808   (let ((org-archive-location
 809          (if (save-excursion (org-back-to-heading)
 810                              (> (org-outline-level) 1))
 811              (concat (car (split-string org-archive-location "::"))
 812                      "::* "
 813                      (car (org-get-outline-path)))
 814            org-archive-location)))
 815     ad-do-it))
 816 #+end_src
 817
 818 Thus, if you have an outline structure such as...
 819
 820 #+begin_src org
 821 ,* Heading
 822 ,** Subheading
 823 ,*** Subsubheading
 824 #+end_src
 825
 826 ...archiving "Subsubheading" to a new file will set the location in
 827 the new file to the top level heading:
 828
 829 #+begin_src org
 830 ,* Heading
 831 ,** Subsubheading
 832 #+end_src
 833
 834 While this hack obviously destroys the outline hierarchy somewhat, it
 835 at least preserves the logic of level one groupings.
 836
 837 A slightly more complex version of this hack will not only keep the
 838 archive organized by top-level headings, but will also preserve the
 839 tags found on those headings:
 840
 841 #+begin_src emacs-lisp
 842   (defun my-org-inherited-no-file-tags ()
 843     (let ((tags (org-entry-get nil "ALLTAGS" 'selective))
 844           (ltags (org-entry-get nil "TAGS")))
 845       (mapc (lambda (tag)
 846               (setq tags
 847                     (replace-regexp-in-string (concat tag ":") "" tags)))
 848             (append org-file-tags (when ltags (split-string ltags ":" t))))
 849       (if (string= ":" tags) nil tags)))
 850
 851   (defadvice org-archive-subtree (around my-org-archive-subtree-low-level activate)
 852     (let ((tags (my-org-inherited-no-file-tags))
 853           (org-archive-location
 854            (if (save-excursion (org-back-to-heading)
 855                                (> (org-outline-level) 1))
 856                (concat (car (split-string org-archive-location "::"))
 857                        "::* "
 858                        (car (org-get-outline-path)))
 859              org-archive-location)))
 860       ad-do-it
 861       (with-current-buffer (find-file-noselect (org-extract-archive-file))
 862         (save-excursion
 863           (while (org-up-heading-safe))
 864           (org-set-tags-to tags)))))
 865 #+end_src
 866
 867 *** Archive in a date tree
 868
 869 Posted to Org-mode mailing list by Osamu Okano [2010-04-21 Wed].
 870
 871 (Make sure org-datetree.el is loaded for this to work.)
 872
 873 #+begin_src emacs-lisp
 874 ;; (setq org-archive-location "%s_archive::date-tree")
 875 (defadvice org-archive-subtree
 876   (around org-archive-subtree-to-data-tree activate)
 877   "org-archive-subtree to date-tree"
 878   (if
 879       (string= "date-tree"
 880                (org-extract-archive-heading
 881                 (org-get-local-archive-location)))
 882       (let* ((dct (decode-time (org-current-time)))
 883              (y (nth 5 dct))
 884              (m (nth 4 dct))
 885              (d (nth 3 dct))
 886              (this-buffer (current-buffer))
 887              (location (org-get-local-archive-location))
 888              (afile (org-extract-archive-file location))
 889              (org-archive-location
 890               (format "%s::*** %04d-%02d-%02d %s" afile y m d
 891                       (format-time-string "%A" (encode-time 0 0 0 d m y)))))
 892         (message "afile=%s" afile)
 893         (unless afile
 894           (error "Invalid `org-archive-location'"))
 895         (save-excursion
 896           (switch-to-buffer (find-file-noselect afile))
 897           (org-datetree-find-year-create y)
 898           (org-datetree-find-month-create y m)
 899           (org-datetree-find-day-create y m d)
 900           (widen)
 901           (switch-to-buffer this-buffer))
 902         ad-do-it)
 903     ad-do-it))
 904 #+end_src
 905
 906 *** Add inherited tags to archived entries
 907
 908 To make =org-archive-subtree= keep inherited tags, Osamu OKANO suggests to
 909 advise the function like this:
 910
 911 #+begin_example
 912 (defadvice org-archive-subtree
 913   (before add-inherited-tags-before-org-archive-subtree activate)
 914     "add inherited tags before org-archive-subtree"
 915     (org-set-tags-to (org-get-tags-at)))
 916 #+end_example
 917
 918 ** Using and Managing Org-Metadata
 919 *** Remove redundant tags of headlines
 920 -- David Maus
 921
 922 A small function that processes all headlines in current buffer and
 923 removes tags that are local to a headline and inherited by a parent
 924 headline or the #+FILETAGS: statement.
 925
 926 #+BEGIN_SRC emacs-lisp
 927   (defun dmj/org-remove-redundant-tags ()
 928     "Remove redundant tags of headlines in current buffer.
 929
 930   A tag is considered redundant if it is local to a headline and
 931   inherited by a parent headline."
 932     (interactive)
 933     (when (eq major-mode 'org-mode)
 934       (save-excursion
 935         (org-map-entries
 936          '(lambda ()
 937             (let ((alltags (split-string (or (org-entry-get (point) "ALLTAGS") "") ":"))
 938                   local inherited tag)
 939               (dolist (tag alltags)
 940                 (if (get-text-property 0 'inherited tag)
 941                     (push tag inherited) (push tag local)))
 942               (dolist (tag local)
 943                 (if (member tag inherited) (org-toggle-tag tag 'off)))))
 944          t nil))))
 945 #+END_SRC
 946
 947 *** Remove empty property drawers
 948
 949 David Maus proposed this:
 950
 951 #+begin_src emacs-lisp
 952 (defun dmj:org:remove-empty-propert-drawers ()
 953   "*Remove all empty property drawers in current file."
 954   (interactive)
 955   (unless (eq major-mode 'org-mode)
 956     (error "You need to turn on Org mode for this function."))
 957   (save-excursion
 958     (goto-char (point-min))
 959     (while (re-search-forward ":PROPERTIES:" nil t)
 960       (save-excursion
 961         (org-remove-empty-drawer-at "PROPERTIES" (match-beginning 0))))))
 962 #+end_src
 963
 964 *** Group task list by a property
 965
 966 This advice allows you to group a task list in Org-Mode.  To use it,
 967 set the variable =org-agenda-group-by-property= to the name of a
 968 property in the option list for a TODO or TAGS search.  The resulting
 969 agenda view will group tasks by that property prior to searching.
 970
 971 #+begin_src emacs-lisp
 972 (defvar org-agenda-group-by-property nil
 973   "Set this in org-mode agenda views to group tasks by property")
 974
 975 (defun org-group-bucket-items (prop items)
 976   (let ((buckets ()))
 977     (dolist (item items)
 978       (let* ((marker (get-text-property 0 'org-marker item))
 979              (pvalue (org-entry-get marker prop t))
 980              (cell (assoc pvalue buckets)))
 981         (if cell
 982             (setcdr cell (cons item (cdr cell)))
 983           (setq buckets (cons (cons pvalue (list item))
 984                               buckets)))))
 985     (setq buckets (mapcar (lambda (bucket)
 986                             (cons (car bucket)
 987                                   (reverse (cdr bucket))))
 988                           buckets))
 989     (sort buckets (lambda (i1 i2)
 990                     (string< (car i1) (car i2))))))
 991
 992 (defadvice org-finalize-agenda-entries (around org-group-agenda-finalize
 993                                                (list &optional nosort))
 994   "Prepare bucketed agenda entry lists"
 995   (if org-agenda-group-by-property
 996       ;; bucketed, handle appropriately
 997       (let ((text ""))
 998         (dolist (bucket (org-group-bucket-items
 999                          org-agenda-group-by-property
1000                          list))
1001           (let ((header (concat "Property "
1002                                 org-agenda-group-by-property
1003                                 " is "
1004                                 (or (car bucket) "<nil>") ":\n")))
1005             (add-text-properties 0 (1- (length header))
1006                                  (list 'face 'org-agenda-structure)
1007                                  header)
1008             (setq text
1009                   (concat text header
1010                           ;; recursively process
1011                           (let ((org-agenda-group-by-property nil))
1012                             (org-finalize-agenda-entries
1013                              (cdr bucket) nosort))
1014                           "\n\n"))))
1015         (setq ad-return-value text))
1016     ad-do-it))
1017 (ad-activate 'org-finalize-agenda-entries)
1018 #+end_src
1019 *** A way to tag a task so that when clocking-out user is prompted to take a note.
1020     Thanks to Richard Riley (see [[http://permalink.gmane.org/gmane.emacs.orgmode/40896][this post on the mailing list]]).
1021
1022 A small hook run when clocking out of a task that prompts for a note
1023 when the tag "=clockout_note=" is found in a headline. It uses the tag
1024 ("=clockout_note=") so inheritance can also be used...
1025
1026 #+begin_src emacs-lisp
1027   (defun rgr/check-for-clock-out-note()
1028         (interactive)
1029         (save-excursion
1030           (org-back-to-heading)
1031           (let ((tags (org-get-tags)))
1032             (and tags (message "tags: %s " tags)
1033                  (when (member "clocknote" tags)
1034                    (org-add-note))))))
1035
1036   (add-hook 'org-clock-out-hook 'rgr/check-for-clock-out-note)
1037 #+end_src
1038 *** Dynamically adjust tag position
1039 Here is a bit of code that allows you to have the tags always
1040 right-adjusted in the buffer.
1041
1042 This is useful when you have bigger window than default window-size
1043 and you dislike the aesthetics of having the tag in the middle of the
1044 line.
1045
1046 This hack solves the problem of adjusting it whenever you change the
1047 window size.
1048 Before saving it will revert the file to having the tag position be
1049 left-adjusted so that if you track your files with version control,
1050 you won't run into artificial diffs just because the window-size
1051 changed.
1052
1053 *IMPORTANT*: This is probably slow on very big files.
1054
1055 #+begin_src emacs-lisp
1056 (setq ba/org-adjust-tags-column t)
1057
1058 (defun ba/org-adjust-tags-column-reset-tags ()
1059   "In org-mode buffers it will reset tag position according to
1060 `org-tags-column'."
1061   (when (and
1062          (not (string= (buffer-name) "*Remember*"))
1063          (eql major-mode 'org-mode))
1064     (let ((b-m-p (buffer-modified-p)))
1065       (condition-case nil
1066           (save-excursion
1067             (goto-char (point-min))
1068             (command-execute 'outline-next-visible-heading)
1069             ;; disable (message) that org-set-tags generates
1070             (flet ((message (&rest ignored) nil))
1071               (org-set-tags 1 t))
1072             (set-buffer-modified-p b-m-p))
1073         (error nil)))))
1074
1075 (defun ba/org-adjust-tags-column-now ()
1076   "Right-adjust `org-tags-column' value, then reset tag position."
1077   (set (make-local-variable 'org-tags-column)
1078        (- (- (window-width) (length org-ellipsis))))
1079   (ba/org-adjust-tags-column-reset-tags))
1080
1081 (defun ba/org-adjust-tags-column-maybe ()
1082   "If `ba/org-adjust-tags-column' is set to non-nil, adjust tags."
1083   (when ba/org-adjust-tags-column
1084     (ba/org-adjust-tags-column-now)))
1085
1086 (defun ba/org-adjust-tags-column-before-save ()
1087   "Tags need to be left-adjusted when saving."
1088   (when ba/org-adjust-tags-column
1089      (setq org-tags-column 1)
1090      (ba/org-adjust-tags-column-reset-tags)))
1091
1092 (defun ba/org-adjust-tags-column-after-save ()
1093   "Revert left-adjusted tag position done by before-save hook."
1094   (ba/org-adjust-tags-column-maybe)
1095   (set-buffer-modified-p nil))
1096
1097 ; automatically align tags on right-hand side
1098 (add-hook 'window-configuration-change-hook
1099           'ba/org-adjust-tags-column-maybe)
1100 (add-hook 'before-save-hook 'ba/org-adjust-tags-column-before-save)
1101 (add-hook 'after-save-hook 'ba/org-adjust-tags-column-after-save)
1102 (add-hook 'org-agenda-mode-hook '(lambda ()
1103                                   (setq org-agenda-tags-column (- (window-width)))))
1104
1105 ; between invoking org-refile and displaying the prompt (which
1106 ; triggers window-configuration-change-hook) tags might adjust,
1107 ; which invalidates the org-refile cache
1108 (defadvice org-refile (around org-refile-disable-adjust-tags)
1109   "Disable dynamically adjusting tags"
1110   (let ((ba/org-adjust-tags-column nil))
1111     ad-do-it))
1112 (ad-activate 'org-refile)
1113 #+end_src
1114 ** Org Agenda and Task Management
1115 *** Make it easier to set org-agenda-files from multiple directories
1116 - Matt Lundin
1117
1118 #+begin_src emacs-lisp
1119 (defun my-org-list-files (dirs ext)
1120   "Function to create list of org files in multiple subdirectories.
1121 This can be called to generate a list of files for
1122 org-agenda-files or org-refile-targets.
1123
1124 DIRS is a list of directories.
1125
1126 EXT is a list of the extensions of files to be included."
1127   (let ((dirs (if (listp dirs)
1128                   dirs
1129                 (list dirs)))
1130         (ext (if (listp ext)
1131                  ext
1132                (list ext)))
1133         files)
1134     (mapc
1135      (lambda (x)
1136        (mapc
1137         (lambda (y)
1138           (setq files
1139                 (append files
1140                         (file-expand-wildcards
1141                          (concat (file-name-as-directory x) "*" y)))))
1142         ext))
1143      dirs)
1144     (mapc
1145      (lambda (x)
1146        (when (or (string-match "/.#" x)
1147                  (string-match "#$" x))
1148          (setq files (delete x files))))
1149      files)
1150     files))
1151
1152 (defvar my-org-agenda-directories '("~/org/")
1153   "List of directories containing org files.")
1154 (defvar my-org-agenda-extensions '(".org")
1155   "List of extensions of agenda files")
1156
1157 (setq my-org-agenda-directories '("~/org/" "~/work/"))
1158 (setq my-org-agenda-extensions '(".org" ".ref"))
1159
1160 (defun my-org-set-agenda-files ()
1161   (interactive)
1162   (setq org-agenda-files (my-org-list-files
1163                           my-org-agenda-directories
1164                           my-org-agenda-extensions)))
1165
1166 (my-org-set-agenda-files)
1167 #+end_src
1168
1169 The code above will set your "default" agenda files to all files
1170 ending in ".org" and ".ref" in the directories "~/org/" and "~/work/".
1171 You can change these values by setting the variables
1172 my-org-agenda-extensions and my-org-agenda-directories. The function
1173 my-org-agenda-files-by-filetag uses these two variables to determine
1174 which files to search for filetags (i.e., the larger set from which
1175 the subset will be drawn).
1176
1177 You can also easily use my-org-list-files to "mix and match"
1178 directories and extensions to generate different lists of agenda
1179 files.
1180
1181 *** Restrict org-agenda-files by filetag
1182   :PROPERTIES:
1183   :CUSTOM_ID: set-agenda-files-by-filetag
1184   :END:
1185 - Matt Lundin
1186
1187 It is often helpful to limit yourself to a subset of your agenda
1188 files. For instance, at work, you might want to see only files related
1189 to work (e.g., bugs, clientA, projectxyz, etc.). The FAQ has helpful
1190 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
1191 commands]]. These solutions, however, require reapplying a filter each
1192 time you call the agenda or writing several new custom agenda commands
1193 for each context. Another solution is to use directories for different
1194 types of tasks and to change your agenda files with a function that
1195 sets org-agenda-files to the appropriate directory. But this relies on
1196 hard and static boundaries between files.
1197
1198 The following functions allow for a more dynamic approach to selecting
1199 a subset of files based on filetags:
1200
1201 #+begin_src emacs-lisp
1202 (defun my-org-agenda-restrict-files-by-filetag (&optional tag)
1203   "Restrict org agenda files only to those containing filetag."
1204   (interactive)
1205   (let* ((tagslist (my-org-get-all-filetags))
1206          (ftag (or tag
1207                    (completing-read "Tag: "
1208                                     (mapcar 'car tagslist)))))
1209     (org-agenda-remove-restriction-lock 'noupdate)
1210     (put 'org-agenda-files 'org-restrict (cdr (assoc ftag tagslist)))
1211     (setq org-agenda-overriding-restriction 'files)))
1212
1213 (defun my-org-get-all-filetags ()
1214   "Get list of filetags from all default org-files."
1215   (let ((files org-agenda-files)
1216         tagslist x)
1217     (save-window-excursion
1218       (while (setq x (pop files))
1219         (set-buffer (find-file-noselect x))
1220         (mapc
1221          (lambda (y)
1222            (let ((tagfiles (assoc y tagslist)))
1223              (if tagfiles
1224                  (setcdr tagfiles (cons x (cdr tagfiles)))
1225                (add-to-list 'tagslist (list y x)))))
1226          (my-org-get-filetags)))
1227       tagslist)))
1228
1229 (defun my-org-get-filetags ()
1230   "Get list of filetags for current buffer"
1231   (let ((ftags org-file-tags)
1232         x)
1233     (mapcar
1234      (lambda (x)
1235        (org-substring-no-properties x))
1236      ftags)))
1237 #+end_src
1238
1239 Calling my-org-agenda-restrict-files-by-filetag results in a prompt
1240 with all filetags in your "normal" agenda files. When you select a
1241 tag, org-agenda-files will be restricted to only those files
1242 containing the filetag. To release the restriction, type C-c C-x >
1243 (org-agenda-remove-restriction-lock).
1244
1245 *** Highlight the agenda line under cursor
1246
1247 This is useful to make sure what task you are operating on.
1248
1249 #+BEGIN_SRC emacs-lisp
1250 (add-hook 'org-agenda-mode-hook '(lambda () (hl-line-mode 1)))
1251 #+END_SRC emacs-lisp
1252
1253 Under XEmacs:
1254
1255 #+BEGIN_SRC emacs-lisp
1256 ;; hl-line seems to be only for emacs
1257 (require 'highline)
1258 (add-hook 'org-agenda-mode-hook '(lambda () (highline-mode 1)))
1259
1260 ;; highline-mode does not work straightaway in tty mode.
1261 ;; I use a black background
1262 (custom-set-faces
1263   '(highline-face ((((type tty) (class color))
1264                     (:background "white" :foreground "black")))))
1265 #+END_SRC emacs-lisp
1266
1267 *** Split horizontally for agenda
1268
1269 If you would like to split the frame into two side-by-side windows when
1270 displaying the agenda, try this hack from Jan Rehders, which uses the
1271 `toggle-window-split' from
1272
1273 http://www.emacswiki.org/cgi-bin/wiki/ToggleWindowSplit
1274
1275 #+BEGIN_SRC emacs-lisp
1276 ;; Patch org-mode to use vertical splitting
1277 (defadvice org-prepare-agenda (after org-fix-split)
1278   (toggle-window-split))
1279 (ad-activate 'org-prepare-agenda)
1280 #+END_SRC
1281
1282 *** Automatically add an appointment when clocking in a task
1283
1284 #+BEGIN_SRC emacs-lisp
1285 ;; Make sure you have a sensible value for `appt-message-warning-time'
1286 (defvar bzg-org-clock-in-appt-delay 100
1287   "Number of minutes for setting an appointment by clocking-in")
1288 #+END_SRC
1289
1290 This function let's you add an appointment for the current entry.
1291 This can be useful when you need a reminder.
1292
1293 #+BEGIN_SRC emacs-lisp
1294 (defun bzg-org-clock-in-add-appt (&optional n)
1295   "Add an appointment for the Org entry at point in N minutes."
1296   (interactive)
1297   (save-excursion
1298     (org-back-to-heading t)
1299     (looking-at org-complex-heading-regexp)
1300     (let* ((msg (match-string-no-properties 4))
1301            (ct-time (decode-time))
1302            (appt-min (+ (cadr ct-time)
1303                         (or n bzg-org-clock-in-appt-delay)))
1304            (appt-time ; define the time for the appointment
1305             (progn (setf (cadr ct-time) appt-min) ct-time)))
1306       (appt-add (format-time-string
1307                  "%H:%M" (apply 'encode-time appt-time)) msg)
1308       (if (interactive-p) (message "New appointment for %s" msg)))))
1309 #+END_SRC
1310
1311 You can advise =org-clock-in= so that =C-c C-x C-i= will automatically
1312 add an appointment:
1313
1314 #+BEGIN_SRC emacs-lisp
1315 (defadvice org-clock-in (after org-clock-in-add-appt activate)
1316   "Add an appointment when clocking a task in."
1317   (bzg-org-clock-in-add-appt))
1318 #+END_SRC
1319
1320 You may also want to delete the associated appointment when clocking
1321 out.  This function does this:
1322
1323 #+BEGIN_SRC emacs-lisp
1324 (defun bzg-org-clock-out-delete-appt nil
1325   "When clocking out, delete any associated appointment."
1326   (interactive)
1327   (save-excursion
1328     (org-back-to-heading t)
1329     (looking-at org-complex-heading-regexp)
1330     (let* ((msg (match-string-no-properties 4)))
1331       (setq appt-time-msg-list
1332             (delete nil
1333                     (mapcar
1334                      (lambda (appt)
1335                        (if (not (string-match (regexp-quote msg)
1336                                               (cadr appt))) appt))
1337                      appt-time-msg-list)))
1338       (appt-check))))
1339 #+END_SRC
1340
1341 And here is the advice for =org-clock-out= (=C-c C-x C-o=)
1342
1343 #+BEGIN_SRC emacs-lisp
1344 (defadvice org-clock-out (before org-clock-out-delete-appt activate)
1345   "Delete an appointment when clocking a task out."
1346   (bzg-org-clock-out-delete-appt))
1347 #+END_SRC
1348
1349 *IMPORTANT*: You can add appointment by clocking in in both an
1350 =org-mode= and an =org-agenda-mode= buffer.  But clocking out from
1351 agenda buffer with the advice above will bring an error.
1352
1353 *** Remove time grid lines that are in an appointment
1354
1355 The agenda shows lines for the time grid.  Some people think that
1356 these lines are a distraction when there are appointments at those
1357 times.  You can get rid of the lines which coincide exactly with the
1358 beginning of an appointment.  Michael Ekstrand has written a piece of
1359 advice that also removes lines that are somewhere inside an
1360 appointment:
1361
1362 #+begin_src emacs-lisp
1363 (defun org-time-to-minutes (time)
1364   "Convert an HHMM time to minutes"
1365   (+ (* (/ time 100) 60) (% time 100)))
1366
1367 (defun org-time-from-minutes (minutes)
1368   "Convert a number of minutes to an HHMM time"
1369   (+ (* (/ minutes 60) 100) (% minutes 60)))
1370
1371 (defadvice org-agenda-add-time-grid-maybe (around mde-org-agenda-grid-tweakify
1372                                                   (list ndays todayp))
1373   (if (member 'remove-match (car org-agenda-time-grid))
1374       (flet ((extract-window
1375               (line)
1376               (let ((start (get-text-property 1 'time-of-day line))
1377                     (dur (get-text-property 1 'duration line)))
1378                 (cond
1379                  ((and start dur)
1380                   (cons start
1381                         (org-time-from-minutes
1382                          (+ dur (org-time-to-minutes start)))))
1383                  (start start)
1384                  (t nil)))))
1385         (let* ((windows (delq nil (mapcar 'extract-window list)))
1386                (org-agenda-time-grid
1387                 (list (car org-agenda-time-grid)
1388                       (cadr org-agenda-time-grid)
1389                       (remove-if
1390                        (lambda (time)
1391                          (find-if (lambda (w)
1392                                     (if (numberp w)
1393                                         (equal w time)
1394                                       (and (>= time (car w))
1395                                            (< time (cdr w)))))
1396                                   windows))
1397                        (caddr org-agenda-time-grid)))))
1398           ad-do-it))
1399     ad-do-it))
1400 (ad-activate 'org-agenda-add-time-grid-maybe)
1401 #+end_src
1402 *** Disable vc for Org mode agenda files
1403 -- David Maus
1404
1405 Even if you use Git to track your agenda files you might not need
1406 vc-mode to be enabled for these files.
1407
1408 #+begin_src emacs-lisp
1409 (add-hook 'find-file-hook 'dmj/disable-vc-for-agenda-files-hook)
1410 (defun dmj/disable-vc-for-agenda-files-hook ()
1411   "Disable vc-mode for Org agenda files."
1412   (if (and (fboundp 'org-agenda-file-p)
1413            (org-agenda-file-p (buffer-file-name)))
1414       (remove-hook 'find-file-hook 'vc-find-file-hook)
1415     (add-hook 'find-file-hook 'vc-find-file-hook)))
1416 #+end_src
1417
1418 *** Easy customization of TODO colors
1419 -- Ryan C. Thompson
1420
1421 Here is some code I came up with some code to make it easier to
1422 customize the colors of various TODO keywords. As long as you just
1423 want a different color and nothing else, you can customize the
1424 variable org-todo-keyword-faces and use just a string color (i.e. a
1425 string of the color name) as the face, and then org-get-todo-face
1426 will convert the color to a face, inheriting everything else from
1427 the standard org-todo face.
1428
1429 To demonstrate, I currently have org-todo-keyword-faces set to
1430
1431 #+BEGIN_SRC emacs-lisp
1432 (("IN PROGRESS" . "dark orange")
1433  ("WAITING" . "red4")
1434  ("CANCELED" . "saddle brown"))
1435 #+END_SRC emacs-lisp
1436
1437   Here's the code, in a form you can put in your =.emacs=
1438
1439 #+BEGIN_SRC emacs-lisp
1440 (eval-after-load 'org-faces
1441  '(progn
1442     (defcustom org-todo-keyword-faces nil
1443       "Faces for specific TODO keywords.
1444 This is a list of cons cells, with TODO keywords in the car and
1445 faces in the cdr.  The face can be a symbol, a color, or a
1446 property list of attributes, like (:foreground \"blue\" :weight
1447 bold :underline t)."
1448       :group 'org-faces
1449       :group 'org-todo
1450       :type '(repeat
1451               (cons
1452                (string :tag "Keyword")
1453                (choice color (sexp :tag "Face")))))))
1454
1455 (eval-after-load 'org
1456  '(progn
1457     (defun org-get-todo-face-from-color (color)
1458       "Returns a specification for a face that inherits from org-todo
1459  face and has the given color as foreground. Returns nil if
1460  color is nil."
1461       (when color
1462         `(:inherit org-warning :foreground ,color)))
1463
1464     (defun org-get-todo-face (kwd)
1465       "Get the right face for a TODO keyword KWD.
1466 If KWD is a number, get the corresponding match group."
1467       (if (numberp kwd) (setq kwd (match-string kwd)))
1468       (or (let ((face (cdr (assoc kwd org-todo-keyword-faces))))
1469             (if (stringp face)
1470                 (org-get-todo-face-from-color face)
1471               face))
1472           (and (member kwd org-done-keywords) 'org-done)
1473           'org-todo))))
1474 #+END_SRC emacs-lisp
1475
1476 *** Add an effort estimate on the fly when clocking in
1477
1478 You can use =org-clock-in-prepare-hook= to add an effort estimate.
1479 This way you can easily have a "tea-timer" for your tasks when they
1480 don't already have an effort estimate.
1481
1482 #+begin_src emacs-lisp
1483 (add-hook 'org-clock-in-prepare-hook
1484           'my-org-mode-ask-effort)
1485
1486 (defun my-org-mode-ask-effort ()
1487   "Ask for an effort estimate when clocking in."
1488   (unless (org-entry-get (point) "Effort")
1489     (let ((effort
1490            (completing-read
1491             "Effort: "
1492             (org-entry-get-multivalued-property (point) "Effort"))))
1493       (unless (equal effort "")
1494         (org-set-property "Effort" effort)))))
1495 #+end_src
1496
1497 Or you can use a default effort for such a timer:
1498
1499 #+begin_src emacs-lisp
1500 (add-hook 'org-clock-in-prepare-hook
1501           'my-org-mode-add-default-effort)
1502
1503 (defvar org-clock-default-effort "1:00")
1504
1505 (defun my-org-mode-add-default-effort ()
1506   "Add a default effort estimation."
1507   (unless (org-entry-get (point) "Effort")
1508     (org-set-property "Effort" org-clock-default-effort)))
1509 #+end_src
1510
1511 *** Refresh the agenda view regurally
1512
1513 Hack sent by Kiwon Um:
1514
1515 #+begin_src emacs-lisp
1516 (defun kiwon/org-agenda-redo-in-other-window ()
1517   "Call org-agenda-redo function even in the non-agenda buffer."
1518   (interactive)
1519   (let ((agenda-window (get-buffer-window org-agenda-buffer-name t)))
1520     (when agenda-window
1521       (with-selected-window agenda-window (org-agenda-redo)))))
1522 (run-at-time nil 300 'kiwon/org-agenda-redo-in-other-window)
1523 #+end_src
1524
1525 *** Reschedule agenda items to today with a single command
1526
1527 This was suggested by Carsten in reply to David Abrahams:
1528
1529 #+begin_example emacs-lisp
1530 (defun org-agenda-reschedule-to-today ()
1531   (interactive)
1532   (flet ((org-read-date (&rest rest) (current-time)))
1533     (call-interactively 'org-agenda-schedule)))
1534 #+end_example
1535
1536 *** Mark subtree DONE along with all subheadings
1537
1538 Bernt Hansen [[http://permalink.gmane.org/gmane.emacs.orgmode/44693][suggested]] this command:
1539
1540 #+begin_src emacs-lisp
1541 (defun bh/mark-subtree-done ()
1542   (interactive)
1543   (org-mark-subtree)
1544   (let ((limit (point)))
1545     (save-excursion
1546       (exchange-point-and-mark)
1547       (while (> (point) limit)
1548         (org-todo "DONE")
1549         (outline-previous-visible-heading 1))
1550       (org-todo "DONE"))))
1551 #+end_src
1552
1553 Then M-x bh/mark-subtree-done.
1554
1555 ** Exporting org files
1556 *** Specifying LaTeX commands to floating environments
1557
1558 The keyword ~placement~ can be used to specify placement options to
1559 floating environments (like =\begin{figure}= and =\begin{table}=}) in
1560 LaTeX export. Org passes along everything passed in options as long as
1561 there are no spaces. One can take advantage of this to pass other
1562 LaTeX commands and have their scope limited to the floating
1563 environment.
1564
1565 For example one can set the fontsize of a table different from the
1566 default normal size by putting something like =\footnotesize= right
1567 after the placement options. During LaTeX export using the
1568 ~#+ATTR_LaTeX:~ line below:
1569
1570 #+begin_src org
1571   ,#+ATTR_LaTeX: placement=[<options>]\footnotesize
1572 #+end_src
1573
1574 exports the associated floating environment as shown in the following
1575 block.
1576
1577 #+begin_src latex
1578 \begin{table}[<options>]\footnotesize
1579 ...
1580 \end{table}
1581 #+end_src
1582
1583 * Hacking Org: Working with Org-mode and other Emacs Packages.
1584 ** org-remember-anything
1585
1586 [[http://www.emacswiki.org/cgi-bin/wiki/Anything][Anything]] users may find the snippet below interesting:
1587
1588 #+BEGIN_SRC emacs-lisp
1589 (defvar org-remember-anything
1590   '((name . "Org Remember")
1591     (candidates . (lambda () (mapcar 'car org-remember-templates)))
1592     (action . (lambda (name)
1593                 (let* ((orig-template org-remember-templates)
1594                        (org-remember-templates
1595                         (list (assoc name orig-template))))
1596                   (call-interactively 'org-remember))))))
1597 #+END_SRC
1598
1599 You can add it to your 'anything-sources' variable and open remember directly
1600 from anything. I imagine this would be more interesting for people with many
1601 remember templatesm, so that you are out of keys to assign those to. You should
1602 get something like this:
1603
1604 [[file:images/thumbs/org-remember-anything.png]]
1605
1606 ** Org-mode and saveplace.el
1607
1608 Fix a problem with saveplace.el putting you back in a folded position:
1609
1610 #+begin_src emacs-lisp
1611 (add-hook 'org-mode-hook
1612           (lambda ()
1613             (when (outline-invisible-p)
1614               (save-excursion
1615                 (outline-previous-visible-heading 1)
1616                 (org-show-subtree)))))
1617 #+end_src
1618
1619 ** Using ido-completing-read to find attachments
1620 -- Matt Lundin
1621
1622 Org-attach is great for quickly linking files to a project. But if you
1623 use org-attach extensively you might find yourself wanting to browse
1624 all the files you've attached to org headlines. This is not easy to do
1625 manually, since the directories containing the files are not human
1626 readable (i.e., they are based on automatically generated ids). Here's
1627 some code to browse those files using ido (obviously, you need to be
1628 using ido):
1629
1630 #+begin_src emacs-lisp
1631 (load-library "find-lisp")
1632
1633 ;; Adapted from http://www.emacswiki.org/emacs/RecentFiles
1634
1635 (defun my-ido-find-org-attach ()
1636   "Find files in org-attachment directory"
1637   (interactive)
1638   (let* ((enable-recursive-minibuffers t)
1639          (files (find-lisp-find-files org-attach-directory "."))
1640          (file-assoc-list
1641           (mapcar (lambda (x)
1642                     (cons (file-name-nondirectory x)
1643                           x))
1644                   files))
1645          (filename-list
1646           (remove-duplicates (mapcar #'car file-assoc-list)
1647                              :test #'string=))
1648          (filename (ido-completing-read "Org attachments: " filename-list nil t))
1649          (longname (cdr (assoc filename file-assoc-list))))
1650     (ido-set-current-directory
1651      (if (file-directory-p longname)
1652          longname
1653        (file-name-directory longname)))
1654     (setq ido-exit 'refresh
1655           ido-text-init ido-text
1656           ido-rotate-temp t)
1657     (exit-minibuffer)))
1658
1659 (add-hook 'ido-setup-hook 'ido-my-keys)
1660
1661 (defun ido-my-keys ()
1662   "Add my keybindings for ido."
1663   (define-key ido-completion-map (kbd "C-;") 'my-ido-find-org-attach))
1664 #+end_src
1665
1666 To browse your org attachments using ido fuzzy matching and/or the
1667 completion buffer, invoke ido-find-file as usual (=C-x C-f=) and then
1668 press =C-;=.
1669
1670 ** Use idle timer for automatic agenda views
1671
1672 From John Wiegley's mailing list post (March 18, 2010):
1673
1674 #+begin_quote
1675 I have the following snippet in my .emacs file, which I find very
1676 useful. Basically what it does is that if I don't touch my Emacs for 5
1677 minutes, it displays the current agenda. This keeps my tasks "always
1678 in mind" whenever I come back to Emacs after doing something else,
1679 whereas before I had a tendency to forget that it was there.
1680 #+end_quote
1681
1682   - [[http://mid.gmane.org/55590EA7-C744-44E5-909F-755F0BBE452D@gmail.com][John Wiegley: Displaying your Org agenda after idle time]]
1683
1684 #+begin_src emacs-lisp
1685 (defun jump-to-org-agenda ()
1686   (interactive)
1687   (let ((buf (get-buffer "*Org Agenda*"))
1688         wind)
1689     (if buf
1690         (if (setq wind (get-buffer-window buf))
1691             (select-window wind)
1692           (if (called-interactively-p)
1693               (progn
1694                 (select-window (display-buffer buf t t))
1695                 (org-fit-window-to-buffer)
1696                 ;; (org-agenda-redo)
1697                 )
1698             (with-selected-window (display-buffer buf)
1699               (org-fit-window-to-buffer)
1700               ;; (org-agenda-redo)
1701               )))
1702       (call-interactively 'org-agenda-list)))
1703   ;;(let ((buf (get-buffer "*Calendar*")))
1704   ;;  (unless (get-buffer-window buf)
1705   ;;    (org-agenda-goto-calendar)))
1706   )
1707
1708 (run-with-idle-timer 300 t 'jump-to-org-agenda)
1709 #+end_src
1710
1711 #+results:
1712 : [nil 0 300 0 t jump-to-org-agenda nil idle]
1713
1714 ** Link to Gnus messages by Message-Id
1715
1716 In a [[http://thread.gmane.org/gmane.emacs.orgmode/8860][recent thread]] on the Org-Mode mailing list, there was some
1717 discussion about linking to Gnus messages without encoding the folder
1718 name in the link.  The following code hooks in to the store-link
1719 function in Gnus to capture links by Message-Id when in nnml folders,
1720 and then provides a link type "mid" which can open this link.  The
1721 =mde-org-gnus-open-message-link= function uses the
1722 =mde-mid-resolve-methods= variable to determine what Gnus backends to
1723 scan.  It will go through them, in order, asking each to locate the
1724 message and opening it from the first one that reports success.
1725
1726 It has only been tested with a single nnml backend, so there may be
1727 bugs lurking here and there.
1728
1729 The logic for finding the message was adapted from [[http://www.emacswiki.org/cgi-bin/wiki/FindMailByMessageId][an Emacs Wiki
1730 article]].
1731
1732 #+begin_src emacs-lisp
1733 ;; Support for saving Gnus messages by Message-ID
1734 (defun mde-org-gnus-save-by-mid ()
1735   (when (memq major-mode '(gnus-summary-mode gnus-article-mode))
1736     (when (eq major-mode 'gnus-article-mode)
1737       (gnus-article-show-summary))
1738     (let* ((group gnus-newsgroup-name)
1739            (method (gnus-find-method-for-group group)))
1740       (when (eq 'nnml (car method))
1741         (let* ((article (gnus-summary-article-number))
1742                (header (gnus-summary-article-header article))
1743                (from (mail-header-from header))
1744                (message-id
1745                 (save-match-data
1746                   (let ((mid (mail-header-id header)))
1747                     (if (string-match "<\\(.*\\)>" mid)
1748                         (match-string 1 mid)
1749                       (error "Malformed message ID header %s" mid)))))
1750                (date (mail-header-date header))
1751                (subject (gnus-summary-subject-string)))
1752           (org-store-link-props :type "mid" :from from :subject subject
1753                                 :message-id message-id :group group
1754                                 :link (org-make-link "mid:" message-id))
1755           (apply 'org-store-link-props
1756                  :description (org-email-link-description)
1757                  org-store-link-plist)
1758           t)))))
1759
1760 (defvar mde-mid-resolve-methods '()
1761   "List of methods to try when resolving message ID's.  For Gnus,
1762 it is a cons of 'gnus and the select (type and name).")
1763 (setq mde-mid-resolve-methods
1764       '((gnus nnml "")))
1765
1766 (defvar mde-org-gnus-open-level 1
1767   "Level at which Gnus is started when opening a link")
1768 (defun mde-org-gnus-open-message-link (msgid)
1769   "Open a message link with Gnus"
1770   (require 'gnus)
1771   (require 'org-table)
1772   (catch 'method-found
1773     (message "[MID linker] Resolving %s" msgid)
1774     (dolist (method mde-mid-resolve-methods)
1775       (cond
1776        ((and (eq (car method) 'gnus)
1777              (eq (cadr method) 'nnml))
1778         (funcall (cdr (assq 'gnus org-link-frame-setup))
1779                  mde-org-gnus-open-level)
1780         (when gnus-other-frame-object
1781           (select-frame gnus-other-frame-object))
1782         (let* ((msg-info (nnml-find-group-number
1783                           (concat "<" msgid ">")
1784                           (cdr method)))
1785                (group (and msg-info (car msg-info)))
1786                (message (and msg-info (cdr msg-info)))
1787                (qname (and group
1788                            (if (gnus-methods-equal-p
1789                                 (cdr method)
1790                                 gnus-select-method)
1791                                group
1792                              (gnus-group-full-name group (cdr method))))))
1793           (when msg-info
1794             (gnus-summary-read-group qname nil t)
1795             (gnus-summary-goto-article message nil t))
1796           (throw 'method-found t)))
1797        (t (error "Unknown link type"))))))
1798
1799 (eval-after-load 'org-gnus
1800   '(progn
1801      (add-to-list 'org-store-link-functions 'mde-org-gnus-save-by-mid)
1802      (org-add-link-type "mid" 'mde-org-gnus-open-message-link)))
1803 #+end_src
1804
1805 ** Store link upon sending a message in Gnus
1806
1807 Ulf Stegemann came up with this solution (see his [[http://www.mail-archive.com/emacs-orgmode@gnu.org/msg33278.html][original message]]):
1808
1809 #+begin_src emacs-lisp
1810 (defun ulf-message-send-and-org-gnus-store-link (&optional arg)
1811   "Send message with `message-send-and-exit' and store org link to message copy.
1812 If multiple groups appear in the Gcc header, the link refers to
1813 the copy in the last group."
1814   (interactive "P")
1815     (save-excursion
1816       (save-restriction
1817         (message-narrow-to-headers)
1818         (let ((gcc (car (last
1819                          (message-unquote-tokens
1820                           (message-tokenize-header
1821                            (mail-fetch-field "gcc" nil t) " ,")))))
1822               (buf (current-buffer))
1823               (message-kill-buffer-on-exit nil)
1824               id to from subject desc link newsgroup xarchive)
1825         (message-send-and-exit arg)
1826         (or
1827          ;; gcc group found ...
1828          (and gcc
1829               (save-current-buffer
1830                 (progn (set-buffer buf)
1831                        (setq id (org-remove-angle-brackets
1832                                  (mail-fetch-field "Message-ID")))
1833                        (setq to (mail-fetch-field "To"))
1834                        (setq from (mail-fetch-field "From"))
1835                        (setq subject (mail-fetch-field "Subject"))))
1836               (org-store-link-props :type "gnus" :from from :subject subject
1837                                     :message-id id :group gcc :to to)
1838               (setq desc (org-email-link-description))
1839               (setq link (org-gnus-article-link
1840                           gcc newsgroup id xarchive))
1841               (setq org-stored-links
1842                     (cons (list link desc) org-stored-links)))
1843          ;; no gcc group found ...
1844          (message "Can not create Org link: No Gcc header found."))))))
1845
1846 (define-key message-mode-map [(control c) (control meta c)]
1847   'ulf-message-send-and-org-gnus-store-link)
1848 #+end_src
1849
1850 ** Send html messages and attachments with Wanderlust
1851   -- David Maus
1852
1853 /Note/: The module [[file:org-contrib/org-mime.org][Org-mime]] in Org's contrib directory provides
1854 similar functionality for both Wanderlust and Gnus.  The hack below is
1855 still somewhat different: It allows you to toggle sending of html
1856 messages within Wanderlust transparently.  I.e. html markup of the
1857 message body is created right before sending starts.
1858
1859 *** Send HTML message
1860
1861 Putting the code below in your .emacs adds following four functions:
1862
1863 - dmj/wl-send-html-message
1864
1865   Function that does the job: Convert everything between "--text
1866   follows this line--" and first mime entity (read: attachment) or
1867   end of buffer into html markup using `org-export-region-as-html'
1868   and replaces original body with a multipart MIME entity with the
1869   plain text version of body and the html markup version.  Thus a
1870   recipient that prefers html messages can see the html markup,
1871   recipients that prefer or depend on plain text can see the plain
1872   text.
1873
1874   Cannot be called interactively: It is hooked into SEMI's
1875   `mime-edit-translate-hook' if message should be HTML message.
1876
1877 - dmj/wl-send-html-message-draft-init
1878
1879   Cannot be called interactively: It is hooked into WL's
1880   `wl-mail-setup-hook' and provides a buffer local variable to
1881   toggle.
1882
1883 - dmj/wl-send-html-message-draft-maybe
1884
1885   Cannot be called interactively: It is hooked into WL's
1886   `wl-draft-send-hook' and hooks `dmj/wl-send-html-message' into
1887   `mime-edit-translate-hook' depending on whether HTML message is
1888   toggled on or off
1889
1890 - dmj/wl-send-html-message-toggle
1891
1892   Toggles sending of HTML message.  If toggled on, the letters
1893   "HTML" appear in the mode line.
1894
1895   Call it interactively!  Or bind it to a key in `wl-draft-mode'.
1896
1897 If you have to send HTML messages regularly you can set a global
1898 variable `dmj/wl-send-html-message-toggled-p' to the string "HTML" to
1899 toggle on sending HTML message by default.
1900
1901 The image [[http://s11.directupload.net/file/u/15851/48ru5wl3.png][here]] shows an example of how the HTML message looks like in
1902 Google's web front end.  As you can see you have the whole markup of
1903 Org at your service: *bold*, /italics/, tables, lists...
1904
1905 So even if you feel uncomfortable with sending HTML messages at least
1906 you send HTML that looks quite good.
1907
1908 #+begin_src emacs-lisp
1909 (defun dmj/wl-send-html-message ()
1910   "Send message as html message.
1911 Convert body of message to html using
1912   `org-export-region-as-html'."
1913   (require 'org)
1914   (save-excursion
1915     (let (beg end html text)
1916       (goto-char (point-min))
1917       (re-search-forward "^--text follows this line--$")
1918       ;; move to beginning of next line
1919       (beginning-of-line 2)
1920       (setq beg (point))
1921       (if (not (re-search-forward "^--\\[\\[" nil t))
1922           (setq end (point-max))
1923         ;; line up
1924         (end-of-line 0)
1925         (setq end (point)))
1926       ;; grab body
1927       (setq text (buffer-substring-no-properties beg end))
1928       ;; convert to html
1929       (with-temp-buffer
1930         (org-mode)
1931         (insert text)
1932         ;; handle signature
1933         (when (re-search-backward "^-- \n" nil t)
1934           ;; preserve link breaks in signature
1935           (insert "\n#+BEGIN_VERSE\n")
1936           (goto-char (point-max))
1937           (insert "\n#+END_VERSE\n")
1938           ;; grab html
1939           (setq html (org-export-region-as-html
1940                       (point-min) (point-max) t 'string))))
1941       (delete-region beg end)
1942       (insert
1943        (concat
1944         "--" "<<alternative>>-{\n"
1945         "--" "[[text/plain]]\n" text
1946         "--" "[[text/html]]\n"  html
1947         "--" "}-<<alternative>>\n")))))
1948
1949 (defun dmj/wl-send-html-message-toggle ()
1950   "Toggle sending of html message."
1951   (interactive)
1952   (setq dmj/wl-send-html-message-toggled-p
1953         (if dmj/wl-send-html-message-toggled-p
1954             nil "HTML"))
1955   (message "Sending html message toggled %s"
1956            (if dmj/wl-send-html-message-toggled-p
1957                "on" "off")))
1958
1959 (defun dmj/wl-send-html-message-draft-init ()
1960   "Create buffer local settings for maybe sending html message."
1961   (unless (boundp 'dmj/wl-send-html-message-toggled-p)
1962     (setq dmj/wl-send-html-message-toggled-p nil))
1963   (make-variable-buffer-local 'dmj/wl-send-html-message-toggled-p)
1964   (add-to-list 'global-mode-string
1965                '(:eval (if (eq major-mode 'wl-draft-mode)
1966                            dmj/wl-send-html-message-toggled-p))))
1967
1968 (defun dmj/wl-send-html-message-maybe ()
1969   "Maybe send this message as html message.
1970
1971 If buffer local variable `dmj/wl-send-html-message-toggled-p' is
1972 non-nil, add `dmj/wl-send-html-message' to
1973 `mime-edit-translate-hook'."
1974   (if dmj/wl-send-html-message-toggled-p
1975       (add-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)
1976     (remove-hook 'mime-edit-translate-hook 'dmj/wl-send-html-message)))
1977
1978 (add-hook 'wl-draft-reedit-hook 'dmj/wl-send-html-message-draft-init)
1979 (add-hook 'wl-mail-setup-hook 'dmj/wl-send-html-message-draft-init)
1980 (add-hook 'wl-draft-send-hook 'dmj/wl-send-html-message-maybe)
1981 #+end_src
1982
1983 *** Attach HTML of region or subtree
1984
1985 Instead of sending a complete HTML message you might only send parts
1986 of an Org file as HTML for the poor souls who are plagued with
1987 non-proportional fonts in their mail program that messes up pretty
1988 ASCII tables.
1989
1990 This short function does the trick: It exports region or subtree to
1991 HTML, prefixes it with a MIME entity delimiter and pushes to killring
1992 and clipboard.  If a region is active, it uses the region, the
1993 complete subtree otherwise.
1994
1995 #+begin_src emacs-lisp
1996 (defun dmj/org-export-region-as-html-attachment (beg end arg)
1997   "Export region between BEG and END as html attachment.
1998 If BEG and END are not set, use current subtree.  Region or
1999 subtree is exported to html without header and footer, prefixed
2000 with a mime entity string and pushed to clipboard and killring.
2001 When called with prefix, mime entity is not marked as
2002 attachment."
2003   (interactive "r\nP")
2004   (save-excursion
2005     (let* ((beg (if (region-active-p) (region-beginning)
2006                   (progn
2007                     (org-back-to-heading)
2008                     (point))))
2009            (end (if (region-active-p) (region-end)
2010                   (progn
2011                     (org-end-of-subtree)
2012                     (point))))
2013            (html (concat "--[[text/html"
2014                          (if arg "" "\nContent-Disposition: attachment")
2015                          "]]\n"
2016                          (org-export-region-as-html beg end t 'string))))
2017       (when (fboundp 'x-set-selection)
2018         (ignore-errors (x-set-selection 'PRIMARY html))
2019         (ignore-errors (x-set-selection 'CLIPBOARD html)))
2020       (message "html export done, pushed to kill ring and clipboard"))))
2021 #+end_src
2022
2023 *** Adopting for Gnus
2024
2025 The whole magic lies in the special strings that mark a HTML
2026 attachment.  So you might just have to find out what these special
2027 strings are in message-mode and modify the functions accordingly.
2028 ** Add sunrise/sunset times to the agenda.
2029   -- Nick Dokos
2030
2031 The diary package provides the function =diary-sunrise-sunset= which can be used
2032 in a diary s-expression in some agenda file like this:
2033
2034 #+begin_src org-mode
2035 %%(diary-sunrise-sunset)
2036 #+end_src
2037
2038 Seb Vauban asked if it is possible to put sunrise and sunset in
2039 separate lines. Here is a hack to do that. It adds two functions (they
2040 have to be available before the agenda is shown, so I add them early
2041 in my org-config file which is sourced from .emacs, but you'll have to
2042 suit yourself here) that just parse the output of
2043 diary-sunrise-sunset, instead of doing the right thing which would be
2044 to take advantage of the data structures that diary/solar.el provides.
2045 In short, a hack - so perfectly suited for inclusion here :-)
2046
2047 The functions (and latitude/longitude settings which you have to modify for
2048 your location) are as follows:
2049
2050 #+begin_src emacs-lisp
2051 (setq calendar-latitude 40.3)
2052 (setq calendar-longitude -71.0)
2053 (defun diary-sunrise ()
2054   (let ((dss (diary-sunrise-sunset)))
2055     (with-temp-buffer
2056       (insert dss)
2057       (goto-char (point-min))
2058       (while (re-search-forward " ([^)]*)" nil t)
2059         (replace-match "" nil nil))
2060       (goto-char (point-min))
2061       (search-forward ",")
2062       (buffer-substring (point-min) (match-beginning 0)))))
2063
2064 (defun diary-sunset ()
2065   (let ((dss (diary-sunrise-sunset))
2066         start end)
2067     (with-temp-buffer
2068       (insert dss)
2069       (goto-char (point-min))
2070       (while (re-search-forward " ([^)]*)" nil t)
2071         (replace-match "" nil nil))
2072       (goto-char (point-min))
2073       (search-forward ", ")
2074       (setq start (match-end 0))
2075       (search-forward " at")
2076       (setq end (match-beginning 0))
2077       (goto-char start)
2078       (capitalize-word 1)
2079       (buffer-substring start end))))
2080 #+end_src
2081
2082 You also need to add a couple of diary s-expressions in one of your agenda
2083 files:
2084
2085 #+begin_src org-mode
2086 %%(diary-sunrise)
2087 %%(diary-sunset)
2088 #+end_src
2089
2090 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]].
2091 In comparison to the version posted on the mailing list, this one
2092 gets rid of the timezone information.
2093 * Hacking Org: Working with Org-mode and External Programs.
2094
2095
2096
2097 : I've [...] created some procmail and shell glue that takes emails and
2098 : inserts them into an org-file so that I can capture stuff on the go using
2099 : the email program.
2100
2101 That's [[http://tychoish.com/code/org-mail/][here]].
2102
2103 ** Use Org-mode with Screen [Andrew Hyatt]
2104
2105 "The general idea is that you start a task in which all the work will
2106 take place in a shell.  This usually is not a leaf-task for me, but
2107 usually the parent of a leaf task.  From a task in your org-file, M-x
2108 ash-org-screen will prompt for the name of a session.  Give it a name,
2109 and it will insert a link.  Open the link at any time to go the screen
2110 session containing your work!"
2111
2112 http://article.gmane.org/gmane.emacs.orgmode/5276
2113
2114 #+BEGIN_SRC emacs-lisp
2115 (require 'term)
2116
2117 (defun ash-org-goto-screen (name)
2118   "Open the screen with the specified name in the window"
2119   (interactive "MScreen name: ")
2120   (let ((screen-buffer-name (ash-org-screen-buffer-name name)))
2121     (if (member screen-buffer-name
2122                 (mapcar 'buffer-name (buffer-list)))
2123         (switch-to-buffer screen-buffer-name)
2124       (switch-to-buffer (ash-org-screen-helper name "-dr")))))
2125
2126 (defun ash-org-screen-buffer-name (name)
2127   "Returns the buffer name corresponding to the screen name given."
2128   (concat "*screen " name "*"))
2129
2130 (defun ash-org-screen-helper (name arg)
2131   ;; Pick the name of the new buffer.
2132   (let ((term-ansi-buffer-name
2133          (generate-new-buffer-name
2134           (ash-org-screen-buffer-name name))))
2135     (setq term-ansi-buffer-name
2136           (term-ansi-make-term
2137            term-ansi-buffer-name "/usr/bin/screen" nil arg name))
2138     (set-buffer term-ansi-buffer-name)
2139     (term-mode)
2140     (term-char-mode)
2141     (term-set-escape-char ?\C-x)
2142     term-ansi-buffer-name))
2143
2144 (defun ash-org-screen (name)
2145   "Start a screen session with name"
2146   (interactive "MScreen name: ")
2147   (save-excursion
2148     (ash-org-screen-helper name "-S"))
2149   (insert-string (concat "[[screen:" name "]]")))
2150
2151 ;; And don't forget to add ("screen" . "elisp:(ash-org-goto-screen
2152 ;; \"%s\")") to org-link-abbrev-alist.
2153 #+END_SRC
2154
2155 ** Org Agenda + Appt + Zenity
2156 #+BEGIN_HTML
2157 <a name="agenda-appt-zenity"></a>
2158 #+END_HTML
2159 Russell Adams posted this setup [[http://article.gmane.org/gmane.emacs.orgmode/5806][on the list]].  It makes sure your agenda
2160 appointments are known by Emacs, and it displays warnings in a [[http://live.gnome.org/Zenity][zenity]]
2161 popup window.
2162
2163 #+BEGIN_SRC emacs-lisp
2164 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2165 ; For org appointment reminders
2166
2167 ;; Get appointments for today
2168 (defun my-org-agenda-to-appt ()
2169   (interactive)
2170   (setq appt-time-msg-list nil)
2171   (let ((org-deadline-warning-days 0))    ;; will be automatic in org 5.23
2172         (org-agenda-to-appt)))
2173
2174 ;; Run once, activate and schedule refresh
2175 (my-org-agenda-to-appt)
2176 (appt-activate t)
2177 (run-at-time "24:01" nil 'my-org-agenda-to-appt)
2178
2179 ; 5 minute warnings
2180 (setq appt-message-warning-time 15)
2181 (setq appt-display-interval 5)
2182
2183 ; Update appt each time agenda opened.
2184 (add-hook 'org-finalize-agenda-hook 'my-org-agenda-to-appt)
2185
2186 ; Setup zenify, we tell appt to use window, and replace default function
2187 (setq appt-display-format 'window)
2188 (setq appt-disp-window-function (function my-appt-disp-window))
2189
2190 (defun my-appt-disp-window (min-to-app new-time msg)
2191   (save-window-excursion (shell-command (concat
2192     "/usr/bin/zenity --info --title='Appointment' --text='"
2193     msg "' &") nil nil)))
2194 #+END_SRC
2195
2196 ** Org-Mode + gnome-osd
2197
2198 Richard Riley uses gnome-osd in interaction with Org-Mode to display
2199 appointments.  You can look at the code on the [[http://www.emacswiki.org/emacs-en/OrgMode-OSD][emacswiki]].
2200
2201 ** remind2org
2202
2203 From Detlef Steuer
2204
2205 http://article.gmane.org/gmane.emacs.orgmode/5073
2206
2207 #+BEGIN_QUOTE
2208 Remind (http://www.roaringpenguin.com/products/remind) is a very powerful
2209 command line calendaring program. Its features superseed the possibilities
2210 of orgmode in the area of date specifying, so that I want to use it
2211 combined with orgmode.
2212
2213 Using the script below I'm able use remind and incorporate its output in my
2214 agenda views.  The default of using 13 months look ahead is easily
2215 changed. It just happens I sometimes like to look a year into the
2216 future. :-)
2217 #+END_QUOTE
2218
2219 ** Useful webjumps for conkeror
2220
2221 If you are using the [[http://conkeror.org][conkeror browser]], maybe you want to put this into
2222 your =~/.conkerorrc= file:
2223
2224 #+begin_example
2225 define_webjump("orglist", "http://search.gmane.org/?query=%s&group=gmane.emacs.orgmode");
2226 define_webjump("worg", "http://www.google.com/cse?cx=002987994228320350715%3Az4glpcrritm&ie=UTF-8&q=%s&sa=Search&siteurl=orgmode.org%2Fworg%2F");
2227 #+end_example
2228
2229 It creates two [[http://conkeror.org/Webjumps][webjumps]] for easily searching the Worg website and the
2230 Org-mode mailing list.
2231
2232 ** Use MathJax for HTML export without requiring JavaScript
2233 As of 2010-08-14, MathJax is the default method used to export math to HTML.
2234
2235 If you like the results but do not want JavaScript in the exported pages,
2236 check out [[http://www.jboecker.de/2010/08/15/staticmathjax.html][Static MathJax]], a XULRunner application which generates a static
2237 HTML file from the exported version. It can also embed all referenced fonts
2238 within the HTML file itself, so there are no dependencies to external files.
2239
2240 The download archive contains an elisp file which integrates it into the Org
2241 export process (configurable per file with a "#+StaticMathJax:" line).
2242
2243 Read README.org and the comments in org-static-mathjax.el for usage instructions.
2244 ** Search Org files using lgrep
2245
2246 Matt Lundin suggests this:
2247
2248 #+begin_src emacs-lisp
2249   (defun my-org-grep (search &optional context)
2250     "Search for word in org files.
2251
2252 Prefix argument determines number of lines."
2253     (interactive "sSearch for: \nP")
2254     (let ((grep-find-ignored-files '("#*" ".#*"))
2255           (grep-template (concat "grep <X> -i -nH "
2256                                  (when context
2257                                    (concat "-C" (number-to-string context)))
2258                                  " -e <R> <F>")))
2259       (lgrep search "*org*" "/home/matt/org/")))
2260
2261   (global-set-key (kbd "<f8>") 'my-org-grep)
2262 #+end_src
2263
2264 ** Automatic screenshot insertion
2265
2266 Suggested by Russell Adams
2267
2268 #+begin_src emacs-lisp
2269   (defun my-org-screenshot ()
2270     "Take a screenshot into a time stamped unique-named file in the
2271   same directory as the org-buffer and insert a link to this file."
2272     (interactive)
2273     (setq filename
2274           (concat
2275            (make-temp-name
2276             (concat (buffer-file-name)
2277                     "_"
2278                     (format-time-string "%Y%m%d_%H%M%S_")) ) ".png"))
2279     (call-process "import" nil nil nil filename)
2280     (insert (concat "[[" filename "]]"))
2281     (org-display-inline-images))
2282 #+end_src
2283
2284 ** Capture invitations/appointments from MS Exchange emails
2285
2286 Dirk-Jan C.Binnema [[http://article.gmane.org/gmane.emacs.orgmode/27684/][provided]] code to do this.  Please check
2287 [[file:code/elisp/org-exchange-capture.el][org-exchange-capture.el]]
2288
2289 ** Audio/video file playback within org mode
2290
2291 Paul Sexton provided code that makes =file:= links to audio or video files
2292 (MP3, WAV, OGG, AVI, MPG, et cetera) play those files using the [[https://github.com/dbrock/bongo][Bongo]] Emacs
2293 media player library. The user can pause, skip forward and backward in the
2294 track, and so on from without leaving Emacs. Links can also contain a time
2295 after a double colon -- when this is present, playback will begin at that
2296 position in the track.
2297
2298 See the file [[file:code/elisp/org-player.el][org-player.el]]
2299
2300 ** Under X11 Keep a window with the current agenda items at all time
2301
2302 I struggle to keep (in emacs) a window with the agenda at all times.
2303 For a long time I have wanted a sticky window that keeps this
2304 information, and then use my window manager to place it and remove its
2305 decorations (I can also force its placement in the stack: top always,
2306 for example).
2307
2308 I wrote a small program in qt that simply monitors an HTML file and
2309 displays it. Nothing more. It does the work for me, and maybe somebody
2310 else will find it useful. It relies on exporting the agenda as HTML
2311 every time the org file is saved, and then this little program
2312 displays the html file. The window manager is responsible of removing
2313 decorations, making it sticky, and placing it in same place always.
2314
2315 Here is a screenshot (see window to the bottom right). The decorations
2316 are removed by the window manager:
2317
2318 http://turingmachine.org/hacking/org-mode/orgdisplay.png
2319
2320 Here is the code. As I said, very, very simple, but maybe somebody will
2321 find if useful.
2322
2323 http://turingmachine.org/hacking/org-mode/
2324
2325 --daniel german
2326
2327 ** Script (thru procmail) to output emails to an Org file
2328
2329 Tycho Garen sent [[http://comments.gmane.org/gmane.emacs.orgmode/44773][this]]: