mirrors
/
org-mode
mirror of https://git.savannah.gnu.org/git/emacs/org-mode.git
0
0
Fork 1
Code Releases Activity

Intermediate state, I am just trying comiting now.

This commit is contained in:
Carsten Dominik 2008-01-31 16:04:26 +01:00
parent 011a15f3a9
commit 93c665b56d
63 changed files with 84212 additions and 2824 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

348
BUGFIXING/org-log.el Normal file
View File

@ -0,0 +1,348 @@
(defun org-agenda-switch-to (&optional delete-other-windows)
"Go to the Org-mode file which contains the item at point."
(interactive)
(let ((cb (current-buffer))
(line (org-current-line))
(col (current-column))
(buf (current-buffer))
(pos (point)))
(with-current-buffer (get-buffer-create "OrgAgendaGotoLog")
(goto-char (point-max))
(insert "--------------------------------------------------------\n")
(insert (format "This command: %s\n" this-command))
(insert (format "Last command: %s\n" last-command))
(insert (format "Line/Column/Point: %d/%d/%d\n" line col pos))))
(orglog-describe-char (point))
(let* ((marker (or (get-text-property (point) 'org-marker)
(org-agenda-error)))
(buffer (marker-buffer marker))
(pos (marker-position marker)))
(switch-to-buffer buffer)
(and delete-other-windows (delete-other-windows))
(widen)
(goto-char pos)
(when (org-mode-p)
(org-show-context 'agenda)
(save-excursion
(and (outline-next-heading)
(org-flag-heading nil))))
(let ((cb (current-buffer))
(pos (point)))
(with-current-buffer (get-buffer-create "OrgAgendaGotoLog")
(goto-char (point-max))
(insert (format "Arrived: %s %d\n" cb pos))))))
(defun org-agenda-goto (&optional highlight)
"Go to the Org-mode file which contains the item at point."
(interactive)
(let ((cb (current-buffer))
(line (org-current-line))
(col (current-column))
(buf (current-buffer))
(pos (point)))
(with-current-buffer (get-buffer-create "OrgAgendaGotoLog")
(goto-char (point-max))
(insert "--------------------------------------------------------\n")
(insert (format "This command: %s\n" this-command))
(insert (format "Last command: %s\n" last-command))
(insert (format "Line/Column/Point: %d/%d/%d\n" line col pos))))
(orglog-describe-char (point))
(let* ((marker (or (get-text-property (point) 'org-marker)
(org-agenda-error)))
(buffer (marker-buffer marker))
(pos (marker-position marker)))
(switch-to-buffer-other-window buffer)
(widen)
(goto-char pos)
(when (org-mode-p)
(org-show-context 'agenda)
(save-excursion
(and (outline-next-heading)
(org-flag-heading nil)))) ; show the next heading
(run-hooks 'org-agenda-after-show-hook)
(and highlight (org-highlight (point-at-bol) (point-at-eol)))
(let ((cb (current-buffer))
(pos (point)))
(with-current-buffer (get-buffer-create "OrgAgendaGotoLog")
(goto-char (point-max))
(insert (format "Arrived: %s %d\n" cb pos))))))
(defun orglog-describe-char (pos)
"Describe the character after POS (interactively, the character after point).
The information includes character code, charset and code points in it,
syntax, category, how the character is encoded in a file,
character composition information (if relevant),
as well as widgets, buttons, overlays, and text properties."
(interactive "d")
(if (>= pos (point-max))
(error "No character follows specified position"))
(let* ((char (char-after pos))
(charset (char-charset char))
(composition (find-composition pos nil nil t))
(component-chars nil)
(display-table (or (window-display-table)
buffer-display-table
standard-display-table))
(disp-vector (and display-table (aref display-table char)))
(multibyte-p enable-multibyte-characters)
(overlays (mapcar #'(lambda (o) (overlay-properties o))
(overlays-at pos)))
(char-description (if (not multibyte-p)
(single-key-description char)
(if (< char 128)
(single-key-description char)
(string-to-multibyte
(char-to-string char)))))
(text-props-desc
(let ((tmp-buf (generate-new-buffer " *text-props*")))
(unwind-protect
(progn
(describe-text-properties pos tmp-buf)
(with-current-buffer tmp-buf (buffer-string)))
(kill-buffer tmp-buf))))
item-list max-width unicode)
(if (or (< char 256)
(memq 'mule-utf-8 (find-coding-systems-region pos (1+ pos)))
(get-char-property pos 'untranslated-utf-8))
(setq unicode (or (get-char-property pos 'untranslated-utf-8)
(encode-char char 'ucs))))
(setq item-list
`(("character"
,(format "%s (%d, #o%o, #x%x%s)"
(apply 'propertize char-description
(text-properties-at pos))
char char char
(if unicode
(format ", U+%04X" unicode)
"")))
("charset"
,`(insert-text-button
,(symbol-name charset)
'type 'help-character-set 'help-args '(,charset))
,(format "(%s)" (charset-description charset)))
("code point"
,(let ((split (split-char char)))
`(insert-text-button
,(if (= (charset-dimension charset) 1)
(format "#x%02X" (nth 1 split))
(format "#x%02X #x%02X" (nth 1 split)
(nth 2 split)))
'action (lambda (&rest ignore)
(list-charset-chars ',charset)
(with-selected-window
(get-buffer-window "*Character List*" 0)
(goto-char (point-min))
(forward-line 2) ;Skip the header.
(let ((case-fold-search nil))
(search-forward ,(char-to-string char)
nil t))))
'help-echo
"mouse-2, RET: show this character in its character set")))
("syntax"
,(let ((syntax (syntax-after pos)))
(with-temp-buffer
(internal-describe-syntax-value syntax)
(buffer-string))))
("category"
,@(let ((category-set (char-category-set char)))
(if (not category-set)
'("-- none --")
(mapcar #'(lambda (x) (format "%c:%s"
x (category-docstring x)))
(category-set-mnemonics category-set)))))
,@(let ((props (aref char-code-property-table char))
ps)
(when props
(while props
(push (format "%s:" (pop props)) ps)
(push (format "%s;" (pop props)) ps))
(list (cons "Properties" (nreverse ps)))))
("to input"
,@(let ((key-list (and (eq input-method-function
'quail-input-method)
(quail-find-key char))))
(if (consp key-list)
(list "type"
(mapconcat #'(lambda (x) (concat "\"" x "\""))
key-list " or ")
"with"
`(insert-text-button
,current-input-method
'type 'help-input-method
'help-args '(,current-input-method))))))
("buffer code"
,(encoded-string-description
(string-as-unibyte (char-to-string char)) nil))
("file code"
,@(let* ((coding buffer-file-coding-system)
(encoded (encode-coding-char char coding)))
(if encoded
(list (encoded-string-description encoded coding)
(format "(encoded by coding system %S)" coding))
(list "not encodable by coding system"
(symbol-name coding)))))
("display"
,(cond
(disp-vector
(setq disp-vector (copy-sequence disp-vector))
(dotimes (i (length disp-vector))
(setq char (aref disp-vector i))
(aset disp-vector i
(cons char (describe-char-display
pos (glyph-char char)))))
(format "by display table entry [%s] (see below)"
(mapconcat
#'(lambda (x)
(format "?%c" (glyph-char (car x))))
disp-vector " ")))
(composition
(let ((from (car composition))
(to (nth 1 composition))
(next (1+ pos))
(components (nth 2 composition))
ch)
(setcar composition
(and (< from pos) (buffer-substring from pos)))
(setcar (cdr composition)
(and (< next to) (buffer-substring next to)))
(dotimes (i (length components))
(if (integerp (setq ch (aref components i)))
(push (cons ch (describe-char-display pos ch))
component-chars)))
(setq component-chars (nreverse component-chars))
(format "composed to form \"%s\" (see below)"
(buffer-substring from to))))
(t
(let ((display (describe-char-display pos char)))
(if (display-graphic-p (selected-frame))
(if display
(concat
"by this font (glyph code)\n"
(format " %s (#x%02X)"
(car display) (cdr display)))
"no font available")
(if display
(format "terminal code %s" display)
"not encodable for terminal"))))))
,@(let ((face
(if (not (or disp-vector composition))
(cond
((and show-trailing-whitespace
(save-excursion (goto-char pos)
(looking-at "[ \t]+$")))
'trailing-whitespace)
((and nobreak-char-display unicode (eq unicode '#xa0))
'nobreak-space)
((and nobreak-char-display unicode (eq unicode '#xad))
'escape-glyph)
((and (< char 32) (not (memq char '(9 10))))
'escape-glyph)))))
(if face (list (list "hardcoded face"
`(insert-text-button
,(symbol-name face)
'type 'help-face 'help-args '(,face))))))
,@(let ((unicodedata (and unicode
(describe-char-unicode-data unicode))))
(if unicodedata
(cons (list "Unicode data" " ") unicodedata)))))
(setq max-width (apply #'max (mapcar #'(lambda (x)
(if (cadr x) (length (car x)) 0))
item-list)))
(with-current-buffer (get-buffer-create "OrgAgendaGotoLog")
(goto-char (point-max))
(set-buffer-multibyte multibyte-p)
(let ((formatter (format "%%%ds:" max-width)))
(dolist (elt item-list)
(when (cadr elt)
(insert (format formatter (car elt)))
(dolist (clm (cdr elt))
(if (eq (car-safe clm) 'insert-text-button)
(progn (insert " ") (eval clm))
(when (>= (+ (current-column)
(or (string-match "\n" clm)
(string-width clm))
1)
(window-width))
(insert "\n")
(indent-to (1+ max-width)))
(insert " " clm)))
(insert "\n"))))
(when overlays
(save-excursion
(goto-char (point-min))
(re-search-forward "character:[ \t\n]+")
(let* ((end (+ (point) (length char-description))))
(mapc #'(lambda (props)
(let ((o (make-overlay (point) end)))
(while props
(overlay-put o (car props) (nth 1 props))
(setq props (cddr props)))))
overlays))))
(when disp-vector
(insert
"\nThe display table entry is displayed by ")
(if (display-graphic-p (selected-frame))
(progn
(insert "these fonts (glyph codes):\n")
(dotimes (i (length disp-vector))
(insert (glyph-char (car (aref disp-vector i))) ?:
(propertize " " 'display '(space :align-to 5))
(if (cdr (aref disp-vector i))
(format "%s (#x%02X)" (cadr (aref disp-vector i))
(cddr (aref disp-vector i)))
"-- no font --")
"\n")
(let ((face (glyph-face (car (aref disp-vector i)))))
(when face
(insert (propertize " " 'display '(space :align-to 5))
"face: ")
(insert (concat "`" (symbol-name face) "'"))
(insert "\n")))))
(insert "these terminal codes:\n")
(dotimes (i (length disp-vector))
(insert (car (aref disp-vector i))
(propertize " " 'display '(space :align-to 5))
(or (cdr (aref disp-vector i)) "-- not encodable --")
"\n"))))
(when composition
(insert "\nComposed")
(if (car composition)
(if (cadr composition)
(insert " with the surrounding characters \""
(car composition) "\" and \""
(cadr composition) "\"")
(insert " with the preceding character(s) \""
(car composition) "\""))
(if (cadr composition)
(insert " with the following character(s) \""
(cadr composition) "\"")))
(insert " by the rule:\n\t("
(mapconcat (lambda (x)
(format (if (consp x) "%S" "?%c") x))
(nth 2 composition)
" ")
")")
(insert "\nThe component character(s) are displayed by ")
(if (display-graphic-p (selected-frame))
(progn
(insert "these fonts (glyph codes):")
(dolist (elt component-chars)
(insert "\n " (car elt) ?:
(propertize " " 'display '(space :align-to 5))
(if (cdr elt)
(format "%s (#x%02X)" (cadr elt) (cddr elt))
"-- no font --"))))
(insert "these terminal codes:")
(dolist (elt component-chars)
(insert "\n " (car elt) ":"
(propertize " " 'display '(space :align-to 5))
(or (cdr elt) "-- not encodable --"))))
(insert "\nSee the variable `reference-point-alist' for "
"the meaning of the rule.\n"))
(if text-props-desc (insert text-props-desc)))))

235
CONTRIB/org-depend.el Normal file
View File

@ -0,0 +1,235 @@
;;; org-depend.el --- TODO dependencies for Org-mode
;; This file is not part of GNU Emacs.
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; WARNING: This file is just a PROOF OF CONCEPT, not a supported part
;; of Org-mode.
;;
;; This is an example implementation of TODO dependencies in Org-mode.
;; It uses the new hooks in version 5.13 of Org-mode,
;; `org-trigger-hook' and `org-blocker-hook'.
;;
;; It implements the following:
;;
;; Triggering
;; ----------
;;
;; 1) If an entry contains a TRIGGER property that contains the string
;; "chain-siblings(KEYWORD)", then switching that entry to DONE does
;; do the following:
;; - The sibling following this entry switched to todo-state KEYWORD.
;; - The sibling also gets a TRIGGER property "chain-sibling(KEYWORD)",
;; property, to make sure that, when *it* is DONE, the chain will
;; continue.
;;
;; 2) If the TRIGGER property contains any other words like
;; XYZ(KEYWORD), these are treated as entry id's with keywords. That
;; means, Org-mode will search for an entry with the ID property XYZ
;; and switch that entry to KEYWORD as well.
;;
;; Blocking
;; --------
;;
;; 1) If an entry contains a BLOCKER property that contains the word
;; "previous-sibling", the sibling above the current entry is
;; checked when you try to mark it DONE. If it is still in a TODO
;; state, the current state change is blocked.
;;
;; 2) If the BLOCKER property contains any other words, these are
;; treated as entry id's. That means, Org-mode will search for an
;; entry with the ID property exactly equal to this word. If any
;; of these entries is not yet marked DONE, the current state change
;; will be blocked.
;;
;; 3) Whenever a state change is blocked, an org-mark is pushed, so that
;; you can find the offending entry with `C-c &'.
;;
;;; Example:
;;
;; When trying this example, make sure that the settings for TODO keywords
;; have been activated, i.e. include the following line and press C-c C-c
;; on the line before working with the example:
;;
;; #+TYP_TODO: TODO NEXT | DONE
;;
;; * TODO Win a million in Las Vegas
;; The "third" TODO (see above) cannot become a TODO without this money.
;;
;; :PROPERTIES:
;; :ID: I-cannot-do-it-without-money
;; :END:
;;
;; * Do this by doing a chain of TODO's
;; ** NEXT This is the first in this chain
;; :PROPERTIES:
;; :TRIGGER: chain-siblings(NEXT)
;; :END:
;;
;; ** This is the second in this chain
;;
;; ** This is the third in this chain
;; :PROPERTIES:
;; :BLOCKER: I-cannot-do-it-without-money
;; :END:
;;
;; ** This is the forth in this chain
;; When this is DONE, we will also trigger entry XYZ-is-my-id
;; :PROPERTIES:
;; :TRIGGER: XYZ-is-my-id(TODO)
;; :END:
;;
;; ** This is the fifth in this chain
;;
;; * Start writing report
;; :PROPERTIES:
;; :ID: XYZ-is-my-id
;; :END:
;;
;;
(require 'org)
(defun org-depend-trigger-todo (change-plist)
"Trigger new TODO entries after the current is switched to DONE.
This does two different kinds of triggers:
- If the current entry contains a TRIGGER property that contains
\"chain-siblings(KEYWORD)\", it goes to the next sibling, marks it
KEYWORD and also installs the \"chain-sibling\" trigger to continue
the chain.
- Any other word (space-separated) like XYZ(KEYWORD) in the TRIGGER
property is seen as an entry id. Org-mode finds the entry with the
corresponding ID property and switches it to the state TODO as well."
;; Get information from the plist
(let* ((type (plist-get change-plist :type))
(pos (plist-get change-plist :position))
(from (plist-get change-plist :from))
(to (plist-get change-plist :to))
(org-log-done nil) ; IMPROTANT!: no logging during automatic trigger!
trigger triggers tr p1 kwd)
(catch 'return
(unless (eq type 'todo-state-change)
;; We are only handling todo-state-change....
(throw 'return t))
(unless (and (member from org-not-done-keywords)
(member to org-done-keywords))
;; This is not a change from TODO to DONE, ignore it
(throw 'return t))
;; OK, we just switched from a TODO state to a DONE state
;; Lets see if this entry has a TRIGGER property.
;; If yes, split it up on whitespace.
(setq trigger (org-entry-get pos "TRIGGER")
triggers (and trigger (org-split-string trigger "[ \t]+")))
;; Go through all the triggers
(while (setq tr (pop triggers))
(cond
((string-match "\\`chain-siblings(\\(.*?\\))\\'" tr)
;; This is a TODO chain of siblings
(setq kwd (match-string 1 tr))
(catch 'exit
(save-excursion
(goto-char pos)
;; find the sibling, exit if no more siblings
(condition-case nil
(outline-forward-same-level 1)
(error (throw 'exit t)))
;; mark the sibling TODO
(org-todo kwd)
;; make sure the sibling will continue the chain
(org-entry-add-to-multivalued-property
nil "TRIGGER" (format "chain-siblings(%s)" kwd)))))
((string-match "\\`\\(\\S-+\\)(\\(.*?\\))\\'" tr)
;; This seems to be ENTRY_ID(KEYWORD)
(setq id (match-string 1 tr)
kwd (match-string 2 tr)
p1 (org-find-entry-with-id id))
(when p1
;; there is an entry with this ID, mark it TODO
(save-excursion
(goto-char p1)
(org-todo kwd)))))))))
(defun org-depend-block-todo (change-plist)
"Block turning an entry into a TODO.
This checks for a BLOCKER property in an entry and checks
all the entries listed there. If any of them is not done,
block changing the current entry into a TODO entry. If the property contains
the word \"previous-sibling\", the sibling above the current entry is checked.
Any other words are treated as entry id's. If an entry exists with the
this ID property, that entry is also checked."
;; Get information from the plist
(let* ((type (plist-get change-plist :type))
(pos (plist-get change-plist :position))
(from (plist-get change-plist :from))
(to (plist-get change-plist :to))
(org-log-done nil) ; IMPROTANT!: no logging during automatic trigger
blocker blockers bl p1)
(catch 'return
(unless (eq type 'todo-state-change)
;; We are not handling this kind of change
(throw 'return t))
(unless (and (not from) (member to org-not-done-keywords))
;; This is not a change from nothing to TODO, ignore it
(throw 'return t))
;; OK, the plan is to switch from nothing to TODO
;; Lets see if we will allow it. Find the BLOCKER property
;; and split it on whitespace.
(setq blocker (org-entry-get pos "BLOCKER")
blockers (and blocker (org-split-string blocker "[ \t]+")))
;; go through all the blockers
(while (setq bl (pop blockers))
(cond
((equal bl "previous-sibling")
;; the sibling is required to be DONE.
(catch 'ignore
(save-excursion
(goto-char pos)
;; find the older sibling, exit if no more siblings
(condition-case nil
(outline-backward-same-level 1)
(error (throw 'ignore t)))
;; Check if this entry is not yet done and block
(unless (org-entry-is-done-p)
;; return nil, to indicate that we block the change!
(org-mark-ring-push)
(throw 'return nil)))))
((setq p1 (org-find-entry-with-id bl))
;; there is an entry with this ID, check it out
(save-excursion
(goto-char p1)
(unless (org-entry-is-done-p)
;; return nil, to indicate that we block the change!
(org-mark-ring-push)
(throw 'return nil))))))
t ; return t to indicate that we are not blocking
)))
(add-hook 'org-trigger-hook 'org-depend-trigger-todo)
(add-hook 'org-blocker-hook 'org-depend-block-todo)
;;; org-depend.el ends here

33
CONTRIB/org-export-freemind-0.1.0/ChangeLog Executable file
View File

@ -0,0 +1,33 @@
2007-06-25 Marco Vezzoli <noise dot otn at alice dot it>
* org-export-freemind-install.el (org-export-as-freemind):
- created installation file
2007-06-25 Marco Vezzoli <noise dot otn at alice dot it>
* org-export-freemind.el (org-export-as-freemind):
- created customization variables for org-freemind-icons-alist and
org-freemind-cloud-alist
- fixed export bug to handle level jump (e.g. a * followed by a ***)
- added keybinding 'C-c C-x f' org-export-as-freemind
2007-06-02 Marco Vezzoli <noise dot otn at alice dot it>
* org-export-freemind.el (org-export-as-freemind):
- fixed conversion bug: all headings are converted inserting html
entities
- added configuration with org-freemind-icons-alist: an alist that
allows to associate regexp with builtins freemind icons
- added configuration with org-freemind-cloud-alist: an alist that
allows to associate regexp with cloud colors
- added org-export-as-freemind-agenda-files : exports all agenda
files in separate files with the same name and extension .mm
- added org-export-as-freemind-agenda-files-one-file : do the same
but grouping all trees in a single file

50
CONTRIB/org-export-freemind-0.1.0/README Executable file
View File

@ -0,0 +1,50 @@
The project
-----------
This is an extension to emacs Org Mode [1] to export into FreeMind
[2], two very valuable productivity tools.
This code is donated to both porjects and is distributable under any
of the copyright notices of these.
Current status of the code is alpha: use it at your own
risk. Nonetheless I'm happy to support user of this code as far as I
can.
Install
-------
Before use this code please verify you have Org Mode correctly
installed in your emacs.
Installation:
copy all *.el files into the org installation directory.
add the following line to your .emacs
(require org-export-freemind-install)
This will define the following functions:
org-export-as-freemind: export current buffer into a freemind file
with the same name, placed in the XOXO publishing directory
org-export-as-freemind-agenda-files: export all agenda files into
separate freemind files, placed on the XOXO publishing directory
org-export-as-freemind-agenda-files-one-file: export all agenda files
into a single freemind file
also the following variables are set
org-freemind-icons-alist: an alist which associates regexp with
freemind builtin icons
org-freemind-cloud-alist: an alist which associates regexp with
freemind cloud colors (rrggbb hex notation)
Todos
-----
- try to export html parts
[1] http://staff.science.uva.nl/~dominik/Tools/org/
[2] http://freemind.sourceforge.net/wiki/index.php/Main_Page

7
CONTRIB/org-export-freemind-0.1.0/org-export-freemind-install.el Executable file
View File

@ -0,0 +1,7 @@
(autoload 'org-export-as-freemind "org-export-freemind"
"export a single org file in freemind format" t)
(autoload 'org-export-as-freemind-agenda-files "org-export-freemind"
"export all agenda files file in freemind format" t)
(autoload 'org-export-as-freemind-agenda-files-one-file "org-export-freemind"
"export all agenda files file in freemind format into a single file" t)
(provide 'org-export-freemind-install)

196
CONTRIB/org-export-freemind-0.1.0/org-export-freemind.el Executable file
View File

@ -0,0 +1,196 @@
;;; org-export-freemind - exporting utilities from org-mode to freemind
;; Copyright (C) 2007 Marco Vezzoli
;; Author: marco vezzoli <noise.otn@alice.it>
;; Created:
;; Version: 0.1.0
;; Keywords: org-mode export freemind
;; Commentary:
;; This file is *not* part of GNU Emacs.
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2 of
;; the License, or (at your option) any later version.
;; This program is distributed in the hope that it will be
;; useful, but WITHOUT ANY WARRANTY; without even the implied
;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;; PURPOSE. See the GNU General Public License for more details.
;; You should have received a copy of the GNU General Public
;; License along with this program; if not, write to the Free
;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301 USA
;;; Code:
(defgroup org-export-freemind ()
"This group let you customize your own export into freemind format"
:group 'org-export)
(defcustom org-freemind-icons-alist
'(("TODO" . "button_cancel")
("SPEC" . "pencil")
("WIP" . "pencil")
("TEST" . "xmag")
("DONE" . "button_ok"))
"change the icon according to a regular expression"
:type '(alist :key-type regexp
:value-type string)
:group 'org-export-freemind)
(defcustom org-freemind-cloud-alist
'((":PROJECT:" . "ccffcc")
(":MEETING:" . "ccccff"))
"create a cloud with the defined color if title match a regexp"
:type '(alist :key-type regexp :value-type string)
:group 'org-export-freemind)
(defun org-export-as-freemind (&optional buffer outbuffer)
"Export the org buffer as FreeMind XML.
"
(interactive (list (current-buffer) ()))
;; A quickie abstraction
;; Output everything as FreeMind
(with-current-buffer (get-buffer buffer)
(goto-char (point-min)) ;; CD: beginning-of-buffer is not allowed.
(let* ((opt-plist (org-combine-plists (org-default-export-plist)
(org-infile-export-plist)))
(title (or (plist-get opt-plist :title)
(file-name-sans-extension
(file-name-nondirectory buffer-file-name))))
(filename (concat (file-name-as-directory
(org-export-directory :xoxo opt-plist))
title
".mm"))
(out (if (bufferp outbuffer)
outbuffer
(find-file-noselect filename)))
(last-level 0)
(hanging-li nil))
;; Check the output buffer is empty.
;; Kick off the output
(unless (bufferp outbuffer)
(progn
(with-current-buffer out (erase-buffer))
(org-export-as-xoxo-insert-into out "<map version='0.8.0'>\n")))
(org-export-as-xoxo-insert-into out
"<node TEXT='" title "'"
(if (bufferp outbuffer)
" FOLDED='true'" "")
">\n")
(if (bufferp outbuffer)
(org-export-as-xoxo-insert-into out "<cloud COLOR='#ccffff'/>\n"))
(while (re-search-forward "^\\(\\*+\\) \\(.+\\)" (point-max) 't)
(let* ((hd (match-string-no-properties 1))
(level (length hd))
(text (match-string-no-properties 2)))
(save-excursion
(goto-char (match-end 0))
(catch 'loop
(while 't
(forward-line)
(if (looking-at "^[ \t]\\(.*\\)")
()
(throw 'loop "")))))
;; Handle level rendering
(cond
((> level last-level)
(let ((rept (- level last-level 1))
(value ()))
(dotimes (i rept value)
(org-export-as-xoxo-insert-into out "<node FOLDED='false' TEXT='.'>\n")))
(org-export-as-xoxo-insert-into out "\n<node FOLDED='true' TEXT='"))
((< level last-level)
(let ((rept (+ (- last-level level) 1))
(value ()))
(dotimes (i rept value)
(org-export-as-xoxo-insert-into out "</node>\n")))
(org-export-as-xoxo-insert-into out "<node FOLDED='true' TEXT='"))
((equal level last-level)
(org-export-as-xoxo-insert-into out "</node>\n<node FOLDED='true' TEXT='")))
(setq last-level level)
;; And output the new node
(let* ((heading
(concat "<html><h3>"
(replace-regexp-in-string
":.*:"
(lambda (x)
(concat "<font color='red'>" x "</font>"))
text)
"</h3></html>"))
(html-quoted-heading (org-html-expand heading))
(exp-quote-heading (replace-regexp-in-string "'" "&quot;" html-quoted-heading)))
(org-export-as-xoxo-insert-into out exp-quote-heading "'>\n"))
(dolist (rule org-freemind-icons-alist)
(if (string-match (car rule) text)
(org-export-as-xoxo-insert-into out "<icon BUILTIN='" (cdr rule) "'/>\n")))
(dolist (rule org-freemind-cloud-alist)
(when (string-match (car rule) text)
(progn
(org-export-as-xoxo-insert-into out
"<cloud COLOR='#" (cdr rule) "'/>\n")
(message (cdr rule))
)))
))
;; Finally finish off the map
(let ((value ()))
(org-export-as-xoxo-insert-into out "\n")
(dotimes (i last-level value)
(org-export-as-xoxo-insert-into out "</node>\n")))
(org-export-as-xoxo-insert-into out "</node>\n")
;; Finish the buffer off and clean it up.
(unless (bufferp outbuffer)
(progn
(org-export-as-xoxo-insert-into out "</map>\n")
(switch-to-buffer-other-window out)
(indent-region (point-min) (point-max) nil)
(save-buffer)
(goto-char (point-min))
)))))
(defun org-export-as-freemind-agenda-files ()
"Export all agenda files into Freemind format
each files is saved with .mm extension
into the XOXO publishing directory"
(interactive)
(dolist (file org-agenda-files)
(org-check-agenda-file file)
(set-buffer (org-get-agenda-file-buffer file))
(org-export-as-freemind (current-buffer))
))
(defun org-export-as-freemind-agenda-files-one-file (filename)
"Export all agenda files into FreeMind format.
All results are grouped in a single .mm file"
(interactive "FFile to save: ")
(let* ((title (file-name-sans-extension
(file-name-nondirectory filename)))
(out (find-file-noselect filename)))
(with-current-buffer out (erase-buffer))
(org-export-as-xoxo-insert-into out "<map version='0.8.0'><node TEXT='" title "'>\n")
(dolist (file org-agenda-files)
(org-check-agenda-file file)
(set-buffer (org-get-agenda-file-buffer file))
(org-export-as-freemind (current-buffer) out)
)
(org-export-as-xoxo-insert-into out "</node></map>\n")
(switch-to-buffer-other-window out)
(indent-region (point-min) (point-max) nil)
(save-buffer)
(goto-char (point-min))
))
(define-key org-mode-map "\C-c\C-xf" 'org-export-as-freemind)
;;; org-export-freemind ends here

196
CONTRIB/org-export-freemind.el Normal file
View File

@ -0,0 +1,196 @@
;;; org-export-freemind - exporting utilities from org-mode to freemind
;; Copyright (C) 2007 Marco Vezzoli
;; Author: marco vezzoli <noise.otn@alice.it>
;; Created:
;; Version: 0.1.0
;; Keywords: org-mode export freemind
;; Commentary:
;; This file is *not* part of GNU Emacs.
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2 of
;; the License, or (at your option) any later version.
;; This program is distributed in the hope that it will be
;; useful, but WITHOUT ANY WARRANTY; without even the implied
;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;; PURPOSE. See the GNU General Public License for more details.
;; You should have received a copy of the GNU General Public
;; License along with this program; if not, write to the Free
;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301 USA
;;; Code:
(defgroup org-export-freemind ()
"This group let you customize your own export into freemind format"
:group 'org-export)
(defcustom org-freemind-icons-alist
'(("TODO" . "button_cancel")
("SPEC" . "pencil")
("WIP" . "pencil")
("TEST" . "xmag")
("DONE" . "button_ok"))
"change the icon according to a regular expression"
:type '(alist :key-type regexp
:value-type string)
:group 'org-export-freemind)
(defcustom org-freemind-cloud-alist
'((":PROJECT:" . "ccffcc")
(":MEETING:" . "ccccff"))
"create a cloud with the defined color if title match a regexp"
:type '(alist :key-type regexp :value-type string)
:group 'org-export-freemind)
(defun org-export-as-freemind (&optional buffer outbuffer)
"Export the org buffer as FreeMind XML.
"
(interactive (list (current-buffer) ()))
;; A quickie abstraction
;; Output everything as FreeMind
(with-current-buffer (get-buffer buffer)
(goto-char (point-min)) ;; CD: beginning-of-buffer is not allowed.
(let* ((opt-plist (org-combine-plists (org-default-export-plist)
(org-infile-export-plist)))
(title (or (plist-get opt-plist :title)
(file-name-sans-extension
(file-name-nondirectory buffer-file-name))))
(filename (concat (file-name-as-directory
(org-export-directory :xoxo opt-plist))
title
".mm"))
(out (if (bufferp outbuffer)
outbuffer
(find-file-noselect filename)))
(last-level 0)
(hanging-li nil))
;; Check the output buffer is empty.
;; Kick off the output
(unless (bufferp outbuffer)
(progn
(with-current-buffer out (erase-buffer))
(org-export-as-xoxo-insert-into out "<map version='0.8.0'>\n")))
(org-export-as-xoxo-insert-into out
"<node TEXT='" title "'"
(if (bufferp outbuffer)
" FOLDED='true'" "")
">\n")
(if (bufferp outbuffer)
(org-export-as-xoxo-insert-into out "<cloud COLOR='#ccffff'/>\n"))
(while (re-search-forward "^\\(\\*+\\) \\(.+\\)" (point-max) 't)
(let* ((hd (match-string-no-properties 1))
(level (length hd))
(text (match-string-no-properties 2)))
(save-excursion
(goto-char (match-end 0))
(catch 'loop
(while 't
(forward-line)
(if (looking-at "^[ \t]\\(.*\\)")
()
(throw 'loop "")))))
;; Handle level rendering
(cond
((> level last-level)
(let ((rept (- level last-level 1))
(value ()))
(dotimes (i rept value)
(org-export-as-xoxo-insert-into out "<node FOLDED='false' TEXT='.'>\n")))
(org-export-as-xoxo-insert-into out "\n<node FOLDED='true' TEXT='"))
((< level last-level)
(let ((rept (+ (- last-level level) 1))
(value ()))
(dotimes (i rept value)
(org-export-as-xoxo-insert-into out "</node>\n")))
(org-export-as-xoxo-insert-into out "<node FOLDED='true' TEXT='"))
((equal level last-level)
(org-export-as-xoxo-insert-into out "</node>\n<node FOLDED='true' TEXT='")))
(setq last-level level)
;; And output the new node
(let* ((heading
(concat "<html><h3>"
(replace-regexp-in-string
":.*:"
(lambda (x)
(concat "<font color='red'>" x "</font>"))
text)
"</h3></html>"))
(html-quoted-heading (org-html-expand heading))
(exp-quote-heading (replace-regexp-in-string "'" "&quot;" html-quoted-heading)))
(org-export-as-xoxo-insert-into out exp-quote-heading "'>\n"))
(dolist (rule org-freemind-icons-alist)
(if (string-match (car rule) text)
(org-export-as-xoxo-insert-into out "<icon BUILTIN='" (cdr rule) "'/>\n")))
(dolist (rule org-freemind-cloud-alist)
(when (string-match (car rule) text)
(progn
(org-export-as-xoxo-insert-into out
"<cloud COLOR='#" (cdr rule) "'/>\n")
(message (cdr rule))
)))
))
;; Finally finish off the map
(let ((value ()))
(org-export-as-xoxo-insert-into out "\n")
(dotimes (i last-level value)
(org-export-as-xoxo-insert-into out "</node>\n")))
(org-export-as-xoxo-insert-into out "</node>\n")
;; Finish the buffer off and clean it up.
(unless (bufferp outbuffer)
(progn
(org-export-as-xoxo-insert-into out "</map>\n")
(switch-to-buffer-other-window out)
(indent-region (point-min) (point-max) nil)
(save-buffer)
(goto-char (point-min))
)))))
(defun org-export-as-freemind-agenda-files ()
"Export all agenda files into Freemind format
each files is saved with .mm extension
into the XOXO publishing directory"
(interactive)
(dolist (file org-agenda-files)
(org-check-agenda-file file)
(set-buffer (org-get-agenda-file-buffer file))
(org-export-as-freemind (current-buffer))
))
(defun org-export-as-freemind-agenda-files-one-file (filename)
"Export all agenda files into FreeMind format.
All results are grouped in a single .mm file"
(interactive "FFile to save: ")
(let* ((title (file-name-sans-extension
(file-name-nondirectory filename)))
(out (find-file-noselect filename)))
(with-current-buffer out (erase-buffer))
(org-export-as-xoxo-insert-into out "<map version='0.8.0'><node TEXT='" title "'>\n")
(dolist (file org-agenda-files)
(org-check-agenda-file file)
(set-buffer (org-get-agenda-file-buffer file))
(org-export-as-freemind (current-buffer) out)
)
(org-export-as-xoxo-insert-into out "</node></map>\n")
(switch-to-buffer-other-window out)
(indent-region (point-min) (point-max) nil)
(save-buffer)
(goto-char (point-min))
))
(define-key org-mode-map "\C-c\C-xf" 'org-export-as-freemind)
;;; org-export-freemind ends here

153
CONTRIB/org-mairix.el Normal file
View File

@ -0,0 +1,153 @@
;;; org-mairix.el ---
;; Copyright 2007 Bastien Guerry
;;
;; Author: Bastien.Guerry@ens.fr
;; Version: $Id: org-mairix.el,v 0.0 2007/08/11 17:23:40 guerry Exp $
;; Keywords:
;; X-URL: not distributed yet
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;; Commentary:
;; Code and ideas from Carsten Dominik, Adam Spiers and Georg C. F. Greve.
;; Put this file into your load-path and the following into your ~/.emacs:
;; (require 'org-mairix)
;;; Code:
(require 'org)
(defgroup org-mairix nil
"Mairix link support for Org."
:tag "Org Mairix"
:group 'org)
(defcustom mairix-results-group "nnmaildir+index:mfolder"
"Gnus groupe where to list mairix search results."
:group 'org-mairix
:type '(string))
(defun org-add-link-type (type &optional follow publish)
"Add TYPE to the list of `org-link-types'.
Re-compute all regular expressions depending on `org-link-types'."
(add-to-list 'org-link-types type t)
(setq org-link-re-with-space
(concat
"<?\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
"\\([^" org-non-link-chars " ]"
"[^" org-non-link-chars "]*"
"[^" org-non-link-chars " ]\\)>?"))
(setq org-link-re-with-space2
(concat
"<?\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
"\\([^" org-non-link-chars " ]"
"[^]\t\n\r]*"
"[^" org-non-link-chars " ]\\)>?"))
(setq org-angle-link-re
(concat
"<\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
"\\([^" org-non-link-chars " ]"
"[^" org-non-link-chars "]*"
"\\)>"))
(setq org-plain-link-re
(concat
"\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
"\\([^]\t\n\r<>,;() ]+\\)"))
(setq org-bracket-link-analytic-regexp
(concat
"\\[\\["
"\\(\\(" (mapconcat 'identity org-link-types "\\|") "\\):\\)?"
"\\([^]]+\\)"
"\\]"
"\\(\\[" "\\([^]]+\\)" "\\]\\)?"
"\\]"))
(add-hook 'org-follow-link-functions follow)
(add-hook 'org-publish-link-functions publish))
(defun org-mairix-follow-link (path)
"Follow a Mairix link."
(require 'gnus)
(funcall (cdr (assq 'gnus org-link-frame-setup)))
(if gnus-other-frame-object (select-frame gnus-other-frame-object))
(mairix-search path))
(defun org-mairix-publish-link (path)
"Convert mairix PATH into a (dummy) raw link."
;; FIXME: should we have a format argument for HTML/LaTeX publishing?
(if (string-match org-bracket-link-analytic-regexp path)
(match-string 5 path) path))
(defun org-mairix-store-link (path)
"Store a mairix link."
(when (memq major-mode '(gnus-summary-mode gnus-article-mode))
(let* ((group gnus-newsgroup-name)
(article (gnus-summary-article-number))
(header (gnus-summary-article-header article))
(from (mail-header-from header))
(message-id (mail-header-id header))
(date (mail-header-date header))
(subject (gnus-summary-subject-string)))
(org-store-link-props :type "mairix"
:from from
:subject subject
:message-id message-id
:group group)
;; FIXME: what about cpltxt and link vars we used so far?
;; (setq cpltxt (org-email-link-description))
;; (setq link (org-make-link "mairix:m:"
;; (substring message-id 1 -1))))))
(org-make-link "mairix:m:" (substring message-id 1 -1)))))
;; mairix internals
(defun mairix-result-evaluate (string)
"Display search results of previous mairix process."
(let ((mmatches (string-to-number (substring string 7 -8))))
(if (eq mmatches 0)
(message "Mairix returned no matches, sorry.")
(message "Mairix returned %d matches." mmatches)
(gnus-group-quick-select-group 0 mairix-results-group)
(gnus-summary-reselect-current-group t t))))
(org-add-link-type "mairix"
'org-mairix-follow-link
'org-mairix-publish-link)
(add-hook 'org-store-link-functions 'org-mairix-store-link)
(defun mairix-search (string)
"Uses mairix to search through my mail, replacing current search results."
(interactive "MMairix search: ")
(mairix-result-evaluate
(shell-command-to-string (concat "mairix " string))))
(provide 'org-mairix)
(eval-when-compile
(require 'cl))
;;;;##########################################################################
;;;; User Options, Variables
;;;;##########################################################################
;;; org-mairix.el ends here

39
CONTRIB/org-man.el Normal file
View File

@ -0,0 +1,39 @@
;;; org-man.el - Support for links to manpages in Org-mode
(require 'org)
(org-add-link-type "man" 'org-man-open)
(add-hook 'org-store-link-functions 'org-man-store-link)
(defcustom org-man-command 'man
"The Emacs command to be used to display a man page."
:group 'org-link
:type '(choice (const man) (const woman)))
(defun org-man-open (path)
"Visit the manpage on PATH.
PATH should be a topic that can be thrown at the man command."
(funcall org-man-command path))
(defun org-man-store-link ()
"Store a link to a README file."
(when (memq major-mode '(Man-mode woman-mode))
;; This is a man page, we do make this link
(let* ((page (org-man-get-page-name))
(link (concat "man:" page))
(description (format "Manpage for %s" page)))
(org-store-link-props
:type "man"
:link link
:description description))))
(defun org-man-get-page-name ()
"Extract the page name from the buffer name."
;; This works for both `Man-mode' and `woman-mode'.
(if (string-match " \\(\\S-+\\)\\*" (buffer-name))
(match-string 1 (buffer-name))
(error "Cannot create link to this man page")))
(provide 'org-man)
;;; org-man.el ends here

488
CONTRIB/org-toc.el Normal file
View File

@ -0,0 +1,488 @@
;;; org-toc.el --- Table of contents for Org-mode buffer
;; Copyright 2007 Bastien Guerry
;;
;; Author: Bastien Guerry <bzg AT altern DOT org>
;; Keywords: Org table of contents
;; Homepage: http://www.cognition.ens.fr/~guerry/u/org-toc.el
;; Version: 0.8
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;; Commentary:
;; This library implements a browsable table of contents for Org files.
;; Put this file into your load-path and the following into your ~/.emacs:
;; (require 'org-toc)
;;; Code:
(provide 'org-toc)
(eval-when-compile
(require 'cl))
;;; Custom variables:
(defvar org-toc-base-buffer nil)
(defvar org-toc-columns-shown nil)
(defvar org-toc-odd-levels-only nil)
(defvar org-toc-config-alist nil)
(defvar org-toc-cycle-global-status nil)
(defalias 'org-show-table-of-contents 'org-toc-show)
(defgroup org-toc nil
"Options concerning the browsable table of contents of Org-mode."
:tag "Org TOC"
:group 'org)
(defcustom org-toc-default-depth 1
"Default depth when invoking `org-toc-show' without argument."
:group 'org-toc
:type '(choice
(const :tag "same as base buffer" nil)
(integer :tag "level")))
(defcustom org-toc-follow-mode nil
"Non-nil means navigating through the table of contents will
move the point in the Org buffer accordingly."
:group 'org-toc
:type 'boolean)
(defcustom org-toc-info-mode nil
"Non-nil means navigating through the table of contents will
show the properties for the current headline in the echo-area."
:group 'org-toc
:type 'boolean)
(defcustom org-toc-show-subtree-mode nil
"Non-nil means show subtree when going to headline or following
it while browsing the table of contents."
:group 'org-toc
:type '(choice
(const :tag "show subtree" t)
(const :tag "show entry" nil)))
(defcustom org-toc-recenter-mode t
"Non-nil means recenter the Org buffer when following the
headlines in the TOC buffer."
:group 'org-toc
:type 'boolean)
(defcustom org-toc-recenter 0
"Where to recenter the Org buffer when unfolding a subtree.
This variable is only used when `org-toc-recenter-mode' is set to
'custom. A value >=1000 will call recenter with no arg."
:group 'org-toc
:type 'integer)
(defcustom org-toc-info-exclude '("ALLTAGS")
"A list of excluded properties when displaying info in the
echo-area. The COLUMNS property is always exluded."
:group 'org-toc
:type 'lits)
;;; Org TOC mode:
(defvar org-toc-mode-map (make-sparse-keymap)
"Keymap for `org-toc-mode'.")
(defun org-toc-mode ()
"A major mode for browsing the table of contents of an Org buffer.
\\{org-toc-mode-map}"
(interactive)
(kill-all-local-variables)
(use-local-map org-toc-mode-map)
(setq mode-name "Org TOC")
(setq major-mode 'org-toc-mode))
;; toggle modes
(define-key org-toc-mode-map "f" 'org-toc-follow-mode)
(define-key org-toc-mode-map "S" 'org-toc-show-subtree-mode)
(define-key org-toc-mode-map "s" 'org-toc-store-config)
(define-key org-toc-mode-map "g" 'org-toc-restore-config)
(define-key org-toc-mode-map "i" 'org-toc-info-mode)
(define-key org-toc-mode-map "r" 'org-toc-recenter-mode)
;; navigation keys
(define-key org-toc-mode-map "p" 'org-toc-previous)
(define-key org-toc-mode-map "n" 'org-toc-next)
(define-key org-toc-mode-map [(left)] 'org-toc-previous)
(define-key org-toc-mode-map [(right)] 'org-toc-next)
(define-key org-toc-mode-map [(up)] 'org-toc-previous)
(define-key org-toc-mode-map [(down)] 'org-toc-next)
(define-key org-toc-mode-map "1" (lambda() (interactive) (org-toc-show 1 (point))))
(define-key org-toc-mode-map "2" (lambda() (interactive) (org-toc-show 2 (point))))
(define-key org-toc-mode-map "3" (lambda() (interactive) (org-toc-show 3 (point))))
(define-key org-toc-mode-map "4" (lambda() (interactive) (org-toc-show 4 (point))))
(define-key org-toc-mode-map " " 'org-toc-goto)
(define-key org-toc-mode-map "q" 'org-toc-quit)
(define-key org-toc-mode-map "x" 'org-toc-quit)
;; go to the location and stay in the base buffer
(define-key org-toc-mode-map [(tab)] 'org-toc-jump)
(define-key org-toc-mode-map "v" 'org-toc-jump)
;; go to the location and delete other windows
(define-key org-toc-mode-map [(return)]
(lambda() (interactive) (org-toc-jump t)))
;; special keys
(define-key org-toc-mode-map "c" 'org-toc-columns)
(define-key org-toc-mode-map "?" 'org-toc-help)
(define-key org-toc-mode-map ":" 'org-toc-cycle-subtree)
(define-key org-toc-mode-map "\C-c\C-o" 'org-open-at-point)
;; global cycling in the base buffer
(define-key org-toc-mode-map (kbd "C-S-<iso-lefttab>")
'org-toc-cycle-base-buffer)
;; subtree cycling in the base buffer
(define-key org-toc-mode-map [(control tab)]
(lambda() (interactive) (org-toc-goto nil t)))
;;; Toggle functions:
(defun org-toc-follow-mode ()
"Toggle follow mode in a `org-toc-mode' buffer."
(interactive)
(setq org-toc-follow-mode (not org-toc-follow-mode))
(message "Follow mode is %s"
(if org-toc-follow-mode "on" "off")))
(defun org-toc-info-mode ()
"Toggle info mode in a `org-toc-mode' buffer."
(interactive)
(setq org-toc-info-mode (not org-toc-info-mode))
(message "Info mode is %s"
(if org-toc-info-mode "on" "off")))
(defun org-toc-show-subtree-mode ()
"Toggle show subtree mode in a `org-toc-mode' buffer."
(interactive)
(setq org-toc-show-subtree-mode (not org-toc-show-subtree-mode))
(message "Show subtree mode is %s"
(if org-toc-show-subtree-mode "on" "off")))
(defun org-toc-recenter-mode (&optional line)
"Toggle recenter mode in a `org-toc-mode' buffer. If LINE is
specified, then make `org-toc-recenter' use this value."
(interactive "P")
(setq org-toc-recenter-mode (not org-toc-recenter-mode))
(when (numberp line)
(setq org-toc-recenter-mode t)
(setq org-toc-recenter line))
(message "Recenter mode is %s"
(if org-toc-recenter-mode
(format "on, line %d" org-toc-recenter) "off")))
(defun org-toc-cycle-subtree ()
"Locally cycle a headline through two states: 'children and
'folded"
(interactive)
(let ((beg (point))
(end (save-excursion (end-of-line) (point)))
(ov (car (org-overlays-at (point))))
status)
(if ov (setq status (org-overlay-get ov 'status))
(setq ov (org-make-overlay beg end)))
;; change the folding status of this headline
(cond ((or (null status) (eq status 'folded))
(show-children)
(message "CHILDREN")
(org-overlay-put ov 'status 'children))
((eq status 'children)
(show-branches)
(message "BRANCHES")
(org-overlay-put ov 'status 'branches))
(t (hide-subtree)
(message "FOLDED")
(org-overlay-put ov 'status 'folded)))))
;;; Main show function:
;; FIXME name this org-before-first-heading-p?
(defun org-toc-before-first-heading-p ()
"Before first heading?"
(save-excursion
(null (re-search-backward "^\\*+ " nil t))))
;;;###autoload
(defun org-toc-show (&optional depth position)
"Show the table of contents of the current Org-mode buffer."
(interactive "P")
(if (org-mode-p)
(progn (setq org-toc-base-buffer (current-buffer))
(setq org-toc-odd-levels-only org-odd-levels-only))
(if (eq major-mode 'org-toc-mode)
(switch-to-buffer org-toc-base-buffer)
(error "Not in an Org buffer")))
;; create the new window display
(let ((pos (or position
(save-excursion
(if (org-toc-before-first-heading-p)
(progn (re-search-forward "^\\*+ " nil t)
(match-beginning 0))
(point))))))
(setq org-toc-cycle-global-status org-cycle-global-status)
(delete-other-windows)
(and (get-buffer "*org-toc*") (kill-buffer "*org-toc*"))
(switch-to-buffer-other-window
(make-indirect-buffer org-toc-base-buffer "*org-toc*"))
;; make content before 1st headline invisible
(goto-char (point-min))
(let* ((beg (point-min))
(end (and (re-search-forward "^\\*" nil t)
(1- (match-beginning 0))))
(ov (org-make-overlay beg end))
(help (format "Table of contents for %s (press ? for a quick help):\n"
(buffer-name org-toc-base-buffer))))
(org-overlay-put ov 'invisible t)
(org-overlay-put ov 'before-string help))
;; build the browsable TOC
(cond (depth
(let* ((dpth (if org-toc-odd-levels-only
(1- (* depth 2)) depth)))
(org-content dpth)
(setq org-toc-cycle-global-status
`(org-content ,dpth))))
((null org-toc-default-depth)
(if (eq org-toc-cycle-global-status 'overview)
(progn (org-overview)
(setq org-cycle-global-status 'overview)
(run-hook-with-args 'org-cycle-hook 'overview))
(progn (org-overview)
;; FIXME org-content to show only headlines?
(org-content)
(setq org-cycle-global-status 'contents)
(run-hook-with-args 'org-cycle-hook 'contents))))
(t (let* ((dpth0 org-toc-default-depth)
(dpth (if org-toc-odd-levels-only
(1- (* dpth0 2)) dpth0)))
(org-content dpth)
(setq org-toc-cycle-global-status
`(org-content ,dpth)))))
(goto-char pos))
(move-beginning-of-line nil)
(org-toc-mode)
(shrink-window-if-larger-than-buffer)
(setq buffer-read-only t))
;;; Navigation functions:
(defun org-toc-goto (&optional jump cycle)
"From Org TOC buffer, follow the targeted subtree in the Org window.
If JUMP is non-nil, go to the base buffer.
If JUMP is 'delete, go to the base buffer and delete other windows.
If CYCLE is non-nil, cycle the targeted subtree in the Org window."
(interactive)
(let ((pos (point))
(toc-buf (current-buffer)))
(switch-to-buffer-other-window org-toc-base-buffer)
(goto-char pos)
(if cycle (org-cycle)
(progn (org-overview)
(if org-toc-show-subtree-mode
(org-show-subtree)
(org-show-entry))
(org-show-context)))
(if org-toc-recenter-mode
(if (>= org-toc-recenter 1000) (recenter)
(recenter org-toc-recenter)))
(cond ((null jump)
(switch-to-buffer-other-window toc-buf))
((eq jump 'delete)
(delete-other-windows)))))
(defun org-toc-cycle-base-buffer ()
"Call `org-cycle' with a prefix argument in the base buffer."
(interactive)
(switch-to-buffer-other-window org-toc-base-buffer)
(org-cycle t)
(other-window 1))
(defun org-toc-jump (&optional delete)
"From Org TOC buffer, jump to the targeted subtree in the Org window.
If DELETE is non-nil, delete other windows when in the Org buffer."
(interactive "P")
(if delete (org-toc-goto 'delete)
(org-toc-goto t)))
(defun org-toc-previous ()
"Go to the previous headline of the TOC."
(interactive)
(if (save-excursion
(beginning-of-line)
(re-search-backward "^\\*" nil t))
(outline-previous-visible-heading 1)
(message "No previous heading"))
(if org-toc-info-mode (org-toc-info))
(if org-toc-follow-mode (org-toc-goto)))
(defun org-toc-next ()
"Go to the next headline of the TOC."
(interactive)
(outline-next-visible-heading 1)
(if org-toc-info-mode (org-toc-info))
(if org-toc-follow-mode (org-toc-goto)))
(defun org-toc-quit ()
"Quit the current Org TOC buffer."
(interactive)
(kill-this-buffer)
(other-window 1)
(delete-other-windows))
;;; Special functions:
(defun org-toc-columns ()
"Toggle columns view in the Org buffer from Org TOC."
(interactive)
(let ((indirect-buffer (current-buffer)))
(switch-to-buffer org-toc-base-buffer)
(if (not org-toc-columns-shown)
(progn (org-columns)
(setq org-toc-columns-shown t))
(progn (org-columns-remove-overlays)
(setq org-toc-columns-shown nil)))
(switch-to-buffer indirect-buffer)))
(defun org-toc-info ()
"Show properties of current subtree in the echo-area."
(interactive)
(let ((pos (point))
(indirect-buffer (current-buffer))
props prop msg)
(switch-to-buffer org-toc-base-buffer)
(goto-char pos)
(setq props (org-entry-properties))
(while (setq prop (pop props))
(unless (or (equal (car prop) "COLUMNS")
(member (car prop) org-toc-info-exclude))
(let ((p (car prop))
(v (cdr prop)))
(if (equal p "TAGS")
(setq v (mapconcat 'identity (split-string v ":" t) " ")))
(setq p (concat p ":"))
(add-text-properties 0 (length p) '(face org-special-keyword) p)
(setq msg (concat msg p " " v " ")))))
(switch-to-buffer indirect-buffer)
(message msg)))
;;; Store and restore TOC configuration:
(defun org-toc-store-config ()
"Store the current status of the tables of contents in
`org-toc-config-alist'."
(interactive)
(let ((file (buffer-file-name org-toc-base-buffer))
(pos (point))
(hlcfg (org-toc-get-headlines-status)))
(setq org-toc-config-alist
(delete (assoc file org-toc-config-alist)
org-toc-config-alist))
(add-to-list 'org-toc-config-alist
`(,file ,pos ,org-toc-cycle-global-status ,hlcfg))
(message "TOC configuration saved: (%s)"
(if (listp org-toc-cycle-global-status)
(concat "org-content "
(number-to-string
(cadr org-toc-cycle-global-status)))
(symbol-name org-toc-cycle-global-status)))))
(defun org-toc-restore-config ()
"Get the stored status in `org-toc-config-alist' and set the
current table of contents to it."
(interactive)
(let* ((file (buffer-file-name org-toc-base-buffer))
(conf (cdr (assoc file org-toc-config-alist)))
(pos (car conf))
(status (cadr conf))
(hlcfg (caddr conf)) hlcfg0 ov)
(cond ((listp status)
(org-toc-show (cadr status) (point)))
((eq status 'overview)
(org-overview)
(setq org-cycle-global-status 'overview)
(run-hook-with-args 'org-cycle-hook 'overview))
(t
(org-overview)
(org-content)
(setq org-cycle-global-status 'contents)
(run-hook-with-args 'org-cycle-hook 'contents)))
(while (setq hlcfg0 (pop hlcfg))
(save-excursion
(goto-char (point-min))
(when (search-forward (car hlcfg0) nil t)
(unless (org-overlays-at (match-beginning 0))
(setq ov (org-make-overlay (match-beginning 0)
(match-end 0))))
(cond ((eq (cdr hlcfg0) 'children)
(show-children)
(message "CHILDREN")
(org-overlay-put ov 'status 'children))
((eq (cdr hlcfg0) 'branches)
(show-branches)
(message "BRANCHES")
(org-overlay-put ov 'status 'branches))))))
(goto-char pos)
(if org-toc-follow-mode (org-toc-goto))
(message "Last TOC configuration restored")
(sit-for 1)
(if org-toc-info-mode (org-toc-info))))
(defun org-toc-get-headlines-status ()
"Return an alist of headlines and their associated folding
status."
(let (output ovs)
(save-excursion
(goto-char (point-min))
(while (and (not (eobp))
(goto-char (next-overlay-change (point))))
(when (looking-at "^\\*+ ")
(add-to-list
'output
(cons (buffer-substring-no-properties
(match-beginning 0)
(save-excursion
(end-of-line) (point)))
(overlay-get
(car (overlays-at (point))) 'status))))))
;; return an alist like (("* Headline" . 'status))
output))
;; In Org TOC buffer, hide headlines below the first level.
(defun org-toc-help ()
"Display a quick help message in the echo-area for `org-toc-mode'."
(interactive)
(let ((st-start 0)
(help-message
"\[space\] show heading \[1-4\] hide headlines below this level
\[TAB\] jump to heading \[f\] toggle follow mode (currently %s)
\[return\] jump and delete others windows \[i\] toggle info mode (currently %s)
\[S-TAB\] cycle subtree (in Org) \[S\] toggle show subtree mode (currently %s)
\[C-S-TAB\] global cycle (in Org) \[r\] toggle recenter mode (currently %s)
\[:\] cycle subtree (in TOC) \[c\] toggle column view (currently %s)
\[n/p\] next/previous heading \[s\] save TOC configuration
\[q\] quit the TOC \[g\] restore last TOC configuration"))
(while (string-match "\\[[^]]+\\]" help-message st-start)
(add-text-properties (match-beginning 0)
(match-end 0) '(face bold) help-message)
(setq st-start (match-end 0)))
(message help-message
(if org-toc-follow-mode "on" "off")
(if org-toc-info-mode "on" "off")
(if org-toc-show-subtree-mode "on" "off")
(if org-toc-recenter-mode (format "on, line %s" org-toc-recenter) "off")
(if org-toc-columns-shown "on" "off"))))
;;;;##########################################################################
;;;; User Options, Variables
;;;;##########################################################################
;;; org-toc.el ends here

41
ChangeLog
View File

@ -1,13 +1,46 @@
2008-01-26 Carsten Dominik <dominik@science.uva.nl>
* org.el (org-archive-all-done): Fixed incorrect number of stars
in regexp.
2008-01-25 Carsten Dominik <dominik@science.uva.nl>
* org.el (org-refile-get-location): New function.
(org-refile-goto-last-stored): New function.
(org-global-tags-completion-table): Add the value of org-tag-alist
in each buffer, to make sure that also unused tags will be
available for completion.
2008-01-24 Carsten Dominik <dominik@carsten-dominiks-macbook-pro.local>
* org.el (org-columns-edit-value)
(org-columns-next-allowed-value): Only update if not in agenda.
2008-01-22 Carsten Dominik <dominik@science.uva.nl>
* org.el (org-clocktable-steps): New function.
(org-dblock-write:clocktable): Call `org-clocktable-steps'.
(org-archive-subtree): Add the outline tree context as a
property.
(org-closest-date): New optional argument `prefer'.
(org-goto-auto-isearch): New option.
(org-goto-map, org-get-location): Implement auto-isearch.
(org-goto-local-auto-isearch-map): New variable.
(org-goto-local-search-forward-headings)
(org-goto-local-auto-isearch): New functions
-----------------------------------------------------------------------
Installed as 5.19a
2008-01-18 Carsten Dominik <dominik@science.uva.nl>
* org.el (org-entry-properties): Include the CLOCKSUM special
property.
(org-columns-edit-value): Do not allow to edit the special
CLOCKSUM property.
2008-01-15 Carsten Dominik <dominik@science.uva.nl>
* org.el (org-flag-drawer): Use the original value of
(org-flag-drawer): Use the original value of
`outline-regexp'.
(org-remember-handler): Add invisible-ok flag to call to
`org-end-of-subtree'

3
EXPERIMENTAL/find-links-to-local.el Normal file
View File

@ -0,0 +1,3 @@
(defun org-find-links ()
(let* ((file (buffer-file-name))
(tname (file-truename file)))

328
EXPERIMENTAL/interactive-query/org-interactive-query.patch.txt Normal file
View File

@ -0,0 +1,328 @@
--- org-vendor/org.el 2008-01-06 10:30:26.000000000 -0500
+++ org/org.el 2008-01-12 17:19:15.000000000 -0500
@@ -15078,7 +15078,8 @@
(let ((org-last-tags-completion-table
(org-global-tags-completion-table)))
(setq match (completing-read
- "Match: " 'org-tags-completion-function nil nil nil
+ "Match: " 'org-tags-completion-function nil nil
+ org-agenda-query-string
'org-tags-history))))
;; Parse the string and create a lisp form
@@ -18812,6 +18813,7 @@
(defvar org-agenda-follow-mode nil)
(defvar org-agenda-show-log nil)
(defvar org-agenda-redo-command nil)
+(defvar org-agenda-query-string nil)
(defvar org-agenda-mode-hook nil)
(defvar org-agenda-type nil)
(defvar org-agenda-force-single-file nil)
@@ -18947,6 +18949,10 @@
(org-defkey org-agenda-mode-map [(right)] 'org-agenda-later)
(org-defkey org-agenda-mode-map [(left)] 'org-agenda-earlier)
(org-defkey org-agenda-mode-map "\C-c\C-x\C-c" 'org-agenda-columns)
+(org-defkey org-agenda-mode-map "=" 'org-agenda-query-clear-cmd)
+(org-defkey org-agenda-mode-map "/" 'org-agenda-query-and-cmd)
+(org-defkey org-agenda-mode-map ";" 'org-agenda-query-or-cmd)
+(org-defkey org-agenda-mode-map "\\" 'org-agenda-query-not-cmd)
(defvar org-agenda-keymap (copy-keymap org-agenda-mode-map)
"Local keymap for agenda entries from Org-mode.")
@@ -20423,9 +20429,10 @@
(setq matcher (org-make-tags-matcher match)
match (car matcher) matcher (cdr matcher))
(org-prepare-agenda (concat "TAGS " match))
+ (setq org-agenda-query-string match)
(setq org-agenda-redo-command
(list 'org-tags-view (list 'quote todo-only)
- (list 'if 'current-prefix-arg nil match)))
+ (list 'if 'current-prefix-arg nil 'org-agenda-query-string)))
(setq files (org-agenda-files)
rtnall nil)
(while (setq file (pop files))
@@ -20461,7 +20468,7 @@
(add-text-properties pos (1- (point)) (list 'face 'org-warning))
(setq pos (point))
(unless org-agenda-multi
- (insert "Press `C-u r' to search again with new search string\n"))
+ (insert "Press `C-u r' to enter new search string; use `/;\\=' to adjust interactively\n"))
(add-text-properties pos (1- (point)) (list 'face 'org-agenda-structure)))
(when rtnall
(insert (org-finalize-agenda-entries rtnall) "\n"))
@@ -20471,6 +20478,275 @@
(org-finalize-agenda)
(setq buffer-read-only t)))
+;;; Agenda interactive query manipulation
+
+(defcustom org-agenda-query-selection-single-key t
+ "Non-nil means, query manipulation exits after first change.
+When nil, you have to press RET to exit it.
+During query selection, you can toggle this flag with `C-c'.
+This variable can also have the value `expert'. In this case, the window
+displaying the tags menu is not even shown, until you press C-c again."
+ :group 'org-agenda
+ :type '(choice
+ (const :tag "No" nil)
+ (const :tag "Yes" t)
+ (const :tag "Expert" expert)))
+
+(defun org-agenda-query-selection (current op table &optional todo-table)
+ "Fast query manipulation with single keys.
+CURRENT is the current query string, OP is the initial
+operator (one of \"+|-=\"), TABLE is an alist of tags and
+corresponding keys, possibly with grouping information.
+TODO-TABLE is a similar table with TODO keywords, should these
+have keys assigned to them. If the keys are nil, a-z are
+automatically assigned. Returns the new query string, or nil to
+not change the current one."
+ (let* ((fulltable (append table todo-table))
+ (maxlen (apply 'max (mapcar
+ (lambda (x)
+ (if (stringp (car x)) (string-width (car x)) 0))
+ fulltable)))
+ (fwidth (+ maxlen 3 1 3))
+ (ncol (/ (- (window-width) 4) fwidth))
+ (expert (eq org-agenda-query-selection-single-key 'expert))
+ (exit-after-next org-agenda-query-selection-single-key)
+ (done-keywords org-done-keywords)
+ tbl char cnt e groups ingroup
+ tg c2 c c1 ntable rtn)
+ (save-window-excursion
+ (if expert
+ (set-buffer (get-buffer-create " *Org tags*"))
+ (delete-other-windows)
+ (split-window-vertically)
+ (org-switch-to-buffer-other-window (get-buffer-create " *Org tags*")))
+ (erase-buffer)
+ (org-set-local 'org-done-keywords done-keywords)
+ (insert "Query: " current "\n")
+ (org-agenda-query-op-line op)
+ (insert "\n\n")
+ (org-fast-tag-show-exit exit-after-next)
+ (setq tbl fulltable char ?a cnt 0)
+ (while (setq e (pop tbl))
+ (cond
+ ((equal e '(:startgroup))
+ (push '() groups) (setq ingroup t)
+ (when (not (= cnt 0))
+ (setq cnt 0)
+ (insert "\n"))
+ (insert "{ "))
+ ((equal e '(:endgroup))
+ (setq ingroup nil cnt 0)
+ (insert "}\n"))
+ (t
+ (setq tg (car e) c2 nil)
+ (if (cdr e)
+ (setq c (cdr e))
+ ;; automatically assign a character.
+ (setq c1 (string-to-char
+ (downcase (substring
+ tg (if (= (string-to-char tg) ?@) 1 0)))))
+ (if (or (rassoc c1 ntable) (rassoc c1 table))
+ (while (or (rassoc char ntable) (rassoc char table))
+ (setq char (1+ char)))
+ (setq c2 c1))
+ (setq c (or c2 char)))
+ (if ingroup (push tg (car groups)))
+ (setq tg (org-add-props tg nil 'face
+ (cond
+ ((not (assoc tg table))
+ (org-get-todo-face tg))
+ (t nil))))
+ (if (and (= cnt 0) (not ingroup)) (insert " "))
+ (insert "[" c "] " tg (make-string
+ (- fwidth 4 (length tg)) ?\ ))
+ (push (cons tg c) ntable)
+ (when (= (setq cnt (1+ cnt)) ncol)
+ (insert "\n")
+ (if ingroup (insert " "))
+ (setq cnt 0)))))
+ (setq ntable (nreverse ntable))
+ (insert "\n")
+ (goto-char (point-min))
+ (if (and (not expert) (fboundp 'fit-window-to-buffer))
+ (fit-window-to-buffer))
+ (setq rtn
+ (catch 'exit
+ (while t
+ (message "[a-z..]:Toggle [SPC]:clear [RET]:accept [TAB]:free%s%s"
+ (if groups " [!] no groups" " [!]groups")
+ (if expert " [C-c]:window" (if exit-after-next " [C-c]:single" " [C-c]:multi")))
+ (setq c (let ((inhibit-quit t)) (read-char-exclusive)))
+ (cond
+ ((= c ?\r) (throw 'exit t))
+ ((= c ?!)
+ (setq groups (not groups))
+ (goto-char (point-min))
+ (while (re-search-forward "[{}]" nil t) (replace-match " ")))
+ ((= c ?\C-c)
+ (if (not expert)
+ (org-fast-tag-show-exit
+ (setq exit-after-next (not exit-after-next)))
+ (setq expert nil)
+ (delete-other-windows)
+ (split-window-vertically)
+ (org-switch-to-buffer-other-window " *Org tags*")
+ (and (fboundp 'fit-window-to-buffer)
+ (fit-window-to-buffer))))
+ ((or (= c ?\C-g)
+ (and (= c ?q) (not (rassoc c ntable))))
+ (setq quit-flag t))
+ ((= c ?\ )
+ (setq current "")
+ (if exit-after-next (setq exit-after-next 'now)))
+ ((= c ?\[) ; clear left
+ (org-agenda-query-decompose current)
+ (setq current (concat "/" (match-string 2 current)))
+ (if exit-after-next (setq exit-after-next 'now)))
+ ((= c ?\]) ; clear right
+ (org-agenda-query-decompose current)
+ (setq current (match-string 1 current))
+ (if exit-after-next (setq exit-after-next 'now)))
+ ((= c ?\t)
+ (condition-case nil
+ (setq current (read-string "Query: " current))
+ (quit))
+ (if exit-after-next (setq exit-after-next 'now)))
+ ;; operators
+ ((or (= c ?/) (= c ?+)) (setq op "+"))
+ ((or (= c ?\;) (= c ?|)) (setq op "|"))
+ ((or (= c ?\\) (= c ?-)) (setq op "-"))
+ ((= c ?=) (setq op "="))
+ ;; todos
+ ((setq e (rassoc c todo-table) tg (car e))
+ (setq current (org-agenda-query-manip
+ current op groups 'todo tg))
+ (if exit-after-next (setq exit-after-next 'now)))
+ ;; tags
+ ((setq e (rassoc c ntable) tg (car e))
+ (setq current (org-agenda-query-manip
+ current op groups 'tag tg))
+ (if exit-after-next (setq exit-after-next 'now))))
+ (if (eq exit-after-next 'now) (throw 'exit t))
+ (goto-char (point-min))
+ (beginning-of-line 1)
+ (delete-region (point) (point-at-eol))
+ (insert "Query: " current)
+ (beginning-of-line 2)
+ (delete-region (point) (point-at-eol))
+ (org-agenda-query-op-line op)
+ (goto-char (point-min)))))
+ (if rtn current nil))))
+
+(defun org-agenda-query-op-line (op)
+ (insert "Operator: "
+ (org-agenda-query-op-entry (equal op "+") "/+" "and")
+ (org-agenda-query-op-entry (equal op "|") ";|" "or")
+ (org-agenda-query-op-entry (equal op "-") "\\-" "not")
+ (org-agenda-query-op-entry (equal op "=") "=" "clear")))
+
+(defun org-agenda-query-op-entry (matchp chars str)
+ (if matchp
+ (org-add-props (format "[%s %s] " chars (upcase str))
+ nil 'face 'org-todo)
+ (format "[%s]%s " chars str)))
+
+(defun org-agenda-query-decompose (current)
+ (string-match "\\([^/]*\\)/?\\(.*\\)" current))
+
+(defun org-agenda-query-clear (current prefix tag)
+ (if (string-match (concat prefix "\\b" (regexp-quote tag) "\\b") current)
+ (replace-match "" t t current)
+ current))
+
+(defun org-agenda-query-manip (current op groups kind tag)
+ "Apply an operator to a query string and a tag.
+CURRENT is the current query string, OP is the operator, GROUPS is a
+list of lists of tags that are mutually exclusive. KIND is 'tag for a
+regular tag, or 'todo for a TODO keyword, and TAG is the tag or
+keyword string."
+ ;; If this tag is already in query string, remove it.
+ (setq current (org-agenda-query-clear current "[-\\+&|]?" tag))
+ (if (equal op "=") current
+ ;; When using AND, also remove mutually exclusive tags.
+ (if (equal op "+")
+ (loop for g in groups do
+ (if (member tag g)
+ (mapc (lambda (x)
+ (setq current
+ (org-agenda-query-clear current "\\+" x)))
+ g))))
+ ;; Decompose current query into q1 (tags) and q2 (TODOs).
+ (org-agenda-query-decompose current)
+ (let* ((q1 (match-string 1 current))
+ (q2 (match-string 2 current)))
+ (cond
+ ((eq kind 'tag)
+ (concat q1 op tag "/" q2))
+ ;; It's a TODO; when using AND, drop all other TODOs.
+ ((equal op "+")
+ (concat q1 "/+" tag))
+ (t
+ (concat q1 "/" q2 op tag))))))
+
+(defun org-agenda-query-global-todo-keys (&optional files)
+ "Return alist of all TODO keywords and their fast keys, in all FILES."
+ (let (alist)
+ (unless (and files (car files))
+ (setq files (org-agenda-files)))
+ (save-excursion
+ (loop for f in files do
+ (set-buffer (find-file-noselect f))
+ (loop for k in org-todo-key-alist do
+ (setq alist (org-agenda-query-merge-todo-key
+ alist k)))))
+ alist))
+
+(defun org-agenda-query-merge-todo-key (alist entry)
+ (let (e)
+ (cond
+ ;; if this is not a keyword (:startgroup, etc), ignore it
+ ((not (stringp (car entry))))
+ ;; if keyword already exists, replace char if it's null
+ ((setq e (assoc (car entry) alist))
+ (when (null (cdr e)) (setcdr e (cdr entry))))
+ ;; if char already exists, prepend keyword but drop char
+ ((rassoc (cdr entry) alist)
+ (error "TRACE POSITION 2")
+ (setq alist (cons (cons (car entry) nil) alist)))
+ ;; else, prepend COPY of entry
+ (t
+ (setq alist (cons (cons (car entry) (cdr entry)) alist)))))
+ alist)
+
+(defun org-agenda-query-generic-cmd (op)
+ "Activate query manipulation with OP as initial operator."
+ (let ((q (org-agenda-query-selection org-agenda-query-string op
+ org-tag-alist
+ (org-agenda-query-global-todo-keys))))
+ (when q
+ (setq org-agenda-query-string q)
+ (org-agenda-redo))))
+
+(defun org-agenda-query-clear-cmd ()
+ "Activate query manipulation, to clear a tag from the string."
+ (interactive)
+ (org-agenda-query-generic-cmd "="))
+
+(defun org-agenda-query-and-cmd ()
+ "Activate query manipulation, initially using the AND (+) operator."
+ (interactive)
+ (org-agenda-query-generic-cmd "+"))
+
+(defun org-agenda-query-or-cmd ()
+ "Activate query manipulation, initially using the OR (|) operator."
+ (interactive)
+ (org-agenda-query-generic-cmd "|"))
+
+(defun org-agenda-query-not-cmd ()
+ "Activate query manipulation, initially using the NOT (-) operator."
+ (interactive)
+ (org-agenda-query-generic-cmd "-"))
+
;;; Agenda Finding stuck projects
(defvar org-agenda-skip-regexp nil

28057
EXPERIMENTAL/interactive-query/org.el Normal file
View File

File diff suppressed because it is too large Load Diff

10836
org_xemacs.el → EXPERIMENTAL/interactive-query/org.el.orig
View File

File diff suppressed because it is too large Load Diff

70
EXPERIMENTAL/john.el Normal file
View File

@ -0,0 +1,70 @@
(require 'org-install)
(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
(define-key mode-specific-map [?a] 'org-agenda)
(eval-after-load "org"
'(progn
(define-prefix-command 'org-todo-state-map)
(define-key org-mode-map "\C-cx" 'org-todo-state-map)
(define-key org-todo-state-map "x"
#'(lambda nil (interactive) (org-todo "CANCELLED")))
(define-key org-todo-state-map "d"
#'(lambda nil (interactive) (org-todo "DONE")))
(define-key org-todo-state-map "f"
#'(lambda nil (interactive) (org-todo "DEFERRED")))
(define-key org-todo-state-map "l"
#'(lambda nil (interactive) (org-todo "DELEGATED")))
(define-key org-todo-state-map "s"
#'(lambda nil (interactive) (org-todo "STARTED")))
(define-key org-todo-state-map "w"
#'(lambda nil (interactive) (org-todo "WAITING")))
(define-key org-agenda-mode-map "\C-n" 'next-line)
(define-key org-agenda-keymap "\C-n" 'next-line)
(define-key org-agenda-mode-map "\C-p" 'previous-line)
(define-key org-agenda-keymap "\C-p" 'previous-line)))
(require 'remember)
(add-hook 'remember-mode-hook 'org-remember-apply-template)
(define-key global-map [(control meta ?r)] 'remember)
(custom-set-variables
'(org-agenda-files (quote ("~/todo.org")))
'(org-default-notes-file "~/notes.org")
'(org-agenda-ndays 7)
'(org-deadline-warning-days 14)
'(org-agenda-show-all-dates t)
'(org-agenda-skip-deadline-if-done t)
'(org-agenda-skip-scheduled-if-done t)
'(org-agenda-start-on-weekday nil)
'(org-reverse-note-order t)
'(org-fast-tag-selection-single-key (quote expert))
'(org-agenda-custom-commands
(quote (("d" todo "DELEGATED" nil)
("c" todo "DONE|DEFERRED|CANCELLED" nil)
("w" todo "WAITING" nil)
("W" agenda "" ((org-agenda-ndays 21)))
("A" agenda ""
((org-agenda-skip-function
(lambda nil
(org-agenda-skip-entry-if (quote notregexp) "\\=.*\\[#A\\]")))
(org-agenda-ndays 1)
(org-agenda-overriding-header "Today's Priority #A tasks: ")))
("u" alltodo ""
((org-agenda-skip-function
(lambda nil
(org-agenda-skip-entry-if (quote scheduled) (quote deadline)
(quote regexp) "<[^>\n]+>")))
(org-agenda-overriding-header "Unscheduled TODO entries: "))))))
'(org-remember-store-without-prompt t)
'(org-remember-templates
(quote ((116 "* TODO %?\n %u" "./todo.txt" "Tasks")
(110 "* %u %?" "./notes.txt" "Notes"))))
'(remember-annotation-functions (quote (org-remember-annotation)))
'(remember-handler-functions (quote (org-remember-handler))))

154
EXPERIMENTAL/org-bibtex.el Normal file
View File

@ -0,0 +1,154 @@
;;; org-bibtex.el --- Org links to BibTeX entries
;;
;; Copyright 2007 Bastien Guerry
;;
;; Author: bzg AT altern DOT org
;; Version: 0.2
;; Keywords: org, wp, remember
;; URL: http://www.cognition.ens.fr/~guerry/u/org-bibtex.el
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;
;;; Commentary:
;;
;; The Org mode already lets you store/insert links to BibTeX entries.
;;
;; But what if you want to insert the author or the title of a BibTeX
;; item in a *remember* buffer? This library lets you deal with this
;; by adding more properties to the BibTeX link.
;;
;; The available properties for each entry are listed here:
;;
;; :author :publisher :volume :pages
;; :editor :url :number :journal
;; :title :year :series :address
;; :booktitle :month :annote :abstract
;; :key :btype
;;
;; Here is an example of a remember template that use some of this
;; information (:author :year :title :journal :pages):
;;
;; (setq org-remember-templates
;; '((?b "* READ %?\n\n%a\n\n%:author (%:year): %:title\n \
;; In %:journal, %:pages.")))
;;
;; Let's say you want to remember this BibTeX entry:
;;
;; @Article{dolev83,
;; author = {Danny Dolev and Andrew C. Yao},
;; title = {On the security of public-key protocols},
;; journal = {IEEE Transaction on Information Theory},
;; year = 1983,
;; volume = 2,
;; number = 29,
;; pages = {198--208},
;; month = {Mars}
;; }
;;
;; M-x `org-remember' on this entry will produce this buffer:
;;
;; =====================================================================
;; * READ <== [point here]
;;
;; [[file:/file.bib::dolev83][Dolev & Yao 1983: security of public key protocols]]
;;
;; Danny Dolev and Andrew C. Yao (1983): On the security of public-key protocols
;; In IEEE Transaction on Information Theory, 198--208.
;; =====================================================================
;;
;;; History:
;;
;; This piece of code was inspired by a request of Austin Frank:
;; http://article.gmane.org/gmane.emacs.orgmode/4112
;;
;; Put this file into your load-path and the following into your ~/.emacs:
;; (require 'org-bibtex)
;;; Code:
(provide 'org-bibtex)
(require 'org)
(defvar description nil) ; dynamically scoped in org.el
(org-add-link-type "bibtex" 'org-bibtex-open)
(add-hook 'org-store-link-functions 'org-bibtex-store-link)
;; (defun org-bibtex-publish (path)
;; "Build the description of the BibTeX entry for publishing."
;; (let* ((search (when (string-match "::\\(.+\\)\\'" path)
;; (match-string 1 path)))
;; (path (substring path 0 (match-beginning 0)))
;; key)
;; (with-temp-buffer
;; (org-open-file path t nil search)
;; (setq key (org-create-file-search-functions)))
;; (or description key)))
(defun org-bibtex-open (path)
"Visit the bibliography entry on PATH."
(let* ((search (when (string-match "::\\(.+\\)\\'" path)
(match-string 1 path)))
(path (substring path 0 (match-beginning 0))))
(org-open-file path t nil search)))
(defun org-bibtex-store-link ()
"Store a link to a BibTeX entry."
(when (eq major-mode 'bibtex-mode)
(let* ((search (run-hook-with-args-until-success
'org-create-file-search-functions))
(link (concat "file:" (abbreviate-file-name buffer-file-name)
"::" search))
(entry (mapcar ; repair strings enclosed in "..." or {...}
(lambda(c)
(if (string-match
"^\\(?:{\\|\"\\)\\(.*\\)\\(?:}\\|\"\\)$" (cdr c))
(cons (car c) (match-string 1 (cdr c))) c))
(save-excursion
(bibtex-beginning-of-entry)
(bibtex-parse-entry)))))
(org-store-link-props
:key (cdr (assoc "=key=" entry))
:author (or (cdr (assoc "author" entry)) "[no author]")
:editor (or (cdr (assoc "editor" entry)) "[no editor]")
:title (or (cdr (assoc "title" entry)) "[no title]")
:booktitle (or (cdr (assoc "booktitle" entry)) "[no booktitle]")
:journal (or (cdr (assoc "journal" entry)) "[no journal]")
:publisher (or (cdr (assoc "publisher" entry)) "[no publisher]")
:pages (or (cdr (assoc "pages" entry)) "[no pages]")
:url (or (cdr (assoc "url" entry)) "[no url]")
:year (or (cdr (assoc "year" entry)) "[no year]")
:month (or (cdr (assoc "month" entry)) "[no month]")
:address (or (cdr (assoc "address" entry)) "[no address]")
:volume (or (cdr (assoc "volume" entry)) "[no volume]")
:number (or (cdr (assoc "number" entry)) "[no number]")
:annote (or (cdr (assoc "annote" entry)) "[no annotation]")
:series (or (cdr (assoc "series" entry)) "[no series]")
:abstract (or (cdr (assoc "abstract" entry)) "[no abstract]")
:btype (or (cdr (assoc "=type=" entry)) "[no type]")
:type "bibtex"
:link link
:description description))))
(provide 'org-bibtex)
;;;;##########################################################################
;;;; User Options, Variables
;;;;##########################################################################
;;; org-bibtex.el ends here

235
EXPERIMENTAL/org-depend.el Normal file
View File

@ -0,0 +1,235 @@
;;; org-depend.el --- TODO dependencies for Org-mode
;; This file is not part of GNU Emacs.
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; WARNING: This file is just a PROOF OF CONCEPT, not a supported part
;; of Org-mode.
;;
;; This is an example implementation of TODO dependencies in Org-mode.
;; It uses the new hooks in version 5.13 of Org-mode,
;; `org-trigger-hook' and `org-blocker-hook'.
;;
;; It implements the following:
;;
;; Triggering
;; ----------
;;
;; 1) If an entry contains a TRIGGER property that contains the string
;; "chain-siblings(KEYWORD)", then switching that entry to DONE does
;; do the following:
;; - The sibling following this entry switched to todo-state KEYWORD.
;; - The sibling also gets a TRIGGER property "chain-sibling(KEYWORD)",
;; property, to make sure that, when *it* is DONE, the chain will
;; continue.
;;
;; 2) If the TRIGGER property contains any other words like
;; XYZ(KEYWORD), these are treated as entry id's with keywords. That
;; means, Org-mode will search for an entry with the ID property XYZ
;; and switch that entry to KEYWORD as well.
;;
;; Blocking
;; --------
;;
;; 1) If an entry contains a BLOCKER property that contains the word
;; "previous-sibling", the sibling above the current entry is
;; checked when you try to mark it DONE. If it is still in a TODO
;; state, the current state change is blocked.
;;
;; 2) If the BLOCKER property contains any other words, these are
;; treated as entry id's. That means, Org-mode will search for an
;; entry with the ID property exactly equal to this word. If any
;; of these entries is not yet marked DONE, the current state change
;; will be blocked.
;;
;; 3) Whenever a state change is blocked, an org-mark is pushed, so that
;; you can find the offending entry with `C-c &'.
;;
;;; Example:
;;
;; When trying this example, make sure that the settings for TODO keywords
;; have been activated, i.e. include the following line and press C-c C-c
;; on the line before working with the example:
;;
;; #+TYP_TODO: TODO NEXT | DONE
;;
;; * TODO Win a million in Las Vegas
;; The "third" TODO (see above) cannot become a TODO without this money.
;;
;; :PROPERTIES:
;; :ID: I-cannot-do-it-without-money
;; :END:
;;
;; * Do this by doing a chain of TODO's
;; ** NEXT This is the first in this chain
;; :PROPERTIES:
;; :TRIGGER: chain-siblings(NEXT)
;; :END:
;;
;; ** This is the second in this chain
;;
;; ** This is the third in this chain
;; :PROPERTIES:
;; :BLOCKER: I-cannot-do-it-without-money
;; :END:
;;
;; ** This is the forth in this chain
;; When this is DONE, we will also trigger entry XYZ-is-my-id
;; :PROPERTIES:
;; :TRIGGER: XYZ-is-my-id(TODO)
;; :END:
;;
;; ** This is the fifth in this chain
;;
;; * Start writing report
;; :PROPERTIES:
;; :ID: XYZ-is-my-id
;; :END:
;;
;;
(require 'org)
(defun org-depend-trigger-todo (change-plist)
"Trigger new TODO entries after the current is switched to DONE.
This does two different kinds of triggers:
- If the current entry contains a TRIGGER property that contains
\"chain-siblings(KEYWORD)\", it goes to the next sibling, marks it
KEYWORD and also installs the \"chain-sibling\" trigger to continue
the chain.
- Any other word (space-separated) like XYZ(KEYWORD) in the TRIGGER
property is seen as an entry id. Org-mode finds the entry with the
corresponding ID property and switches it to the state TODO as well."
;; Get information from the plist
(let* ((type (plist-get change-plist :type))
(pos (plist-get change-plist :position))
(from (plist-get change-plist :from))
(to (plist-get change-plist :to))
(org-log-done nil) ; IMPROTANT!: no logging during automatic trigger!
trigger triggers tr p1 kwd)
(catch 'return
(unless (eq type 'todo-state-change)
;; We are only handling todo-state-change....
(throw 'return t))
(unless (and (member from org-not-done-keywords)
(member to org-done-keywords))
;; This is not a change from TODO to DONE, ignore it
(throw 'return t))
;; OK, we just switched from a TODO state to a DONE state
;; Lets see if this entry has a TRIGGER property.
;; If yes, split it up on whitespace.
(setq trigger (org-entry-get pos "TRIGGER")
triggers (and trigger (org-split-string trigger "[ \t]+")))
;; Go through all the triggers
(while (setq tr (pop triggers))
(cond
((string-match "\\`chain-siblings(\\(.*?\\))\\'" tr)
;; This is a TODO chain of siblings
(setq kwd (match-string 1 tr))
(catch 'exit
(save-excursion
(goto-char pos)
;; find the sibling, exit if no more siblings
(condition-case nil
(outline-forward-same-level 1)
(error (throw 'exit t)))
;; mark the sibling TODO
(org-todo kwd)
;; make sure the sibling will continue the chain
(org-entry-add-to-multivalued-property
nil "TRIGGER" (format "chain-siblings(%s)" kwd)))))
((string-match "\\`\\(\\S-+\\)(\\(.*?\\))\\'" tr)
;; This seems to be ENTRY_ID(KEYWORD)
(setq id (match-string 1 tr)
kwd (match-string 2 tr)
p1 (org-find-entry-with-id id))
(when p1
;; there is an entry with this ID, mark it TODO
(save-excursion
(goto-char p1)
(org-todo kwd)))))))))
(defun org-depend-block-todo (change-plist)
"Block turning an entry into a TODO.
This checks for a BLOCKER property in an entry and checks
all the entries listed there. If any of them is not done,
block changing the current entry into a TODO entry. If the property contains
the word \"previous-sibling\", the sibling above the current entry is checked.
Any other words are treated as entry id's. If an entry exists with the
this ID property, that entry is also checked."
;; Get information from the plist
(let* ((type (plist-get change-plist :type))
(pos (plist-get change-plist :position))
(from (plist-get change-plist :from))
(to (plist-get change-plist :to))
(org-log-done nil) ; IMPROTANT!: no logging during automatic trigger
blocker blockers bl p1)
(catch 'return
(unless (eq type 'todo-state-change)
;; We are not handling this kind of change
(throw 'return t))
(unless (and (not from) (member to org-not-done-keywords))
;; This is not a change from nothing to TODO, ignore it
(throw 'return t))
;; OK, the plan is to switch from nothing to TODO
;; Lets see if we will allow it. Find the BLOCKER property
;; and split it on whitespace.
(setq blocker (org-entry-get pos "BLOCKER")
blockers (and blocker (org-split-string blocker "[ \t]+")))
;; go through all the blockers
(while (setq bl (pop blockers))
(cond
((equal bl "previous-sibling")
;; the sibling is required to be DONE.
(catch 'ignore
(save-excursion
(goto-char pos)
;; find the older sibling, exit if no more siblings
(condition-case nil
(outline-backward-same-level 1)
(error (throw 'ignore t)))
;; Check if this entry is not yet done and block
(unless (org-entry-is-done-p)
;; return nil, to indicate that we block the change!
(org-mark-ring-push)
(throw 'return nil)))))
((setq p1 (org-find-entry-with-id bl))
;; there is an entry with this ID, check it out
(save-excursion
(goto-char p1)
(unless (org-entry-is-done-p)
;; return nil, to indicate that we block the change!
(org-mark-ring-push)
(throw 'return nil))))))
t ; return t to indicate that we are not blocking
)))
(add-hook 'org-trigger-hook 'org-depend-trigger-todo)
(add-hook 'org-blocker-hook 'org-depend-block-todo)
;;; org-depend.el ends here

158
EXPERIMENTAL/org-elisp-symbol.el Normal file
View File

@ -0,0 +1,158 @@
;;; org-elisp-symbol.el --- Org links to emacs-lisp symbols
;;
;; Copyright 2007 Bastien Guerry
;;
;; Author: bzg AT altern DOT org
;; Version: 0.2
;; Keywords: org, remember, lisp
;; URL: http://www.cognition.ens.fr/~guerry/u/org-elisp-symbol.el
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;
;;; Commentary:
;;
;; Org-mode already lets you store/insert links to emacs-lisp files,
;; just like any other file. This package lets you precisely link to
;; any emacs-lisp symbol and access uesful information about the symbol.
;;
;; Here is the list of available properties when linking from a elisp-symbol:
;;
;; :name The symbol's name.
;; :stype The symbol's type (commandp, function, etc.)
;; :def The function used to set the symbol's value (defun, etc.)
;; :keys The keys associated with the command.
;; :args The arguments of the function.
;; :docstring The docstring of the symbol.
;; :doc The first line of the dostring.
;; :comment A comment line just above the sexp, if any.
;; :fixme A FIXME comment line just above the sexp, if any.
;;
;; Let's say we have a defun like this one:
;;
;; ;; FIXME update docstring
;; (defun org-export-latex-lists ()
;; "Convert lists to LaTeX."
;; (goto-char (point-min))
;; (while (re-search-forward org-export-latex-list-beginning-re nil t)
;; (beginning-of-line)
;; (insert (org-list-to-latex (org-list-parse-list t)) "\n")))
;;
;; And a remember template like:
;;
;; (setq org-remember-templates
;; '((?s "* DEBUG `%:name' (%:args)\n\n%?\n\nFixme: %:fixme\n \
;; Doc: \"%:doc\"\n\n%a")))
;;
;; Then M-x `org-remember' on this sexp will produce this buffer:
;;
;; =====================================================================
;; * DEBUG `org-export-latex-lists' ()
;;
;; <== point
;;
;; Fixme: update the docstring
;; Doc: "Convert lists to LaTeX."
;;
;; [[file:~/path/file.el::defun%20org-export-latex-lists][Function: org-export-latex-lists]]
;; =====================================================================
;;
;; Put this file into your load-path and the following into your ~/.emacs:
;; (require 'org-elisp-symbol)
;;; Code:
(provide 'org-elisp-symbol)
(require 'org)
(org-add-link-type "elisp-symbol" 'org-elisp-symbol-open)
(add-hook 'org-store-link-functions 'org-elisp-symbol-store-link)
(defun org-elisp-symbol-open (path)
"Visit the emacs-lisp elisp-symbol at PATH."
(let* ((search (when (string-match "::\\(.+\\)\\'" path)
(match-string 1 path)))
(path (substring path 0 (match-beginning 0))))
(org-open-file path t nil search)))
(defun org-elisp-symbol-store-link ()
"Store a link to an emacs-lisp elisp-symbol."
(when (eq major-mode 'emacs-lisp-mode)
(save-excursion
(or (looking-at "^(") (beginning-of-defun))
(looking-at "^(\\([a-z]+\\) \\([^)\n ]+\\) ?\n?[ \t]*\\(?:(\\(.*\\))\\)?")
(let* ((end (save-excursion
(save-match-data
(end-of-defun) (point))))
(def (match-string 1))
(name (match-string 2))
(sym-name (intern-soft name))
(stype (cond ((commandp sym-name) "Command")
((functionp sym-name) "Function")
((user-variable-p sym-name) "User variable")
((eq def "defvar") "Variable")
((eq def "defmacro") "Macro")
(t "Symbol")))
(args (if (match-string 3)
(mapconcat (lambda (a) (unless (string-match "^&" a) a))
(split-string (match-string 3)) " ")
"no arg"))
(docstring (cond ((functionp sym-name)
(documentation sym-name))
((string-match "[Vv]ariable" stype)
(documentation-property sym-name
'variable-documentation))
(t "no documentation")))
(doc (and (string-match "^\\([^\n]+\\)$" docstring)
(match-string 1 docstring)))
(fixme (save-excursion
(beginning-of-defun) (end-of-defun)
(if (re-search-forward "^;+ ?FIXME[ :]*\\(.*\\)$" end t)
(match-string 1) "nothing to fix")))
(comment (save-excursion
(beginning-of-defun) (end-of-defun)
(if (re-search-forward "^;;+ ?\\(.*\\)$" end t)
(match-string 1) "no comment")))
keys keys-desc link description)
(if (equal stype "Command")
(setq keys (where-is-internal sym-name)
keys-desc
(if keys (mapconcat 'key-description keys " ") "none")))
(setq link (concat "file:" (abbreviate-file-name buffer-file-name)
"::" def " " name))
(setq description (concat stype ": " name))
(org-store-link-props
:type "elisp-symbol"
:link link
:description description
:def def
:name name
:stype stype
:args args
:keys keys-desc
:docstring docstring
:doc doc
:fixme fixme
:comment comment)))))
(provide 'org-elisp-symbol)
;;;;##########################################################################
;;;; User Options, Variables
;;;;##########################################################################
;;; org-elisp-symbol.el ends here

135
EXPERIMENTAL/org-fastup.el Normal file
View File

@ -0,0 +1,135 @@
;; Then I don't really thing you would have to be able to customize
;; this, as there are only very few operations for which this makes
;; sense:
;; A**** Archive
;; T**** Mark TODO
;; D**** Mark DONE
;; N**** Cycle TODO to the next state
;; Can't really think of anything else.
;; I prefer configurable, because then people can use numbers. This is
;; the idea that the editor may have limited UI. I'm using a j2me based
;; editor called JPE at the moment:
;; http://my-communicator.com/s80/software/applications.php?fldAuto=556&faq=2
;; But other people may be using something like this:
;; http://www.getjar.com/products/3960/TextEditor
;; Or this which i'm currently playing with:
;; http://www.bermin.net/index.html
;; As for other things, it depends on what you want emacs to be able to
;; do with an externally changed org mode file. For me this is about
;; using org mode in an intelligent way with my mobile phone/pda. I can
;; imagine wanting to write functions like:
;; * move this huge piece of text and tables down a level
;; <* move this huge piece of text and tables up a level
;; M* ask to recategorise this heading when i open org mode
;; +* remind me about this when i open org mode so i can brain dump on it
;; in a real editor.
;; D* ask me to schedule this as an event when i open org mode.
;; O* open my mail client to send an email to this email address i just got
;; C* search bbdb for the contact details of the phone no on this line.
;; c* search ldap for the contact details of this name
;; B* open a web browser to this link i wanted to check out when i got back to my machine
;; R* remind me to look at TheseSearchTags headings when i get back to my machine.
(defcustom org-fastup-action-alist
'((?A org-archive t)
(?T (org-todo 1) nil)
(?D (org-todo (length org-todo-keywords)) nil)
(?N org-todo nil)
(?< org-promote-subtree t)
(?> org-demote-subtree t)
(?M org-set-tags nil)
(?S org-schedule t))
"List of fastupdate actions.
Each entry in this list is a list of 3 items:
- A character representing the fastupdate action
- A function or form to be executed, with cursor at beginning of headline
- A flag indicating if execution of this action should normally be confirmed."
:group 'org-fastup
:type '(repeat
(list :value (?a nil t)
(character :tag "Prefix char")
(choice
(const :tag "Archive this subtree" org-archive)
(const :tag "Make TODO" (org-todo 1))
(const :tag "Mark DONE" (org-todo (length org-todo-keywords)))
(const :tag "Cycle TODO" org-todo)
(const :tag "Promote subtree" org-promote-subtree)
(const :tag "Demote subtree" org-demote-subtree)
(const :tag "Set Tags" org-set-tags)
(const :tag "Schedule" org-schedule)
(const :tag "Set Deadline" org-schedule)
(sexp))
(boolean :tag "Confirm"))))
(defun org-fastup-check-buffer ()
"Check for and execute fastupdate actions.
This first checks if there are any fastupdate actions in the buffer.
If yes, the user is asked for a processing mode, with three possibilities
with respect to confirming actions:
Always confirm each action before executing it
Never execute all actions without prior confirmation
Maybe get only confirmation for actions that have been configured
as requiring confirmation in `org-fastup-action-alist'.
The command will then walk through the buffer, stop at each eaction
and do the right thing there."
(interactive)
(show-all) ; make everything visible
(let ((start (point-min))
;; FIXME: should I limit the regexp to match existing actions?
;; I think not, to catch typos
(re "^\\([-a-zA-Z0-9!@#$%^&+?<>]\\)\\*+")
s action confirm)
(if (not (save-excursion
(goto-char (point-min))
(re-search-forward re nil t)))
(if (interactive-p) (message "No fastupdate actions in this buffer"))
(goto-char start)
(message "Fastupdate: Confirm actions [A]lways [Maybe] [N]ever, or [Q]uit?")
(setq reaction (read-char-exclusive))
(cond
((memq reaction '(?q ?Q)) (error "Abort"))
((memq reaction '(?a ?A)) (setq cf 'always))
((memq reaction '(?m ?M)) (setq cf 'maybe))
((memq reaction '(?n ?N)) (setq cf 'never)))
(while (re-search-forward re nil t)
(goto-char (setq start (match-beginning 0)))
(setq s (match-string 1)
entry (assoc (string-to-char s) org-fastup-action-alist)
action (nth 1 entry)
confirm (nth 2 entry))
(cond
((null action)
(if (y-or-n-p "Unknown action. Remove fastupdate character? ")
(delete-region start (1+ start))
(goto-char (1+ start))))
((or (equal cf 'never)
(and (eq cf 'maybe) (not confirm))
(y-or-n-p (format "execute action [%s] " s)))
(delete-region start (1+ start))
;; FIXME: wrap the following into condition-case and
;; handle any errors in some way.
(if (symbolp action) (funcall action) (eval action))
;; FIXME: remove the sit-for
(sit-for 2))
(t
(if (y-or-n-p "Action denied. Remove fastupdate character? ")
;; Remove the character, without action.
(delete-region start (1+ start))
;; Just leave the character in and skip this location
(goto-char (1+ start)))))))))

107
EXPERIMENTAL/org-indent.el Normal file
View File

@ -0,0 +1,107 @@
;; Need to hook into demotion, promotion functions: Redo the entire subtree
;; Problem: I have this huge list of overlays, should I be able
;; to reuse them?
; should be a mode...
(defconst org-indent-strings (make-vector 80 nil))
(loop for i from 0 to 79 do
(aset org-indent-strings i (org-add-props (make-string i ?\ )
nil 'face '(:underline nil :background "grey95"))))
(defvar org-indent-overlays nil)
(make-variable-buffer-local 'org-indent-overlays)
(defun org-indent-initialize-buffer ()
(interactive)
(when (org-mode-p)
(org-remove-indent-overlays)
(let (n)
(save-excursion
(save-restriction
(widen)
(goto-char (point-min))
(while (< (point) (point-max))
(cond
((looking-at outline-regexp)
(setq n (1+ (funcall outline-level))))
(n
(setq ov (org-make-overlay (1- (point)) (point)))
(org-overlay-put ov 'after-string (aref org-indent-strings n))
(org-overlay-put ov 'evaporate t)
(org-overlay-put ov 'rear-sticky nil)
(org-overlay-put ov 'front-sticky nil)
(org-overlay-put ov 'org-indent n)
(push ov org-indent-overlays)))
(beginning-of-line 2)))))))
(run-with-idle-timer 10 t 'org-indent-initialize-buffer)
(defun org-indent-refresh (start end)
"Refresh indentation overlays in the range given."
(save-excursion
(goto-char start)
(when (search-forward "\n" end t)
(goto-char start)
(beginning-of-line 0)
(let ((n (or (get-char-property (max (point-min) (1- (point)))
'org-indent) 0))
ov e)
(while (<= (point) end)
(mapc (lambda (x) (if (org-overlay-get x 'org-indent)
(if (> (setq e (org-overlay-end x)) (point))
(org-move-overlay x (1- e) e)
(org-delete-overlay x)
(setq org-indent-overlays
(delq x org-indent-overlays)))))
(overlays-at (max (point-min) (1- (point)))))
(cond
((looking-at outline-regexp)
(setq n (1+ (funcall outline-level))))
(n
(setq ov (org-make-overlay (1- (point)) (point)))
(org-overlay-put ov 'after-string (aref org-indent-strings n))
(org-overlay-put ov 'evaporate t)
(org-overlay-put ov 'rear-sticky nil)
(org-overlay-put ov 'front-sticky nil)
(org-overlay-put ov 'org-indent n)
(push ov org-indent-overlays)))
(beginning-of-line 2))))))
(defun org-remove-indent-overlays ()
(interactive)
(mapc 'org-delete-overlay org-indent-overlays)
(setq org-indent-overlays nil))
(defun org-indent-after-change-function (start end length)
"After change function for org-indent.
Notices when an insert has added some lines and adjusts
the line number extents accordingly."
(if (= start end)
() ;; this is a deletion
(org-indent-refresh start end)))
(add-hook 'after-change-functions 'org-indent-after-change-function)
(defun org-fixup-indentation (diff)
""
(save-excursion
(let ((end (save-excursion (outline-next-heading)
(point-marker)))
(prohibit (if (> diff 0)
"^\\S-"
(concat "^ \\{0," (int-to-string (- diff)) "\\}\\S-")))
col)
(if (eq org-adapt-indentation 'virtual)
(org-indent-refresh (point) end)
(unless (save-excursion (end-of-line 1)
(re-search-forward prohibit end t))
(while (and (< (point) end)
(re-search-forward "^[ \t]+" end t))
(goto-char (match-end 0))
(setq col (current-column))
(if (< diff 0) (replace-match ""))
(indent-to (+ diff col))))
(move-marker end nil)))))
(setq org-adapt-indentation 'virtual)

642
EXPERIMENTAL/org-panel.el Normal file
View File

@ -0,0 +1,642 @@
;;; org-panel.el --- Simple routines for us with bad memory
;;
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
;; Created: Thu Nov 15 15:35:03 2007
;; Version: 0.21
;; Lxast-Updated: Wed Nov 21 03:06:03 2007 (3600 +0100)
;; URL:
;; Keywords:
;; Compatibility:
;;
;; Fxeatures that might be required by this library:
;;
;; `easymenu', `font-lock', `noutline', `org', `outline', `syntax',
;; `time-date'.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; This defines a kind of control panel for `org-mode'. This control
;; panel should make it fast to move around and edit structure etc.
;;
;; To bring up the control panel type
;;
;; M-x orgpan-panel
;;
;; Type ? there for help.
;;
;; I suggest you add the following to your .emacs for quick access of
;; the panel:
;;
;; (eval-after-load 'org-mode
;; (define-key org-mode-map [(control ?c) ?p] 'orgpan-panel))
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Change log:
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING. If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
;; Floor, Boston, MA 02110-1301, USA.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:
(require 'org)
(require 'outline)
;; Fix-me: this is for testing. A minor mode version interferes badly
;; with emulation minor modes. On the other hand, the other version
;; interferes badly with (interactive ...).
(defvar orgpan-minor-mode-version t)
(defface orgpan-field
'((t (:inherit 'widget-field)))
"Face for fields."
:group 'winsize)
(defvar orgpan-field-face 'orgpan-field)
(defface orgpan-active-field
'((t (:inherit 'highlight)))
"Face for fields."
:group 'winsize)
(defvar orgpan-active-field-face 'orgpan-active-field)
(defface orgpan-spaceline
'((t (:height 0.2)))
"Face for spacing lines."
:group 'winsize)
(defcustom orgpan-panel-buttons nil
"Panel style, if non-nil use buttons.
If there are buttons in the panel they are used to change the way
the arrow keys work. The panel looks something like this, with
the first button chosen:
[Navigate] [Restructure] [TODO/Priority]
----------
up/down, left: Go to, right: Visibility
The line below the buttons try to give a short hint about what
the arrow keys does. \(Personally I prefer the version without
buttons since I then do not have to remember which button is
active.)"
:type 'boolean
:group 'winsize)
;; Fix-me: add org-mode-map
(defconst orgpan-org-mode-commands nil)
(defconst orgpan-org-commands
'(
orgpan-copy-subtree
orgpan-cut-subtree
orgpan-paste-subtree
undo
;;
;orgpan-occur
;;
org-cycle
org-global-cycle
outline-up-heading
outline-next-visible-heading
outline-previous-visible-heading
outline-forward-same-level
outline-backward-same-level
org-todo
org-show-todo-tree
org-priority-up
org-priority-down
org-move-subtree-up
org-move-subtree-down
org-do-promote
org-do-demote
org-promote-subtree
org-demote-subtree))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Hook functions etc
;;(defvar orgpan-this-panel-window nil)
(defun orgpan-delete-panel ()
"Remove the panel."
(interactive)
(when (buffer-live-p orgpan-panel-buffer)
(delete-windows-on orgpan-panel-buffer)
(kill-buffer orgpan-panel-buffer))
(setq orgpan-panel-buffer nil)
(setq orgpan-panel-window nil)
(orgpan-panel-minor-mode 0)
(remove-hook 'post-command-hook 'orgpan-minor-post-command)
(remove-hook 'post-command-hook 'orgpan-mode-post-command)
;;(remove-hook 'window-configuration-change-hook 'orgpan-window-config-change)
)
(defvar orgpan-last-command-was-from-panel nil)
(defun orgpan-mode-pre-command ()
(setq orgpan-last-command-was-from-panel nil)
(condition-case err
(if (not (and (windowp orgpan-org-window)
(window-live-p orgpan-org-window)))
(progn
(setq this-command 'ignore)
(orgpan-delete-panel)
(message "The window belonging to the panel had disappeared, removed panel."))
(let ((buf (window-buffer orgpan-org-window)))
(when (with-current-buffer buf
(derived-mode-p 'org-mode))
(setq orgpan-last-org-buffer buf))
;; Fix me: add a list of those commands that are not
;; meaningful from the panel (for example org-time-stamp)
(when (or (memq this-command orgpan-org-commands)
(memq this-command orgpan-org-mode-commands)
;; For some reason not all org commands are found above:
(string= "org-" (substring (format "%s" this-command) 0 4)))
(if (not (with-current-buffer buf
(derived-mode-p 'org-mode)))
(progn
(if (buffer-live-p orgpan-org-buffer)
(set-window-buffer orgpan-org-window orgpan-org-buffer)
(message "Please use `l' or `b' to choose an org-mode buffer"))
(setq this-command 'ignore))
(setq orgpan-org-buffer (window-buffer orgpan-org-window))
(setq orgpan-last-command-was-from-panel t)
(select-window orgpan-org-window)
;;(when (active-minibuffer-window
;;(set-buffer orgpan-org-buffer)
))))
(error (lwarn 't :warning "orgpan-pre: %S" err))))
(defun orgpan-mode-post-command ()
(condition-case err
(progn
(unless (and (windowp orgpan-panel-window)
(window-live-p orgpan-panel-window)
(bufferp orgpan-panel-buffer)
(buffer-live-p orgpan-panel-buffer))
;;(orgpan-delete-panel)
)
(when (and orgpan-last-command-was-from-panel
(windowp orgpan-panel-window)
(window-live-p orgpan-panel-window))
(select-window orgpan-panel-window)
(when (derived-mode-p 'orgpan-mode)
(setq deactivate-mark t)
(when orgpan-panel-buttons
(unless (and orgpan-point
(= (point) orgpan-point))
;; Go backward so it is possible to click on a "button":
(orgpan-backward-field)))))
(setq orgpan-this-panel-window nil))
(error (lwarn 't :warning "orgpan-post: %S" err))))
;; (defun orgpan-window-config-change ()
;; "Check if any frame is displaying an orgpan panel.
;; If not remove `orgpan-mode-post-command' and this function from
;; the hooks."
;; (condition-case err
;; (unless (and (
;; (let ((found-pan nil))
;; (dolist (f (frame-list))
;; (dolist (w (window-list f 'nomini))
;; (with-current-buffer (window-buffer w)
;; (when (derived-mode-p 'orgpan-mode)
;; (setq found-pan t)))))
;; (unless found-pan
;; (remove-hook 'post-command-hook 'orgpan-mode-post-command)
;; (remove-hook 'window-configuration-change-hook 'orgpan-window-config-change)))
;; (error (lwarn 't :warning "Error in orgpan-config-change: %S" err))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Commands
(defun orgpan-last-buffer ()
"Open last org-mode buffer in panels org window."
(interactive)
(let ((buf (window-buffer orgpan-org-window))
(last-buf orgpan-last-org-buffer))
(when (with-current-buffer buf
(derived-mode-p 'org-mode))
(setq orgpan-last-org-buffer buf))
(when (eq last-buf buf)
(setq last-buf nil))
(if (not last-buf)
(orgpan-switch-buffer)
(set-window-buffer orgpan-org-window last-buf))))
(defun orgpan-switch-buffer ()
"Switch to next org-mode buffer in panels org window."
(interactive)
(let ((buf (window-buffer orgpan-org-window))
(org-buffers nil))
(with-current-buffer buf
(when (derived-mode-p 'org-mode)
(bury-buffer buf)
(setq orgpan-last-org-buffer buf)))
(setq org-buffers (delq nil (mapcar (lambda (buf)
(when (with-current-buffer buf
(derived-mode-p 'org-mode))
buf))
(buffer-list))))
(setq org-buffers (delq buf org-buffers))
(set-window-buffer orgpan-org-window (car org-buffers))
(setq orgpan-org-buffer (car org-buffers))))
(defun orgpan-paste-subtree ()
(interactive)
(if (y-or-n-p "Paste subtree here? ")
(org-paste-subtree)
(message "Nothing was pasted")))
(defun orgpan-cut-subtree ()
(interactive)
(let ((heading (progn
(org-back-to-heading)
(buffer-substring (point) (line-end-position))
)))
(if (y-or-n-p (format "Do you want to cut the subtree\n%s\n? " heading))
(org-cut-subtree)
(message "Nothing was cut"))))
(defun orgpan-copy-subtree ()
(interactive)
(let ((heading (progn
(org-back-to-heading)
(buffer-substring (point) (line-end-position))
)))
(if (y-or-n-p (format "Do you want to copy the subtree\n%s\n? " heading))
(org-copy-subtree)
(message "Nothing was copied"))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Buttons
(defvar orgpan-ovl-help nil)
(defun orgpan-check-panel-mode ()
(unless (derived-mode-p 'orgpan-mode)
(error "Not orgpan-mode in buffer: " major-mode)))
(defun orgpan-display-bindings-help ()
(orgpan-check-panel-mode)
(setq orgpan-point (point))
(let* ((ovls (overlays-at (point)))
(ovl (car ovls))
(help (when ovl (overlay-get ovl 'orgpan-explain))))
(dolist (o (overlays-in (point-min) (point-max)))
(overlay-put o 'face orgpan-field-face))
(overlay-put ovl 'face orgpan-active-field-face)
(overlay-put orgpan-ovl-help 'before-string help)))
(defun orgpan-forward-field ()
(interactive)
(orgpan-check-panel-mode)
(let ((pos (next-overlay-change (point))))
(unless (overlays-at pos)
(setq pos (next-overlay-change pos)))
(when (= pos (point-max))
(setq pos (point-min))
(unless (overlays-at pos)
(setq pos (next-overlay-change pos))))
(goto-char pos))
(orgpan-display-bindings-help))
(defun orgpan-backward-field ()
(interactive)
(orgpan-check-panel-mode)
(when (= (point) (point-min))
(goto-char (point-max)))
(let ((pos (previous-overlay-change (point))))
(unless (overlays-at pos)
(setq pos (previous-overlay-change pos)))
(goto-char pos))
(orgpan-display-bindings-help))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Mode
(defconst orgpan-mode-map
;; Fix-me: clean up here!
;; Fix-me: viper support
(let ((map (make-sparse-keymap)))
(define-key map [?q] 'orgpan-delete-panel)
(define-key map [??] 'orgpan-help)
;; Copying etc
(define-key map [?c] 'orgpan-copy-subtree)
(define-key map [?x] 'orgpan-cut-subtree)
(define-key map [?p] 'orgpan-paste-subtree)
(define-key map [?z] 'undo)
;; Buffers:
(define-key map [?b] 'orgpan-switch-buffer)
(define-key map [?l] 'orgpan-last-buffer)
;; Some keys for moving between headings. Emacs keys for next/prev
;; line seems ok:
(define-key map [(control ?p)] 'outline-previous-visible-heading)
(define-key map [(control ?n)] 'outline-next-visible-heading)
(define-key map [(shift control ?p)] 'outline-backward-same-level)
(define-key map [(shift control ?n)] 'outline-forward-same-level)
;; A mnemunic for up:
(define-key map [(control ?u)] 'outline-up-heading)
;; Search sparse tree:
;;
;; Fix-me: Search does not work, some problem with
;; interactive. Probably have to turn the whole thing around and
;; always be in the org buffer, but with a minor mode running
;; there.
;;
;;(define-key map [?s] 'org-sparse-tree)
(define-key map [?s] 'orgpan-occur)
;; Same as in org-mode:
;;(define-key map [(control ?c)(control ?v)] 'org-show-todo-tree)
;; Fix-me: This leads to strange problems:
;;(define-key map [t] 'ignore)
map))
(defun orgpan-occur ()
"Replacement for `org-occur'.
Technical reasons."
(interactive)
(let ((rgx (read-from-minibuffer "my mini Regexp: ")))
(setq orgpan-last-command-was-from-panel t)
(select-window orgpan-org-window)
(org-occur rgx)))
(defvar orgpan-panel-window nil
"The window showing `orgpan-panel-buffer'.")
(defvar orgpan-panel-buffer nil
"The panel buffer.
There can be only one such buffer at any time.")
(defvar orgpan-org-window nil)
;;(make-variable-buffer-local 'orgpan-org-window)
;; Fix-me: used?
(defvar orgpan-org-buffer nil)
;;(make-variable-buffer-local 'orgpan-org-buffer)
(defvar orgpan-last-org-buffer nil)
;;(make-variable-buffer-local 'orgpan-last-org-buffer)
(defvar orgpan-point nil)
;;(make-variable-buffer-local 'orgpan-point)
(defun orgpan-avoid-viper-in-buffer ()
;; Fix-me: This is ugly. However see `this-major-mode-requires-vi-state':
(set (make-local-variable 'viper-emacs-state-mode-list) '(orgpan-mode))
(set (make-local-variable 'viper-new-major-mode-buffer-list) nil)
(local-set-key [?\ ] 'ignore))
(define-derived-mode orgpan-mode nil "Org-Panel"
"Mode for org-simple.el control panel."
(setq buffer-read-only t)
(unless orgpan-minor-mode-version
(add-hook 'pre-command-hook 'orgpan-mode-pre-command nil t)
(add-hook 'post-command-hook 'orgpan-mode-post-command t))
(orgpan-avoid-viper-in-buffer)
(setq cursor-type nil))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Panel layout
(defun orgpan-insert-field (text keymap explain)
(insert text)
(let* ((end (point))
(len (length text))
(beg (- end len))
(ovl (make-overlay beg end)))
(overlay-put ovl 'face orgpan-field-face)
(overlay-put ovl 'keymap keymap)
(overlay-put ovl 'orgpan-explain explain)))
(defconst orgpan-with-keymap
(let ((map (make-sparse-keymap)))
(set-keymap-parent map org-mode-map)
;; Users are used to tabbing between fields:
(define-key map [(tab)] 'orgpan-forward-field)
(define-key map [(shift tab)] 'orgpan-backward-field)
;; Now we must use something else for visibility (first does not work if Viper):
(define-key map [(meta tab)] 'org-cycle)
(define-key map [(control meta tab)] 'org-global-cycle)
map))
(defconst orgpan-without-keymap
(let ((map (make-sparse-keymap)))
(set-keymap-parent map org-mode-map)
;; Visibility (those are in org-mode-map):
;;(define-key map [tab] 'org-cycle)
;;(define-key map [(shift tab)] 'org-global-cycle)
;; Navigate:
(define-key map [left] 'outline-up-heading)
(define-key map [right] 'org-cycle)
(define-key map [up] 'outline-previous-visible-heading)
(define-key map [down] 'outline-next-visible-heading)
(define-key map [(shift down)] 'outline-forward-same-level)
(define-key map [(shift up)] 'outline-backward-same-level)
;; Restructure:
(define-key map [(control up)] 'org-move-subtree-up)
(define-key map [(control down)] 'org-move-subtree-down)
(define-key map [(control left)] 'org-do-promote)
(define-key map [(control right)] 'org-do-demote)
(define-key map [(control shift left)] 'org-promote-subtree)
(define-key map [(control shift right)] 'org-demote-subtree)
;; Todo etc
(define-key map [?+] 'org-priority-up)
(define-key map [?-] 'org-priority-down)
(define-key map [?t] 'org-todo)
map))
(defun orgpan-make-panel-without-buttons (buf)
(with-current-buffer buf
(insert (propertize "Org Panel" 'face 'orgpan-active-field))
(insert " ? for help, q quit\n")
(insert (propertize "arrows" 'face 'font-lock-keyword-face)
": Go to, "
(propertize "C-arrows" 'face 'font-lock-keyword-face)
": Edit tree\n"
(propertize "cxpz" 'face 'font-lock-keyword-face)
": copy cut paste undo, "
(propertize "tT+-" 'face 'font-lock-keyword-face)
": todo priority, "
(propertize "s" 'face 'font-lock-keyword-face)
" search"
)
(set-keymap-parent orgpan-mode-map orgpan-without-keymap)
))
(defun orgpan-make-panel-with-buttons (buf)
(with-current-buffer buf
(let* ((base-map (make-sparse-keymap))
(space-line (propertize "\n\n" 'face 'orgpan-spaceline))
(arrow-face 'font-lock-keyword-face)
(L (propertize "left" 'face arrow-face))
(R (propertize "right" 'face arrow-face))
(U (propertize "up" 'face arrow-face))
(D (propertize "down" 'face arrow-face)))
;;(message D)(sit-for 2)
(define-key base-map [left] 'ignore)
(define-key base-map [right] 'ignore)
(define-key base-map [up] 'ignore)
(define-key base-map [down] 'ignore)
(define-key base-map [?q] 'delete-window)
(define-key base-map [??] 'orgpan-help)
;; Navigating
(let ((map (copy-keymap base-map)))
(define-key map [left] 'outline-up-heading)
(define-key map [right] 'org-cycle)
(define-key map [up] 'outline-previous-visible-heading)
(define-key map [down] 'outline-next-visible-heading)
(define-key map [(shift down)] 'outline-forward-same-level)
(define-key map [(shift up)] 'outline-backward-same-level)
(orgpan-insert-field "Navigate" map (concat U "/" D ", " L ": Go to, " R ": Visibility")))
(insert " ")
(let ((map (copy-keymap base-map)))
(define-key map [up] 'org-move-subtree-up)
(define-key map [down] 'org-move-subtree-down)
(define-key map [left] 'org-do-promote)
(define-key map [right] 'org-do-demote)
(define-key map [(shift left)] 'org-promote-subtree)
(define-key map [(shift right)] 'org-demote-subtree)
(orgpan-insert-field
"Restructure" map
(concat U "/" D ": "
(propertize "Move" 'face 'font-lock-warning-face)
", " L "/" R ": "
(propertize "Level (w S: Subtree Level)" 'face 'font-lock-warning-face))))
(insert " ")
(let ((map (copy-keymap base-map)))
(define-key map [up] 'org-priority-up)
(define-key map [down] 'org-priority-down)
(define-key map [right] 'org-todo)
(orgpan-insert-field "TODO/priority" map
(concat R ": TODO, " U "/" D ": Priority")))
)
(insert " ? for help, q quit\n")
(orgpan-display-bindings-help)
(setq orgpan-ovl-help (make-overlay (point) (point)))
))
(defun orgpan-make-panel-buffer ()
"Make the panel buffer."
(let* ((buf-name "*Org Panel*"))
(when orgpan-panel-buffer (kill-buffer orgpan-panel-buffer))
(setq orgpan-panel-buffer (get-buffer-create buf-name))
(if orgpan-panel-buttons
(orgpan-make-panel-with-buttons orgpan-panel-buffer)
(orgpan-make-panel-without-buttons orgpan-panel-buffer))
(with-current-buffer orgpan-panel-buffer
(orgpan-mode)
(goto-char (point-min)))
orgpan-panel-buffer))
(defun orgpan-help ()
(interactive)
(set-keymap-parent orgpan-with-keymap nil)
(set-keymap-parent orgpan-without-keymap nil)
(describe-function 'orgpan-panel)
(set-keymap-parent orgpan-with-keymap org-mode-map)
(set-keymap-parent orgpan-without-keymap org-mode-map)
(message "Use 'l' to remove help window")
)
(defun orgpan-panel ()
"Create a control panel for current `org-mode' buffer.
The control panel may be used to quickly move around and change
the headings. The idea is that when you want to to a lot of this
kind of editing you should be able to do that with few
keystrokes (and without having to remember the complicated
keystrokes). A typical situation when this perhaps can be useful
is when you are looking at your notes file \(usually ~/.notes,
see `remember-data-file') where you have saved quick notes with
`remember'.
The keys below are defined in the panel. Note that the commands
are carried out in the `org-mode' buffer that belongs to the
panel.
\\{orgpan-mode-map}
In addition to the keys above most of the keys in `org-mode' can
also be used from the panel.
Note: There are two forms of the control panel, one with buttons
and one without. The default is without, see
`orgpan-panel-buttons'. If buttons are used choosing a different
button changes the binding of the arrow keys."
(interactive)
(unless (derived-mode-p 'org-mode)
(error "Buffer is not in org-mode"))
(orgpan-delete-panel)
(unless orgpan-org-mode-commands
(map-keymap (lambda (ev def)
(when (and def
(symbolp def)
(fboundp def))
(setq orgpan-org-mode-commands
(cons def orgpan-org-mode-commands))))
org-mode-map))
;;(org-back-to-heading)
;;(remove-hook 'window-configuration-change-hook 'orgpan-window-config-change)
(split-window)
(set-window-buffer (selected-window) (orgpan-make-panel-buffer))
(setq orgpan-panel-window (selected-window))
;;(set-window-dedicated-p (selected-window) t)
(fit-window-to-buffer nil nil 3)
(setq orgpan-org-window (next-window))
;; The minor mode version starts here:
(when orgpan-minor-mode-version
(select-window orgpan-org-window)
(orgpan-panel-minor-mode 1)
(add-hook 'post-command-hook 'orgpan-minor-post-command t)))
(defun orgpan-minor-post-command ()
(unless (and
;; Check org window and buffer
(windowp orgpan-org-window)
(window-live-p orgpan-org-window)
(eq orgpan-org-window (selected-window))
(derived-mode-p 'org-mode)
;; Check panel window and buffer
(windowp orgpan-panel-window)
(window-live-p orgpan-panel-window)
(bufferp orgpan-panel-buffer)
(buffer-live-p orgpan-panel-buffer)
(eq (window-buffer orgpan-panel-window) orgpan-panel-buffer)
;; Check minor mode
orgpan-panel-minor-mode)
(orgpan-delete-panel)))
(define-minor-mode orgpan-panel-minor-mode
"Minor mode used in `org-mode' buffer when showing panel."
:keymap orgpan-mode-map
:lighter " PANEL"
:group 'orgpan
)
(provide 'org-panel)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; org-panel.el ends here

191
EXPERIMENTAL/org-pic.el Normal file
View File

@ -0,0 +1,191 @@
;;; Modified picture mode with extra functions and bindings
;; BUGS: The mouse stuff does not really work reliable
;; What it really needs:
;; Picture areas should always start with ":"
;; Automatic recognize the region and use the right commands, also
;; extending the region.
;; Picture mode
;; ------------
;; Simple ASCII drawings can be made in picture-mode. You can toggle
;; picture mode with `C-c C-c' (unless you have turned it off with the
;; variable `org-enable-picture-mode'). See the picture-mode
;; documentation for details. Some additional bindings are provided by
;; org-mode:
;;
;; M-up M-7 M-8 M-9 \
;; M-left M-right M-u M-o } Draw lines in keypad-like directions
;; M-down M-j M-k M-o /
;;
;; M-- Draw line from mark to point, set mark at end.
;; S-mouse1 Freehand drawing with the mouse.
;;
(defcustom org-enable-picture-mode t
"Non-nil means, C-c C-c switches to picture mode.
When nil, this command is disabled."
:group 'org
:type 'boolean)
(defun org-edit-picture ()
"Switch to picture mode and save the value of `transient-mark-mode'.
Turn transient-mark-mode off while in picture-mode."
(interactive)
(if (not org-enable-picture-mode)
(error
"Set variable `org-enable-picture-mode' to allow picture-mode."))
;; FIXME: This is not XEmacs compatible yet
(set (make-local-variable 'org-transient-mark-mode)
transient-mark-mode)
(set (make-local-variable 'org-cursor-color)
(frame-parameter nil 'cursor-color))
(set (make-local-variable 'transient-mark-mode) nil)
(set-cursor-color "red")
(picture-mode)
(message (substitute-command-keys
"Type \\[org-picture-mode-exit] in this buffer to return it to Org mode.")))
(defun org-picture-mode-exit (&optional arg)
"Turn off picture mode and restore `transient-mark-mode'."
(interactive "P")
(if (local-variable-p 'org-transient-mark-mode)
(setq transient-mark-mode org-transient-mark-mode))
(if (local-variable-p 'org-cursor-color)
(set-cursor-color org-cursor-color))
(if (fboundp 'deactivate-mark) (deactivate-mark))
(if (fboundp 'zmacs-deactivate-region) (zmacs-deactivate-region))
(picture-mode-exit))
(eval-after-load "picture"
' (progn
(define-key picture-mode-map [(meta left)] (lambda (arg) (interactive "p") (org-picture-draw 4 arg)))
(define-key picture-mode-map [(meta right)] (lambda (arg) (interactive "p") (org-picture-draw 6 arg)))
(define-key picture-mode-map [(meta up)] (lambda (arg) (interactive "p") (org-picture-draw 8 arg)))
(define-key picture-mode-map [(meta down)] (lambda (arg) (interactive "p") (org-picture-draw 2 arg)))
(define-key picture-mode-map [(meta shift left)] (lambda (arg) (interactive "p") (org-picture-draw 7 arg)))
(define-key picture-mode-map [(meta shift right)] (lambda (arg) (interactive "p") (org-picture-draw 3 arg)))
(define-key picture-mode-map [(meta shift up)] (lambda (arg) (interactive "p") (org-picture-draw 9 arg)))
(define-key picture-mode-map [(meta shift down)] (lambda (arg) (interactive "p") (org-picture-draw 1 arg)))
(define-key picture-mode-map [(meta ?j)] (lambda (arg) (interactive "p") (org-picture-draw 1 arg)))
(define-key picture-mode-map [(meta ?k)] (lambda (arg) (interactive "p") (org-picture-draw 2 arg)))
(define-key picture-mode-map [(meta ?l)] (lambda (arg) (interactive "p") (org-picture-draw 3 arg)))
(define-key picture-mode-map [(meta ?u)] (lambda (arg) (interactive "p") (org-picture-draw 4 arg)))
(define-key picture-mode-map [(meta ?o)] (lambda (arg) (interactive "p") (org-picture-draw 6 arg)))
(define-key picture-mode-map [(meta ?7)] (lambda (arg) (interactive "p") (org-picture-draw 7 arg)))
(define-key picture-mode-map [(meta ?8)] (lambda (arg) (interactive "p") (org-picture-draw 8 arg)))
(define-key picture-mode-map [(meta ?9)] (lambda (arg) (interactive "p") (org-picture-draw 9 arg)))
(define-key picture-mode-map [(meta ?-)] 'org-picture-draw-line)
(define-key picture-mode-map [mouse-2] 'org-picture-mouse-line-to-here)
(define-key picture-mode-map [mouse-1] 'org-picture-mouse-set-point)
(define-key picture-mode-map [(shift down-mouse-1)] 'org-picture-draw-with-mouse)
(define-key picture-mode-map "\C-c\C-c" 'org-picture-mode-exit)))
(defun org-picture-draw (dir arg)
"Draw ARG character into the direction given by DIR."
(cond
((equal dir 1)
(picture-movement-sw)
(setq last-command-event ?/) (picture-self-insert arg))
((equal dir 2)
(picture-movement-down)
(setq last-command-event ?|) (picture-self-insert arg))
((equal dir 3)
(picture-movement-se)
(setq last-command-event ?\\) (picture-self-insert arg))
((equal dir 4)
(picture-movement-left)
(setq last-command-event ?-) (picture-self-insert arg))
((equal dir 5))
((equal dir 6)
(picture-movement-right)
(setq last-command-event ?-) (picture-self-insert arg))
((equal dir 7)
(picture-movement-nw)
(setq last-command-event ?\\) (picture-self-insert arg))
((equal dir 8)
(picture-movement-up)
(setq last-command-event ?|) (picture-self-insert arg))
((equal dir 9)
(picture-movement-ne)
(setq last-command-event ?/) (picture-self-insert arg)))
(picture-movement-right))
(defun org-picture-draw-line (&optional beg end)
"Draw a line from mark to point."
(interactive)
(unless (and beg end)
(setq beg (mark 'force)
end (point)))
(let (x1 x2 y1 y2 n i Dx Dy dx dy char lp x y x1a y1a lastx lasty)
(goto-char beg)
(setq x1 (current-column) y1 (count-lines (point-min) (point)))
(if (bolp) (setq y1 (1+ y1)))
(goto-char end)
(setq x2 (current-column) y2 (count-lines (point-min) (point)))
(if (bolp) (setq y2 (1+ y2)))
(setq Dx (- x2 x1) Dy (- y2 y1)
n (+ (abs Dx) (abs Dy))
n (sqrt (+ (* Dx Dx) (* Dy Dy)))
n (max (abs Dx) (abs Dy))
n (max (abs Dx) (abs Dy))
dx (/ (float Dx) (float n)) dy (/ (float Dy) (float n)))
(setq x1a (floor (+ x1 (* 1. dx) .5))
y1a (floor (+ y1 (* 1. dy) .5)))
;; Do the loop
(setq i -1)
(setq lastx x1a lasty y1a)
(while (< i n)
(setq i (1+ i)
x (floor (+ x1 (* (float i) dx) .5))
y (floor (+ y1 (* (float i) dy) .5)))
(setq char (cond ((= lastx x) ?|) ((= lasty y) ?-)
((> (* (- x lastx) (- y lasty)) 0) ?\\)
(t ?/))
lastx x lasty y)
(goto-line y)
(move-to-column x t)
(setq last-command-event char)
(setq lp (point))
(picture-self-insert 1))
(goto-char lp)
(set-mark lp)))
(defun org-picture-mouse-line-to-here (ev)
"Draw a line from point to the click position."
(interactive "e")
(let* ((beg (move-marker (make-marker) (point))))
(org-picture-mouse-set-point ev)
(org-picture-draw-line beg (point))
(move-marker beg nil)))
;; Draw with the mouse
(defun org-picture-mouse-set-point (ev)
"Mouse-set-point, but force position."
(interactive "e")
(let* ((colrow (posn-col-row (event-end ev)))
(col (car colrow)) (line (cdr colrow))
(realline (1+ (+ (count-lines (point-min) (window-start)) line))))
(goto-line realline)
(while (and (eobp)
(not (> (count-lines (point-min) (point-max)) realline)))
(newline))
(goto-line realline)
(move-to-column col t)))
(defun org-picture-draw-with-mouse (ev)
"Use the mouse like a brush and paint stars where it goes."
(interactive "e")
(let (lastcr cr)
(track-mouse
(catch 'exit
(while t
(setq e (read-event))
(if (not (eq (car e) 'mouse-movement)) (throw 'exit nil))
(setq cr (posn-col-row (event-end e)))
(when (not (equal cr lastcr))
(setq lastcr cr)
(org-picture-mouse-set-point e)
(setq last-command-event ?*)
(save-excursion
(picture-self-insert 1))))))))

111
EXPERIMENTAL/sacha-load.el Normal file
View File

@ -0,0 +1,111 @@
(defun sacha/org-show-load ()
"Show my unscheduled time and free time for the day."
(interactive)
(let ((time (sacha/org-calculate-free-time
;; today
(calendar-gregorian-from-absolute (time-to-days (current-time)))
;; now
(let* ((now (decode-time))
(cur-hour (nth 2 now))
(cur-min (nth 1 now)))
(+ (* cur-hour 60) cur-min))
;; until the last time in my time grid
(let ((last (car (last (elt org-agenda-time-grid 2)))))
(+ (* (/ last 100) 60) (% last 100))))))
(message "%.1f%% load: %d minutes to be scheduled, %d minutes free, %d minutes gap\n"
(/ (car time) (* .01 (cdr time)))
(car time)
(cdr time)
(- (cdr time) (car time)))))
(defun sacha/org-agenda-load (match)
"Can be included in `org-agenda-custom-commands'."
(let ((inhibit-read-only t)
(time (sacha/org-calculate-free-time
;; today
(calendar-gregorian-from-absolute org-starting-day)
;; now if today, else start of day
(if (= org-starting-day
(time-to-days (current-time)))
(let* ((now (decode-time))
(cur-hour (nth 2 now))
(cur-min (nth 1 now)))
(+ (* cur-hour 60) cur-min))
(let ((start (car (elt org-agenda-time-grid 2))))
(+ (* (/ start 100) 60) (% start 100))))
;; until the last time in my time grid
(let ((last (car (last (elt org-agenda-time-grid 2)))))
(+ (* (/ last 100) 60) (% last 100))))))
(goto-char (point-max))
(insert (format
"%.1f%% load: %d minutes to be scheduled, %d minutes free, %d minutes gap\n"
(/ (car time) (* .01 (cdr time)))
(car time)
(cdr time)
(- (cdr time) (car time))))))
(defun sacha/org-calculate-free-time (date start-time end-of-day)
"Return a cons cell of the form (TASK-TIME . FREE-TIME) for DATE, given START-TIME and END-OF-DAY.
DATE is a list of the form (MONTH DAY YEAR).
START-TIME and END-OF-DAY are the number of minutes past midnight."
(save-window-excursion
(let ((files org-agenda-files)
(total-unscheduled 0)
(total-gap 0)
file
rtn
rtnall
entry
(last-timestamp start-time)
scheduled-entries)
(while (setq file (car files))
(catch 'nextfile
(org-check-agenda-file file)
(setq rtn (org-agenda-get-day-entries file date :scheduled :timestamp))
(setq rtnall (append rtnall rtn)))
(setq files (cdr files)))
;; For each item on the list
(while (setq entry (car rtnall))
(let ((time (get-text-property 1 'time entry)))
(cond
((and time (string-match "\\([^-]+\\)-\\([^-]+\\)" time))
(setq scheduled-entries (cons (cons
(save-match-data (appt-convert-time (match-string 1 time)))
(save-match-data (appt-convert-time (match-string 2 time))))
scheduled-entries)))
((and time
(string-match "\\([^-]+\\)\\.+" time)
(string-match "^[A-Z]+ \\(\\[#[A-Z]\\]\\)? \\([0-9]+\\)" (get-text-property 1 'txt entry)))
(setq scheduled-entries
(let ((start (and (string-match "\\([^-]+\\)\\.+" time)
(appt-convert-time (match-string 1 time)))))
(cons (cons start
(and (string-match "^[A-Z]+ \\(\\[#[A-Z]\\]\\)? \\([0-9]+\\) " (get-text-property 1 'txt entry))
(+ start (string-to-number (match-string 2 (get-text-property 1 'txt entry))))))
scheduled-entries))))
((string-match "^[A-Z]+ \\([0-9]+\\)" (get-text-property 1 'txt entry))
(setq total-unscheduled (+ (string-to-number
(match-string 1 (get-text-property 1 'txt entry)))
total-unscheduled)))))
(setq rtnall (cdr rtnall)))
;; Sort the scheduled entries by time
(setq scheduled-entries (sort scheduled-entries (lambda (a b) (< (car a) (car b)))))
(while scheduled-entries
(let ((start (car (car scheduled-entries)))
(end (cdr (car scheduled-entries))))
(cond
;; are we in the middle of this timeslot?
((and (>= last-timestamp start)
(< = last-timestamp end))
;; move timestamp later, no change to time
(setq last-timestamp end))
;; are we completely before this timeslot?
((< last-timestamp start)
;; add gap to total, skip to the end
(setq total-gap (+ (- start last-timestamp) total-gap))
(setq last-timestamp end)))
(setq scheduled-entries (cdr scheduled-entries))))
(if (< last-timestamp end-of-day)
(setq total-gap (+ (- end-of-day last-timestamp) total-gap)))
(cons total-unscheduled total-gap))))

27
Makefile
View File

@ -68,9 +68,9 @@ DOCFILES = org.texi org.pdf org
CARDFILES = orgcard.tex orgcard.pdf orgcard_letter.pdf
TEXIFILES = org.texi
INFOFILES = org
HTMLDIR = /home/dominik/public_html/Tools/org
HG_RELEASES = ../org-mode-all-releases-hg/
.SUFFIXES: .el .elc .texi
SHELL = /bin/sh
@ -154,6 +154,10 @@ orgcard_letter.ps: orgcard_letter.dvi
webfiles:
(cd ORGWEBPAGE; emacs -batch -l ~/.emacs index.org -f org-publish-current-project)
web:
make webfiles
(cd ORGWEBPAGE/tmp; lftp -f ../../../org-mode-proprietary/ftp_upload_website)
html: org.html
html_split: org.texi
@ -168,12 +172,6 @@ pdf: org.pdf
card: orgcard.pdf orgcard.ps orgcard_letter.pdf orgcard_letter.ps
xcompile:
xemacs -batch -q -f batch-byte-compile $(LISPFILES)
ecompile:
emacs -batch -q -f batch-byte-compile $(LISPFILES)
distfile:
@if [ "X$(TAG)" = "X" ]; then echo "*** No tag ***"; exit 1; fi
touch org.texi orgcard.tex
@ -214,15 +212,15 @@ trackrelease:
cp -r org-$(TAG)/* $(HG_RELEASES)
(cd $(HG_RELEASES); hg addremove; hg ci -m $(TAG); hg tag $(TAG))
upload:
(cd RELEASEDIR; lftp -f ../ftp_script)
upload_release:
(cd RELEASEDIR; lftp -f ../../org-mode-proprietary/ftp_upload_release)
upload_manual:
lftp -f ftp_script2
lftp -f ../org-mode-proprietary/ftp_upload_manual
relup:
make release
make upload
make upload_release
make upload_manual
clean:
@ -230,7 +228,14 @@ clean:
rm -f *~
rm -f *.aux *.cp *.cps *.dvi *.fn *.fns *.ky *.kys *.pg *.pgs
rm -f *.toc *.tp *.tps *.vr *.vrs *.log *.html *.ps
rm -f orgcard_letter.tex orgcard_letter.pdf
rm -f org-install.el
rm -rf manual
rm -rf RELEASEDIR
.el.elc:
$(ELC) $<
push:
git+ssh://repo.or.cz/svr/git/org-mode.git master

BIN
ORGWEBPAGE/.DS_Store vendored Normal file
View File

Binary file not shown.

6354
ORGWEBPAGE/Changes.html Normal file
View File

File diff suppressed because it is too large Load Diff

3353
ORGWEBPAGE/Changes.org Normal file
View File

File diff suppressed because it is too large Load Diff

3152
ORGWEBPAGE/Changes.txt Normal file
View File

File diff suppressed because it is too large Load Diff

555
ORGWEBPAGE/faq.html Normal file
View File

@ -0,0 +1,555 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-mode Frequently Asked Questions</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2007/09/10 07:06:01"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css"> <style type="text/css"> .tag { color: red; font-weight:bold}</style>
</head><body>
<h1 class="title">Org-mode Frequently Asked Questions</h1>
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">1 General</a>
<ul>
<li><a href="#sec-2">1.1 Use features in other modes</a></li>
<li><a href="#sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</a></li>
</ul>
</li>
<li><a href="#sec-4">2 Errors</a>
<ul>
<li><a href="#sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></a></li>
<li><a href="#sec-6">2.2 CUA mode does not work with Org-mode</a></li>
<li><a href="#sec-7">2.3 <code>winddmove.el</code> does not work with Org-mode.</a></li>
</ul>
</li>
<li><a href="#sec-8">3 Setup and Structure</a>
<ul>
<li><a href="#sec-9">3.1 Org-mode as default mode</a></li>
<li><a href="#sec-10">3.2 Get rid of extra stars in outline</a></li>
<li><a href="#sec-11">3.3 Two windows on same Org-mode file</a></li>
<li><a href="#sec-12">3.4 Insert empty lines before new headings and plain list items</a></li>
<li><a href="#sec-13">3.5 Amount of context in sparse trees</a></li>
<li><a href="#sec-14">3.6 Stacking calls to org-occur</a></li>
</ul>
</li>
<li><a href="#sec-15">4 Hyperlinks</a>
<ul>
<li><a href="#sec-16">4.1 Confirmation for shell and elisp links</a></li>
<li><a href="#sec-17">4.2 Use RET or TAB to follow a link</a></li>
<li><a href="#sec-18">4.3 Clicking on a link without activating it</a></li>
</ul>
</li>
<li><a href="#sec-19">5 Export</a>
<ul>
<li><a href="#sec-20">5.1 Make TODO entries items, not headlines in HTML export</a></li>
<li><a href="#sec-21">5.2 Export only a subtree</a></li>
<li><a href="#sec-22">5.3 How to import org-mode calendar data into Mac OSX ical</a></li>
</ul>
</li>
<li><a href="#sec-23">6 Tables</a>
<ul>
<li><a href="#sec-24">6.1 #ERROR fields in tables</a></li>
<li><a href="#sec-25">6.2 Unwanted new lines in table</a></li>
<li><a href="#sec-26">6.3 Automatic detection of formulas</a></li>
<li><a href="#sec-27">6.4 Change indentation of a table</a></li>
<li><a href="#sec-28">6.5 Performance issues with table alignment</a></li>
<li><a href="#sec-29">6.6 Performance issues with table calculation</a></li>
<li><a href="#sec-30">6.7 Incrementing numbers</a></li>
</ul>
</li>
<li><a href="#sec-31">7 Agenda</a>
<ul>
<li><a href="#sec-32">7.1 Include Org-mode agenda into Emacs diary</a></li>
</ul>
</li>
</ul>
<h2 id="sec-1">1 General</h2>
<h3 id="sec-2">1.1 Use features in other modes</h3>
<p><b>I would like to use editing features of org-mode in other modes, is this possible?</b>
</p>
<p>
Not really. For tables there is <code>orgtbl-mode</code> which implements the
table editor as a minor mode. For other features you need to switch to
Org-mode temporarily, or prepare text in a different buffer.
</p>
<h3 id="sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</h3>
<p>
<b>Can I get the visibility-cycling features in outline-mode and outline-minor-mode?</b>
</p>
<p>
Yes, these functions are written in a way that they are independent of
the outline setup. The following setup provides standard Org-mode
functionality in outline-mode on <code>TAB</code> and <code>S-TAB</code>. For
outline-minor-mode, we use <code>C-TAB</code> instead of <code>TAB</code>,
because <code>TAB</code> usually has mode-specific tasks.
</p>
<p>
<pre>
(add-hook 'outline-minor-mode-hook
(lambda ()
(define-key outline-minor-mode-map [(control tab)] 'org-cycle)
(define-key outline-minor-mode-map [(shift tab)] 'org-global-cycle)))
(add-hook 'outline-mode-hook
(lambda ()
(define-key outline-mode-map [(tab)] 'org-cycle)
(define-key outline-mode-map [(shift tab)] 'org-global-cycle)))
</pre>
</p>
<p>
Or check out <i>outline-magic.el</i>, which does this and also provides
promotion and demotion functionality. <i>outline-magic.el</i> is
available at <a href="http://www.astro.uva.nl/~dominik/Tools/OutlineMagic">Outline Magic</a>.
</p>
<h2 id="sec-4">2 Errors</h2>
<h3 id="sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></h3>
<p><b>When I try to use Org-mode, I always get the error message @code{(wrong-type-argument keymapp nil)}</b>
</p>
<p>
This is a conflict with an outdated version of the <i>allout.el</i>, see
the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section in the manual
</p>
<h3 id="sec-6">2.2 CUA mode does not work with Org-mode</h3>
<p>
<b>Org-mode takes over the S-cursor keys. I also want to use CUA-mode, is there a way to fix this conflict?</b>
</p>
<p>
Yes, see the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section of the manual.
</p>
<h3 id="sec-7">2.3 <code>winddmove.el</code> does not work with Org-mode.</h3>
<p>
<b>Org-mode takes over the S-cursor keys. I also want to use windmove.el, is there a way to fix this conflict?</b>
</p>
<p>
Yes, see the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section of the manual.
</p>
<h2 id="sec-8">3 Setup and Structure</h2>
<h3 id="sec-9">3.1 Org-mode as default mode</h3>
<p>
<b>Org-mode seems to be a useful default mode for the various README files I have scattered through my directories</b>. <b>How do I turn it on for all README files?</b>
</p>
<p>
Add the following to your .emacs file:
</p>
<p>
<pre>
(add-to-list 'auto-mode-alist '("README$" . org-mode))
</pre>
</p>
<p>
You can even make it the default mode for any files with unspecified
mode using
</p>
<p>
<pre>
(setq default-major-mode 'org-mode)
</pre>
</p>
<h3 id="sec-10">3.2 Get rid of extra stars in outline</h3>
<p>
<b>All these stars are driving me mad, I just find the Emacs outlines unreadable. Can't you just put white space and a single star as a starter for headlines?</b>
</p>
<p>
See the section <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Clean%20outline%20view">Clean outline view</a> in the manual.
</p>
<h3 id="sec-11">3.3 Two windows on same Org-mode file</h3>
<p><b>I would like to have two windows on the same Org-mode file, but with different outline visibility. Is that possible?</b>
</p>
<p>
You may use <i>indirect buffers</i> which do exactly this. See the
documentation on the command <code>make-indirect-buffer</code>.
</p>
<h3 id="sec-12">3.4 Insert empty lines before new headings and plain list items</h3>
<p>
<b>I would like to have an empty line before each newly inserted headline, but not before each newly inserted plain-list item</b>.
</p>
<p>
<pre>
(setq org-blank-before-new-entry
'((heading . t) (plain-list-item . nil))
</pre>
</p>
<h3 id="sec-13">3.5 Amount of context in sparse trees</h3>
<p>
*Sparse tree show the headline hierarchy above each match, and also
the headline following a match. I'd like to construct more compact
trees, with less context.*
</p>
<p>
Take a look at the variables <code>org-show-hierarchy-above</code> and
<code>org-show-following-headline</code>.
</p>
<h3 id="sec-14">3.6 Stacking calls to org-occur</h3>
<p>
<b>Each call to org-occur starts again from OVERVIEW and exposes only the matches of the current call. I'd like to combine the effect of several calls</b>.
</p>
<p>
You can construct a regular expression that matches all targets you
want. Alternatively, use a <code>C-u</code> prefix with the second and any
further calls to <code>org-occur</code> to keep the current visibility and
highlighting in addition to the new ones.
</p>
<h2 id="sec-15">4 Hyperlinks</h2>
<h3 id="sec-16">4.1 Confirmation for shell and elisp links</h3>
<p>
<b>When I am executing shell/elisp links I always get a confirmation prompt and need to type "yes RET", that's 4 key presses! Can I get rid of this?</b>
</p>
<p>
The confirmation is there to protect you from unwantingly execute
potentially dangerous commands. For example, imagine a link
<pre>
[[shell:rm -rf ~/*][ Google Search]]
</pre>
</p>
<p>
In an Org-mode buffer, this command would look like <i>Google Search</i>,
but really it would remove your home directory. If you wish, you can
make it easier to respond to the query by setting
</p>
<p>
<pre>
(setq org-confirm-shell-link-function 'y-or-n-p
org-confirm-elisp-link-function 'y-or-n-p).
</pre>
</p>
<p>
Then a single keypress will be enough to confirm those links. It is
also possible to turn off this check entirely, but I strongly recommend
against this. Be warned.
</p>
<h3 id="sec-17">4.2 Use RET or TAB to follow a link</h3>
<p>
<b>From other packages like Emacs-wiki, I am used to follow links with <code>RET</code> when the cursor is on the link. Is this also possible in org-mode?</b>
</p>
<p>
Yes, and you may also use TAB.
</p>
<p>
<pre>
(setq org-return-follows-link t)
(setq org-tab-follows-link t)
</pre>
</p>
<h3 id="sec-18">4.3 Clicking on a link without activating it</h3>
<p>
<b>Each time I click inside a link in order to set point to this location, Org-mode actually follows the link</b>
</p>
<p>
Activating links with <code>mouse-1</code> is a new feature in Emacs 22, to make
link behavior similar to other applications like web browsers. If you
hold the mouse button down a bit longer, the cursor will be set
without following the link. If you cannot get used to this behavior,
you can (as in Emacs 21) use <code>mouse-2</code> to follow links and turn off
link activation for <code>mouse-1</code> with
</p>
<p>
<pre>
(setq org-mouse-1-follows-link nil)
</pre>
</p>
<h2 id="sec-19">5 Export</h2>
<h3 id="sec-20">5.1 Make TODO entries items, not headlines in HTML export</h3>
<p>
<b>When I export my TODO list, every TODO item becomes a separate section. How do I enforce these items to be exported as an itemized list?</b>
</p>
<p>
If you plan to use ASCII or HTML export, make sure things you want to
be exported as item lists are level 4 at least, even if that does mean
there is a level jump. For example:
</p>
<p>
<pre>
* Todays top priorities
**** TODO write a letter to xyz
**** TODO Finish the paper
**** Pick up kids at the school
</pre>
</p>
<p>
Alternatively, if you need a specific value for the heading/item
transition in a particular file, use the <code>#+OPTIONS</code> line to
configure the H switch.
</p>
<p>
<pre>
#+OPTIONS: H:2; ...
</pre>
</p>
<h3 id="sec-21">5.2 Export only a subtree</h3>
<p>
<b>I would like to export only a subtree of my file to HTML. How?</b>
</p>
<p>
If you want to export a subtree, mark the subtree as region and then
export. Marking can be done with <code>C-c @ C-x C-x</code>, for example.
</p>
<h3 id="sec-22">5.3 How to import org-mode calendar data into Mac OSX ical</h3>
<p>
<b>I would like my iCal program on Mac OSX to import the iCalendar file produced by Org-mode. How?</b>
</p>
<p>
<i>This is for OSX 10.3, see below for 10.4:</i> When using iCal under
Apple MacOS X, you can create a new calendar <i>OrgMode</i> (the default
name for the calendar created by <code>C-c C-e c</code>, see the variables
<code>org-icalendar-combined-name</code> and
<code>org-combined-agenda-icalendar-file</code>). Then set Org-mode to overwrite
the corresponding file <i>~/Library/Calendars/OrgMode.ics</i>. You may
even use AppleScript to make iCal re-read the calendar files each time
a new version of <i>OrgMode.ics</i> is produced. Here is the setup needed
for this:
</p>
<p>
<pre>
(setq org-combined-agenda-icalendar-file
"~/Library/Calendars/OrgMode.ics")
(add-hook 'org-after-save-iCalendar-file-hook
(lambda ()
(shell-command
"osascript -e 'tell application \"iCal\" to reload calendars'")))
</pre>
</p>
<p>
For Mac OS X 10.4, you need to write the ics file to
<code>/Library/WebServer/Documents/</code> and then subscribe iCalendar to
<code>http: //localhost/orgmode.ics</code>
</p>
<h2 id="sec-23">6 Tables</h2>
<h3 id="sec-24">6.1 #ERROR fields in tables</h3>
<p>
<b>One of my table columns has started to fill up with <code>#ERROR</code>. What is going on?</b>
</p>
<p>
Org-mode tried to compute the column from other fields using a
formula stored in the <code>#+TBLFM:</code> line just below the table, and
the evaluation of the formula fails. Fix the fields used in the
formula, or fix the formula, or remove it!
</p>
<h3 id="sec-25">6.2 Unwanted new lines in table</h3>
<p>
<b>When I am in the last column of a table and just above a horizontal line in the table, pressing TAB creates a new table line before the horizontal line</b>. <b>How can I quickly move to the line below the horizontal line instead?</b>
</p>
<p>
Press <code>down</code> (to get on the separator line) and then <code>TAB</code>.
Or configure the variable
</p>
<p>
<pre>
(setq org-table-tab-jumps-over-hlines t)
</pre>
</p>
<h3 id="sec-26">6.3 Automatic detection of formulas</h3>
<p><b>I need to use fields in my table that start with "=", and each time I enter such a field, Org-mode thinks this is a formula</b>.
</p>
<p>
With the setting
</p>
<p>
<pre>
(setq org-table-formula-evaluate-inline nil)
</pre>
</p>
<p>
this will no longer happen. You can still use formulas using the
commands <tt>C-c =</tt> and <tt>C-u C-c =</tt>
</p>
<h3 id="sec-27">6.4 Change indentation of a table</h3>
<p><b>How can I change the indentation of an entire table without fixing every line by hand?</b>
</p>
<p>
The indentation of a table is set by the first line. So just fix the
indentation of the first line and realign with <code>TAB</code>.
</p>
<h3 id="sec-28">6.5 Performance issues with table alignment</h3>
<p><b>I have a huge table in a file, and the automatic realign of tables is just taking too long. What can I do?</b>
</p>
<p>
Either split the table into several by inserting an empty line every
100 lines or so. Or turn off the automatic re-align with
</p>
<p>
<pre>
(setq org-table-automatic-realign nil)
</pre>
</p>
<p>
After this the only way to realign a table is to press <code>C-c C-c</code>. It
will no longer happen automatically, removing the corresponding delays
during editing.
</p>
<h3 id="sec-29">6.6 Performance issues with table calculation</h3>
<p><b>I have a complex table with lots of formulas, and recomputing the table takes rather long. What can I do?</b>
</p>
<p>
Nothing, really. The spreadsheet in org is mostly done to make
calculations possible, not so much to make them fast. Since Org-mode
is firmly committed to the ASCII format, nothing is stopping you from
editing the table by hand. Therefore, there is no internal
representation of the data. Each time Org-mode starts a computation,
it must scan the table for special lines, find the fields etc. This
is slow. Furthermore, Calc is slow compared to hardware computations.
To make this work with normal editing, recalculation is not happening
automatically, or only for the current line, so that the long wait for
a full table iteration only happens when you ask for it.
</p>
<p>
So for really complex tables, moving to a "real" spreadsheet may still
be the best option.
</p>
<p>
That said, there are some ways to optimize things in Org-mode, and I
have been thinking about moving a bit further down this line.
However, for my applications this has so far not been an issue at all.
If you have a good case,you could try to convince me.
</p>
<h3 id="sec-30">6.7 Incrementing numbers</h3>
<p><b>When I press <code>S-RET</code> in a table field to copy its value down, the content is not copied as is, but it is increased by one. Is that a bug or a feature</b>
</p>
<p>
Well, it is <i>supposed</i> to be a feature, to make it easy to create a
column with increasing numbers. If this gets into your way, turn it
off with
</p>
<p>
<pre>
(setq org-org-table-copy-increment nil)
</pre>
</p>
<h2 id="sec-31">7 Agenda</h2>
<h3 id="sec-32">7.1 Include Org-mode agenda into Emacs diary</h3>
<p><b>Is it possible to include entries from org-mode files into my emacs diary?</b>
</p>
<p>
Since the org-mode agenda is much more powerful and can contain the
diary, you should think twice before deciding to do this. If you
insist, however, integrating Org-mode information into the diary is
possible. You need to turn on <i>fancy diary display</i> by setting in
.emacs:
</p>
<p>
<pre>
(add-hook 'diary-display-hook 'fancy-diary-display)
</pre>
</p>
<p>
Then include the following line into your ~/diary file, in
order to get the entries from all files listed in the variable
<code>org-agenda-files</code>
</p>
<p>
<pre>
&amp;%%(org-diary)
</pre>
You may also select specific files with
</p>
<p>
<pre>
&amp;%%(org-diary) ~/path/to/some/org-file.org
&amp;%%(org-diary) ~/path/to/another/org-file.org
</pre>
</p>
<p>
If you now launch the calendar and press <tt>d</tt> to display a diary, the
headlines of entries containing a timestamp, date range, schedule, or
deadline referring to the selected date will be listed. Just like
Org-mode's agenda view, the diary for <i>today</i> contains additional
entries for overdue deadlines and scheduled items. See also the
documentation of the <code>org-diary</code> function. Under XEmacs, it is
not possible to jump back from the diary to the org, this works only in
the agenda buffer.
</p>
<p class="author"> Author: Carsten Dominik
<a href="mailto:carsten.dominik@gmail.com">&lt;carsten.dominik@gmail.com&gt;</a>
</p>
<p class="date"> Date: 2007/09/10 07:06:01</p>
</body>
</html>

372
ORGWEBPAGE/faq.org Normal file
View File

@ -0,0 +1,372 @@
#+STARTUP: overview align
#+TYP_TODO: TODO IDEA WISH QUESTION DECLINED INCONSISTENCY BUG DONE
#+OPTIONS: H:2 num:t toc:t \n:nil @:t ::t |:t ^:t *:t TeX:t
#+EMAIL: carsten.dominik@gmail.com
#+TITLE: Org-mode Frequently Asked Questions
* General
** Use features in other modes
*I would like to use editing features of org-mode in other modes, is
this possible?*
Not really. For tables there is =orgtbl-mode= which implements the
table editor as a minor mode. For other features you need to switch to
Org-mode temporarily, or prepare text in a different buffer.
** Visibility cycling in Outline-mode and Outline-minor-mode
*Can I get the visibility-cycling features in outline-mode and
outline-minor-mode?*
Yes, these functions are written in a way that they are independent of
the outline setup. The following setup provides standard Org-mode
functionality in outline-mode on =TAB= and =S-TAB=. For
outline-minor-mode, we use =C-TAB= instead of =TAB=,
because =TAB= usually has mode-specific tasks.
:(add-hook 'outline-minor-mode-hook
: (lambda ()
: (define-key outline-minor-mode-map [(control tab)] 'org-cycle)
: (define-key outline-minor-mode-map [(shift tab)] 'org-global-cycle)))
:(add-hook 'outline-mode-hook
: (lambda ()
: (define-key outline-mode-map [(tab)] 'org-cycle)
: (define-key outline-mode-map [(shift tab)] 'org-global-cycle)))
Or check out /outline-magic.el/, which does this and also provides
promotion and demotion functionality. /outline-magic.el/ is
available at [[http://www.astro.uva.nl/~dominik/Tools/OutlineMagic][Outline Magic]].
* Errors
** =(wrong-type-argument keymapp nil)=
*When I try to use Org-mode, I always get the error message
@code{(wrong-type-argument keymapp nil)}*
This is a conflict with an outdated version of the /allout.el/, see
the [[http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts][Conflicts]] section in the manual
** CUA mode does not work with Org-mode
*Org-mode takes over the S-cursor keys. I also want to use CUA-mode,
is there a way to fix this conflict?*
Yes, see the [[http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts][Conflicts]] section of the manual.
** =winddmove.el= does not work with Org-mode.
*Org-mode takes over the S-cursor keys. I also want to use windmove.el,
is there a way to fix this conflict?*
Yes, see the [[http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts][Conflicts]] section of the manual.
* Setup and Structure
** Org-mode as default mode
*Org-mode seems to be a useful default mode for the various README
files I have scattered through my directories*. *How do I turn it on
for all README files?*
Add the following to your .emacs file:
: (add-to-list 'auto-mode-alist '("README$" . org-mode))
You can even make it the default mode for any files with unspecified
mode using
: (setq default-major-mode 'org-mode)
** Get rid of extra stars in outline
*All these stars are driving me mad, I just find the Emacs outlines
unreadable. Can't you just put white space and a single star as a
starter for headlines?*
See the section [[http://staff.science.uva.nl/~dominik/Tools/org/org.html#Clean%20outline%20view][Clean outline view]] in the manual.
** Two windows on same Org-mode file
*I would like to have two windows on the same Org-mode file, but with
different outline visibility. Is that possible?*
You may use /indirect buffers/ which do exactly this. See the
documentation on the command =make-indirect-buffer=.
** Insert empty lines before new headings and plain list items
*I would like to have an empty line before each newly inserted
headline, but not before each newly inserted plain-list item*.
: (setq org-blank-before-new-entry
: '((heading . t) (plain-list-item . nil))
** Amount of context in sparse trees
*Sparse tree show the headline hierarchy above each match, and also
the headline following a match. I'd like to construct more compact
trees, with less context.*
Take a look at the variables =org-show-hierarchy-above= and
=org-show-following-headline=.
** Stacking calls to org-occur
*Each call to org-occur starts again from OVERVIEW and exposes only
the matches of the current call. I'd like to combine the effect of
several calls*.
You can construct a regular expression that matches all targets you
want. Alternatively, use a =C-u= prefix with the second and any
further calls to =org-occur= to keep the current visibility and
highlighting in addition to the new ones.
* Hyperlinks
** Confirmation for shell and elisp links
*When I am executing shell/elisp links I always get a confirmation
prompt and need to type "yes RET", that's 4 key presses! Can I get
rid of this?*
The confirmation is there to protect you from unwantingly execute
potentially dangerous commands. For example, imagine a link
:[[shell:rm -rf ~/*][ Google Search]]
In an Org-mode buffer, this command would look like /Google Search/,
but really it would remove your home directory. If you wish, you can
make it easier to respond to the query by setting
: (setq org-confirm-shell-link-function 'y-or-n-p
: org-confirm-elisp-link-function 'y-or-n-p).
Then a single keypress will be enough to confirm those links. It is
also possible to turn off this check entirely, but I strongly recommend
against this. Be warned.
** Use RET or TAB to follow a link
*From other packages like Emacs-wiki, I am used to follow links with
=RET= when the cursor is on the link. Is this also possible in org-mode?*
Yes, and you may also use TAB.
: (setq org-return-follows-link t)
: (setq org-tab-follows-link t)
** Clicking on a link without activating it
*Each time I click inside a link in order to set point to this
location, Org-mode actually follows the link*
Activating links with =mouse-1= is a new feature in Emacs 22, to make
link behavior similar to other applications like web browsers. If you
hold the mouse button down a bit longer, the cursor will be set
without following the link. If you cannot get used to this behavior,
you can (as in Emacs 21) use =mouse-2= to follow links and turn off
link activation for =mouse-1= with
: (setq org-mouse-1-follows-link nil)
* Remember
*Can I automatically start the clock when opening a remember template?*
Yes, this is possible. Use the following code and make sure that
after executing it, `my-start-clock-if-needed' is in
`remember-mode-hook' /after/ `org-remember-apply-template'.
: (add-hook 'remember-mode-hook 'my-start-clock-if-needed 'append)
: (defun my-start-clock-if-needed ()
: (save-excursion
: (goto-char (point-min))
: (when (re-search-forward " *CLOCK-IN *" nil t)
: (replace-match "")
: (org-clock-in))))
Then, when a template contains the key string CLOCK-IN, the clock will
be started. Starting with Org-mode version 5.20, the clock will
automatically be stopped when storing the remember buffer.
* Export
** Make TODO entries items, not headlines in HTML export
*When I export my TODO list, every TODO item becomes a separate
section. How do I enforce these items to be exported as an itemized
list?*
If you plan to use ASCII or HTML export, make sure things you want to
be exported as item lists are level 4 at least, even if that does mean
there is a level jump. For example:
: * Todays top priorities
: **** TODO write a letter to xyz
: **** TODO Finish the paper
: **** Pick up kids at the school
Alternatively, if you need a specific value for the heading/item
transition in a particular file, use the =#+OPTIONS= line to
configure the H switch.
: #+OPTIONS: H:2; ...
** Export only a subtree
*I would like to export only a subtree of my file to HTML. How?*
If you want to export a subtree, mark the subtree as region and then
export. Marking can be done with =C-c @ C-x C-x=, for example.
** How to import org-mode calendar data into Mac OSX ical
*I would like my iCal program on Mac OSX to import the iCalendar file
produced by Org-mode. How?*
/This is for OSX 10.3, see below for 10.4:/ When using iCal under
Apple MacOS X, you can create a new calendar /OrgMode/ (the default
name for the calendar created by =C-c C-e c=, see the variables
=org-icalendar-combined-name= and
=org-combined-agenda-icalendar-file=). Then set Org-mode to overwrite
the corresponding file /~/Library/Calendars/OrgMode.ics/. You may
even use AppleScript to make iCal re-read the calendar files each time
a new version of /OrgMode.ics/ is produced. Here is the setup needed
for this:
: (setq org-combined-agenda-icalendar-file
: "~/Library/Calendars/OrgMode.ics")
: (add-hook 'org-after-save-iCalendar-file-hook
: (lambda ()
: (shell-command
: "osascript -e 'tell application \"iCal\" to reload calendars'")))
For Mac OS X 10.4, you need to write the ics file to
=/Library/WebServer/Documents/= and then subscribe iCalendar to
=http: //localhost/orgmode.ics=
* Tables
** #ERROR fields in tables
*One of my table columns has started to fill up with =#ERROR=. What
is going on?*
Org-mode tried to compute the column from other fields using a
formula stored in the =#+TBLFM:= line just below the table, and
the evaluation of the formula fails. Fix the fields used in the
formula, or fix the formula, or remove it!
** Unwanted new lines in table
*When I am in the last column of a table and just above a horizontal
line in the table, pressing TAB creates a new table line before the
horizontal line*. *How can I quickly move to the line below the
horizontal line instead?*
Press =down= (to get on the separator line) and then =TAB=.
Or configure the variable
: (setq org-table-tab-jumps-over-hlines t)
** Automatic detection of formulas
*I need to use fields in my table that start with "=", and each time
I enter such a field, Org-mode thinks this is a formula*.
With the setting
: (setq org-table-formula-evaluate-inline nil)
this will no longer happen. You can still use formulas using the
commands @<tt>C-c =@</tt> and @<tt>C-u C-c =@</tt>
** Change indentation of a table
*How can I change the indentation of an entire table without fixing
every line by hand?*
The indentation of a table is set by the first line. So just fix the
indentation of the first line and realign with =TAB=.
** Performance issues with table alignment
*I have a huge table in a file, and the automatic realign of tables
is just taking too long. What can I do?*
Either split the table into several by inserting an empty line every
100 lines or so. Or turn off the automatic re-align with
: (setq org-table-automatic-realign nil)
After this the only way to realign a table is to press =C-c C-c=. It
will no longer happen automatically, removing the corresponding delays
during editing.
** Performance issues with table calculation
*I have a complex table with lots of formulas, and recomputing the
table takes rather long. What can I do?*
Nothing, really. The spreadsheet in org is mostly done to make
calculations possible, not so much to make them fast. Since Org-mode
is firmly committed to the ASCII format, nothing is stopping you from
editing the table by hand. Therefore, there is no internal
representation of the data. Each time Org-mode starts a computation,
it must scan the table for special lines, find the fields etc. This
is slow. Furthermore, Calc is slow compared to hardware computations.
To make this work with normal editing, recalculation is not happening
automatically, or only for the current line, so that the long wait for
a full table iteration only happens when you ask for it.
So for really complex tables, moving to a "real" spreadsheet may still
be the best option.
That said, there are some ways to optimize things in Org-mode, and I
have been thinking about moving a bit further down this line.
However, for my applications this has so far not been an issue at all.
If you have a good case,you could try to convince me.
** Incrementing numbers
*When I press =S-RET= in a table field to copy its value down, the
content is not copied as is, but it is increased by one.
Is that a bug or a feature*
Well, it is /supposed/ to be a feature, to make it easy to create a
column with increasing numbers. If this gets into your way, turn it
off with
: (setq org-org-table-copy-increment nil)
* Agenda
** Include Org-mode agenda into Emacs diary
*Is it possible to include entries from org-mode files into my emacs
diary?*
Since the org-mode agenda is much more powerful and can contain the
diary, you should think twice before deciding to do this. If you
insist, however, integrating Org-mode information into the diary is
possible. You need to turn on /fancy diary display/ by setting in
.emacs:
: (add-hook 'diary-display-hook 'fancy-diary-display)
Then include the following line into your ~/diary file, in
order to get the entries from all files listed in the variable
=org-agenda-files=
: &%%(org-diary)
You may also select specific files with
: &%%(org-diary) ~/path/to/some/org-file.org
: &%%(org-diary) ~/path/to/another/org-file.org
If you now launch the calendar and press @<tt>d@</tt> to display a diary, the
headlines of entries containing a timestamp, date range, schedule, or
deadline referring to the selected date will be listed. Just like
Org-mode's agenda view, the diary for /today/ contains additional
entries for overdue deadlines and scheduled items. See also the
documentation of the =org-diary= function. Under XEmacs, it is
not possible to jump back from the diary to the org, this works only in
the agenda buffer.
* COMMENT HTML style specifications
# Local Variables:
# org-export-html-style: "<link rel=stylesheet href=\"freeshell2.css\" type=\"text/css\"> <style type=\"text/css\"> .tag { color: red; font-weight:bold}</style>"
# End:

66
ORGWEBPAGE/freeshell2.css Normal file
View File

@ -0,0 +1,66 @@
body {
font-family: helvetica, verdana, sans-serif;
font-size: 12pt;
margin-top: 5%;
margin-bottom: 8%;
background: white; color: black;
margin-left: 15%; margin-right: 15%;
}
h1 {
font-size: 18pt;
color: #ff8c00;
padding-top: 1em;
border-bottom: 2px solid #aaa;
}
h2 {
font-size: 16pt;
padding-top: 1em;
border-bottom: 1px solid #ccc;
}
h3 {
font-size: 14pt;
padding-top: 0.5em;
border-bottom: 1px solid #eee;
}
.todo, .deadline { color: red; }
.done { color: green; }
.timestamp { color: grey }
.timestamp-kwd { color: CadetBlue; }
.tag { background-color:lightblue; font-weight:normal; }
.target { background-color: lavender; }
.menu {
color: #666;
}
.menu a:link {
color: #888;
}
.menu a:active {
color: #888;
}
.menu a:visited {
color: #888;
}
img { align: center; }
pre {
border: 1pt solid #AEBDCC;
background-color: #F3F5F7;
padding: 5pt;
font-family: courier, monospace;
font-size: 9pt;
}
table { border-collapse: collapse; }
td, th {
vertical-align: top;
border: 1pt solid #ADB9CC;
}

403
ORGWEBPAGE/index.html Normal file
View File

@ -0,0 +1,403 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-Mode Homepage</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2008/01/18 12:46:32"/>
<meta name="author" content="Carsten Dominik"/>
<style type="text/css">
html {
font-family: Times, serif;
font-size: 12pt;
}
.title { text-align: center; }
.todo { color: red; }
.done { color: green; }
.timestamp { color: grey }
.timestamp-kwd { color: CadetBlue }
.tag { background-color:lightblue; font-weight:normal }
.target { background-color: lavender; }
pre {
border: 1pt solid #AEBDCC;
background-color: #F3F5F7;
padding: 5pt;
font-family: courier, monospace;
}
table { border-collapse: collapse; }
td, th {
vertical-align: top;
<!--border: 1pt solid #ADB9CC;-->
}
</style>
</head><body>
<h1 class="title">Org-Mode Homepage</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">Org - an Emacs Mode for Notes and Project Planning</a></li>
<li><a href="#sec-2">Current Version (5.19) and Compatibility</a></li>
<li><a href="#sec-3">Downloads</a></li>
<li><a href="#sec-4">Documentation</a>
<ul>
<li><a href="#sec-5">Manual and Reference card</a></li>
</ul>
</li>
<li><a href="#sec-6">Links</a>
<ul>
<li><a href="#sec-7">Mailing list</a></li>
<li><a href="#sec-8">Tutorials</a></li>
<li><a href="#sec-9">Org-mode, GTD and other task management systems </a></li>
<li><a href="#sec-10">Add-Ons</a></li>
<li><a href="#sec-11">Translators</a></li>
<li><a href="#sec-15">Alternative distributions</a></li>
<li><a href="#sec-16">Contributing to Org-mode</a></li>
<li><a href="#sec-17">Future Development</a></li>
</ul>
</li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">Org - an Emacs Mode for Notes and Project Planning</h2>
<BASE href="http://orgmode.org/index.html">
<p>
Org-mode is a mode for keeping notes, maintaining ToDo lists, and doing
project planning with a fast and effective plain-text system.
</p>
<p>
Org-mode develops organizational tasks around NOTES files that contain
information about projects as plain text. Org-mode is implemented on
top of outline-mode, which makes it possible to keep the content of
large files well structured. Visibility cycling and structure editing
help to work with the tree. Tables are easily created with a built-in
table editor. Org-mode supports ToDo items, deadlines, time stamps,
and scheduling. It dynamically compiles entries into an agenda.
Plain text URL-like links connect to websites, emails, Usenet
messages, BBDB entries, and any files related to the projects. For
printing and sharing of notes, an Org-mode file can be exported as a
structured ASCII file, HTML, and LaTeX.
</p>
</div>
<div class="outline-2">
<h2 id="sec-2">Current Version (5.19) and Compatibility</h2>
<p>
The current version is 5.19. To see what has changed in recent
releases, check this <a href="Changes.html">list of user-visible changes</a>. These descriptions
are extensive, to avoid that people will be printing the manual after
each incremental release. If you have an older version of the manual,
just check the release notes and you will be up-to-date.
</p>
<p>
This package works on Emacs 22, and (with minor restrictions) on Emacs
21 and XEmacs 21 (where you must also use <i>noutline.el</i> shipped with
Org-mode). The Emacs 22.1 release ships with Org-mode version 4.67c.
The latest CVS emacs trunk usually contains a fairly recent version,
but may lag a bit behind the website release.
</p>
</div>
<div class="outline-2">
<h2 id="sec-3">Downloads</h2>
<ul>
<li>Distribution<br/>
Download as <a href="org-5.19.zip">zip file</a> or <a href="org-5.19.tar.gz">gzipped tar archive</a>. These archives contain
both the Lisp file org.el and the documentation in PDF and (TeX)Info
formats. A shell script to simplify upgrading to the newest release
has been posted <a href="http://www.philfam.co.uk/pete/GTD/org-mode/update-org.sh">here</a>.
</li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-4">Documentation</h2>
<div class="outline-3">
<h3 id="sec-5">Manual and Reference card</h3>
<ul>
<li>
Read the documentation <a href="manual/index.html">online</a>. This is a version consisting of many
small files, to save bandwidth. If you really need it, you can also
have the entire manual in a <a href="org.html">single monolithic file</a>.
</li>
<li>
Download the documentation in other formats: <a href="org.pdf">PDF</a>, <a href="org">Info</a>, or <a href="org.texi">TeXInfo</a>.
</li>
<li>
Download the <a href="orgcard.pdf">Refcard</a> for org-mode, and Kyle Sherman hast created a
<a href="orgcard.txt">text version</a> of the reference card
</li>
<li>
There is also a <a href="http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fManual">Japanese translation</a> of the manual (version 4.60),
produced by Takeshi Okano.
</li>
<li>
The <a href="faq.html">FAQ</a> is not very up-to-date, but may still answer some of your
questions. Please have a look before posting to emacs-orgmode@gnu.org.
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-6">Links</h2>
<div class="outline-3">
<h3 id="sec-7">Mailing list</h3>
<p>
There is a mailing list for discussion about org-mode.
</p>
<ul>
<li>
Subscribe to it at <a href="http://lists.gnu.org/mailman/listinfo/emacs-orgmode">this webpage</a>.
</li>
<li>
Directly <a href="mailto:emacs-orgmode@gnu.org">send mail to it</a>. If you are not subscribed, a moderator
will look at the message before passing it through to the
list. If that has happened once, future messages from your email
address will get through immediately, even if you remain
unsubscribed.
</li>
<li>
Read the list on <a href="http://www.gmane.org">Gmane</a> through a <a href="http://news.gmane.org/gmane.emacs.orgmode">web interface</a> or with a
<a href="news://news.gmane.org/gmane.emacs.orgmode">newsreader</a>.
<li><form method="get" action="http://search.gmane.org/">
<input type="text" name="query">
<input type="hidden" name="group" value="gmane.emacs.orgmode">
<input type="submit" value="Search gmane.emacs.orgmode">
</form>
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-8">Tutorials</h3>
<p>
<a href="tutorials.html">Tutorials and screencasts</a> are listed on a separate page.
</p>
</div>
<div class="outline-3">
<h3 id="sec-9">Org-mode, GTD and other task management systems </h3>
<p>Org-mode is flexible enough to implement many different ways of
organizing your projects. A frequently discusses scheme is <a href="http://www.davidco.com/">David Allen's</a> strategy for <a href="http://en.wikipedia.org/wiki/GTD">Getting Things Done</a>. But it is clearly not
the only way to us Org-mode for planning. Here are a couple of
links related to this topic.
</p>
<ul>
<li>
<a href="http://johnwiegley.com">John Wiegley</a> has written an excellent document describing his
way of using Org-mode as a <a href="http://johnwiegley.com/org.mode.day.planner.html">day planner</a>. See also some later
messages for enhancements of his setup:
<a href="http://article.gmane.org/gmane.emacs.orgmode/2963">emacs-orgmode-2962</a>, <a href="http://article.gmane.org/gmane.emacs.orgmode/3629">emacs-orgmode-3629</a>
</li>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a> has written an <a href="http://members.optusnet.com.au/~charles57/GTD/orgmode.html">article/tutorial</a> about the basic
elements of GTD and how he implements them in Org-mode.
</li>
<li>
There have been several threads on emacs-orgmode@gnu.org related
to GTD, the most important ones are:
<ul>
<li>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/683">Another GTD question</a>, which contains a discussion about basic
GTD aspects. It also contains this
</li>
<li>
<a href="http://article.gmane.org/gmane.emacs.orgmode/715">Post by Carsten</a> summarizing several options for implementing
GTD in org-mode.
</li>
<li>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/523">GTD, Projects and Next Actions in org-mode</a> is a thread where
several people describe their personal setup is
</li>
<li>
The <a href="http://thread.gmane.org/gmane.emacs.orgmode/4915">SOMEDAY/MAYBE vs. low priorities</a> thread contains a
discussion about priorities that is quite instructive.
</li>
<li>
Here is a <a href="http://thread.gmane.org/gmane.emacs.orgmode/4832/focus%3D4854">very instructive post</a> by Pete Phillips explaining
why David Allens book is where you should start to learn GTD,
and that the Internet and Org-mode only come into the game
later, when thinking about the implementation. And since
doing GTD the right way will give you lots of free time, don't
forget to listen to <a href="http://www.detox-jazz.co.uk/">Pete's music</a>!
</li>
</ul></li>
<li>
Also on the web you can find information about how people are
setting up Org-mode to fit their habits. A few examples:
<ul>
<li>
This <a href="http://www.brool.com/?p=82">blog post</a> shows a very simple and clear GTD setup.
</li>
</ul></li>
</ul></div>
<div class="outline-3">
<h3 id="sec-10">Add-Ons</h3>
<ul>
<li>
<a href="http://www.cl.cam.ac.uk/~pz215/">Piotr Zielinski</a> wrote <a href="http://www.cl.cam.ac.uk/~pz215/files/org-mouse.el">org-mouse.el</a> which is now distributed with
Org-mode. It implements great mouse support for many functions in
org-mode.
</li>
<li>
<a href="http://dto.freeshell.org/notebook/">David O'Toole</a> is the author of <a href="http://dto.freeshell.org/e/org-publish.el">org-publish.el</a>. While this is
now part of the Org-mode distribution, you might find the newest
bug fixes and developments at his <a href="http://dto.freeshell.org/notebook/OrgMode.html">Org-mode page</a>, along with
several other projects like <i>org-blog.el</i> and
<i>org-publish-escript.el</i>.
</li>
<li>
<a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a> has been really prolific in writing interesting
add-ons, all available at his <a href="http://www.cognition.ens.fr/~guerry/bastien-org-mode.html">org-mode page</a>:
<ul>
<li>
a package for using Org-mode as the basis for blogging
</li>
<li>
a LaTeX exporter that is now distributed together with
org-mode
</li>
<li>
a special table-of-contents buffer that simplifies navigation
</li>
<li>
a registry to find locations that link a specific document.
</li>
</ul></li>
<li>
George C.F. Greve wrote <a href="http://www.emacswiki.org/emacs/org-mairix.el">org-mairix.el</a> to add links that trigger a
mairix search.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-11">Translators</h3>
<p>
I know about the following attempts to translate from and to
Org-mode files:
</p>
<div class="outline-4">
<h4 id="sec-12">Org-mode to XXX</h4>
<ul>
<li>
<a href="http://www.cognition.ens.fr/~guerry/u/org2rem.el">From Org-mode to remind</a> by <a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>.
</li>
<li>
<a href="org-export-freemind-0.1.0.tar.gz">From Org-mode to Freemind</a> by Marco Vezzoli.
</li>
</ul></div>
<div class="outline-4">
<h4 id="sec-13">XXX to Org-mode</h4>
<ul>
<li>
<a href="http://www.olafdietsche.de/palm/palm2orgmode.pl">From Palm TODO database to Orgmode</a>. This Translator was
written by <a href="http://www.olafdietsche.de/">Olaf Dietsche</a>.
</li>
</ul></div>
<div class="outline-4">
<h4 id="sec-14">Bi-directional</h4>
<p>
Unfortunately nothing so far.
</p>
</div>
</div>
<div class="outline-3">
<h3 id="sec-15">Alternative distributions</h3>
<ul>
<li>
Mark A. Hershberger has made some <a href="https://launchpad.net/~hexmode/+archive">Ubuntu packages</a> for org-mode.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-16">Contributing to Org-mode</h3>
<p>
You can always contribute with ideas and bug reports on the mailing
list. If you want to contribute a patch, code snippets, or a full
add-on, this is very welcome too! However, I can only make it an
official part of Org-mode if you have signed the papers with the
Free Software Foundation. Org-mode is distributed as part of Emacs
and must therefore adhere to strict rules about the copyright of
all included material. If this is what you want to do, <a href="request-assign-future.txt">here</a> is the
form that you have to fill in and send to the FSF. After you
received the final copy with signatures, please scan it and send
the scan to the maintainer.
</p>
</div>
<div class="outline-3">
<h3 id="sec-17">Future Development</h3>
<p>
Org-mode is still developing fast. The best way to stay up-to-date
is to join the mailing list where the changes are developed and
discusssed.
</p>
<p>
Here is a loose <a href="todo.html">list of ideas</a> that are still to be processed
somehow, when I get to it&hellip;
</p>
</div>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten at orgmode dot org">&lt;carsten at orgmode dot org&gt;</a>
</p>
<p class="date"> Date: 2008/01/18 12:46:32</p>
</div></body>
</html>

211
ORGWEBPAGE/index.org Normal file
View File

@ -0,0 +1,211 @@
#+TITLE: Org-Mode Homepage
#+LANGUAGE: en
#+EMAIL: carsten at orgmode dot org
#+OPTIONS: H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:t *:t TeX:t
* Org - an Emacs Mode for Notes and Project Planning
#+HTML: <BASE href="http://orgmode.org/index.html">
Org-mode is a mode for keeping notes, maintaining ToDo lists, and doing
project planning with a fast and effective plain-text system.
Org-mode develops organizational tasks around NOTES files that contain
information about projects as plain text. Org-mode is implemented on
top of outline-mode, which makes it possible to keep the content of
large files well structured. Visibility cycling and structure editing
help to work with the tree. Tables are easily created with a built-in
table editor. Org-mode supports ToDo items, deadlines, time stamps,
and scheduling. It dynamically compiles entries into an agenda.
Plain text URL-like links connect to websites, emails, Usenet
messages, BBDB entries, and any files related to the projects. For
printing and sharing of notes, an Org-mode file can be exported as a
structured ASCII file, HTML, and LaTeX.
* Current Version (5.19a) and Compatibility
The current version is 5.19a. To see what has changed in recent
releases, check this [[file:Changes.html][list of user-visible changes]]. These descriptions
are extensive, to avoid that people will be printing the manual after
each incremental release. If you have an older version of the manual,
just check the release notes and you will be up-to-date.
This package works on Emacs 22, and (with minor restrictions) on Emacs
21 and XEmacs 21 (where you must also use /noutline.el/ shipped with
Org-mode). The Emacs 22.1 release ships with Org-mode version 4.67c.
The latest CVS emacs trunk usually contains a fairly recent version,
but may lag a bit behind the website release.
* Downloads
**** Distribution
Download as [[file:org-5.19a.zip][zip file]] or [[file:org-5.19a.tar.gz][gzipped tar archive]]. These archives contain
both the Lisp file org.el and the documentation in PDF and (TeX)Info
formats. A shell script to simplify upgrading to the newest release
has been posted [[http://www.philfam.co.uk/pete/GTD/org-mode/update-org.sh][here]].
* Documentation
** Manual and Reference card
- Read the documentation [[file:manual/index.html][online]]. This is a version consisting of many
small files, to save bandwidth. If you really need it, you can also
have the entire manual in a [[file:org.html][single monolithic file]].
- Download the documentation in other formats: [[file:org.pdf][PDF]], [[file:org][Info]], or [[file:org.texi][TeXInfo]].
- Download the [[file:orgcard.pdf][Refcard]] for org-mode, and Kyle Sherman hast created a
[[file:orgcard.txt][text version]] of the reference card
- There is also a [[http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fManual][Japanese translation]] of the manual (version 4.60),
produced by Takeshi Okano.
- The [[file:faq.org][FAQ]] is not very up-to-date, but may still answer some of your
questions. Please have a look before posting to emacs-orgmode@gnu.org.
* Links
** Mailing list
There is a mailing list for discussion about org-mode.
- Subscribe to it at [[http://lists.gnu.org/mailman/listinfo/emacs-orgmode][this webpage]].
- Directly [[mailto:emacs-orgmode@gnu.org][send mail to it]]. If you are not subscribed, a moderator
will look at the message before passing it through to the
list. If that has happened once, future messages from your email
address will get through immediately, even if you remain
unsubscribed.
- Read the list on [[http://www.gmane.org][Gmane]] through a [[http://news.gmane.org/gmane.emacs.orgmode][web interface]] or with a
[[news://news.gmane.org/gmane.emacs.orgmode][newsreader]].
#+BEGIN_HTML
<li><form method="get" action="http://search.gmane.org/">
<input type="text" name="query">
<input type="hidden" name="group" value="gmane.emacs.orgmode">
<input type="submit" value="Search gmane.emacs.orgmode">
</form>
#+END_HTML
** Worg - user-driven knowledge-base about org-mode
[[http://129.199.80.1/~guerry/worg/][Worg]], created by [[http://www.cognition.ens.fr/~guerry/][Bastien Guerry]], is a setup to allow users to jointly
edit a number of Org-mode files containing documentation about
Org-mode. This is something like a wiki. If you'd like to contribute
your own setup, screenshots, tutorials etc, please go to [[http://129.199.80.1/~guerry/worg/][the Worg
page]], and start from there.
** Tutorials
[[file:tutorials.org][Tutorials and screencasts]] are listed on a separate page.
** Survey
In November 2007, Charles Cave organized a survey among Org-mode
users. The answers given in this survey can be found [[file:survey.html][here]].
** Org-mode, GTD and other task management systems
Org-mode is flexible enough to implement many different ways of
organizing your projects. A frequently discusses scheme is [[http://www.davidco.com/][David
Allen's]] strategy for [[http://en.wikipedia.org/wiki/GTD][Getting Things Done]]. But it is clearly not
the only way to us Org-mode for planning. Here are a couple of
links related to this topic.
- [[http://johnwiegley.com][John Wiegley]] has written an excellent document describing his
way of using Org-mode as a [[http://johnwiegley.com/org.mode.day.planner.html][day planner]]. See also some later
messages for enhancements of his setup:
[[http://article.gmane.org/gmane.emacs.orgmode/2963][emacs-orgmode-2962]], [[http://article.gmane.org/gmane.emacs.orgmode/3629][emacs-orgmode-3629]]
- [[http://members.optusnet.com.au/charles57/Creative/][Charles Cave]] has written an [[http://members.optusnet.com.au/~charles57/GTD/orgmode.html][article/tutorial]] about the basic
elements of GTD and how he implements them in Org-mode. There
is also a [[http://129.199.80.1/~guerry/org-gtd.html][french translation]] of this document.
- There have been several threads on emacs-orgmode@gnu.org related
to GTD, the most important ones are:
+ [[http://thread.gmane.org/gmane.emacs.orgmode/683][Another GTD question]], which contains a discussion about basic
GTD aspects. It also contains this
+ [[http://article.gmane.org/gmane.emacs.orgmode/715][Post by Carsten]] summarizing several options for implementing
GTD in org-mode.
+ [[http://thread.gmane.org/gmane.emacs.orgmode/523][GTD, Projects and Next Actions in org-mode]] is a thread where
several people describe their personal setup is
+ The [[http://thread.gmane.org/gmane.emacs.orgmode/4915][SOMEDAY/MAYBE vs. low priorities]] thread contains a
discussion about priorities that is quite instructive.
+ Here is a [[http://thread.gmane.org/gmane.emacs.orgmode/4832/focus%3D4854][very instructive post]] by Pete Phillips explaining
why David Allens book is where you should start to learn GTD,
and that the Internet and Org-mode only come into the game
later, when thinking about the implementation. And since
doing GTD the right way will give you lots of free time, don't
forget to listen to [[http://www.detox-jazz.co.uk/][Pete's music]]!
- Also on the web you can find information about how people are
setting up Org-mode to fit their habits. A few examples:
+ This [[http://www.brool.com/?p=82][blog post]] shows a very simple and clear GTD setup.
** Add-Ons
- [[http://www.cl.cam.ac.uk/~pz215/][Piotr Zielinski]] wrote [[http://www.cl.cam.ac.uk/~pz215/files/org-mouse.el][org-mouse.el]] which is now distributed with
Org-mode. It implements great mouse support for many functions in
org-mode.
- [[http://dto.freeshell.org/notebook/][David O'Toole]] is the author of [[http://dto.freeshell.org/e/org-publish.el][org-publish.el]]. While this is
now part of the Org-mode distribution, you might find the newest
bug fixes and developments at his [[http://dto.freeshell.org/notebook/OrgMode.html][Org-mode page]], along with
several other projects like /org-blog.el/ and
/org-publish-escript.el/.
- [[http://www.cognition.ens.fr/~guerry/][Bastien Guerry]] has been really prolific in writing interesting
add-ons, all available at his [[http://www.cognition.ens.fr/~guerry/bastien-org-mode.html][org-mode page]]:
+ a package for using Org-mode as the basis for blogging
+ a LaTeX exporter that is now distributed together with
org-mode
+ a special table-of-contents buffer that simplifies navigation
+ a registry to find locations that link a specific document.
- George C.F. Greve wrote [[http://www.emacswiki.org/emacs/org-mairix.el][org-mairix.el]] to add links that trigger a
mairix search.
** Translators
I know about the following attempts to translate from and to
Org-mode files:
*** Org-mode to XXX
- [[http://www.cognition.ens.fr/~guerry/u/org2rem.el][From Org-mode to remind]] by [[http://www.cognition.ens.fr/~guerry/][Bastien Guerry]].
- [[file:org-export-freemind-0.1.0.tar.gz][From Org-mode to Freemind]] by Marco Vezzoli.
*** XXX to Org-mode
- [[http://www.olafdietsche.de/palm/palm2orgmode.pl][From Palm TODO database to Orgmode]]. This Translator was
written by [[http://www.olafdietsche.de/][Olaf Dietsche]].
- From [[http://thread.gmane.org/gmane.emacs.orgmode/5073][Remind to Org]] by Detlef Steuer.
*** Bi-directional
Unfortunately nothing so far.
** Alternative distributions
- Mark A. Hershberger has made some [[https://launchpad.net/~hexmode/+archive][Ubuntu packages]] for org-mode.
** Contributing to Org-mode
You can always contribute with ideas and bug reports on the mailing
list. If you want to contribute a patch, code snippets, or a full
add-on, this is very welcome too! However, I can only make it an
official part of Org-mode if you have signed the papers with the
Free Software Foundation. Org-mode is distributed as part of Emacs
and must therefore adhere to strict rules about the copyright of
all included material. If this is what you want to do, [[file:request-assign-future.txt][here]] is the
form that you have to fill in and send to the FSF. After you
received the final copy with signatures, please scan it and send
the scan to the maintainer.
** Future Development
Org-mode is still developing fast. The best way to stay up-to-date
is to join the mailing list where the changes are developed and
discusssed.
Here is a loose [[file:todo.org][list of ideas]] that are still to be processed
somehow, when I get to it...
* Related Software
[[http://sachachua.com/wp/][Sacha Chua]] about [[http://sachachua.com/wp/2007/12/26/emacs-choosing-between-org-and-planner/][Choosing between Planner and Org]].

151
ORGWEBPAGE/index.txt Normal file
View File

@ -0,0 +1,151 @@
Org-Mode Homepage
=================
Author: Carsten Dominik <dominik at science dot uva dot nl>
Date: 2007/05/13 09:31:34
Table of Contents
=================
Org - an Emacs Mode for Notes and Project Planning
Current Version
Compatibility
Downloads
Frequently Asked Questions
Mailing list
Links
Tutorials
Org-mode and GTD
Add-Ons
Future Development
Org - an Emacs Mode for Notes and Project Planning
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Org-mode is a mode for keeping notes, maintaining ToDo lists, and doing
project planning with a fast and effective plain-text system.
Org-mode develops organizational tasks around NOTES files that contain
information about projects as plain text. Org-mode is implemented on
top of outline-mode, which makes it possible to keep the content of
large files well structured. Visibility cycling and structure editing
help to work with the tree. Tables are easily created with a built-in
table editor. Org-mode supports ToDo items, deadlines, time stamps,
and scheduling. It dynamically compiles entries into an agenda.
Plain text URL-like links connect to websites, emails, Usenet
messages, BBDB entries, and any files related to the projects. For
printing and sharing of notes, an Org-mode file can be exported as a
structured ASCII file, or as HTML.
Current Version
===============
The current version is 4.74. To see what has changed in recent
releases, check this [list of user-visible changes].
Compatibility
=============
This package works on Emacs 21 and (with minor restrictions) on
XEmacs 21. Version 4.67c will be part of the Emacs 22.1 release.
*Attention XEmacs users*: Starting with Org-mode 4.38, Org-mode will
only work correctly with XEmacs if you use [noutline.el], a new
implementation of outline-mode. Until this package becomes part of
XEmacs, you can find it in the xemacs subdirectory of the Org-mode
distribution. Just compile it and place it onto you load path,
Org-mode will load it automatically.
Downloads
=========
* Distribution
Download as [zip file] or [gzipped tar archive]. These archives
contain both the Lisp file org.el and the documentation in PDF
and (TeX)Info formats.
* Documentation
- Read the documentation [online].
- Download the documentation in [PDF], [Info], or [TeXInfo] format.
- Download the [Refcard] for org-mode.
- There is also a [Japanese translation] of the manual (version 4.60), produced by Takeshi Okano.
Frequently Asked Questions
==========================
The [FAQ] used to be part of the manual but this is no longer the case.
Mailing list
============
There is a mailing list for discussion about org-mode. You can
subscribe to it at [this webpage] or directly [send mail to it] (which
will make it to the list after the moderator has accepted it.
Furthermore you can access the mailing list on [Gmane] through a
[web interface] or with a
[newsreader].
Links
=====
Tutorials
---------
- There is a very nice introductory [OrgMode tutorial] by [David O'Toole] covering the basics of TODO lists and the agenda. It
has been translated into [French], [Japanese], [Chinese], and [Korean].
Org-mode and GTD
----------------
Org-mode is flexible enough to implement many different ways of
organizing your projects. A frequently discusses scheme is [David Allen's] strategy for [Getting Things Done]. Here are a couple of
links related to this topic.
- [Charles Cave] has written an [article/tutorial] about the basic
elements of GTD and how he implements them in Org-mode.
- There have been several threads on emacs-orgmode@gnu.org related
to GTD, the most important ones are:
- [Another GTD question], which contains a discussion about basic
GTD aspects. It also contains this
- [Post by Carsten] summarising several options for implementing
GTD in org-mode.
- [GTD, Projects and Next Actions in org-mode] is a thread where
several people describe their personal setup is
- Also on the web you can find information about how people are
setting up Org-mode to fit their habits. A few examples:
- This [blog post] shows a very simple and clear GTD setup.
Add-Ons
-------
- [Piotr Zielinski] wrote [org-mouse.el] which is now distributed with
Org-mode. It implements very interesting mouse support for many
functions in org-mode.
- [David O'Toole] is the author of [org-publish.el]. While this is
now part of the Org-mode distribution, you might find the newest
bug fixes and developments at his [Org-mode page], along with
several other projects like /org-blog.el/ and
/org-publish-escript.el/.
- [Bastien Guerry] has a package for using Org-mode as the basis for
blogging, it is available at [this page].
+ Translators
I know about the following attempts to translate from and to
Org-mode files:
- [From Palm TODO database to Orgmode]. This Translator was
written by [Olaf Dietsche].
- [From Org-mode to remind] by [Bastien Guerry].
Future Development
------------------
- Here is a [list of ideas] that are still to be processed somehow,
when I get to it.

5
ORGWEBPAGE/org.texi Normal file
View File

@ -0,0 +1,5 @@
@c Local Variables:
@c mode: texinfo
@c TeX-master: t
@c End:

24
ORGWEBPAGE/org/index.html Normal file
View File

@ -0,0 +1,24 @@
<html lang="en">
<head>
<title>Untitled</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Untitled">
<meta name="generator" content="makeinfo 4.8">
<link title="Top" rel="start" href="#Top">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
</head>
<body>
</body></html>

231
ORGWEBPAGE/qanda.org Normal file
View File

@ -0,0 +1,231 @@
#+STARTUP: overview align
#+TYP_TODO: TODO IDEA WISH QUESTION DECLINED INCONSISTENCY BUG DONE
#+OPTIONS: H:2 num:t toc:t \n:nil @:t ::t |:t ^:t *:t TeX:t
#+EMAIL: carsten.dominik@gmail.com
#+TITLE: Org-mode Frequently Asked Questions
* General
** Use features in other modes
*I would like to use editing features of org-mode in other modes, is this possible?*
Not really. For tables there is =orgtbl-mode= which implements the
table editor as a minor mode. For other features you need to switch to
Org-mode temporarily, or prepare text in a different buffer.
** Visibility cycling in Outline-mode and Outline-minor-mode
%Can I get the visibility-cycling features in outline-mode and
outline-minor-mode?%
Yes, these functions are written in a way that they are independent of
the outline setup. The following setup provides standard Org-mode
functionality in outline-mode on =TAB= and =S-TAB=. For
outline-minor-mode, we use =C-TAB= instead of =TAB=,
because =TAB= usually has mode-specific tasks.
:(add-hook 'outline-minor-mode-hook
: (lambda ()
: (define-key outline-minor-mode-map [(control tab)] 'org-cycle)
: (define-key outline-minor-mode-map [(shift tab)] 'org-global-cycle)))
:(add-hook 'outline-mode-hook
: (lambda ()
: (define-key outline-mode-map [(tab)] 'org-cycle)
: (define-key outline-mode-map [(shift tab)] 'org-global-cycle)))
Or check out /outline-magic.el/, which does this and also provides
promotion and demotion functionality. @file{outline-magic.el} is
available at [[http://www.astro.uva.nl/~dominik/Tools/OutlineMagic][Outline Magic]].
* Errors
** =(wrong-type-argument keymapp nil)=
When I try to use Org-mode, I always get the error message
@code{(wrong-type-argument keymapp nil)} This is a conflict with an
outdated version of the /allout.el/.
** CUA mode does not work with Org-mode
%Org-mode takes over the S-cursor keys. I also want to use CUA-mode,
is there a way to fix this conflict?%
Yes, see the /Conflicts/ section of the manual.
* Setup and Structure
** Org-mode as default mode
%Org-mode seems to be a useful default mode for the various README
files I have scattered through my directories%. %How do I turn it on
for all README files?%
Add the following to your .emacs file:
: (add-to-list 'auto-mode-alist '("README$" . org-mode))
** Get rid of extra stars in outline
%All these stars are driving me mad, I just find the Emacs outlines
unreadable. Can't you just put white space and a single star as a
starter for headlines?%
See the section /Clean outline view/ in the manual.
** Two windows on same Org-mode file
%I would like to have two windows on the same Org-mode file, but with
different outline visibility. Is that possible?%
In GNU Emacs, you may use /indirect buffers/ which do exactly this.
See the documentation on the command =make-indirect-buffer=. In
XEmacs, this is currently not possible because of the different outline
implementation.
* Hyperlinks
** Broken links after Org-mode 4.20
%Some of my links stopped working after I upgraded to a version 4.20
or later. Why is this, and how can I fix it?%
These must be links in plain text, containing white space, such as
: bbdb:Richard Stallman
You need to protect these links by putting double brackets around
them, like
: [[bbdb:Richard Stallman]]
** Converting links to double-bracket format
%I see that Org-mode now creates links using the double bracket
convention that hides the link part and the brackets, only showing the
description part. How can I convert my old links to this new format?%
Execute once in each Org-mode file: =M-x org-upgrade-old-links=
This replaces angular brackets with the new link format.
** Angular bracket links preference
%I don't care if you find the new bracket links great, I am attached
to the old style using angular brackets and no hiding of the link
text. Please give them back to me, don't tell me it is not possible!%
Would I let you down like that? If you must, you can do this
: (setq org-link-style 'plain
: org-link-format "<%s>")
** Confirmation for shell and elips links
%When I am executing shell/elisp links I always get a confirmation
prompt and need to type =yes RET=, that's 4 key presses! Can I get
rid of this?%
The confirmation is there to protect you from unwantingly execute
potentially dangerous commands. For example, imagine a link
:[[shell:rm -rf ~/*][ Google Search]]
In an Org-mode buffer, this command would look like /Google Search/,
but really it would remove your home directory. If you wish, you can
make it easier to respond to the query by setting
=org-confirm-shell-link-function= and/or
=org-confirm-elisp-link-function= to =y-or-n-p=. Then a single yc
keypress will be enough to confirm those links. It is also possible
to turn off this check entirely, but I do not recommend to do this.
Be warned.
* Export
** Make TODO entries items, not headlines in HTML export
%When I export my TODO list, every TODO item becomes a separate
section. How do I enforce these items to be exported as an itemized
list?%
If you plan to use ASCII or HTML export, make sure things you want to
be exported as item lists are level 4 at least, even if that does mean
there is a level jump. For example:
: * Todays top priorities
: **** TODO write a letter to xyz
: **** TODO Finish the paper
: **** Pick up kids at the school
Alternatively, if you need a specific value for the heading/item
transition in a particular file, use the =#+OPTIONS= line to
configure the H switch.
: #+OPTIONS: H:2; ...
** Export only a subtree
%I would like to export only a subtree of my file to HTML. How?%
If you want to export a subtree, mark the subtree as region and then
export. Marking can be done with =C-c @@ C-x C-x=, for example.
* Tables
** #ERROR fields in tables
%One of my table columns has started to fill up with =#ERROR=. What
is going on?%
Org-mode tried to compute the column from other fields using a
formula stored in the =#+TBLFM:= line just below the table, and
the evaluation of the formula fails. Fix the fields used in the
formula, or fix the formula, or remove it!
** Unwanted new lines in table
%When I am in the last column of a table and just above a horizontal
line in the table, pressing TAB creates a new table line before the
horizontal line%. %How can I quickly move to the line below the
horizontal line instead?%
Press =down= (to get on the separator line) and then =TAB=
Or configure the variable =org-table-tab-jumps-over-hlines=.
** Change indentation of a table
%How can I change the indentation of an entire table without fixing
every line by hand?%
The indentation of a table is set by the first line. So just fix the
indentation of the first line and realign with =TAB=.
* Agenda
** Include Org-mode agenda into Emacs diary
%Is it possible to include entries from org-mode files into my emacs
diary?%
Since the org-mode agenda is much more powerful and can contain the
diary, you should think twice
before deciding to do this. Integrating Org-mode information into the
diary is, however, possible. You need to turn on /fancy diary
display/ by setting in .emacs:
: (add-hook 'diary-display-hook 'fancy-diary-display)
Then include the following line into your ~/diary file, in
order to get the entries from all files listed in the variable
=org-agenda-files=
: &%%(org-diary)
You may also select specific files with
: &%%(org-diary) ~/path/to/some/org-file.org
: &%%(org-diary) ~/path/to/another/org-file.org
If you now launch the calendar and press d to display a diary, the
headlines of entries containing a timestamp, date range, schedule, or
deadline referring to the selected date will be listed. Just like
Org-mode's agenda view, the diary for @emph{today} contains additional
entries for overdue deadlines and scheduled items. See also the
documentation of the @command{org-diary} function. Under XEmacs, it is
not possible to jump back from the diary to the org, this works only in
the agenda buffer.
* COMMENT HTML style specifications
# Local Variables:
# org-export-html-style: "<link rel=stylesheet href=\"freeshell2.css\" type=\"text/css\"> <style type=\"text/css\"> .tag { color: red; font-weight:bold}</style>"
# End:

2195
ORGWEBPAGE/survey.html Normal file
View File

File diff suppressed because it is too large Load Diff

1158
ORGWEBPAGE/survey.org Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
ORGWEBPAGE/tmp/.DS_Store vendored Normal file
View File

Binary file not shown.

6368
ORGWEBPAGE/tmp/Changes.html Normal file
View File

File diff suppressed because it is too large Load Diff

3562
ORGWEBPAGE/tmp/Changes.txt Normal file
View File

File diff suppressed because it is too large Load Diff

663
ORGWEBPAGE/tmp/faq.html Normal file
View File

@ -0,0 +1,663 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-mode Frequently Asked Questions</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2008/01/27 10:12:10"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css">
</head><body>
<h1 class="title">Org-mode Frequently Asked Questions</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">1 General</a>
<ul>
<li><a href="#sec-2">1.1 Use features in other modes</a></li>
<li><a href="#sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</a></li>
</ul>
</li>
<li><a href="#sec-4">2 Errors</a>
<ul>
<li><a href="#sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></a></li>
<li><a href="#sec-6">2.2 CUA mode does not work with Org-mode</a></li>
<li><a href="#sec-7">2.3 <code>winddmove.el</code> does not work with Org-mode.</a></li>
</ul>
</li>
<li><a href="#sec-8">3 Setup and Structure</a>
<ul>
<li><a href="#sec-9">3.1 Org-mode as default mode</a></li>
<li><a href="#sec-10">3.2 Get rid of extra stars in outline</a></li>
<li><a href="#sec-11">3.3 Two windows on same Org-mode file</a></li>
<li><a href="#sec-12">3.4 Insert empty lines before new headings and plain list items</a></li>
<li><a href="#sec-13">3.5 Amount of context in sparse trees</a></li>
<li><a href="#sec-14">3.6 Stacking calls to org-occur</a></li>
</ul>
</li>
<li><a href="#sec-15">4 Hyperlinks</a>
<ul>
<li><a href="#sec-16">4.1 Confirmation for shell and elisp links</a></li>
<li><a href="#sec-17">4.2 Use RET or TAB to follow a link</a></li>
<li><a href="#sec-18">4.3 Clicking on a link without activating it</a></li>
</ul>
</li>
<li><a href="#sec-19">5 Remember</a></li>
<li><a href="#sec-20">6 Export</a>
<ul>
<li><a href="#sec-21">6.1 Make TODO entries items, not headlines in HTML export</a></li>
<li><a href="#sec-22">6.2 Export only a subtree</a></li>
<li><a href="#sec-23">6.3 How to import org-mode calendar data into Mac OSX ical</a></li>
</ul>
</li>
<li><a href="#sec-24">7 Tables</a>
<ul>
<li><a href="#sec-25">7.1 #ERROR fields in tables</a></li>
<li><a href="#sec-26">7.2 Unwanted new lines in table</a></li>
<li><a href="#sec-27">7.3 Automatic detection of formulas</a></li>
<li><a href="#sec-28">7.4 Change indentation of a table</a></li>
<li><a href="#sec-29">7.5 Performance issues with table alignment</a></li>
<li><a href="#sec-30">7.6 Performance issues with table calculation</a></li>
<li><a href="#sec-31">7.7 Incrementing numbers</a></li>
</ul>
</li>
<li><a href="#sec-32">8 Agenda</a>
<ul>
<li><a href="#sec-33">8.1 Include Org-mode agenda into Emacs diary</a></li>
</ul>
</li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">1 General</h2>
<div class="outline-3">
<h3 id="sec-2">1.1 Use features in other modes</h3>
<p><b>I would like to use editing features of org-mode in other modes, is this possible?</b>
</p>
<p>
Not really. For tables there is <code>orgtbl-mode</code> which implements the
table editor as a minor mode. For other features you need to switch to
Org-mode temporarily, or prepare text in a different buffer.
</p>
</div>
<div class="outline-3">
<h3 id="sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</h3>
<p>
<b>Can I get the visibility-cycling features in outline-mode and outline-minor-mode?</b>
</p>
<p>
Yes, these functions are written in a way that they are independent of
the outline setup. The following setup provides standard Org-mode
functionality in outline-mode on <code>TAB</code> and <code>S-TAB</code>. For
outline-minor-mode, we use <code>C-TAB</code> instead of <code>TAB</code>,
because <code>TAB</code> usually has mode-specific tasks.
</p>
<p>
<pre>
(add-hook 'outline-minor-mode-hook
(lambda ()
(define-key outline-minor-mode-map [(control tab)] 'org-cycle)
(define-key outline-minor-mode-map [(shift tab)] 'org-global-cycle)))
(add-hook 'outline-mode-hook
(lambda ()
(define-key outline-mode-map [(tab)] 'org-cycle)
(define-key outline-mode-map [(shift tab)] 'org-global-cycle)))
</pre>
</p>
<p>
Or check out <i>outline-magic.el</i>, which does this and also provides
promotion and demotion functionality. <i>outline-magic.el</i> is
available at <a href="http://www.astro.uva.nl/~dominik/Tools/OutlineMagic">Outline Magic</a>.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-4">2 Errors</h2>
<div class="outline-3">
<h3 id="sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></h3>
<p><b>When I try to use Org-mode, I always get the error message @code{(wrong-type-argument keymapp nil)}</b>
</p>
<p>
This is a conflict with an outdated version of the <i>allout.el</i>, see
the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section in the manual
</p>
</div>
<div class="outline-3">
<h3 id="sec-6">2.2 CUA mode does not work with Org-mode</h3>
<p>
<b>Org-mode takes over the S-cursor keys. I also want to use CUA-mode, is there a way to fix this conflict?</b>
</p>
<p>
Yes, see the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section of the manual.
</p>
</div>
<div class="outline-3">
<h3 id="sec-7">2.3 <code>winddmove.el</code> does not work with Org-mode.</h3>
<p>
<b>Org-mode takes over the S-cursor keys. I also want to use windmove.el, is there a way to fix this conflict?</b>
</p>
<p>
Yes, see the <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Conflicts">Conflicts</a> section of the manual.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-8">3 Setup and Structure</h2>
<div class="outline-3">
<h3 id="sec-9">3.1 Org-mode as default mode</h3>
<p>
<b>Org-mode seems to be a useful default mode for the various README files I have scattered through my directories</b>. <b>How do I turn it on for all README files?</b>
</p>
<p>
Add the following to your .emacs file:
</p>
<p>
<pre>
(add-to-list 'auto-mode-alist '("README$" . org-mode))
</pre>
</p>
<p>
You can even make it the default mode for any files with unspecified
mode using
</p>
<p>
<pre>
(setq default-major-mode 'org-mode)
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-10">3.2 Get rid of extra stars in outline</h3>
<p>
*All these stars are driving me mad, I just find the Emacs outlines
unreadable. Can't you just put white space and a single star as a
starter for headlines?*
</p>
<p>
See the section <a href="http://staff.science.uva.nl/~dominik/Tools/org/org.html#Clean%20outline%20view">Clean outline view</a> in the manual.
</p>
</div>
<div class="outline-3">
<h3 id="sec-11">3.3 Two windows on same Org-mode file</h3>
<p><b>I would like to have two windows on the same Org-mode file, but with different outline visibility. Is that possible?</b>
</p>
<p>
You may use <i>indirect buffers</i> which do exactly this. See the
documentation on the command <code>make-indirect-buffer</code>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-12">3.4 Insert empty lines before new headings and plain list items</h3>
<p>
<b>I would like to have an empty line before each newly inserted headline, but not before each newly inserted plain-list item</b>.
</p>
<p>
<pre>
(setq org-blank-before-new-entry
'((heading . t) (plain-list-item . nil))
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-13">3.5 Amount of context in sparse trees</h3>
<p>
*Sparse tree show the headline hierarchy above each match, and also
the headline following a match. I'd like to construct more compact
trees, with less context.*
</p>
<p>
Take a look at the variables <code>org-show-hierarchy-above</code> and
<code>org-show-following-headline</code>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-14">3.6 Stacking calls to org-occur</h3>
<p>
*Each call to org-occur starts again from OVERVIEW and exposes only
the matches of the current call. I'd like to combine the effect of
several calls*.
</p>
<p>
You can construct a regular expression that matches all targets you
want. Alternatively, use a <code>C-u</code> prefix with the second and any
further calls to <code>org-occur</code> to keep the current visibility and
highlighting in addition to the new ones.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-15">4 Hyperlinks</h2>
<div class="outline-3">
<h3 id="sec-16">4.1 Confirmation for shell and elisp links</h3>
<p>
*When I am executing shell/elisp links I always get a confirmation
prompt and need to type "yes RET", that's 4 key presses! Can I get
rid of this?*
</p>
<p>
The confirmation is there to protect you from unwantingly execute
potentially dangerous commands. For example, imagine a link
<pre>
[[shell:rm -rf ~/*][ Google Search]]
</pre>
</p>
<p>
In an Org-mode buffer, this command would look like <i>Google Search</i>,
but really it would remove your home directory. If you wish, you can
make it easier to respond to the query by setting
</p>
<p>
<pre>
(setq org-confirm-shell-link-function 'y-or-n-p
org-confirm-elisp-link-function 'y-or-n-p).
</pre>
</p>
<p>
Then a single keypress will be enough to confirm those links. It is
also possible to turn off this check entirely, but I strongly recommend
against this. Be warned.
</p>
</div>
<div class="outline-3">
<h3 id="sec-17">4.2 Use RET or TAB to follow a link</h3>
<p>
<b>From other packages like Emacs-wiki, I am used to follow links with =RET= when the cursor is on the link. Is this also possible in org-mode?</b>
</p>
<p>
Yes, and you may also use TAB.
</p>
<p>
<pre>
(setq org-return-follows-link t)
(setq org-tab-follows-link t)
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-18">4.3 Clicking on a link without activating it</h3>
<p>
<b>Each time I click inside a link in order to set point to this location, Org-mode actually follows the link</b>
</p>
<p>
Activating links with <code>mouse-1</code> is a new feature in Emacs 22, to make
link behavior similar to other applications like web browsers. If you
hold the mouse button down a bit longer, the cursor will be set
without following the link. If you cannot get used to this behavior,
you can (as in Emacs 21) use <code>mouse-2</code> to follow links and turn off
link activation for <code>mouse-1</code> with
</p>
<p>
<pre>
(setq org-mouse-1-follows-link nil)
</pre>
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-19">5 Remember</h2>
<p>
<b>Can I automatically start the clock when opening a remember template?</b>
</p>
<p>
Yes, this is possible. Use the following code and make sure that
after executing it, `my-start-clock-if-needed' is in
`remember-mode-hook' <i>after</i> `org-remember-apply-template'.
</p>
<p>
<pre>
(add-hook 'remember-mode-hook 'my-start-clock-if-needed 'append)
(defun my-start-clock-if-needed ()
(save-excursion
(goto-char (point-min))
(when (re-search-forward " *CLOCK-IN *" nil t)
(replace-match "")
(org-clock-in))))
</pre>
</p>
<p>
Then, when a template contains the key string CLOCK-IN, the clock will
be started. Starting with Org-mode version 5.20, the clock will
automatically be stopped when storing the remember buffer.
</p>
</div>
<div class="outline-2">
<h2 id="sec-20">6 Export</h2>
<div class="outline-3">
<h3 id="sec-21">6.1 Make TODO entries items, not headlines in HTML export</h3>
<p>
*When I export my TODO list, every TODO item becomes a separate
section. How do I enforce these items to be exported as an itemized
list?*
</p>
<p>
If you plan to use ASCII or HTML export, make sure things you want to
be exported as item lists are level 4 at least, even if that does mean
there is a level jump. For example:
</p>
<p>
<pre>
* Todays top priorities
**** TODO write a letter to xyz
**** TODO Finish the paper
**** Pick up kids at the school
</pre>
</p>
<p>
Alternatively, if you need a specific value for the heading/item
transition in a particular file, use the <code>#+OPTIONS</code> line to
configure the H switch.
</p>
<p>
<pre>
#+OPTIONS: H:2; ...
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-22">6.2 Export only a subtree</h3>
<p>
<b>I would like to export only a subtree of my file to HTML. How?</b>
</p>
<p>
If you want to export a subtree, mark the subtree as region and then
export. Marking can be done with <code>C-c @ C-x C-x</code>, for example.
</p>
</div>
<div class="outline-3">
<h3 id="sec-23">6.3 How to import org-mode calendar data into Mac OSX ical</h3>
<p>
<b>I would like my iCal program on Mac OSX to import the iCalendar file produced by Org-mode. How?</b>
</p>
<p>
<i>This is for OSX 10.3, see below for 10.4:</i> When using iCal under
Apple MacOS X, you can create a new calendar <i>OrgMode</i> (the default
name for the calendar created by <code>C-c C-e c</code>, see the variables
<code>org-icalendar-combined-name</code> and
<code>org-combined-agenda-icalendar-file</code>). Then set Org-mode to overwrite
the corresponding file <i>~/Library/Calendars/OrgMode.ics</i>. You may
even use AppleScript to make iCal re-read the calendar files each time
a new version of <i>OrgMode.ics</i> is produced. Here is the setup needed
for this:
</p>
<p>
<pre>
(setq org-combined-agenda-icalendar-file
"~/Library/Calendars/OrgMode.ics")
(add-hook 'org-after-save-iCalendar-file-hook
(lambda ()
(shell-command
"osascript -e 'tell application \"iCal\" to reload calendars'")))
</pre>
</p>
<p>
For Mac OS X 10.4, you need to write the ics file to
<code>/Library/WebServer/Documents/</code> and then subscribe iCalendar to
<code>http: //localhost/orgmode.ics</code>
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-24">7 Tables</h2>
<div class="outline-3">
<h3 id="sec-25">7.1 #ERROR fields in tables</h3>
<p>
<b>One of my table columns has started to fill up with =#ERROR=. What is going on?</b>
</p>
<p>
Org-mode tried to compute the column from other fields using a
formula stored in the <code>#+TBLFM:</code> line just below the table, and
the evaluation of the formula fails. Fix the fields used in the
formula, or fix the formula, or remove it!
</p>
</div>
<div class="outline-3">
<h3 id="sec-26">7.2 Unwanted new lines in table</h3>
<p>
*When I am in the last column of a table and just above a horizontal
line in the table, pressing TAB creates a new table line before the
horizontal line*. <b>How can I quickly move to the line below the horizontal line instead?</b>
</p>
<p>
Press <code>down</code> (to get on the separator line) and then <code>TAB</code>.
Or configure the variable
</p>
<p>
<pre>
(setq org-table-tab-jumps-over-hlines t)
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-27">7.3 Automatic detection of formulas</h3>
<p><b>I need to use fields in my table that start with "=", and each time I enter such a field, Org-mode thinks this is a formula</b>.
</p>
<p>
With the setting
</p>
<p>
<pre>
(setq org-table-formula-evaluate-inline nil)
</pre>
</p>
<p>
this will no longer happen. You can still use formulas using the
commands <tt>C-c =</tt> and <tt>C-u C-c =</tt>
</p>
</div>
<div class="outline-3">
<h3 id="sec-28">7.4 Change indentation of a table</h3>
<p><b>How can I change the indentation of an entire table without fixing every line by hand?</b>
</p>
<p>
The indentation of a table is set by the first line. So just fix the
indentation of the first line and realign with <code>TAB</code>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-29">7.5 Performance issues with table alignment</h3>
<p><b>I have a huge table in a file, and the automatic realign of tables is just taking too long. What can I do?</b>
</p>
<p>
Either split the table into several by inserting an empty line every
100 lines or so. Or turn off the automatic re-align with
</p>
<p>
<pre>
(setq org-table-automatic-realign nil)
</pre>
</p>
<p>
After this the only way to realign a table is to press <code>C-c C-c</code>. It
will no longer happen automatically, removing the corresponding delays
during editing.
</p>
</div>
<div class="outline-3">
<h3 id="sec-30">7.6 Performance issues with table calculation</h3>
<p><b>I have a complex table with lots of formulas, and recomputing the table takes rather long. What can I do?</b>
</p>
<p>
Nothing, really. The spreadsheet in org is mostly done to make
calculations possible, not so much to make them fast. Since Org-mode
is firmly committed to the ASCII format, nothing is stopping you from
editing the table by hand. Therefore, there is no internal
representation of the data. Each time Org-mode starts a computation,
it must scan the table for special lines, find the fields etc. This
is slow. Furthermore, Calc is slow compared to hardware computations.
To make this work with normal editing, recalculation is not happening
automatically, or only for the current line, so that the long wait for
a full table iteration only happens when you ask for it.
</p>
<p>
So for really complex tables, moving to a "real" spreadsheet may still
be the best option.
</p>
<p>
That said, there are some ways to optimize things in Org-mode, and I
have been thinking about moving a bit further down this line.
However, for my applications this has so far not been an issue at all.
If you have a good case,you could try to convince me.
</p>
</div>
<div class="outline-3">
<h3 id="sec-31">7.7 Incrementing numbers</h3>
<p>*When I press <code>S-RET</code> in a table field to copy its value down, the
content is not copied as is, but it is increased by one.
Is that a bug or a feature*
</p>
<p>
Well, it is <i>supposed</i> to be a feature, to make it easy to create a
column with increasing numbers. If this gets into your way, turn it
off with
</p>
<p>
<pre>
(setq org-org-table-copy-increment nil)
</pre>
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-32">8 Agenda</h2>
<div class="outline-3">
<h3 id="sec-33">8.1 Include Org-mode agenda into Emacs diary</h3>
<p><b>Is it possible to include entries from org-mode files into my emacs diary?</b>
</p>
<p>
Since the org-mode agenda is much more powerful and can contain the
diary, you should think twice before deciding to do this. If you
insist, however, integrating Org-mode information into the diary is
possible. You need to turn on <i>fancy diary display</i> by setting in
.emacs:
</p>
<p>
<pre>
(add-hook 'diary-display-hook 'fancy-diary-display)
</pre>
</p>
<p>
Then include the following line into your ~/diary file, in
order to get the entries from all files listed in the variable
<code>org-agenda-files</code>
</p>
<p>
<pre>
&amp;%%(org-diary)
</pre>
You may also select specific files with
</p>
<p>
<pre>
&amp;%%(org-diary) ~/path/to/some/org-file.org
&amp;%%(org-diary) ~/path/to/another/org-file.org
</pre>
</p>
<p>
If you now launch the calendar and press <tt>d</tt> to display a diary, the
headlines of entries containing a timestamp, date range, schedule, or
deadline referring to the selected date will be listed. Just like
Org-mode's agenda view, the diary for <i>today</i> contains additional
entries for overdue deadlines and scheduled items. See also the
documentation of the <code>org-diary</code> function. Under XEmacs, it is
not possible to jump back from the diary to the org, this works only in
the agenda buffer.
</p>
</div>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten.dominik@gmail.com">&lt;carsten.dominik@gmail.com&gt;</a>
</p>
<p class="date"> Date: 2008/01/27 10:12:10</p>
</div></body>
</html>

65
ORGWEBPAGE/tmp/freeshell2.css Normal file
View File

@ -0,0 +1,65 @@
body {
font-family: helvetica, verdana, sans-serif;
font-family: verdana, sans-serif;
font-size: 11pt;
margin-top: 5%;
margin-bottom: 8%;
background: white; color: black;
margin-left: 3% !important; margin-right: 3% !important;
}
h1 {
font-size: 16pt;
color: #cc8c00;
padding-top: 1em;
border-bottom: 2px solid #aaa;
}
h2 {
font-size: 14pt;
padding-top: 1em;
border-bottom: 1px solid #ccc;
}
h3 {
font-size: 12pt;
padding-top: 0.5em;
border-bottom: 1px solid #eee;
}
.todo, .deadline { color: red; font-style: italic }
.done { color: green; font-style: italic }
.timestamp { color: grey }
.timestamp-kwd { color: CadetBlue; }
.tag { background-color:lightblue; font-weight:normal; }
.target { background-color: lavender; }
.menu {
color: #666;
}
.menu a:link {
color: #888;
}
.menu a:active {
color: #888;
}
.menu a:visited {
color: #888;
}
img { align: center; }
pre {
padding: 5pt;
font-family: courier, monospace;
font-size: 10pt;
}
table { border-collapse: collapse; }
td, th {
vertical-align: top;
border: 1pt solid #ADB9CC;
}

419
ORGWEBPAGE/tmp/index.html Normal file
View File

@ -0,0 +1,419 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-Mode Homepage</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2008/01/27 22:14:32"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css">
</head><body>
<h1 class="title">Org-Mode Homepage</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">Org - an Emacs Mode for Notes and Project Planning</a></li>
<li><a href="#sec-2">Current Version (5.19a) and Compatibility</a></li>
<li><a href="#sec-3">Downloads</a></li>
<li><a href="#sec-4">Documentation</a>
<ul>
<li><a href="#sec-5">Manual and Reference card</a></li>
</ul>
</li>
<li><a href="#sec-6">Links</a>
<ul>
<li><a href="#sec-7">Mailing list</a></li>
<li><a href="#sec-8">Worg - user-driven knowledge-base about org-mode</a></li>
<li><a href="#sec-9">Tutorials</a></li>
<li><a href="#sec-10">Survey</a></li>
<li><a href="#sec-11">Org-mode, GTD and other task management systems </a></li>
<li><a href="#sec-12">Add-Ons</a></li>
<li><a href="#sec-13">Translators</a></li>
<li><a href="#sec-17">Alternative distributions</a></li>
<li><a href="#sec-18">Contributing to Org-mode</a></li>
<li><a href="#sec-19">Future Development</a></li>
</ul>
</li>
<li><a href="#sec-20">Related Software</a></li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">Org - an Emacs Mode for Notes and Project Planning</h2>
<BASE href="http://orgmode.org/index.html">
<p>
Org-mode is a mode for keeping notes, maintaining ToDo lists, and doing
project planning with a fast and effective plain-text system.
</p>
<p>
Org-mode develops organizational tasks around NOTES files that contain
information about projects as plain text. Org-mode is implemented on
top of outline-mode, which makes it possible to keep the content of
large files well structured. Visibility cycling and structure editing
help to work with the tree. Tables are easily created with a built-in
table editor. Org-mode supports ToDo items, deadlines, time stamps,
and scheduling. It dynamically compiles entries into an agenda.
Plain text URL-like links connect to websites, emails, Usenet
messages, BBDB entries, and any files related to the projects. For
printing and sharing of notes, an Org-mode file can be exported as a
structured ASCII file, HTML, and LaTeX.
</p>
</div>
<div class="outline-2">
<h2 id="sec-2">Current Version (5.19a) and Compatibility</h2>
<p>
The current version is 5.19a. To see what has changed in recent
releases, check this <a href="Changes.html">list of user-visible changes</a>. These descriptions
are extensive, to avoid that people will be printing the manual after
each incremental release. If you have an older version of the manual,
just check the release notes and you will be up-to-date.
</p>
<p>
This package works on Emacs 22, and (with minor restrictions) on Emacs
21 and XEmacs 21 (where you must also use <i>noutline.el</i> shipped with
Org-mode). The Emacs 22.1 release ships with Org-mode version 4.67c.
The latest CVS emacs trunk usually contains a fairly recent version,
but may lag a bit behind the website release.
</p>
</div>
<div class="outline-2">
<h2 id="sec-3">Downloads</h2>
<ul>
<li>Distribution<br/>
Download as <a href="org-5.19a.zip">zip file</a> or <a href="org-5.19a.tar.gz">gzipped tar archive</a>. These archives contain
both the Lisp file org.el and the documentation in PDF and (TeX)Info
formats. A shell script to simplify upgrading to the newest release
has been posted <a href="http://www.philfam.co.uk/pete/GTD/org-mode/update-org.sh">here</a>.
</li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-4">Documentation</h2>
<div class="outline-3">
<h3 id="sec-5">Manual and Reference card</h3>
<ul>
<li>
Read the documentation <a href="manual/index.html">online</a>. This is a version consisting of many
small files, to save bandwidth. If you really need it, you can also
have the entire manual in a <a href="org.html">single monolithic file</a>.
</li>
<li>
Download the documentation in other formats: <a href="org.pdf">PDF</a>, <a href="org">Info</a>, or <a href="org.texi">TeXInfo</a>.
</li>
<li>
Download the <a href="orgcard.pdf">Refcard</a> for org-mode, and Kyle Sherman hast created a
<a href="orgcard.txt">text version</a> of the reference card
</li>
<li>
There is also a <a href="http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fManual">Japanese translation</a> of the manual (version 4.60),
produced by Takeshi Okano.
</li>
<li>
The <a href="faq.html">FAQ</a> is not very up-to-date, but may still answer some of your
questions. Please have a look before posting to emacs-orgmode@gnu.org.
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-6">Links</h2>
<div class="outline-3">
<h3 id="sec-7">Mailing list</h3>
<p>
There is a mailing list for discussion about org-mode.
</p>
<ul>
<li>
Subscribe to it at <a href="http://lists.gnu.org/mailman/listinfo/emacs-orgmode">this webpage</a>.
</li>
<li>
Directly <a href="mailto:emacs-orgmode@gnu.org">send mail to it</a>. If you are not subscribed, a moderator
will look at the message before passing it through to the
list. If that has happened once, future messages from your email
address will get through immediately, even if you remain
unsubscribed.
</li>
<li>
Read the list on <a href="http://www.gmane.org">Gmane</a> through a <a href="http://news.gmane.org/gmane.emacs.orgmode">web interface</a> or with a
<a href="news://news.gmane.org/gmane.emacs.orgmode">newsreader</a>.
<li><form method="get" action="http://search.gmane.org/">
<input type="text" name="query">
<input type="hidden" name="group" value="gmane.emacs.orgmode">
<input type="submit" value="Search gmane.emacs.orgmode">
</form>
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-8">Worg - user-driven knowledge-base about org-mode</h3>
<p>
<a href="http://129.199.80.1/~guerry/worg/">Worg</a>, created by <a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>, is a setup to allow users to jointly
edit a number of Org-mode files containing documentation about
Org-mode. This is something like a wiki. If you'd like to contribute
your own setup, screenshots, tutorials etc, please go to <a href="http://129.199.80.1/~guerry/worg/">the Worg page</a>, and start from there.
</p>
</div>
<div class="outline-3">
<h3 id="sec-9">Tutorials</h3>
<p>
<a href="tutorials.html">Tutorials and screencasts</a> are listed on a separate page.
</p>
</div>
<div class="outline-3">
<h3 id="sec-10">Survey</h3>
<p>
In November 2007, Charles Cave organized a survey among Org-mode
users. The answers given in this survey can be found <a href="survey.html">here</a>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-11">Org-mode, GTD and other task management systems </h3>
<p>Org-mode is flexible enough to implement many different ways of
organizing your projects. A frequently discusses scheme is <a href="http://www.davidco.com/">David Allen's</a> strategy for <a href="http://en.wikipedia.org/wiki/GTD">Getting Things Done</a>. But it is clearly not
the only way to us Org-mode for planning. Here are a couple of
links related to this topic.
</p>
<ul>
<li>
<a href="http://johnwiegley.com">John Wiegley</a> has written an excellent document describing his
way of using Org-mode as a <a href="http://johnwiegley.com/org.mode.day.planner.html">day planner</a>. See also some later
messages for enhancements of his setup:
<a href="http://article.gmane.org/gmane.emacs.orgmode/2963">emacs-orgmode-2962</a>, <a href="http://article.gmane.org/gmane.emacs.orgmode/3629">emacs-orgmode-3629</a>
</li>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a> has written an <a href="http://members.optusnet.com.au/~charles57/GTD/orgmode.html">article/tutorial</a> about the basic
elements of GTD and how he implements them in Org-mode. There
is also a <a href="http://129.199.80.1/~guerry/org-gtd.html">french translation</a> of this document.
</li>
<li>
There have been several threads on emacs-orgmode@gnu.org related
to GTD, the most important ones are:
<ul>
<li>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/683">Another GTD question</a>, which contains a discussion about basic
GTD aspects. It also contains this
</li>
<li>
<a href="http://article.gmane.org/gmane.emacs.orgmode/715">Post by Carsten</a> summarizing several options for implementing
GTD in org-mode.
</li>
<li>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/523">GTD, Projects and Next Actions in org-mode</a> is a thread where
several people describe their personal setup is
</li>
<li>
The <a href="http://thread.gmane.org/gmane.emacs.orgmode/4915">SOMEDAY/MAYBE vs. low priorities</a> thread contains a
discussion about priorities that is quite instructive.
</li>
<li>
Here is a <a href="http://thread.gmane.org/gmane.emacs.orgmode/4832/focus%3D4854">very instructive post</a> by Pete Phillips explaining
why David Allens book is where you should start to learn GTD,
and that the Internet and Org-mode only come into the game
later, when thinking about the implementation. And since
doing GTD the right way will give you lots of free time, don't
forget to listen to <a href="http://www.detox-jazz.co.uk/">Pete's music</a>!
</li>
</ul></li>
<li>
Also on the web you can find information about how people are
setting up Org-mode to fit their habits. A few examples:
<ul>
<li>
This <a href="http://www.brool.com/?p=82">blog post</a> shows a very simple and clear GTD setup.
</li>
</ul></li>
</ul></div>
<div class="outline-3">
<h3 id="sec-12">Add-Ons</h3>
<ul>
<li>
<a href="http://www.cl.cam.ac.uk/~pz215/">Piotr Zielinski</a> wrote <a href="http://www.cl.cam.ac.uk/~pz215/files/org-mouse.el">org-mouse.el</a> which is now distributed with
Org-mode. It implements great mouse support for many functions in
org-mode.
</li>
<li>
<a href="http://dto.freeshell.org/notebook/">David O'Toole</a> is the author of <a href="http://dto.freeshell.org/e/org-publish.el">org-publish.el</a>. While this is
now part of the Org-mode distribution, you might find the newest
bug fixes and developments at his <a href="http://dto.freeshell.org/notebook/OrgMode.html">Org-mode page</a>, along with
several other projects like <i>org-blog.el</i> and
<i>org-publish-escript.el</i>.
</li>
<li>
<a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a> has been really prolific in writing interesting
add-ons, all available at his <a href="http://www.cognition.ens.fr/~guerry/bastien-org-mode.html">org-mode page</a>:
<ul>
<li>
a package for using Org-mode as the basis for blogging
</li>
<li>
a LaTeX exporter that is now distributed together with
org-mode
</li>
<li>
a special table-of-contents buffer that simplifies navigation
</li>
<li>
a registry to find locations that link a specific document.
</li>
</ul></li>
<li>
George C.F. Greve wrote <a href="http://www.emacswiki.org/emacs/org-mairix.el">org-mairix.el</a> to add links that trigger a
mairix search.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-13">Translators</h3>
<p>
I know about the following attempts to translate from and to
Org-mode files:
</p>
<div class="outline-4">
<h4 id="sec-14">Org-mode to XXX</h4>
<ul>
<li>
<a href="http://www.cognition.ens.fr/~guerry/u/org2rem.el">From Org-mode to remind</a> by <a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>.
</li>
<li>
<a href="org-export-freemind-0.1.0.tar.gz">From Org-mode to Freemind</a> by Marco Vezzoli.
</li>
</ul></div>
<div class="outline-4">
<h4 id="sec-15">XXX to Org-mode</h4>
<ul>
<li>
<a href="http://www.olafdietsche.de/palm/palm2orgmode.pl">From Palm TODO database to Orgmode</a>. This Translator was
written by <a href="http://www.olafdietsche.de/">Olaf Dietsche</a>.
</li>
<li>
From <a href="http://thread.gmane.org/gmane.emacs.orgmode/5073">Org to remind</a> by Detlef Steuer.
</li>
</ul></div>
<div class="outline-4">
<h4 id="sec-16">Bi-directional</h4>
<p>
Unfortunately nothing so far.
</p>
</div>
</div>
<div class="outline-3">
<h3 id="sec-17">Alternative distributions</h3>
<ul>
<li>
Mark A. Hershberger has made some <a href="https://launchpad.net/~hexmode/+archive">Ubuntu packages</a> for org-mode.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-18">Contributing to Org-mode</h3>
<p>
You can always contribute with ideas and bug reports on the mailing
list. If you want to contribute a patch, code snippets, or a full
add-on, this is very welcome too! However, I can only make it an
official part of Org-mode if you have signed the papers with the
Free Software Foundation. Org-mode is distributed as part of Emacs
and must therefore adhere to strict rules about the copyright of
all included material. If this is what you want to do, <a href="request-assign-future.txt">here</a> is the
form that you have to fill in and send to the FSF. After you
received the final copy with signatures, please scan it and send
the scan to the maintainer.
</p>
</div>
<div class="outline-3">
<h3 id="sec-19">Future Development</h3>
<p>
Org-mode is still developing fast. The best way to stay up-to-date
is to join the mailing list where the changes are developed and
discusssed.
</p>
<p>
Here is a loose <a href="todo.html">list of ideas</a> that are still to be processed
somehow, when I get to it&hellip;
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-20">Related Software</h2>
<p><a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2007/12/26/emacs-choosing-between-org-and-planner/">Choosing between Planner and Org</a>.
</p>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten at orgmode dot org">&lt;carsten at orgmode dot org&gt;</a>
</p>
<p class="date"> Date: 2008/01/27 22:14:32</p>
</div></body>
</html>

457
ORGWEBPAGE/tmp/orgcard.txt Normal file
View File

@ -0,0 +1,457 @@
================================================================================
Org-Mode Reference Card (for version 4.79)
================================================================================
================================================================================
Getting Started
================================================================================
(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
(define-key global-map "\C-cl" 'org-store-link) [1]
(define-key global-map "\C-ca" 'org-agenda) [1]
For the many customization options try M-x org-customize
To read the on-line documentation try M-x org-info
================================================================================
Visibility Cycling
================================================================================
rotate current subtree between states TAB
rotate entire buffer between states S-TAB
show the whole file C-c C-a
reveal context around point C-c C-r
show subtree in indirect buffer, ded. frame C-c C-k
================================================================================
Motion
================================================================================
next/previous heading C-c C-n/p
next/previous heading, same level C-c C-f/b
backward to higher level heading C-c C-u
jump to another place in document C-c C-j
previous/next plain list item S-UP/DOWN [3]
================================================================================
Structure Editing
================================================================================
insert new heading/item at current level M-RET
insert new TODO entry/checkbox item M-S-RET
promote current heading up one level M-LEFT
demote current heading down one level M-RIGHT
promote current subtree up one level M-S-LEFT
demote current subtree down one level M-S-RIGHT
move subtree/list item up/down M-S-UP/DOWN
kill subtree C-c C-x C-w
copy subtree C-c C-x M-w
yank subtree C-c C-x C-y
narrow buffer to current subtree C-x n s
================================================================================
Archiving
================================================================================
toggle ARCHIVE tag C-c C-x C-a
force cycling of an ARCHIVEd tree C-TAB
move subtree to archive file C-c C-x C-s
================================================================================
Filtering and Sparse Trees
================================================================================
show sparse tree for all matches of a regexp C-c /
view TODO's in sparse tree C-c C-v
global TODO list in agenda mode C-c t [1]
create sparse tree with all deadlines due C-c C-w
time sorted view of current org file C-c a L
================================================================================
Tables
================================================================================
--------------------------------------------------------------------------------
Creating a table
--------------------------------------------------------------------------------
just start typing, e.g. |Name|Phone|Age RET |- TAB
convert region to table C-c |
... separator at least 3 spaces C-3 C-c |
--------------------------------------------------------------------------------
Commands available inside tables
--------------------------------------------------------------------------------
The following commands work when the cursor is inside a table. Outside of
tables, the same keys may have other functionality.
--------------------------------------------------------------------------------
Re-aligning and field motion
--------------------------------------------------------------------------------
re-align the table without moving the cursor C-c C-c
re-align the table, move to next field TAB
move to previous field S-TAB
re-align the table, move to next row RET
--------------------------------------------------------------------------------
Row and column editing
--------------------------------------------------------------------------------
move the current column left M-LEFT/RIGHT
kill the current column M-S-LEFT
insert new column to left of cursor position M-S-RIGHT
move the current row up/down M-UP/DOWN
kill the current row or horizontal line M-S-UP
insert new row above the current row M-S-DOWN
insert hline below (C-u : above) current row C-c -
sort lines in region C-c ^
--------------------------------------------------------------------------------
Regions
--------------------------------------------------------------------------------
cut rectangular region C-c C-x C-w
copy rectangular region C-c C-x M-w
paste rectangular region C-c C-x C-y
fill paragraph across selected cells C-c C-q
--------------------------------------------------------------------------------
Miscellaneous
--------------------------------------------------------------------------------
to limit column width to N characters, use ...| <N> |...
edit the current field in a separate window C-c `
make current field fully visible C-u TAB
export as tab-separated file M-x org-table-export
import tab-separated file M-x org-table-import
sum numbers in current column/rectangle C-c +
--------------------------------------------------------------------------------
Tables created with the table.el package
--------------------------------------------------------------------------------
insert a new table.el table C-c ~
recognize existing table.el table C-c C-c
convert table (Org-mode <-> table.el) C-c ~
--------------------------------------------------------------------------------
Spreadsheet
--------------------------------------------------------------------------------
Formulas typed in field are executed by TAB, RET and C-c C-c. = introduces a
column formula, := a field formula.
Example: Add Col1 and Col2 |=$1+$2 |
... with printf format specification |=$1+$2;%.2f|
... with constants from constants.el |=$1/$c/$cm |
sum from 2nd to 3rd hline |:=vsum(@II..@III)|
apply current column formula | = |
set and eval column formula C-c =
set and eval field formula C-u C-c =
re-apply all stored equations to current line C-c *
re-apply all stored equations to entire table C-u C-c *
iterate table to stability C-u C-u C-c *
rotate calculation mark through # * ! $ C-#
show line, column, formula reference C-c ?
toggle coordinate grid C-c }
toggle formula debugger C-c {
--------------------------------------------------------------------------------
Formula Editor
--------------------------------------------------------------------------------
edit formulas in separate buffer C-c '
exit and install new formulas C-c C-c
exit, install, and apply new formulas C-u C-c C-c
abort C-c C-q
toggle reference style C-c C-r
pretty-print Lisp formula TAB
complete Lisp symbol M-TAB
shift reference point S-cursor
shift test line for column references M-up/down
scroll the window showing the table M-S-up/down
toggle table coordinate grid C-c }
================================================================================
Links
================================================================================
globally store link to the current location C-c l [1]
insert a link (TAB completes stored links) C-c C-l
insert file link with file name completion C-u C-c C-l
edit (also hidden part of) link at point C-c C-l
open file links in emacs C-c C-o
... force open in emacs/other window C-u C-c C-o
open link at point mouse-1/2
... force open in emacs/other window mouse-3
record a position in mark ring C-c %
jump back to last followed link(s) C-c &
find next link C-c C-x C-n
find previous link C-c C-x C-p
--------------------------------------------------------------------------------
Internal Links
--------------------------------------------------------------------------------
<<My Target>> target
<<<My Target>>> radio target [2]
[[*this text]] find headline
[[this text]] find target or text in buffer
[[this text][description]] optional link text
--------------------------------------------------------------------------------
External Links
--------------------------------------------------------------------------------
file:/home/dominik/img/mars.jpg file, absolute
file:papers/last.pdf file, relative
file:projects.org::*that text find headline
file:projects.org::find me find trgt/string
http://www.astro.uva.nl/dominik on the web
mailto:adent@galaxy.net Email address
news:comp.emacs Usenet group
bbdb:Richard Stallman BBDB person
gnus:group GNUS group
gnus:group#id GNUS message
vm|wl|mhe|rmail:folder Mail folder
vm|wl|mhe|rmail:folder#id Mail message
info:emacs:Regexps Info file:node
shell:ls *.org shell command
elisp:(calendar) elisp form
[[external link][description]] optional link text
================================================================================
Completion
================================================================================
In-buffer completion completes TODO keywords at headline start, TeX macros
after `\', option keywords after `#-â', TAGS after `:', and dictionary words
elsewhere.
complete word at point M-TAB
================================================================================
TODO Items and Checkboxes
================================================================================
rotate the state of the current item C-c C-t
select next/previous state S-LEFT/RIGHT
select next/previous set C-S-LEFT/RIGHT
view TODO items in a sparse tree C-c C-v
view 3rd TODO keyword's sparse tree C-3 C-c C-v
set the priority of the current item C-c , [ABC]
remove priority cookie from current item C-c , SPC
raise/lower priority of current item S-UP/DOWN [3]
insert new checkbox item in plain list M-S-RET
toggle checkbox(es) in region/entry/at point C-c C-x C-b
toggle checkbox at point C-c C-c
checkbox statistics cookies insert [/] or [%]
update checkbox statistics (C-u : whole file) C-c #
================================================================================
Tags
================================================================================
set tags for current heading C-c C-c
realign tags in all headings C-u C-c C-c
create sparse tree with matching tags C-c \
globally (agenda) match tags at cursor C-c C-o
================================================================================
Timestamps
================================================================================
prompt for date and insert timestamp C-c .
like C-c . but insert date and time format C-u C-c .
like C-c . but make stamp inactive C-c !
insert DEADLINE timestamp C-c C-d
insert SCHEDULED timestamp C-c C-s
create sparse tree with all deadlines due C-c C-w
the time between 2 dates in a time range C-c C-y
change timestamp at cursor by ±1 day S-RIGHT/LEFT [3]
change year/month/day at cursor by ±1 S-UP/DOWN [3]
access the calendar for the current date C-c >
insert timestamp matching date in calendar C-c <
access agenda for current date C-c C-o
select date while prompted mouse-1/RET
toggle custom format display for dates/times C-c C-x C-t
--------------------------------------------------------------------------------
Clocking time
--------------------------------------------------------------------------------
start clock on current item C-c C-x C-i
stop clock on current item C-c C-x C-o
cancel current clock C-c C-x C-x
display total subtree times C-c C-x C-d
remove displayed times C-c C-c
insert/update table with clock report C-c C-x C-r
================================================================================
LaTeX and cdlatex-mode
================================================================================
preview LaTeX fragment C-c C-x C-l
expand abbreviation (cdlatex-mode) TAB
insert/modify math symbol (cdlatex-mode) ` / '
================================================================================
Agenda Views
================================================================================
add/move current file to front of agenda C-c [
remove current file from your agenda C-c ]
cycle through agenda file list C-'
compile agenda for the current week C-c a a [1]
compile global TODO list C-c a t [1]
compile TODO list for specific keyword C-c a T [1]
match tags in agenda files C-c a m [1]
match tags in TODO entries C-c a M [1]
find stuck projects C-c a # [1]
show timeline of current org file C-c a L [1]
configure custom commands C-c a C [1]
configure stuck projects C-c a ! [1]
agenda for date at cursor C-c C-o
To set categories, add lines like [2]:
#+CATEGORY: MyCateg
--------------------------------------------------------------------------------
Commands available in an agenda buffer
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
View Org file
--------------------------------------------------------------------------------
show original location of item SPC/mouse-3
show and recenter window L
goto original location in other window TAB/mouse-2
goto original location, delete other windows RET
show subtree in indirect buffer, ded. frame b
toggle follow-mode f
--------------------------------------------------------------------------------
Change display
--------------------------------------------------------------------------------
delete other windows o
switch to daily / weekly view d / w
toggle inclusion of diary entries D
toggle time grid for daily schedule g
toggle display of logbook entries l
refresh agenda buffer with any changes r
save all org-mode buffers s
display the following org-agenda-ndays RIGHT
display the previous org-agenda-ndays LEFT
goto today .
--------------------------------------------------------------------------------
Remote editing
--------------------------------------------------------------------------------
digit argument 0-9
change state of current TODO item t
kill item and source C-k
archive the subtree $
show tags of current headline T
set tags for current headline :
toggle ARCHIVE tag a
set priority of current item p
raise/lower priority of current item S-UP/DOWN [3]
display weighted priority of current item P
schedule/set deadline for this item C-c C-s/d
change timestamp to one day earlier/later S-LEFT/RIGHT [3]
change timestamp to today >
insert new entry into diary i
start the clock on current item (clock-in) I
stop the clock (clock-out) O
cancel current clock X
--------------------------------------------------------------------------------
Misc
--------------------------------------------------------------------------------
Open link in current line C-c C-o
--------------------------------------------------------------------------------
Calendar commands
--------------------------------------------------------------------------------
find agenda cursor date in calendar c
compute agenda for calendar cursor date c
show phases of the moon M
show sunrise/sunset times S
show holidays H
convert date to other calendars C
--------------------------------------------------------------------------------
Quit and Exit
--------------------------------------------------------------------------------
quit agenda, remove agenda buffer q
exit agenda, remove all agenda buffers x
================================================================================
Calendar and Diary Integration
================================================================================
Include Emacs diary entries into Org-mode agenda with:
(setq org-agenda-include-diary t)
================================================================================
Exporting and Publishing
================================================================================
Exporting creates files with extensions .txt and .html in the current
directory. Publishing puts the resulting file into some other place.
export/publish dispatcher C-c C-e
export visible part only C-c C-e v
insert template of export options C-c C-x t
toggle fixed width for entry or region C-c :
--------------------------------------------------------------------------------
HTML formatting
--------------------------------------------------------------------------------
make words bold *bold*
make words italic /italic/
make words underlined _underlined_
sub- and superscripts x^3, J_dust
TeX-like macros \alpha, \to
typeset lines in fixed width font start with :
tables are exported as HTML tables start with |
links become HTML links http:... etc
include html tags @<b>...@</b>
--------------------------------------------------------------------------------
Comments: Text not being exported
--------------------------------------------------------------------------------
Text before the first headline is not considered part of the document and is
therefore never exported. Lines starting with # are comments and are not
exported. Subtrees whose header starts with COMMENT are never exported.
toggle COMMENT keyword on entry C-c ;
================================================================================
Dynamic Blocks
================================================================================
update dynamic block at point C-c C-x C-u
update all dynamic blocks C-u C-c C-x C-u
================================================================================
Notes
================================================================================
[1] This is only a suggestion for a binding of this command. Choose you own
key as shown under INSTALLATION.
[2] After changing a #+KEYWORD or <<<target>>> line, press C-c C-c with the
cursor still in the line to update.
[3] Keybinding affected by org-CUA-compatibility.

449
ORGWEBPAGE/tmp/qanda.html Normal file
View File

@ -0,0 +1,449 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-mode Frequently Asked Questions</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2007/12/20 07:18:18"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css">
</head><body>
<h1 class="title">Org-mode Frequently Asked Questions</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">1 General</a>
<ul>
<li><a href="#sec-2">1.1 Use features in other modes</a></li>
<li><a href="#sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</a></li>
</ul>
</li>
<li><a href="#sec-4">2 Errors</a>
<ul>
<li><a href="#sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></a></li>
<li><a href="#sec-6">2.2 CUA mode does not work with Org-mode</a></li>
</ul>
</li>
<li><a href="#sec-7">3 Setup and Structure</a>
<ul>
<li><a href="#sec-8">3.1 Org-mode as default mode</a></li>
<li><a href="#sec-9">3.2 Get rid of extra stars in outline</a></li>
<li><a href="#sec-10">3.3 Two windows on same Org-mode file</a></li>
</ul>
</li>
<li><a href="#sec-11">4 Hyperlinks</a>
<ul>
<li><a href="#sec-12">4.1 Broken links after Org-mode 4.20</a></li>
<li><a href="#sec-13">4.2 Converting links to double-bracket format</a></li>
<li><a href="#sec-14">4.3 Angular bracket links preference</a></li>
<li><a href="#sec-15">4.4 Confirmation for shell and elips links</a></li>
</ul>
</li>
<li><a href="#sec-16">5 Export</a>
<ul>
<li><a href="#sec-17">5.1 Make TODO entries items, not headlines in HTML export</a></li>
<li><a href="#sec-18">5.2 Export only a subtree</a></li>
</ul>
</li>
<li><a href="#sec-19">6 Tables</a>
<ul>
<li><a href="#sec-20">6.1 #ERROR fields in tables</a></li>
<li><a href="#sec-21">6.2 Unwanted new lines in table</a></li>
<li><a href="#sec-22">6.3 Change indentation of a table</a></li>
</ul>
</li>
<li><a href="#sec-23">7 Agenda</a>
<ul>
<li><a href="#sec-24">7.1 Include Org-mode agenda into Emacs diary</a></li>
</ul>
</li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">1 General</h2>
<div class="outline-3">
<h3 id="sec-2">1.1 Use features in other modes</h3>
<p><b>I would like to use editing features of org-mode in other modes, is this possible?</b>
</p>
<p>
Not really. For tables there is <code>orgtbl-mode</code> which implements the
table editor as a minor mode. For other features you need to switch to
Org-mode temporarily, or prepare text in a different buffer.
</p>
</div>
<div class="outline-3">
<h3 id="sec-3">1.2 Visibility cycling in Outline-mode and Outline-minor-mode</h3>
<p>
%Can I get the visibility-cycling features in outline-mode and
outline-minor-mode?%
</p>
<p>
Yes, these functions are written in a way that they are independent of
the outline setup. The following setup provides standard Org-mode
functionality in outline-mode on <code>TAB</code> and <code>S-TAB</code>. For
outline-minor-mode, we use <code>C-TAB</code> instead of <code>TAB</code>,
because <code>TAB</code> usually has mode-specific tasks.
</p>
<p>
<pre>
(add-hook 'outline-minor-mode-hook
(lambda ()
(define-key outline-minor-mode-map [(control tab)] 'org-cycle)
(define-key outline-minor-mode-map [(shift tab)] 'org-global-cycle)))
(add-hook 'outline-mode-hook
(lambda ()
(define-key outline-mode-map [(tab)] 'org-cycle)
(define-key outline-mode-map [(shift tab)] 'org-global-cycle)))
</pre>
</p>
<p>
Or check out <i>outline-magic.el</i>, which does this and also provides
promotion and demotion functionality. @file{outline-magic.el} is
available at <a href="http://www.astro.uva.nl/~dominik/Tools/OutlineMagic">Outline Magic</a>.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-4">2 Errors</h2>
<div class="outline-3">
<h3 id="sec-5">2.1 <code>(wrong-type-argument keymapp nil)</code></h3>
<p>When I try to use Org-mode, I always get the error message
@code{(wrong-type-argument keymapp nil)} This is a conflict with an
outdated version of the <i>allout.el</i>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-6">2.2 CUA mode does not work with Org-mode</h3>
<p>
%Org-mode takes over the S-cursor keys. I also want to use CUA-mode,
is there a way to fix this conflict?%
</p>
<p>
Yes, see the <i>Conflicts</i> section of the manual.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-7">3 Setup and Structure</h2>
<div class="outline-3">
<h3 id="sec-8">3.1 Org-mode as default mode</h3>
<p>
%Org-mode seems to be a useful default mode for the various README
files I have scattered through my directories%. %How do I turn it on
for all README files?%
</p>
<p>
Add the following to your .emacs file:
</p>
<p>
<pre>
(add-to-list 'auto-mode-alist '("README$" . org-mode))
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-9">3.2 Get rid of extra stars in outline</h3>
<p>
%All these stars are driving me mad, I just find the Emacs outlines
unreadable. Can't you just put white space and a single star as a
starter for headlines?%
</p>
<p>
See the section <i>Clean outline view</i> in the manual.
</p>
</div>
<div class="outline-3">
<h3 id="sec-10">3.3 Two windows on same Org-mode file</h3>
<p>%I would like to have two windows on the same Org-mode file, but with
different outline visibility. Is that possible?%
</p>
<p>
In GNU Emacs, you may use <i>indirect buffers</i> which do exactly this.
See the documentation on the command <code>make-indirect-buffer</code>. In
XEmacs, this is currently not possible because of the different outline
implementation.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-11">4 Hyperlinks</h2>
<div class="outline-3">
<h3 id="sec-12">4.1 Broken links after Org-mode 4.20</h3>
<p>
%Some of my links stopped working after I upgraded to a version 4.20
or later. Why is this, and how can I fix it?%
</p>
<p>
These must be links in plain text, containing white space, such as
</p>
<p>
<pre>
bbdb:Richard Stallman
</pre>
</p>
<p>
You need to protect these links by putting double brackets around
them, like
</p>
<p>
<pre>
[[bbdb:Richard Stallman][bbdb:Richard Stallman]]
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-13">4.2 Converting links to double-bracket format</h3>
<p>
%I see that Org-mode now creates links using the double bracket
convention that hides the link part and the brackets, only showing the
description part. How can I convert my old links to this new format?%
</p>
<p>
Execute once in each Org-mode file: <code>M-x org-upgrade-old-links</code>
This replaces angular brackets with the new link format.
</p>
</div>
<div class="outline-3">
<h3 id="sec-14">4.3 Angular bracket links preference</h3>
<p>
%I don't care if you find the new bracket links great, I am attached
to the old style using angular brackets and no hiding of the link
text. Please give them back to me, don't tell me it is not possible!%
</p>
<p>
Would I let you down like that? If you must, you can do this
</p>
<p>
<pre>
(setq org-link-style 'plain
org-link-format "&lt;%s&gt;")
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-15">4.4 Confirmation for shell and elips links</h3>
<p>%When I am executing shell/elisp links I always get a confirmation
prompt and need to type <code>yes RET</code>, that's 4 key presses! Can I get
rid of this?%
</p>
<p>
The confirmation is there to protect you from unwantingly execute
potentially dangerous commands. For example, imagine a link
<pre>
[[shell:rm -rf ~/*][ Google Search]]
</pre>
</p>
<p>
In an Org-mode buffer, this command would look like <i>Google Search</i>,
but really it would remove your home directory. If you wish, you can
make it easier to respond to the query by setting
<code>org-confirm-shell-link-function</code> and/or
<code>org-confirm-elisp-link-function</code> to <code>y-or-n-p</code>. Then a single yc
keypress will be enough to confirm those links. It is also possible
to turn off this check entirely, but I do not recommend to do this.
Be warned.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-16">5 Export</h2>
<div class="outline-3">
<h3 id="sec-17">5.1 Make TODO entries items, not headlines in HTML export</h3>
<p>
%When I export my TODO list, every TODO item becomes a separate
section. How do I enforce these items to be exported as an itemized
list?%
</p>
<p>
If you plan to use ASCII or HTML export, make sure things you want to
be exported as item lists are level 4 at least, even if that does mean
there is a level jump. For example:
</p>
<p>
<pre>
* Todays top priorities
**** TODO write a letter to xyz
**** TODO Finish the paper
**** Pick up kids at the school
</pre>
</p>
<p>
Alternatively, if you need a specific value for the heading/item
transition in a particular file, use the <code>#+OPTIONS</code> line to
configure the H switch.
</p>
<p>
<pre>
#+OPTIONS: H:2; ...
</pre>
</p>
</div>
<div class="outline-3">
<h3 id="sec-18">5.2 Export only a subtree</h3>
<p>
%I would like to export only a subtree of my file to HTML. How?%
</p>
<p>
If you want to export a subtree, mark the subtree as region and then
export. Marking can be done with <code>C-c @@ C-x C-x</code>, for example.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-19">6 Tables</h2>
<div class="outline-3">
<h3 id="sec-20">6.1 #ERROR fields in tables</h3>
<p>
%One of my table columns has started to fill up with <code>#ERROR</code>. What
is going on?%
</p>
<p>
Org-mode tried to compute the column from other fields using a
formula stored in the <code>#+TBLFM:</code> line just below the table, and
the evaluation of the formula fails. Fix the fields used in the
formula, or fix the formula, or remove it!
</p>
</div>
<div class="outline-3">
<h3 id="sec-21">6.2 Unwanted new lines in table</h3>
<p>
%When I am in the last column of a table and just above a horizontal
line in the table, pressing TAB creates a new table line before the
horizontal line%. %How can I quickly move to the line below the
horizontal line instead?%
</p>
<p>
Press <code>down</code> (to get on the separator line) and then <code>TAB</code>
Or configure the variable <code>org-table-tab-jumps-over-hlines</code>.
</p>
</div>
<div class="outline-3">
<h3 id="sec-22">6.3 Change indentation of a table</h3>
<p>%How can I change the indentation of an entire table without fixing
every line by hand?%
</p>
<p>
The indentation of a table is set by the first line. So just fix the
indentation of the first line and realign with <code>TAB</code>.
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-23">7 Agenda</h2>
<div class="outline-3">
<h3 id="sec-24">7.1 Include Org-mode agenda into Emacs diary</h3>
<p>%Is it possible to include entries from org-mode files into my emacs
diary?%
</p>
<p>
Since the org-mode agenda is much more powerful and can contain the
diary, you should think twice
before deciding to do this. Integrating Org-mode information into the
diary is, however, possible. You need to turn on <i>fancy diary display</i> by setting in .emacs:
</p>
<p>
<pre>
(add-hook 'diary-display-hook 'fancy-diary-display)
</pre>
</p>
<p>
Then include the following line into your ~/diary file, in
order to get the entries from all files listed in the variable
<code>org-agenda-files</code>
</p>
<p>
<pre>
&amp;%%(org-diary)
</pre>
You may also select specific files with
</p>
<p>
<pre>
&amp;%%(org-diary) ~/path/to/some/org-file.org
&amp;%%(org-diary) ~/path/to/another/org-file.org
</pre>
</p>
<p>
If you now launch the calendar and press d to display a diary, the
headlines of entries containing a timestamp, date range, schedule, or
deadline referring to the selected date will be listed. Just like
Org-mode's agenda view, the diary for @emph{today} contains additional
entries for overdue deadlines and scheduled items. See also the
documentation of the @command{org-diary} function. Under XEmacs, it is
not possible to jump back from the diary to the org, this works only in
the agenda buffer.
</p>
</div>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten.dominik@gmail.com">&lt;carsten.dominik@gmail.com&gt;</a>
</p>
<p class="date"> Date: 2007/12/20 07:18:18</p>
</div></body>
</html>

44
ORGWEBPAGE/tmp/request-assign-future.txt Normal file
View File

@ -0,0 +1,44 @@
Please email the following information to assign@gnu.org, and we
will send you the assignment form for your past and future changes.
Please use your full legal name (in ASCII characters) as the subject
line of the message.
----------------------------------------------------------------------
REQUEST: SEND FORM FOR PAST AND FUTURE CHANGES
[What is the name of the program or package you're contributing to?]
Org-mode, which is part of Emacs
[Did you copy any files or text written by someone else in these changes?
Even if that material is free software, we need to know about it.]
[Do you have an employer who might have a basis to claim to own
your changes? Do you attend a school which might make such a claim?]
[For the copyright registration, what country are you a citizen of?]
[What year were you born?]
[Please write your email address here.]
[Please write your postal address here.]
[Which files have you changed so far, and which new files have you written
so far?]

2169
ORGWEBPAGE/tmp/survey.html Normal file
View File

File diff suppressed because it is too large Load Diff

1209
ORGWEBPAGE/tmp/todo.html Normal file
View File

File diff suppressed because it is too large Load Diff

317
ORGWEBPAGE/tmp/tutorials.html Normal file
View File

@ -0,0 +1,317 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-Mode Tutorials, Blogposts, and Screenscasts</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2008/01/20 09:24:39"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css">
</head><body>
<h1 class="title">Org-Mode Tutorials, Blogposts, and Screenscasts</h1>
<p>
This page lists tutorials, screencasts, and extensive blog posts about
<a href="http://orgmode.org">Org-mode</a>
</p>
<BASE href="http://orgmode.org/tutorials.html">
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">General Introductions to Org-mode</a></li>
<li><a href="#sec-2">Special features</a>
<ul>
<li><a href="#sec-3">Sparse Trees</a></li>
<li><a href="#sec-4">Tables</a></li>
<li><a href="#sec-5">The Spreadsheet: Org-mode and Calc</a></li>
<li><a href="#sec-6">Hyperlinks</a></li>
<li><a href="#sec-7">Using TODO states</a></li>
<li><a href="#sec-8">Using TAGS&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-9">Complex searches for Tags, TODO keywords and Properties</a></li>
<li><a href="#sec-10">Timestamps, Appointments etc</a></li>
<li><a href="#sec-11">The Clock Table&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-12">Using Remember Templates&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-13">Properties and Column View</a></li>
<li><a href="#sec-14">Custom Agenda Commands</a></li>
<li><a href="#sec-15">Embedded LaTeX</a></li>
<li><a href="#sec-16">HTML export</a></li>
<li><a href="#sec-17">LaTeX export</a></li>
<li><a href="#sec-18">Publishing</a></li>
<li><a href="#sec-19">Using orgtbl-mode in LaTeX</a></li>
</ul>
</li>
<li><a href="#sec-20">Special tasks</a>
<ul>
<li><a href="#sec-21">Natural Project Planning&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
</ul>
</li>
<li><a href="#sec-22">Personal Setup</a>
<ul>
<li><a href="#sec-23">Extensive documents</a></li>
<li><a href="#sec-24">Short descriptions</a></li>
</ul>
</li>
<li><a href="#sec-25">Org-related pages by Tutorial authors</a></li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">General Introductions to Org-mode</h2>
<ul>
<li>
<a href="http://dto.freeshell.org/notebook/OrgTutorial.html">The OrgMode tutorial</a> by <a href="http://dto.freeshell.org/notebook/">David O'Toole</a>, covering the basics of TODO
lists and the agenda. It has been translated into <a href="http://www.cognition.ens.fr/~guerry/orgtutorialfr.html">French</a>,
<a href="http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fOrgTutorial">Japanese</a>, <a href="http://hokmen.chan.googlepages.com/OrgTutorial.en-cn.html">Chinese</a>, and <a href="http://jmjeong.com/index.php?display=Emacs/OrgMode">Korean</a>.
</li>
<li>
<a href="http://jaderholm.com/screencasts.html">A 25 minute screencast</a> by <a href="http://jaderholm.com">Scott Jaderholm</a>, demonstrating the basic
features of Org-mode.
</li>
<li>
<a href="http://sachachua.com/wp/2008/01/18/outlining-your-notes-with-org/">Outlining Your Notes with Org</a> by <a href="http://sachachua.com/wp/">Sacha Chua</a> covers outlining,
searching and internal links.
</li>
<li>
<a href="http://www.linuxjournal.com/article/9116">Getting Organized with Emacs Org-mode</a> by <a href="http://www.geocities.com/abhijeet_chawan/">Abhijeet Chavan</a>, and
article originally published in the <a href="http://www.linuxjournal.com/">Linux Journal</a>.
</li>
</ul></div>
<div class="outline-2">
<h2 id="sec-2">Special features</h2>
<div class="outline-3">
<h3 id="sec-3">Sparse Trees</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-4">Tables</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-5">The Spreadsheet: Org-mode and Calc</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-6">Hyperlinks</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-7">Using TODO states</h3>
<p><i>Your chance for everlasting fame on the Org-mode homepage</i>
</p></div>
<div class="outline-3">
<h3 id="sec-8">Using TAGS &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/2008/01/04/tagging-in-org-plus-bonus-code-for-timeclocks-and-tags/">Tagging in Org</a> by <a href="http://sachachua.com/wp/">Sacha Chua</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-9">Complex searches for Tags, TODO keywords and Properties</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-10">Timestamps, Appointments etc</h3>
<ul>
<li>
<a href="http://members.optusnet.com.au/~charles57/GTD/org_dates/">Using Dates and Times in Emacs Org-mode</a> by <a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-11">The Clock Table &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/2007/12/30/clocking-time-with-emacs-org/">Clocking time with Emacs Org</a> by <a href="http://sachachua.com/wp/">Sacha Chua</a> .
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-12">Using Remember Templates &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/2007/10/05/remembering-to-org-and-planner/">Remembering to Org and Planner</a> by <a href="http://sachachua.com/wp/">Sacha Chua</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-13">Properties and Column View</h3>
<ul>
<li>
<a href="http://www.cognition.ens.fr/~guerry/org-column-view-tutorial.html">Emacs Org's Column View</a> by <a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>, with an accompanying
<a href="http://www.cognition.ens.fr/~guerry/org-column-screencast.html">screencast</a>.
</li>
<li>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/5107/focus%3D5134">What's the use of Column View?</a> by Christian Egli is ashort
tutorial about Column View that was sent to <a href="http://news.gmane.org/gmane.emacs.orgmode">emacs-orgmode@gnu.org</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-14">Custom Agenda Commands</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-15">Embedded LaTeX</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-16">HTML export</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-17">LaTeX export</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-18">Publishing</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-19">Using orgtbl-mode in LaTeX</h3>
<p><i>Your chance for everlasting fame</i>
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-20">Special tasks</h2>
<div class="outline-3">
<h3 id="sec-21">Natural Project Planning &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a> about using Org-mode to implement <a href="http://members.optusnet.com.au/~charles57/GTD/Natural_Project_Planning.html">Natural Project Planning</a> according to David Allen.
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-22">Personal Setup</h2>
<div class="outline-3">
<h3 id="sec-23">Extensive documents</h3>
<ul>
<li>
<a href="http://johnwiegley.com/org.mode.day.planner.html">Using Org-mode as a day planner</a> by <a href="http://johnwiegley.com">John Wiegley</a>.
</li>
<li>
<a href="http://members.optusnet.com.au/~charles57/GTD/orgmode.html">Using Emacs org-mode for GTD</a> by <a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a>.
</li>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2007/12/22/a-day-in-a-life-with-org/">A day in a life with Org</a> and about the basics of
<a href="http://sachachua.com/wp/2007/12/28/emacs-getting-things-done-with-org-basic/">Getting Things Done with Org</a>
</li>
<li>
<i>Your chance for everlasting fame</i>
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-24">Short descriptions</h3>
<ul>
<li>
David O'Toole explains his setup in <a href="http://thread.gmane.org/gmane.emacs.orgmode/4832">this post</a>.
</li>
<li>
This <a href="http://www.brool.com/?p=82">blog post</a> shows a very simple and clear GTD setup.
</li>
<li>
<i>Your chance for everlasting fame</i>
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-25">Org-related pages by Tutorial authors</h2>
<p>
Here are the pages of a number of people that write for or about
Org-mode
</p>
<ul>
<li>
<a href="http://johnwiegley.com">John Wiegley</a>
</li>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a>
</li>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a>
</li>
<li>
<a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>
</li>
</ul>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten at orgmode dot org">&lt;carsten at orgmode dot org&gt;</a>
</p>
<p class="date"> Date: 2008/01/20 09:24:39</p>
</div></body>
</html>

920
ORGWEBPAGE/todo.html Normal file
View File

@ -0,0 +1,920 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>The Org-mode TODO list</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2007/07/10 10:35:08"/>
<meta name="author" content="Carsten Dominik"/>
<link rel=stylesheet href="freeshell2.css" type="text/css"> <style type="text/css"> .tag { color: red; font-weight:bold}</style>
</head><body>
<h1 class="title">The Org-mode TODO list</h1>
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">1 Introduction</a>
<ul>
<li><a href="#sec-2">1.1 Nomenclature</a></li>
</ul>
</li>
<li><a href="#sec-3">2 Tasks</a>
<ul>
<li><a href="#sec-4">2.1 Structure</a></li>
<li><a href="#sec-5">2.2 Agenda issues</a></li>
<li><a href="#sec-6">2.3 Links</a></li>
<li><a href="#sec-7">2.4 Fast update for external editing</a></li>
<li><a href="#sec-8">2.5 Tables</a></li>
<li><a href="#sec-9">2.6 Properties and Column View</a></li>
<li><a href="#sec-10">2.7 Compatibility issues</a></li>
<li><a href="#sec-11">2.8 Exporting</a></li>
<li><a href="#sec-12">2.9 Miscellaneous Stuff</a></li>
</ul>
</li>
<li><a href="#sec-13">3 Archive</a>
<ul>
<li><a href="#sec-14">3.1 Archived Tasks</a></li>
</ul>
</li>
</ul>
<h2 id="sec-1">1 Introduction</h2>
<p>
This is a loose collection of ideas and TODO items for the future
development of Org-mode. These ideas come from various sources,
mostly from emacs-orgmode@gnu.org, from direct emails to me, or from
my own day-dreaming. I don't always mention the source of an idea,
out of laziness. However, when I implement a good idea, I try to
mention the origin of this idea in the <i>Acknowledgments</i> section of
the manual - let me know if I forgot to give <i>you</i> credit for
something.
</p>
<h3 id="sec-2">1.1 Nomenclature</h3>
<p>On this page, I am using TODO keywords in the following way:
</p><table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<COL align="left"></COL><COL align="left"></COL>
<thead>
<tr><th><b>Keyword</b></th><th>Intention</th></tr>
</thead>
<tbody>
<tr><td><b>TODO</b></td><td>A development that is going to happen, once I have time or once I figure out how to do it.</td></tr>
<tr><td><b>IDEA</b></td><td>A new idea, I have not yet decided what if anything I will do about it.</td></tr>
<tr><td><b>WISH</b></td><td>A wish, probably voiced by someone on emacs-orgmode@gnu.org. This is less than a new idea, more a change in existing behavior.</td></tr>
<tr><td><b>QUESTION</b></td><td>A question someone asked, that needs some thinking before it can be answered</td></tr>
<tr><td><b>DECLINED</b></td><td>I have decided not to implement this feature, but I am keeping it in the list so that people can see it, complain, or still try to convince me.</td></tr>
<tr><td><b>INCONSISTENCY</b></td><td>Some behavior in Org-mode that is not as clean and consistent as I would like it to be.</td></tr>
<tr><td><b>BUG</b></td><td>This needs to be fixed, as soon as possible.</td></tr>
<tr><td><b>DONE</b></td><td>Well, done is done.</td></tr>
<tr><td><i>NEW</i></td><td>This is a tag, indicating recently added entries</td></tr>
</tbody>
</table>
<h2 id="sec-3">2 Tasks</h2>
<h3 id="sec-4">2.1 Structure</h3>
<ul>
<li><span class="todo">TODO</span> Definition lists, like in Muse<br/>
</li>
<li><span class="todo">TODO</span> Get rid of all the \r instances, which were used only for XEmacs.<br/>
</li>
<li><span class="todo">IDEA</span> Should we allow #+TODO as an alias for #+SEQ<sub>TODO</sub>?<br/>
</li>
<li><span class="todo">TODO</span> proper visibility cycling for items<br/>
Make them not hide the text after the final list item.
This is not trivial, we cannot usenormal outline stuff,
needs a separate implementaiton.
</li>
<li><span class="todo">IDEA</span> allow different colors for different TODO keywords/tags.<br/>
</li>
<li><span class="todo">TODO</span> Use an indirect buffer for org-goto.<br/>
Is there a problem with the overriding map?
</li>
<li><span class="todo">WISH</span> Inline TODO entries<br/>
A way to put a TODO entry without starting a new section.
</li>
</ul>
<h3 id="sec-5">2.2 Agenda issues</h3>
<ul>
<li><span class="todo">QUESTION</span> COLUMN View<br/>
is this safe, or could things be messed up with this?
</li>
<li><span class="todo">TODO</span> Make S-right and S-left change TODO keywords<br/>
Right now they change the time stamps. This could be
M-left/right, but this could also cause inconsistencies, because
when on a time stamp, the same keys do exactly this.
</li>
<li><span class="todo">WISH</span> Make more modes changeable from the agenda<br/>
These could be made available for toggling, just like
follow-mode. Examples:
<ul>
<li>
org-agenda-todo-list-sublevels
</li>
<li>
org-tags-match-list-sublevels
</li>
<li>
org-agenda-todo-ignore-scheduled
</li>
</ul></li>
<li><span class="todo">IDEA</span> Sort TODO entries according to type?<br/>
This would apply for the list collection, not in the day entries.
However, I could also have a TODO keyword criterion that could be
used in the day entries, as one of the minor criteria.
</li>
<li><span class="todo">DECLINED</span> Allow separators in the Tag-sorted agenda view<br/>
This feature is not going to come, because block agendas can
achieve the same thing.
</li>
</ul>
<h3 id="sec-6">2.3 Links</h3>
<ul>
<li><span class="todo">WISH</span> When editing links, give access to stored links.<br/>
Not sure why this is needed.
Idea from William Henney.
</li>
<li><span class="todo">WISH</span> Variable of standard links for completion with C-c C-l<br/>
Or something like that, to make standard links fast.
</li>
<li><span class="todo">WISH</span> Make brackets in links possible<br/>
Would require a display property also for the label part of
links.
</li>
<li><span class="todo">IDEA</span> Find all links to a specific file<br/>
</li>
<li><span class="todo">IDEA</span> Make info HTML links work for links to Info files<br/>
Info links of course only work inside Emacs. However, many info
documents are on the web, so the HTML exporter could try to be
smart and convert an Info link into the corresponding link on the
web. For example, we could use the GNU software site then
Name.HTML. Here is the link to be used:
<a href="http://www.gnu.org/software/emacs/manual/html_node/">http://www.gnu.org/software/emacs/manual/html_node/</a> Another
question is, is this URL going to be stable so that it makes sense
to actually put this into org.el?
</li>
<li><span class="todo">IDEA</span> Make news HTML links work, using Google.<br/>
I can use Google groups with a message id to find a USENET message,
even if the original link points to gnus.
</li>
<li><span class="todo">TODO</span> Remove irretrievable links from <i>published</i> HTML output<br/>
This is on David's table, and he will hopefully integrate a
mechanism for this into org-publish.el. The discussion about this
was started by <a href="http://thread.gmane.org/gmane.emacs.orgmode/281">Austin Frank</a>
</li>
<li><span class="todo">DECLINED</span> Agenda collections, based on #+COLLECTION lines.<br/>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/139">Tim Callaghan</a> started the discussion on this one.
Declined because this would depend on local variables and the
agenda commands are global. Also, this can actually be done by
specifying the file list in a custom agenda command.
</li>
<li><span class="todo">DECLINED</span> Make CamelCase words link to corresponding org-mode files.<br/>
Files in the same directory. Or some other way to easy do that.
Would be useful for publishing projects. This would be an
incompatible change, but I don't think anyone is using CamelCase
anyway?
This is marked declined, because link abbreviations now provide an
easy way to make links to other files.
</li>
<li><span class="todo">TODO</span> Document the character protection in links<br/>
I don't think this is really covered anywhere.
Maybe we also should protect characters in the visible part, to
make sure thing will never be on two lines...?
</li>
<li><span class="todo">WISH</span> Radio targets across files<br/>
I guess each org file could write a .orgtargets.filename file, if
it has any radio targets.
</li>
</ul>
<h3 id="sec-7">2.4 <span class="todo">DECLINED</span> Fast update for external editing</h3>
<p>Could I use a dynamic block for this?
</p>
<h3 id="sec-8">2.5 Tables</h3>
<ul>
<li><span class="todo">WISH</span> Row formulas<br/>
@4=.....
</li>
<li><span class="todo">TODO</span> Write a tutorial<br/>
Demonstrate running averages.
</li>
<li><span class="todo">WISH</span> Make a variable that current line should be recomputed always<br/>
in each table, skipping headers of course.
</li>
<li><span class="todo">TODO</span> Allow a table to locally change the unit system<br/>
This is for using constants.el.
Well, it is now possible to do this for the file, is this enough???
</li>
<li><span class="todo">QUESTION</span> Does inserting hlines change references correctly?<br/>
</li>
<li><span class="todo">WISH</span> Interactive way to get a converted table?<br/>
</li>
<li><span class="todo">BUG</span> When computing in a narrowed column, this may go wrong.<br/>
Computing changes fields and does not yet see correctly if the column
width has changed, in the case of a narrowed column.
</li>
<li><span class="todo">DECLINED</span> Alternative for the implementation of orgtbl-minor-mode:<br/>
I could use post-command-hook to set the variable orgtbl-mode.
I will not do this now and only consider it if problems show up.
</li>
<li><span class="todo">DECLINED</span> Table info lines are not necessarily comments in orgtbl-mode<br/>
Should I generalize this? No, because the table itself will not be
in the correct syntax for whatever mode.
</li>
<li><span class="todo">DECLINED</span> S-cursor motion to select part of a table, with proper highlighting.<br/>
Similar to CUA
</li>
</ul>
<h3 id="sec-9">2.6 Properties and Column View</h3>
<ul>
<li><span class="todo">TODO</span> Mouse support for selecting values<br/>
This could/should be part of org-mouse.el.
<ul>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> tags
</li>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> todo
</li>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> priority
</li>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> allowed values
</li>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> deadline
</li>
<li>
<b>[<span style="visibility:hidden;">X</span>]</b> scheduled.
</li>
</ul></li>
<li><span class="todo">BUG</span> We have no clear view on what to do with properties upon export.<br/>
</li>
</ul>
<h3 id="sec-10">2.7 Compatibility issues</h3>
<ul>
<li>Emacs 21 compatibility<br/>
This is being phased out. Almost everything works under Emacs 21,
but in the future I wwill make little effort to support it.
<ul>
<li><span class="todo">DECLINED</span> Column view does not yet work for Emacs 21s.<br/>
Declined, because I don't know how to do this. Too many
problems.
</li>
</ul>
</li>
<li>XEmacs compatibility<br/>
<ul>
<li><span class="todo">QUESTION</span> Is there an issue with the coding system of HTML exported files?<br/>
In the code I used to have a comment saying that
<pre>
(and (fboundp 'coding-system-get)
(boundp 'buffer-file-coding-system)
buffer-file-coding-system))
</pre>
always returns nil, implicating that setting the coding system for
the export buffer would not work correctly. however, I have never
followed up on this and never had a bug report - so I am wondering
if there is an issue at all.
</li>
<li><span class="todo">DECLINED</span> Column view does not yet work for XEmacs.<br/>
Declined, because I don't know how to do this. Too many
problems.
</li>
<li><span class="todo">DECLINED</span> Rewrite the `format' function<br/>
To make narrowing work under XEmacs, I would need to write a
version of <i>format</i> that does transport text properties, or I
would have to rework narrowing entirely. Unlikely that this will
happen, mainly because it is working in Emacs and so does not
bother me personally so much. Anyway, I don't know if people are
actually using narrowing very much at all.
</li>
</ul>
</li>
</ul>
<h3 id="sec-11">2.8 Exporting</h3>
<ul>
<li><span class="todo">IDEA</span> Convert links to footnotes for ASCII export.<br/>
</li>
<li><span class="todo">DECLINED</span> Store LaTeX code as HTML comments<br/>
Declined because I don't really see the need for this.
</li>
<li><span class="todo">IDEA</span> Microformats<br/>
Nic Ferrier has been pushing this agenda for a long time, for
example with <a href="http://thread.gmane.org/gmane.emacs.orgmode/140/">this email</a>. I am not deep enough into the semantic
web that I could do this myself. Maybe we can do this by
modifying the html exporter step-by-step?
</li>
<li><span class="todo">INCONSISTENCY</span> Find a better place for formatting checkboxes<br/>
Right now this is being done as part of `org-html-expand', which
does not seem logically correct.
</li>
<li><span class="todo">DECLINED</span> Can I make the exporter more efficient?<br/>
The line-by-line processing may not be the fastest way to do
this. It certainly uses more resources. Right now the exporters
do work though, so it is unlikely that I am going to change this.
</li>
<li><span class="todo">DECLINED</span> CSV import/export of tables?<br/>
I remember this coming up several times, for example in emails
from <a href="http://thread.gmane.org/gmane.emacs.orgmode/156">Niels Giesen</a> and <a href="http://thread.gmane.org/gmane.emacs.orgmode/139">Tim Callaghan</a>. Org-mode does have
Tab-separated export of tables, so right now I don't really see
the benefit of adding CSV export. Are there applications that do
not understand tab-separated files, but do understand
comma-separated ones?
</li>
<li><span class="todo">DECLINED</span> In HTML export, make links from the time stamps<br/>
Time stamps have their own class now which allows to highlight
them etc. But I was wondering if something more useful could be
done with them, like a link to some kind of calendar...
</li>
</ul>
<h3 id="sec-12">2.9 Miscellaneous Stuff</h3>
<ul>
<li><span class="todo">TODO</span> reinstating a repeated item: keyword for logging.<br/>
</li>
<li><span class="todo">BUG</span> Comments cannot be filled<br/>
</li>
<li><span class="todo">DECLINED</span> HAVE a TIME 3:55 line collecting CLOCK results<br/>
The CLOCK lines could be there in addition, or could even be
removed, so that only one line is kept.
</li>
<li><span class="todo">IDEA</span> New uses for C-c C-c<br/>
<ul>
<li>
Compute time interval on time range
</li>
<li>
Update CLOCK interval
</li>
</ul></li>
<li><span class="todo">QUESTION</span> Fix more beginning-of-line commands<br/>
Org-mode re-binds C-a to make this command go to the beginning of
a visible line. There are other keys which might invoke C-a.
Should these keys be changed as well? one could use
`substitute-key-definition' on the global map to find them all.
</li>
<li><span class="todo">QUESTION</span> Inlining of images in Org-mode files<br/>
</li>
<li><span class="todo">TODO</span> Fixup outline-magic.el, so that it can be used.<br/>
</li>
<li><span class="todo">TODO</span> Use the new argument of bibtex-url<br/>
Roland Winkler was kind enough to implement a new argument to the
`bibtex-url' command that allows me to retrieve the corresponding
URL, whether it is taken from a URL field or constructed in some
clever way. Currently I am not using this, because too many
people use an old Emacs version which does not have this.
however, eventually I will implement this.
</li>
<li><span class="todo">WISH</span> Get people to write articles about how to do GTD with Org-mode.<br/>
There is now one by Charles Cave, read it <a href="http://members.optusnet.com.au/~charles57/GTD/orgmode.html">here</a>
</li>
<li><span class="todo">IDEA</span> Tree statistics<br/>
A key that can be applied to a tree, showing statistics:
<ul>
<li>
how many headlines
</li>
<li>
how many TODO
</li>
<li>
how many DONE
</li>
<li>
Checkboxes
</li>
<li>
etc....
</li>
</ul></li>
<li><span class="todo">QUESTION</span> Do we need a 43 folders implementation?<br/>
That could easily be done in an org-mode file. But then, maybe
this should really be a paper thing.
</li>
<li>Priorities<br/>
Here is some information about priorities, which is not yet
documented.
<ul>
<li> Priorities<br/>
<pre> TODO entries: 1 or 1,2,...
DEADLINE is 10-ddays, i.e. it is 10 on the due day
i.e. it goes above top todo stuff 7 days
before due
SCHEDULED is 5-ddays, i.e. it is 5 on the due date
i.e. it goes above top todo on the due day
TIMESTAMP is 0 i.e. always at bottom
but as a deadline it is 100
but if scheduled it is 99
TIMERANGE is 0 i.e. always at bottom
DIARY is 0 i.e. always at bottom
Priority * 1000
</pre>
</li>
</ul>
</li>
<li><span class="todo">INCONSISTENCY</span>: items don't grow/shrink due to promotion.<br/>
In plain lists, multiple demote/promote commands executed directly
after each other don't change the scope of the command - the
initially selected text continues to be selected. This is
inconsistent with the behavior of outline sections, were the subtree
for promotion/demotion is newly defined after each command. Which
convention is better? Should this be consistent between trees and
plain lists?
</li>
<li><span class="todo">INCONSISTENCY</span>: M-TAB does not work on plain lists. Why???<br/>
</li>
<li><span class="todo">QUESTION</span> grep on directory does not yet work.<br/>
I am actually not sure, I might have addressed this already, but
my memory is failing me. Needs some checking.
</li>
<li><span class="todo">DECLINED</span> Think about Piotr's idea of treating TODO like a TAG.<br/>
The answer is probably NO because the simple part of TODO must
still be there and I like the keyword at the beginning of the line,
just like a checkbox. Of course you can make a TODO tag yourself
at any time.
</li>
<li><span class="todo">DECLINED</span> Inlining of external files<br/>
</li>
<li><span class="todo">DECLINED</span> Should TAB on TODO keyword rotate its state?<br/>
Problem: If the keyword disappears, it will suddenly start to fold....
So my feeling right now is that the answer should be NO.
<p>
No, because S-left/right does this already pretty well
</p>
</li>
<li><span class="todo">DECLINED</span> Create a DONE counter in the mode line<br/>
That counter shows what faction of entries has been marked DONE. I
am not yet sure how useful such a thing would be, because of the
huge number of entries that can be in a file, and the different
weight of such entries.
Declined because we do now have counters for checkboxes, and the
feeling is that this is not so useful for TODOs.
</li>
</ul>
<h2 id="sec-13">3 Archive</h2>
<h3 id="sec-14">3.1 Archived Tasks</h3>
<ul>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:15</span>) Commands to move through an item list<br/>
next item, previous item. What should happen at the boundaries of
the current list?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) Force relative links, would this be useful?<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) Fix empty search string.<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) STARTUP options for logging<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) Make a variable for Pete, to have SCHEDULED at point<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) Fix ASCII export of narrowed columns<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) org-file-apps should allow regular expressions<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:16</span>) fix problem with w32- versus mswindows-....<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Document that font-lock-mode is needed<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Add keyboard access and menu commands for org-project.el<br/>
C-c C-x C-p or something like that.
In the menu, it goes under export, or even its own group.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Document those new keys in orgcard.tex<br/>
C-c C-x C-p or something like that.
In the menu, it goes under export, or even its own group.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Remove SCHEDULED keyword when marking it done.<br/>
in particular when adding a CLOSED timestamp.
Only problem is that when unclosing it, it should be scheduled
again
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Don't show tasks already scheduled for the future, only stuff which<br/>
is not yet scheduled.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Put title and tags in separate classes<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Option to leave out TAGS from export<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Option to leave out Timestamps from export<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Checkable items like Frank Ruell's proposal<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Classify Keywords and time stamps<br/>
&lt;span class="keyword"&gt;SCHEDULED: &lt;/span&gt;&lt;span
class="timestamp"&gt;timestamp goes here&lt;/span&gt;&lt;br&gt;
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Change default for include-all-todo to nil<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Specify TAGS in a special line instead of collecting them dynamically<br/>
The could help to avoid typos and could be faster for very large files.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Some much faster interface for setting tags.<br/>
Basically, use single keys to add/remove tags from the list. Also
for this the idea to define tags in a special line would be good,
in order to have a way to define the shortcuts.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) Remove date stamps from headline if they are not needed.<br/>
Bug report from Scott.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:17</span>) : Maybe s-up/down should change priorities only in headlines<br/>
Right now this works wherever the cursor is. If this is changed,
should S-up or S-down do something else?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:21</span>) Need a command to remove tabulators from a line.<br/>
Use this in ASCII export, to make sure we get the indentation
right.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 09:24</span>) Improve tab in org-cycle:<br/>
<ul>
<li>
there is a bug when the setting is 'white: It requires a
non-empty white line!
</li>
<li>
There should be another setting to have tab be the tabulator in
the white space at the beginning of the line.
</li>
<li>
Finally, when TAB closes an entry, maybe it should go beck to the
beginning of the entry??? On the other hand, it is good to be
able to go back to the old place with just another tab.
</li>
</ul></li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-01 Thu 11:48</span>) Include TAGS into sorting.<br/>
But what strategy should be used when there are several tags?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-06 Tue 10:15</span>) Archiving an entry in current buffer goes to end of file<br/>
Should go to end of subtree.
This is done now, and I also control the amount of empty lines
created by the archiving process in general.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-06 Tue 10:16</span>) Narrowing agenda to current files does not work as advertized.<br/>
C-c a 1 t should make the TODO list for the current file, but does
not.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-06 Tue 10:17</span>) Radio TAGS for the fast tag interface.<br/>
Make lists of tags that are mutually exclusive. So when I turn on
@HOME, @WORK would be turned off automagically. A good syntax for
defining these groups in the #+TAGS line would be:
<pre>
#+TAGS: [@WORK(w) @HOME(h) @CLUB(c)] Laptop(l) PC(p) Car(r)
</pre>
This could indicate that @WORK, @HOME, @CLUB are mutually exclusive.
<p>
If I do this, I will also need a syntax for the global alist to
indicate the same thing.
</p>
<p>
It seems to me that with such grouping of tags, sorting would be
useful as it would improve the overview over the current tags. I
might even be able to support mutually exclusive tags with
fontification in the interface. Or arrange things such that the
mutually exclusive ones are all in the same row or column, to
optimize the visual feedback.
</p>
<p>
For the internal format, I think best would be something like
</p>
<p>
<pre>
'( (:startgroup) ("@work") ("@home") ("@club") (:endgroup)
("Laptop") ("PC") ("Car"))
</pre>
This setup makes sure that assoc and rassoc still do work as
expected.
</p>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-06 Tue 10:17</span>) Should tags be sorted in a certain way?<br/>
Right now, you can either set the tag sequence yourself through
the completion interface. If you use the fast tag selection
interface, the tag sequence depends on the order in which tags are
selected and deselected. maybe a specific roder would be useful
for example the same order as the one given in the configuration?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-06 Tue 10:17</span>) Remove narrowing cookies for export<br/>
Exported tables should not show narrowing cookies. In fact, if a
table line does contain nothing but narrowing cookies, the entire
line should be removed.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-11 Sun 07:32</span>) Track working times similar to time-clock.el<br/>
This was proposed by David O'Toole in an
<a href="http://thread.gmane.org/gmane.emacs.orgmode/387">email to emacs-orgmode@gnu.org</a>. He wants to be able to know the
times when he worked at a particular project. Some reporting
possibility would be needed to make this useful. Maybe sparse
trees with broken-down working times?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-15 Thu 13:35</span>) Make org-store-link do better in image-mode buffers<br/>
Just link to the file.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-15 Thu 13:35</span>) Use a ported version of noutline.el<br/>
Programming the old outline-mode is really a nightmare - the new
outline mode that uses invisibility properties instead of
selective display works really much much better. There is now
an <a href="http://thread.gmane.org/gmane.emacs.orgmode/214/focus=218">experimental port</a> by Greg Chernov, so when I find time I will
try if this works well. If yes, this port should become part of
XEmacs. Once that happens, I could remove a large amount of
ballast from org.el
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-06-15 Thu 13:35</span>) Verify links during export<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:11</span>) Allow counting checkboxes<br/>
Then some statistics should be displayed. One idea is for
checkboxes, to use a special box [%] which will be updated with
percent of done. I could have an alternative [/] that will be
updated with something like [19/25] to show progress, and when the
two numbers are equal, I could highlight then in DONE face, just
like [100%]. All smaller numbers could be highlighted even in
TODO face if I wanted. Hmmm, I am beginning to like this.
<p>
Then: how to update this? Each time a checkbox is added or
toggled, go up and update all the counts, right up to something
which is not an item, or up to the previous header line.
</p>
<p>
Maybe I should also make an option for turning this on, to avoid
slowdown. I guess for long lists this could be slow.
</p>
<p>
Also would need a command for global update.
</p>
<p>
An maybe plain list and checkboxes should get their own chapter?
In Structure they seem to be a bit hidden.....
</p>
<p>
Also a menu sublist...
</p>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:11</span>) Allow stacking calls to org-occur<br/>
This was a proposal from Piotr. It is now possible, the second
and subsequent calls to org-occur need a prefix argument to keep
the previous highlights.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:12</span>) Create a hook to be run after an agenda buffer has been finalized.<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:12</span>) Include TAGS into sorting.<br/>
But what strategy should be used when there are several tags?
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:12</span>) Fixup tag display in agenda buffer.<br/>
The tabs mess up everything. Either remove the tabs, or realign
the tags to some useful column.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:12</span>) Blocks in agenda:<br/>
Make a single agenda buffer that contains several sets of items,
like the TODO list, a tags list, and a day view. Not a bad idea.
This was <a href="http://thread.gmane.org/gmane.emacs.orgmode/167/focus=168">Piotr's idea</a>.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-09-25 Mon 16:12</span>) Make org-store-link do the right thing in dired-mode<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2006-11-02 Thu 10:24</span>) Control over windows being used for agenda and related buffers &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span><br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-01-24 Wed 12:59</span>) Extend access to table fields<br/>
Find a general way to get any rectangular region into a calc
vector
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-01-24 Wed 12:59</span>) Allow links to remote images to be inlined.<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-01-24 Wed 12:59</span>) M-TAB on an already complete tag should add the ":"<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-01-24 Wed 13:07</span>) Need a command to do show hierarchy after isearch.<br/>
Maybe automatically, using isearch-mode-end-hook. But this does
not seem to work, because to is called before the overlays are
re-installed. I can create a new hook, isearch-exit-hook, run in
`isearch-exit'.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-18 Sun 07:16</span>) hook for users to do their own agenda lists<br/>
New function dumping headline into the agenda buffer, based on regexp
and callback, to allow general stuff. For the special tags, we can
search for one and check for the others using the callback.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-18 Sun 07:37</span>) Make C-c C-l also work on a plain link, converting it into bracket.<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-18 Sun 07:37</span>) GNUS <i>&lt;gnus:mail.general#123&gt;</i> stuff should be "Email from:..."<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-18 Sun 07:38</span>) Email/message context: What format?<br/>
I can think of two good formats for this:
<pre>
Email from John Smith (if I an the receiver)
Email to John Smith (if I am the author)
</pre>
or
<pre>
John Smith on: Some subject (this is the current Org-mode default.)
</pre>
The first format requires better parsing of the messages (to get
both author and receiver names), and also
some way to detect if I am the author of this email or not.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-21 Wed 12:04</span>) Allow internal links to match inside <b>other</b> link<br/>
Only the link itself that actually triggered the search.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-02-21 Wed 12:07</span>) Allow fully protected HTML code that will be exported as is<br/>
Currently, <...> works only for simple tags, and I think we
should have something better. Idea: Text between &lt;protecthtml&gt;
and &lt;/protecthtml&gt;, mark it with a text property and then exclude
each match in the run preparing the export.
I guess I could require these at the beginning of the line, like
<p>
or something like that.......
</p>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-03-13 Tue 05:19</span>) Make it possible to set TOC levels independently of headline levels<br/>
The easiest way to do this would obviously be to allow a number
setting for the tco switch, not only a simple t/nil switch. This
can be nice for webpages: One could have only top-level or level
1 and 2 in the toc at the beginning of the page, and then still a
more complex structure below.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-03-13 Tue 05:20</span>) Filling is not done in a compatible way.<br/>
The current setup used the Emacs variables and machine to get the
filling of plain lists and everything lese right. XEmacs uses the
filladapt package, which has different ways to do the same
things. org.el should be smart about this and setup filling under
XEmacs correctly.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-06-06 Wed 17:44</span>) Repeating Schedules?<br/>
<a href="http://thread.gmane.org/gmane.emacs.orgmode/149">Dieter Grollman</a> requested this feature, but for now I have decided
not to do anything about it. I don't see a good way to implement
this, and I believe that cyclic diary entries are good enough for
such tasks.
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-06-14 Thu 13:16</span>) improve item indentation when promoting and demoting<br/>
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-06-14 Thu 13:17</span>) The TODO buffer lists possible TODO keywords<br/>
These are taken from the current buffer, so when multiple buffers
are involved, this list may not be correct.....
</li>
<li><span class="done">DONE</span>( <span class="timestamp">2007-06-14 Thu 13:20</span>) Conflict between bold emphasis and headlines<br/>
At the beginning of a line, Org-mode does not know if <b>bold</b> is a
headline or an emphasis. This will not be easy to fix. The way
to do ii is to require a space after the star in headlines. This
requires to change outline-regexp, outline-level, the many many
times when outline regexp is used in the program, and also the
countless times when I am simply matching th stars directly.
</li>
<li><span class="done">DONE</span> C-c - for cycling bullet types.<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
</li>
<li><span class="done">DONE</span> improve what TAB does with new item<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
same or additional indentation????
</li>
<li><span class="done">DONE</span> Make it easier to do monthly agendas, and agendas for ranges<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
</li>
<li><span class="done">DONE</span> Introduce a LOCATION keyword<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
similar to DEADLINE and SCHEDULED
Idea from Bastien
This could be done now using properties, I don't think we need a
special thing for this anymore.
</li>
<li><span class="done">DONE</span> Times/date not always removed in agenda lines<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
Even when org-agenda-remove-times-when-in-prefix is set, there
seem to be cases where this does not work. I forgot what the
example was - does anyone remember?
</li>
<li><span class="done">DONE</span> Links are still highlighted in fixed-width environments.<br/>
<span class="timestamp-kwd">ARCHIVED: </span> <span class="timestamp">2007-07-02 Mon</span><br/>
This ties in with the problem that there is no way to have
protected HTML code in the file.
</li>
</ul>
<p class="author"> Author: Carsten Dominik
<a href="mailto:carsten.dominik@gmail.com">&lt;carsten.dominik@gmail.com&gt;</a>
</p>
<p class="date"> Date: 2007/07/10 10:35:08</p>
</body>
</html>

649
ORGWEBPAGE/todo.org Normal file
View File

@ -0,0 +1,649 @@
-*- mode:org -*-
#+STARTUP: align
#+TYP_TODO: TODO IDEA WISH QUESTION DECLINED INCONSISTENCY BUG DONE
#+TAGS: NEW(n)
#+OPTIONS: H:2 num:t toc:t \n:nil @:t ::t |:t ^:t *:t TeX:t
#+ARCHIVE: ::** Archived Tasks
#+EMAIL: carsten.dominik@gmail.com
#+TITLE: The Org-mode TODO list
* Introduction
This is a loose collection of ideas and TODO items for the future
development of Org-mode. These ideas come from various sources,
mostly from emacs-orgmode@gnu.org, from direct emails to me, or from
my own day-dreaming. I don't always mention the source of an idea,
out of laziness. However, when I implement a good idea, I try to
mention the origin of this idea in the /Acknowledgments/ section of
the manual - let me know if I forgot to give /you/ credit for
something.
** Nomenclature
On this page, I am using TODO keywords in the following way:
|-----------------+----------------------------------------------------|
| *Keyword* | Intention |
|-----------------+----------------------------------------------------|
| *TODO* | A development that is going to happen, once I have time or once I figure out how to do it. |
| *IDEA* | A new idea, I have not yet decided what if anything I will do about it. |
| *WISH* | A wish, probably voiced by someone on emacs-orgmode@gnu.org. This is less than a new idea, more a change in existing behavior. |
| *QUESTION* | A question someone asked, that needs some thinking before it can be answered |
| *DECLINED* | I have decided not to implement this feature, but I am keeping it in the list so that people can see it, complain, or still try to convince me. |
| *INCONSISTENCY* | Some behavior in Org-mode that is not as clean and consistent as I would like it to be. |
| *BUG* | This needs to be fixed, as soon as possible. |
| *DONE* | Well, done is done. |
| /NEW/ | This is a tag, indicating recently added entries |
| | <50> |
|-----------------+----------------------------------------------------|
* Tasks
** Structure
*** TODO Definition lists, like in Muse
*** TODO Get rid of all the \r instances, which were used only for XEmacs.
*** IDEA Should we allow #+TODO as an alias for #+SEQ_TODO?
*** TODO proper visibility cycling for items
Make them not hide the text after the final list item.
This is not trivial, we cannot usenormal outline stuff,
needs a separate implementaiton.
*** IDEA allow different colors for different TODO keywords/tags.
*** TODO Use an indirect buffer for org-goto.
Is there a problem with the overriding map?
*** WISH Inline TODO entries
A way to put a TODO entry without starting a new section.
*** TODO Speedbar support for agenda.
** Agenda issues
*** QUESTION COLUMN View
is this safe, or could things be messed up with this?
*** TODO Make S-right and S-left change TODO keywords
Right now they change the time stamps. This could be
M-left/right, but this could also cause inconsistencies, because
when on a time stamp, the same keys do exactly this.
*** WISH Make more modes changeable from the agenda
These could be made available for toggling, just like
follow-mode. Examples:
- org-agenda-todo-list-sublevels
- org-tags-match-list-sublevels
- org-agenda-todo-ignore-scheduled
*** IDEA Sort TODO entries according to type?
This would apply for the list collection, not in the day entries.
However, I could also have a TODO keyword criterion that could be
used in the day entries, as one of the minor criteria.
*** DECLINED Allow separators in the Tag-sorted agenda view
This feature is not going to come, because block agendas can
achieve the same thing.
** Links
*** WISH When editing links, give access to stored links.
Not sure why this is needed.
Idea from William Henney.
*** WISH Variable of standard links for completion with C-c C-l
Or something like that, to make standard links fast.
*** WISH Make brackets in links possible
Would require a display property also for the label part of
links.
*** IDEA Find all links to a specific file
*** IDEA Make info HTML links work for links to Info files
Info links of course only work inside Emacs. However, many info
documents are on the web, so the HTML exporter could try to be
smart and convert an Info link into the corresponding link on the
web. For example, we could use the GNU software site then
Name.HTML. Here is the link to be used:
http://www.gnu.org/software/emacs/manual/html_node/ Another
question is, is this URL going to be stable so that it makes sense
to actually put this into org.el?
*** IDEA Make news HTML links work, using Google.
I can use Google groups with a message id to find a USENET message,
even if the original link points to gnus.
*** TODO Remove irretrievable links from /published/ HTML output
This is on David's table, and he will hopefully integrate a
mechanism for this into org-publish.el. The discussion about this
was started by [[http://thread.gmane.org/gmane.emacs.orgmode/281][Austin Frank]]
*** DECLINED Agenda collections, based on #+COLLECTION lines.
[[http://thread.gmane.org/gmane.emacs.orgmode/139][Tim Callaghan]] started the discussion on this one.
Declined because this would depend on local variables and the
agenda commands are global. Also, this can actually be done by
specifying the file list in a custom agenda command.
*** DECLINED Make CamelCase words link to corresponding org-mode files.
Files in the same directory. Or some other way to easy do that.
Would be useful for publishing projects. This would be an
incompatible change, but I don't think anyone is using CamelCase
anyway?
This is marked declined, because link abbreviations now provide an
easy way to make links to other files.
*** TODO Document the character protection in links
I don't think this is really covered anywhere.
Maybe we also should protect characters in the visible part, to
make sure thing will never be on two lines...?
*** WISH Radio targets across files
I guess each org file could write a .orgtargets.filename file, if
it has any radio targets.
** DECLINED Fast update for external editing
Could I use a dynamic block for this?
** Tables
*** WISH Row formulas
@4=.....
*** TODO Write a tutorial
Demonstrate running averages.
*** WISH Make a variable that current line should be recomputed always
in each table, skipping headers of course.
*** TODO Allow a table to locally change the unit system
This is for using constants.el.
Well, it is now possible to do this for the file, is this enough???
*** QUESTION Does inserting hlines change references correctly?
*** WISH Interactive way to get a converted table?
*** BUG When computing in a narrowed column, this may go wrong.
Computing changes fields and does not yet see correctly if the column
width has changed, in the case of a narrowed column.
*** DECLINED Alternative for the implementation of orgtbl-minor-mode:
I could use post-command-hook to set the variable orgtbl-mode.
I will not do this now and only consider it if problems show up.
*** DECLINED Table info lines are not necessarily comments in orgtbl-mode
Should I generalize this? No, because the table itself will not be
in the correct syntax for whatever mode.
*** DECLINED S-cursor motion to select part of a table, with proper highlighting.
Similar to CUA
** Properties and Column View
*** TODO Mouse support for selecting values
This could/should be part of org-mouse.el.
- [ ] tags
- [ ] todo
- [ ] priority
- [ ] allowed values
- [ ] deadline
- [ ] scheduled.
*** BUG We have no clear view on what to do with properties upon export.
** Compatibility issues
*** Emacs 21 compatibility
This is being phased out. Almost everything works under Emacs 21,
but in the future I will make little effort to support it.
**** DECLINED Column view does not yet work for Emacs 21s.
Declined, because I don't know how to do this. Too many
problems.
*** XEmacs compatibility
**** QUESTION Is there an issue with the coding system of HTML exported files?
In the code I used to have a comment saying that
: (and (fboundp 'coding-system-get)
: (boundp 'buffer-file-coding-system)
: buffer-file-coding-system))
always returns nil, implicating that setting the coding system for
the export buffer would not work correctly. however, I have never
followed up on this and never had a bug report - so I am wondering
if there is an issue at all.
**** DECLINED Column view does not yet work for XEmacs.
Declined, because I don't know how to do this. Too many
problems.
**** DECLINED Rewrite the `format' function
To make narrowing work under XEmacs, I would need to write a
version of /format/ that does transport text properties, or I
would have to rework narrowing entirely. Unlikely that this will
happen, mainly because it is working in Emacs and so does not
bother me personally so much. Anyway, I don't know if people are
actually using narrowing very much at all.
** Exporting
*** IDEA Convert links to footnotes for ASCII export.
*** DECLINED Store LaTeX code as HTML comments
Declined because I don't really see the need for this.
*** IDEA Microformats
Nic Ferrier has been pushing this agenda for a long time, for
example with [[http://thread.gmane.org/gmane.emacs.orgmode/140/][this email]]. I am not deep enough into the semantic
web that I could do this myself. Maybe we can do this by
modifying the html exporter step-by-step?
*** INCONSISTENCY Find a better place for formatting checkboxes
Right now this is being done as part of `org-html-expand', which
does not seem logically correct.
*** DECLINED Can I make the exporter more efficient?
The line-by-line processing may not be the fastest way to do
this. It certainly uses more resources. Right now the exporters
do work though, so it is unlikely that I am going to change this.
*** DECLINED CSV import/export of tables?
I remember this coming up several times, for example in emails
from [[http://thread.gmane.org/gmane.emacs.orgmode/156][Niels Giesen]] and [[http://thread.gmane.org/gmane.emacs.orgmode/139][Tim Callaghan]]. Org-mode does have
Tab-separated export of tables, so right now I don't really see
the benefit of adding CSV export. Are there applications that do
not understand tab-separated files, but do understand
comma-separated ones?
*** DECLINED In HTML export, make links from the time stamps
Time stamps have their own class now which allows to highlight
them etc. But I was wondering if something more useful could be
done with them, like a link to some kind of calendar...
** Miscellaneous Stuff
*** TODO reinstating a repeated item: keyword for logging.
*** BUG Comments cannot be filled
*** IDEA New uses for C-c C-c
- Compute time interval on time range
- Update CLOCK interval
*** QUESTION Fix more beginning-of-line commands
Org-mode re-binds C-a to make this command go to the beginning of
a visible line. There are other keys which might invoke C-a.
Should these keys be changed as well? one could use
`substitute-key-definition' on the global map to find them all.
*** QUESTION Inlining of images in Org-mode files
*** TODO Fixup outline-magic.el, so that it can be used.
*** TODO Use the new argument of bibtex-url
Roland Winkler was kind enough to implement a new argument to the
`bibtex-url' command that allows me to retrieve the corresponding
URL, whether it is taken from a URL field or constructed in some
clever way. Currently I am not using this, because too many
people use an old Emacs version which does not have this.
however, eventually I will implement this.
*** WISH Get people to write articles about how to do GTD with Org-mode.
There is now one by Charles Cave, read it [[http://members.optusnet.com.au/~charles57/GTD/orgmode.html][here]]
*** IDEA Tree statistics
A key that can be applied to a tree, showing statistics:
- how many headlines
- how many TODO
- how many DONE
- Checkboxes
- etc....
*** QUESTION Do we need a 43 folders implementation?
That could easily be done in an org-mode file. But then, maybe
this should really be a paper thing.
*** Priorities
Here is some information about priorities, which is not yet
documented.
**** QUOTE Priorities
TODO entries: 1 or 1,2,...
DEADLINE is 10-ddays, i.e. it is 10 on the due day
i.e. it goes above top todo stuff 7 days
before due
SCHEDULED is 5-ddays, i.e. it is 5 on the due date
i.e. it goes above top todo on the due day
TIMESTAMP is 0 i.e. always at bottom
but as a deadline it is 100
but if scheduled it is 99
TIMERANGE is 0 i.e. always at bottom
DIARY is 0 i.e. always at bottom
Priority * 1000
*** INCONSISTENCY: items don't grow/shrink due to promotion.
In plain lists, multiple demote/promote commands executed directly
after each other don't change the scope of the command - the
initially selected text continues to be selected. This is
inconsistent with the behavior of outline sections, were the subtree
for promotion/demotion is newly defined after each command. Which
convention is better? Should this be consistent between trees and
plain lists?
*** INCONSISTENCY: M-TAB does not work on plain lists. Why???
*** QUESTION grep on directory does not yet work.
I am actually not sure, I might have addressed this already, but
my memory is failing me. Needs some checking.
*** DECLINED HAVE a TIME 3:55 line collecting CLOCK results
The CLOCK lines could be there in addition, or could even be
removed, so that only one line is kept.
*** DECLINED Think about Piotr's idea of treating TODO like a TAG.
The answer is probably NO because the simple part of TODO must
still be there and I like the keyword at the beginning of the line,
just like a checkbox. Of course you can make a TODO tag yourself
at any time.
*** DECLINED Inlining of external files
*** DECLINED Should TAB on TODO keyword rotate its state?
Problem: If the keyword disappears, it will suddenly start to fold....
So my feeling right now is that the answer should be NO.
No, because S-left/right does this already pretty well
*** DECLINED Create a DONE counter in the mode line
That counter shows what faction of entries has been marked DONE. I
am not yet sure how useful such a thing would be, because of the
huge number of entries that can be in a file, and the different
weight of such entries.
Declined because we do now have counters for checkboxes, and the
feeling is that this is not so useful for TODOs.
* Archive
** Archived Tasks
*** DONE(<2006-06-01 Thu 09:15>) Commands to move through an item list
next item, previous item. What should happen at the boundaries of
the current list?
*** DONE(<2006-06-01 Thu 09:16>) Force relative links, would this be useful?
*** DONE(<2006-06-01 Thu 09:16>) Fix empty search string.
*** DONE(<2006-06-01 Thu 09:16>) STARTUP options for logging
*** DONE(<2006-06-01 Thu 09:16>) Make a variable for Pete, to have SCHEDULED at point
*** DONE(<2006-06-01 Thu 09:16>) Fix ASCII export of narrowed columns
*** DONE(<2006-06-01 Thu 09:16>) org-file-apps should allow regular expressions
*** DONE(<2006-06-01 Thu 09:16>) fix problem with w32- versus mswindows-....
*** DONE(<2006-06-01 Thu 09:17>) Document that font-lock-mode is needed
*** DONE(<2006-06-01 Thu 09:17>) Add keyboard access and menu commands for org-project.el
C-c C-x C-p or something like that.
In the menu, it goes under export, or even its own group.
*** DONE(<2006-06-01 Thu 09:17>) Document those new keys in orgcard.tex
C-c C-x C-p or something like that.
In the menu, it goes under export, or even its own group.
*** DONE(<2006-06-01 Thu 09:17>) Remove SCHEDULED keyword when marking it done.
in particular when adding a CLOSED timestamp.
Only problem is that when unclosing it, it should be scheduled
again
*** DONE(<2006-06-01 Thu 09:17>) Don't show tasks already scheduled for the future, only stuff which
is not yet scheduled.
*** DONE(<2006-06-01 Thu 09:17>) Put title and tags in separate classes
*** DONE(<2006-06-01 Thu 09:17>) Option to leave out TAGS from export
*** DONE(<2006-06-01 Thu 09:17>) Option to leave out Timestamps from export
*** DONE(<2006-06-01 Thu 09:17>) Checkable items like Frank Ruell's proposal
*** DONE(<2006-06-01 Thu 09:17>) Classify Keywords and time stamps
<span class="keyword">SCHEDULED: </span><span
class="timestamp">timestamp goes here</span><br>
*** DONE(<2006-06-01 Thu 09:17>) Change default for include-all-todo to nil
*** DONE(<2006-06-01 Thu 09:17>) Specify TAGS in a special line instead of collecting them dynamically
The could help to avoid typos and could be faster for very large files.
*** DONE(<2006-06-01 Thu 09:17>) Some much faster interface for setting tags.
Basically, use single keys to add/remove tags from the list. Also
for this the idea to define tags in a special line would be good,
in order to have a way to define the shortcuts.
*** DONE(<2006-06-01 Thu 09:17>) Remove date stamps from headline if they are not needed.
Bug report from Scott.
*** DONE(<2006-06-01 Thu 09:17>) : Maybe s-up/down should change priorities only in headlines
Right now this works wherever the cursor is. If this is changed,
should S-up or S-down do something else?
*** DONE(<2006-06-01 Thu 09:21>) Need a command to remove tabulators from a line.
Use this in ASCII export, to make sure we get the indentation
right.
*** DONE(<2006-06-01 Thu 09:24>) Improve tab in org-cycle:
- there is a bug when the setting is 'white: It requires a
non-empty white line!
- There should be another setting to have tab be the tabulator in
the white space at the beginning of the line.
- Finally, when TAB closes an entry, maybe it should go beck to the
beginning of the entry??? On the other hand, it is good to be
able to go back to the old place with just another tab.
*** DONE(<2006-06-01 Thu 11:48>) Include TAGS into sorting.
But what strategy should be used when there are several tags?
*** DONE(<2006-06-06 Tue 10:15>) Archiving an entry in current buffer goes to end of file
Should go to end of subtree.
This is done now, and I also control the amount of empty lines
created by the archiving process in general.
*** DONE(<2006-06-06 Tue 10:16>) Narrowing agenda to current files does not work as advertized.
C-c a 1 t should make the TODO list for the current file, but does
not.
*** DONE(<2006-06-06 Tue 10:17>) Radio TAGS for the fast tag interface.
Make lists of tags that are mutually exclusive. So when I turn on
@HOME, @WORK would be turned off automagically. A good syntax for
defining these groups in the #+TAGS line would be:
: #+TAGS: [@WORK(w) @HOME(h) @CLUB(c)] Laptop(l) PC(p) Car(r)
This could indicate that @WORK, @HOME, @CLUB are mutually exclusive.
If I do this, I will also need a syntax for the global alist to
indicate the same thing.
It seems to me that with such grouping of tags, sorting would be
useful as it would improve the overview over the current tags. I
might even be able to support mutually exclusive tags with
fontification in the interface. Or arrange things such that the
mutually exclusive ones are all in the same row or column, to
optimize the visual feedback.
For the internal format, I think best would be something like
: '( (:startgroup) ("@work") ("@home") ("@club") (:endgroup)
: ("Laptop") ("PC") ("Car"))
This setup makes sure that assoc and rassoc still do work as
expected.
*** DONE(<2006-06-06 Tue 10:17>) Should tags be sorted in a certain way?
Right now, you can either set the tag sequence yourself through
the completion interface. If you use the fast tag selection
interface, the tag sequence depends on the order in which tags are
selected and deselected. maybe a specific roder would be useful
for example the same order as the one given in the configuration?
*** DONE(<2006-06-06 Tue 10:17>) Remove narrowing cookies for export
Exported tables should not show narrowing cookies. In fact, if a
table line does contain nothing but narrowing cookies, the entire
line should be removed.
*** DONE(<2006-06-11 Sun 07:32>) Track working times similar to time-clock.el
This was proposed by David O'Toole in an
[[http://thread.gmane.org/gmane.emacs.orgmode/387][email to emacs-orgmode@gnu.org]]. He wants to be able to know the
times when he worked at a particular project. Some reporting
possibility would be needed to make this useful. Maybe sparse
trees with broken-down working times?
*** DONE(<2006-06-15 Thu 13:35>) Make org-store-link do better in image-mode buffers
Just link to the file.
*** DONE(<2006-06-15 Thu 13:35>) Use a ported version of noutline.el
Programming the old outline-mode is really a nightmare - the new
outline mode that uses invisibility properties instead of
selective display works really much much better. There is now
an [[http://thread.gmane.org/gmane.emacs.orgmode/214/focus=218][experimental port]] by Greg Chernov, so when I find time I will
try if this works well. If yes, this port should become part of
XEmacs. Once that happens, I could remove a large amount of
ballast from org.el
*** DONE(<2006-06-15 Thu 13:35>) Verify links during export
*** DONE(<2006-09-25 Mon 16:11>) Allow counting checkboxes
Then some statistics should be displayed. One idea is for
checkboxes, to use a special box [%] which will be updated with
percent of done. I could have an alternative [/] that will be
updated with something like [19/25] to show progress, and when the
two numbers are equal, I could highlight then in DONE face, just
like [100%]. All smaller numbers could be highlighted even in
TODO face if I wanted. Hmmm, I am beginning to like this.
Then: how to update this? Each time a checkbox is added or
toggled, go up and update all the counts, right up to something
which is not an item, or up to the previous header line.
Maybe I should also make an option for turning this on, to avoid
slowdown. I guess for long lists this could be slow.
Also would need a command for global update.
An maybe plain list and checkboxes should get their own chapter?
In Structure they seem to be a bit hidden.....
Also a menu sublist...
*** DONE(<2006-09-25 Mon 16:11>) Allow stacking calls to org-occur
This was a proposal from Piotr. It is now possible, the second
and subsequent calls to org-occur need a prefix argument to keep
the previous highlights.
*** DONE(<2006-09-25 Mon 16:12>) Create a hook to be run after an agenda buffer has been finalized.
*** DONE(<2006-09-25 Mon 16:12>) Include TAGS into sorting.
But what strategy should be used when there are several tags?
*** DONE(<2006-09-25 Mon 16:12>) Fixup tag display in agenda buffer.
The tabs mess up everything. Either remove the tabs, or realign
the tags to some useful column.
*** DONE(<2006-09-25 Mon 16:12>) Blocks in agenda:
Make a single agenda buffer that contains several sets of items,
like the TODO list, a tags list, and a day view. Not a bad idea.
This was [[http://thread.gmane.org/gmane.emacs.orgmode/167/focus=168][Piotr's idea]].
*** DONE(<2006-09-25 Mon 16:12>) Make org-store-link do the right thing in dired-mode
*** DONE([2006-11-02 Thu 10:24]) Control over windows being used for agenda and related buffers :NEW:
*** DONE([2007-01-24 Wed 12:59]) Extend access to table fields
Find a general way to get any rectangular region into a calc
vector
*** DONE([2007-01-24 Wed 12:59]) Allow links to remote images to be inlined.
*** DONE([2007-01-24 Wed 12:59]) M-TAB on an already complete tag should add the ":"
*** DONE([2007-01-24 Wed 13:07]) Need a command to do show hierarchy after isearch.
Maybe automatically, using isearch-mode-end-hook. But this does
not seem to work, because to is called before the overlays are
re-installed. I can create a new hook, isearch-exit-hook, run in
`isearch-exit'.
*** DONE([2007-02-18 Sun 07:16]) hook for users to do their own agenda lists
New function dumping headline into the agenda buffer, based on regexp
and callback, to allow general stuff. For the special tags, we can
search for one and check for the others using the callback.
*** DONE([2007-02-18 Sun 07:37]) Make C-c C-l also work on a plain link, converting it into bracket.
*** DONE([2007-02-18 Sun 07:37]) GNUS gnus:mail.general#123 stuff should be "Email from:..."
*** DONE([2007-02-18 Sun 07:38]) Email/message context: What format?
I can think of two good formats for this:
: Email from John Smith (if I an the receiver)
: Email to John Smith (if I am the author)
or
: John Smith on: Some subject (this is the current Org-mode default.)
The first format requires better parsing of the messages (to get
both author and receiver names), and also
some way to detect if I am the author of this email or not.
*** DONE([2007-02-21 Wed 12:04]) Allow internal links to match inside *other* link
Only the link itself that actually triggered the search.
*** DONE([2007-02-21 Wed 12:07]) Allow fully protected HTML code that will be exported as is
Currently, @<...> works only for simple tags, and I think we
should have something better. Idea: Text between <protecthtml>
and </protecthtml>, mark it with a text property and then exclude
each match in the run preparing the export.
I guess I could require these at the beginning of the line, like
#+PROTECT
#+ENDPROECT
or something like that.......
*** DONE([2007-03-13 Tue 05:19]) Make it possible to set TOC levels independently of headline levels
The easiest way to do this would obviously be to allow a number
setting for the tco switch, not only a simple t/nil switch. This
can be nice for webpages: One could have only top-level or level
1 and 2 in the toc at the beginning of the page, and then still a
more complex structure below.
*** DONE([2007-03-13 Tue 05:20]) Filling is not done in a compatible way.
The current setup used the Emacs variables and machine to get the
filling of plain lists and everything lese right. XEmacs uses the
filladapt package, which has different ways to do the same
things. org.el should be smart about this and setup filling under
XEmacs correctly.
*** DONE([2007-06-06 Wed 17:44]) Repeating Schedules?
[[http://thread.gmane.org/gmane.emacs.orgmode/149][Dieter Grollman]] requested this feature, but for now I have decided
not to do anything about it. I don't see a good way to implement
this, and I believe that cyclic diary entries are good enough for
such tasks.
*** DONE([2007-06-14 Thu 13:16]) improve item indentation when promoting and demoting
*** DONE([2007-06-14 Thu 13:17]) The TODO buffer lists possible TODO keywords
These are taken from the current buffer, so when multiple buffers
are involved, this list may not be correct.....
*** DONE([2007-06-14 Thu 13:20]) Conflict between bold emphasis and headlines
At the beginning of a line, Org-mode does not know if *bold* is a
headline or an emphasis. This will not be easy to fix. The way
to do ii is to require a space after the star in headlines. This
requires to change outline-regexp, outline-level, the many many
times when outline regexp is used in the program, and also the
countless times when I am simply matching th stars directly.
*** DONE C-c - for cycling bullet types.
ARCHIVED: <2007-07-02 Mon>
*** DONE improve what TAB does with new item
ARCHIVED: <2007-07-02 Mon>
same or additional indentation????
*** DONE Make it easier to do monthly agendas, and agendas for ranges
ARCHIVED: <2007-07-02 Mon>
*** DONE Introduce a LOCATION keyword
ARCHIVED: <2007-07-02 Mon>
similar to DEADLINE and SCHEDULED
Idea from Bastien
This could be done now using properties, I don't think we need a
special thing for this anymore.
*** DONE Times/date not always removed in agenda lines
ARCHIVED: <2007-07-02 Mon>
Even when org-agenda-remove-times-when-in-prefix is set, there
seem to be cases where this does not work. I forgot what the
example was - does anyone remember?
*** DONE Links are still highlighted in fixed-width environments.
ARCHIVED: <2007-07-02 Mon>
This ties in with the problem that there is no way to have
protected HTML code in the file.
* COMMENT HTML style specifications
# Local Variables:
# org-export-html-style: "<link rel=stylesheet href=\"freeshell2.css\" type=\"text/css\"> <style type=\"text/css\"> .tag { color: red; font-weight:bold}</style>"
# End:

340
ORGWEBPAGE/tutorials.html Normal file
View File

@ -0,0 +1,340 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
lang="en" xml:lang="en">
<head>
<title>Org-Mode Tutorials, Blogposts, and Screenscasts</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"/>
<meta name="generator" content="Org-mode"/>
<meta name="generated" content="2008/01/20 09:11:36"/>
<meta name="author" content="Carsten Dominik"/>
<style type="text/css">
html {
font-family: Times, serif;
font-size: 12pt;
}
.title { text-align: center; }
.todo { color: red; }
.done { color: green; }
.timestamp { color: grey }
.timestamp-kwd { color: CadetBlue }
.tag { background-color:lightblue; font-weight:normal }
.target { background-color: lavender; }
pre {
border: 1pt solid #AEBDCC;
background-color: #F3F5F7;
padding: 5pt;
font-family: courier, monospace;
}
table { border-collapse: collapse; }
td, th {
vertical-align: top;
<!--border: 1pt solid #ADB9CC;-->
}
</style>
</head><body>
<h1 class="title">Org-Mode Tutorials, Blogposts, and Screenscasts</h1>
<p>
This page lists tutorials, screencasts, and extensive blog posts about
<a href="http://orgmode.org">Org-mode</a>
</p>
<BASE href="http://orgmode.org/tutorials.html">
<div id="table-of-contents">
<h2>Table of Contents</h2>
<ul>
<li><a href="#sec-1">General Introductions to Org-mode</a></li>
<li><a href="#sec-2">Special features</a>
<ul>
<li><a href="#sec-3">Sparse Trees</a></li>
<li><a href="#sec-4">Tables</a></li>
<li><a href="#sec-5">The Spreadsheet: Org-mode and Calc</a></li>
<li><a href="#sec-6">Hyperlinks</a></li>
<li><a href="#sec-7">Using TODO states</a></li>
<li><a href="#sec-8">Using TAGS&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-9">Complex searches for Tags, TODO keywords and Properties</a></li>
<li><a href="#sec-10">Timestamps, Appointments etc</a></li>
<li><a href="#sec-11">The Clock Table&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-12">Using Remember Templates&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
<li><a href="#sec-13">Properties and Column View</a></li>
<li><a href="#sec-14">Custom Agenda Commands</a></li>
<li><a href="#sec-15">Embedded LaTeX</a></li>
<li><a href="#sec-16">HTML export</a></li>
<li><a href="#sec-17">LaTeX export</a></li>
<li><a href="#sec-18">Publishing</a></li>
<li><a href="#sec-19">Using orgtbl-mode in LaTeX</a></li>
</ul>
</li>
<li><a href="#sec-20">Special tasks</a>
<ul>
<li><a href="#sec-21">Natural Project Planning&nbsp;&nbsp;&nbsp;<span class="tag"> NEW</span></a></li>
</ul>
</li>
<li><a href="#sec-22">Personal Setup</a>
<ul>
<li><a href="#sec-23">Extensive documents</a></li>
<li><a href="#sec-24">Short descriptions</a></li>
</ul>
</li>
<li><a href="#sec-25">Org-related pages by Tutorial authors</a></li>
</ul>
</div>
<div class="outline-2">
<h2 id="sec-1">General Introductions to Org-mode</h2>
<ul>
<li>
<a href="http://dto.freeshell.org/notebook/OrgTutorial.html">The OrgMode tutorial</a> by <a href="http://dto.freeshell.org/notebook/">David O'Toole</a>, covering the basics of TODO
lists and the agenda. It has been translated into <a href="http://www.cognition.ens.fr/~guerry/orgtutorialfr.html">French</a>,
<a href="http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fOrgTutorial">Japanese</a>, <a href="http://hokmen.chan.googlepages.com/OrgTutorial.en-cn.html">Chinese</a>, and <a href="http://jmjeong.com/index.php?display=Emacs/OrgMode">Korean</a>.
</li>
<li>
<a href="http://jaderholm.com/screencasts.html">A 25 minute screencast</a> by <a href="http://jaderholm.com">Scott Jaderholm</a>, demonstrating the basic
features of Org-mode.
</li>
<li>
<a href="http://sachachua.com/wp/2008/01/18/outlining-your-notes-with-org/">Outlining Your Notes with Org</a> by <a href="http://sachachua.com/wp/">Sacha Chua</a> covers outlining,
searching and internal links.
</li>
<li>
<a href="http://www.linuxjournal.com/article/9116">Getting Organized with Emacs Org-mode</a> by <a href="http://www.geocities.com/abhijeet_chawan/">Abhijeet Chavan</a>, and
article originally published in the <a href="http://www.linuxjournal.com/">Linux Journal</a>.
</li>
</ul></div>
<div class="outline-2">
<h2 id="sec-2">Special features</h2>
<div class="outline-3">
<h3 id="sec-3">Sparse Trees</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-4">Tables</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-5">The Spreadsheet: Org-mode and Calc</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-6">Hyperlinks</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-7">Using TODO states</h3>
<p><i>Your chance for everlasting fame on the Org-mode homepage</i>
</p></div>
<div class="outline-3">
<h3 id="sec-8">Using TAGS &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2008/01/04/tagging-in-org-plus-bonus-code-for-timeclocks-and-tags/">Tagging in Org</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-9">Complex searches for Tags, TODO keywords and Properties</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-10">Timestamps, Appointments etc</h3>
<ul>
<li>
<a href="http://members.optusnet.com.au/~charles57/GTD/org_dates/">Using Dates and Times in Emacs Org-mode</a> by Charles Cave.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-11">The Clock Table &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2007/12/30/clocking-time-with-emacs-org/">Clocking time with Emacs Org</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-12">Using Remember Templates &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2007/10/05/remembering-to-org-and-planner/">Remembering to Org and Planner</a>.
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-13">Properties and Column View</h3>
<ul>
<li>
<a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a> has a <a href="http://www.cognition.ens.fr/~guerry/org-column-view-tutorial.html">tutorial about column view</a> and
demonstrates column view live in this <a href="http://www.cognition.ens.fr/~guerry/org-column-screencast.html">screencast</a>.
</li>
<li>
Christian Egli has created a <a href="http://thread.gmane.org/gmane.emacs.orgmode/5107/focus%3D5134">mini-tutorial for using column view</a>
and posted it to <a href="http://news.gmane.org/gmane.emacs.orgmode">emacs-orgmode@gnu.org</a>
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-14">Custom Agenda Commands</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-15">Embedded LaTeX</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-16">HTML export</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-17">LaTeX export</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-18">Publishing</h3>
<p><i>Your chance for everlasting fame</i>
</p></div>
<div class="outline-3">
<h3 id="sec-19">Using orgtbl-mode in LaTeX</h3>
<p><i>Your chance for everlasting fame</i>
</p>
</div>
</div>
<div class="outline-2">
<h2 id="sec-20">Special tasks</h2>
<div class="outline-3">
<h3 id="sec-21">Natural Project Planning &nbsp;&nbsp;&nbsp;<span class="tag">NEW</span></h3>
<ul>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a> about using Org-mode to implement <a href="http://members.optusnet.com.au/~charles57/GTD/Natural_Project_Planning.html">Natural Project Planning</a> according to David Allen.
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-22">Personal Setup</h2>
<div class="outline-3">
<h3 id="sec-23">Extensive documents</h3>
<ul>
<li>
<a href="http://johnwiegley.com">John Wiegley</a> about <a href="http://johnwiegley.com/org.mode.day.planner.html">using Org-mode as a day planner</a>.
</li>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a> about <a href="http://members.optusnet.com.au/~charles57/GTD/orgmode.html">GTD and Org-mode</a>.
</li>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a> about <a href="http://sachachua.com/wp/2007/12/22/a-day-in-a-life-with-org/">a day in a life with Org</a> and about the basics of
<a href="http://sachachua.com/wp/2007/12/28/emacs-getting-things-done-with-org-basic/">Getting Things Done with Org</a>
</li>
<li>
<i>Your chance for everlasting fame</i>
</li>
</ul></div>
<div class="outline-3">
<h3 id="sec-24">Short descriptions</h3>
<ul>
<li>
David O'Toole explains his setup in <a href="http://thread.gmane.org/gmane.emacs.orgmode/4832">this post</a>.
</li>
<li>
This <a href="http://www.brool.com/?p=82">blog post</a> shows a very simple and clear GTD setup.
</li>
<li>
<i>Your chance for everlasting fame</i>
</li>
</ul></div>
</div>
<div class="outline-2">
<h2 id="sec-25">Org-related pages by Tutorial authors</h2>
<p>
Here are the pages of a number of people that write for or about
Org-mode
</p>
<ul>
<li>
<a href="http://johnwiegley.com">John Wiegley</a>
</li>
<li>
<a href="http://members.optusnet.com.au/charles57/Creative/">Charles Cave</a>
</li>
<li>
<a href="http://sachachua.com/wp/">Sacha Chua</a>
</li>
<li>
<a href="http://www.cognition.ens.fr/~guerry/">Bastien Guerry</a>
</li>
</ul>
</div>
<div id="postamble"><p class="author"> Author: Carsten Dominik
<a href="mailto:carsten at orgmode dot org">&lt;carsten at orgmode dot org&gt;</a>
</p>
<p class="date"> Date: 2008/01/20 09:11:36</p>
</div></body>
</html>

105
ORGWEBPAGE/tutorials.org Normal file
View File

@ -0,0 +1,105 @@
#+TITLE: Org-Mode Tutorials, Blogposts, and Screenscasts
#+LANGUAGE: en
#+EMAIL: carsten at orgmode dot org
#+OPTIONS: H:3 num:nil toc:t \n:nil @:t ::t |:t ^:t *:t TeX:t tags:t skip:nil
This page lists tutorials, screencasts, and extensive blog posts about
[[http://orgmode.org][Org-mode]]
#+HTML: <BASE href="http://orgmode.org/tutorials.html">
* General Introductions to Org-mode
- [[http://dto.freeshell.org/notebook/OrgTutorial.html][The OrgMode tutorial]] by [[http://dto.freeshell.org/notebook/][David O'Toole]], covering the basics of TODO
lists and the agenda. It has been translated into [[http://www.cognition.ens.fr/~guerry/orgtutorialfr.html][French]],
[[http://hpcgi1.nifty.com/spen/index.cgi?OrgMode%2fOrgTutorial][Japanese]], [[http://hokmen.chan.googlepages.com/OrgTutorial.en-cn.html][Chinese]], and [[http://jmjeong.com/index.php?display=Emacs/OrgMode][Korean]].
- [[http://jaderholm.com/screencasts.html][A 25 minute screencast]] by [[http://jaderholm.com][Scott Jaderholm]], demonstrating the basic
features of Org-mode.
- [[http://sachachua.com/wp/2008/01/18/outlining-your-notes-with-org/][Outlining Your Notes with Org]] by [[http://sachachua.com/wp/][Sacha Chua]] covers outlining,
searching and internal links.
- [[http://www.linuxjournal.com/article/9116][Getting Organized with Emacs Org-mode]] by [[http://www.geocities.com/abhijeet_chawan/][Abhijeet Chavan]], and
article originally published in the [[http://www.linuxjournal.com/][Linux Journal]].
* Special features
** Sparse Trees
/Your chance for everlasting fame/
** Tables
/Your chance for everlasting fame/
** The Spreadsheet: Org-mode and Calc
/Your chance for everlasting fame/
** Hyperlinks
/Your chance for everlasting fame/
** Using TODO states
/Your chance for everlasting fame on the Org-mode homepage/
** Using TAGS :NEW:
- [[http://sachachua.com/wp/2008/01/04/tagging-in-org-plus-bonus-code-for-timeclocks-and-tags/][Tagging in Org]] by [[http://sachachua.com/wp/][Sacha Chua]].
** Complex searches for Tags, TODO keywords and Properties
/Your chance for everlasting fame/
** Timestamps, Appointments etc
- [[http://members.optusnet.com.au/~charles57/GTD/org_dates/][Using Dates and Times in Emacs Org-mode]] by [[http://members.optusnet.com.au/charles57/Creative/][Charles Cave]].
** The Clock Table :NEW:
- [[http://sachachua.com/wp/2007/12/30/clocking-time-with-emacs-org/][Clocking time with Emacs Org]] by [[http://sachachua.com/wp/][Sacha Chua]] .
** Using Remember Templates :NEW:
- [[http://sachachua.com/wp/2007/10/05/remembering-to-org-and-planner/][Remembering to Org and Planner]] by [[http://sachachua.com/wp/][Sacha Chua]].
** Properties and Column View
- [[http://www.cognition.ens.fr/~guerry/org-column-view-tutorial.html][Emacs Org's Column View]] by [[http://www.cognition.ens.fr/~guerry/][Bastien Guerry]], with an accompanying
[[http://www.cognition.ens.fr/~guerry/org-column-screencast.html][screencast]].
- [[http://thread.gmane.org/gmane.emacs.orgmode/5107/focus%3D5134][What's the use of Column View?]] by Christian Egli is ashort
tutorial about Column View that was sent to [[http://news.gmane.org/gmane.emacs.orgmode][emacs-orgmode@gnu.org]].
** Custom Agenda Commands
/Your chance for everlasting fame/
** Embedded LaTeX
/Your chance for everlasting fame/
** HTML export
/Your chance for everlasting fame/
** LaTeX export
/Your chance for everlasting fame/
** Publishing
/Your chance for everlasting fame/
** Using orgtbl-mode in LaTeX
/Your chance for everlasting fame/
* Special tasks
** Natural Project Planning :NEW:
- [[http://members.optusnet.com.au/charles57/Creative/][Charles Cave]] about using Org-mode to implement [[http://members.optusnet.com.au/~charles57/GTD/Natural_Project_Planning.html][Natural Project
Planning]] according to David Allen.
* Personal Setup
** Extensive documents
- [[http://johnwiegley.com/org.mode.day.planner.html][Using Org-mode as a day planner]] by [[http://johnwiegley.com][John Wiegley]].
- [[http://members.optusnet.com.au/~charles57/GTD/orgmode.html][Using Emacs org-mode for GTD]] by [[http://members.optusnet.com.au/charles57/Creative/][Charles Cave]].
- [[http://sachachua.com/wp/][Sacha Chua]] about [[http://sachachua.com/wp/2007/12/22/a-day-in-a-life-with-org/][A day in a life with Org]] and about the basics of
[[http://sachachua.com/wp/2007/12/28/emacs-getting-things-done-with-org-basic/][Getting Things Done with Org]]
- /Your chance for everlasting fame/
** Short descriptions
- David O'Toole explains his setup in [[http://thread.gmane.org/gmane.emacs.orgmode/4832][this post]].
- This [[http://www.brool.com/?p=82][blog post]] shows a very simple and clear GTD setup.
- /Your chance for everlasting fame/
* Org-related pages by Tutorial authors
Here are the pages of a number of people that write for or about
Org-mode
- [[http://johnwiegley.com][John Wiegley]]
- [[http://members.optusnet.com.au/charles57/Creative/][Charles Cave]]
- [[http://sachachua.com/wp/][Sacha Chua]]
- [[http://www.cognition.ens.fr/~guerry/][Bastien Guerry]]

206
TODO Normal file
View File

@ -0,0 +1,206 @@
-*- mode:org -*-
Ideas for time estimates:
{22} 22 minutes
{2:} 2 hours
{2:30} 2 hours, 30 minutes
Maybe make a new keyword APPT for appointment, meaning that this is
something I need to attend, as opposed to something which is on that
day and not necessarily something where we need to be present. Not
sure about this.
Should we add this hierarchically? Should parents value be the summed
values of children? I guess not. No. Estimated times should be
atomic, belonging to the detailed entry. If people give estimated
times to parents, their fault.
| | | | | |
|---+---+---+---+---|
| | | | | |
make special completion for refile path, similar to file completion.
Make variables for case-fold-search, there is a request in the survey
">" does not work well in column view, when currently there is no
width defined.
Make cycling put text properties over current state.
Use thee when moving subtrees, to restore them all to the right
state.
C-RET, add empty line just like before the current entry.
Make sure the remember stuff insertion works correctly, find a way to
specify empty leading lines.
Last synch with FSF changes: <2008-01-03 Thu>
Fix special character replacement: not in protected regions, and
require them not to be part of a long chain of strings and dots.
Write CLOCK like this: CLOCK [2007-11-12 Mon 12:30-13:44]
This needs a lot of changing, of course. Clock table and lots more.
Make org-entry-put handle all special properties. Use interactive
interfaces only for interactive calls.
Split into files:
- org.el
- org-tables.el
entry points: align. Hmm, mybe we should just leave it like it is.
- org-agenda.el
- org-export.el
- org-cdlatex.el
Also, all the link types could be in separate files:
Still, org would automatically require these.
I guess it would make some sense to take these out.
- org-bbdb.el
- org-mh.el
etc etc
How to set tags in remember buffer?
integrate org-iswitchb.el
Free up C-c C-v, and use this for other stuff?
document org-agenda-start-day and maybe other dynamical scope variables.
Should I move the remember template stuff to remember.el itself?
Would be good, but is unlikely to happen.
Make org-set-property set the property for all entries in the region.
What other commands?
Map region with commands, general mechanism????
M-q in a line starting with a *bold* string fails. Fuck this wrapping
and paragraph code, it is a desaster
- Agenda view of tags search make the levels of the headline visible
through leading dots. The TODO view doesn't. Maybe the to views
should behave the same on this?
- Modifying the TODO state of an entry while in the agenda tags-todo
view will make the leading dots disappear.
Make ASCII export remove some of the emph markers. Maybe replace
verbatim with single quotes or so.
ASCII export: move links into footnotes
Implement cycling by having a text property on headlines, instead
of doing all this work to figure things out dynamically????????????
Write some command that does:
- gets all the external stuff from David an Bastien
- Changes the version number so that they are consistent
- Have a contrib directory?????
Implement Johns auto-archive.
Have C-c C-e 0 l and C-c C-e 0 h do the region (Bastien)
Remove time grid lines that have an apointment on that time.
Don't show "-----" if something is going on during that time,
this is an indication of being occupied.
Implement block viewing in the agenda, to show how long enties take on
a true time grid.
End date for a repeating thing?
Should we have thinks like <example> ... </example>
like muse does? This is much easier than what we have......
#+BEGIN_example
#+END_example
Completely remove cpltxt from store link and use desc instead.
Implement most internal links as add-ons. Either in external files,
or internally. Anyway, make sure most of them are active.
Bug with columns when there is an invisible link early in the
headline. See properties.org.
hooks in the properties stuff.
org-after-insert-property-drawer-hook.
Function to convert outline to plain and back (Scott Jaderholm)
MEW support??? (this is yet another emacs mailer)
Make org-fill-paragraph respect \\.
How can I update a calculating property without relying on the column
view format? That would require specifying the format in an
additional place, possibly in a data field? This is what I had
first. Maybe it was only partially a good idea????
The problem is that in order to have a column computing, we need to
have a view! So this is not good!
Options:
- use the format!
- have an extra property, like XYZ_OPERATOR.
Then do the operation in the sub tree of the entry that has the
operator property. Quite nice, this one, but may contradict
the format. It is not goot to have this multiple times. So maybe
strictly limit this to those that are in a format.
+ when updating, find the format and then apply to subtree.
+ When updating absolutely everything, find all the formats, get
all the operators, apply to the corresponding subtrees.
+ allow very general operations:
{to-number,to-string,add}
Or simply {add}
Take old value, new value, and add or do whatever is necessary.
This is another exploit.
Three functions.
- Allow the operator in a value after all
search-subtree command/function
Should the default for org-archive-mark-done be nil?
hook after agenda-show, but careful with all the other functions
that use that function. Maybe take the functionality tp a separate
function.
Make something search [-].
The fast interfaces
- org-goto, jumps to an entry in the current buffer
- org-refile, uses the completion interface to file something away
- org-refile with prefix arg allows to jump to a refile location
- remember can use refile, goto, and automatic location search
This is very much confuing:
refile standard can go to any refile location, in different files
we can also us the refile interface to find a headline in the
current buffer.
This needs to be made more consistent.
#+TYP_TODO: TODO BUG INCONSISTENCY IDEA WISH QUESTION DONE
#+OPTIONS: H:1 num:nil toc:t \n:nil @:t ::t |:t ^:t *:t TeX:t
#+EMAIL: carsten.dominik@gmail.com

72
UTILITIES/fake_change_log.pl Executable file
View File

@ -0,0 +1,72 @@
#!/usr/bin/perl
$file1 = shift;
$file2 = shift;
open file1,"<$file1" or die;
while (<file1>) {
if (m/^\s*\((defun|defsubst|defmacro|defcustom|defgroup|defface|defvar|defconst)\s+([-a-zA-Z0-9]+)/) {
if ($1 eq "defun") {
$fun1{$2}++;
} elsif ($1 eq "defsubst") {
$subst1{$2}++;
} elsif ($1 eq "defmacro") {
$macro1{$2}++;
} elsif ($1 eq "defgroup") {
$group1{$2}++;
} elsif ($1 eq "defcustom") {
$custom1{$2}++;
} elsif ($1 eq "defface") {
$face1{$2}++;
} elsif ($1 eq "defvar") {
$var1{$2}++;
} elsif ($1 eq "defconst") {
$const1{$2}++;
}
}
}
close file1;
open file2,"<$file2" or die;
while (<file2>) {
if (m/^\s*\((defun|defsubst|defmacro|defcustom|defgroup|defface|defvar|defconst)\s+([-a-zA-Z0-9]+)/) {
if ($1 eq "defun") {
$fun2{$2}++;
} elsif ($1 eq "defsubst") {
$subst2{$2}++;
} elsif ($1 eq "defmacro") {
$macro2{$2}++;
} elsif ($1 eq "defgroup") {
$group2{$2}++;
} elsif ($1 eq "defcustom") {
$custom2{$2}++;
} elsif ($1 eq "defface") {
$face2{$2}++;
} elsif ($1 eq "defvar") {
$var2{$2}++;
} elsif ($1 eq "defconst") {
$const2{$2}++;
}
}
}
close file2;
foreach $type ("fun","subst","macro","group","custom","face","var","const") {
$cmd1 = '%n1 = %' . $type . "1;";
$cmd2 = '%n2 = %' . $type . "2;";
eval $cmd1;
eval $cmd2;
print "$type added:\n";
foreach (keys %n2) {
unless (defined $n1{$_}) {
print " $_\n";
}
}
print "$type removed:\n";
foreach (keys %n1) {
unless (defined $n2{$_}) {
print " $_\n";
}
}
}

754
org.el
View File

File diff suppressed because it is too large Load Diff

47
org.texi
View File

@ -3,7 +3,7 @@
@setfilename ../../info/org
@settitle Org Mode Manual
@set VERSION 5.19
@set VERSION 5.20
@set DATE January 2008
@dircategory Emacs
@ -1252,7 +1252,7 @@ Org-mode comes with a fast and intuitive table editor. Spreadsheet-like
calculations are supported in connection with the Emacs @file{calc}
package
@ifinfo
(@pxref{Calc,,,calc,Gnu Emacs Calculator Manual}).
(@pxref{Top,Calc,,calc,Gnu Emacs Calculator Manual}).
@end ifinfo
@ifnotinfo
(see the Emacs Calculator manual for more information about the Emacs
@ -3409,7 +3409,7 @@ application of properties, imagine keeping track of one's music CD's,
where properties could be things such as the album artist, date of
release, number of tracks, and so on.
Properties can be conveiently edited and viewed in column view
Properties can be conveniently edited and viewed in column view
(@pxref{Column view}).
Properties are like tags, but with a value. For example, in a file
@ -3739,6 +3739,12 @@ the entire tree, starting from the entry that contains the @code{:COLUMNS:}
property. If none is found, the format is taken from the @code{#+COLUMNS}
line or from the variable @code{org-columns-default-format}, and column
view is established for the current entry and its subtree.
@kindex r
@item r
Recreate the column view, to included hanges happening in the buffer.
@kindex g
@item g
Same as @kbd{r}.
@kindex q
@item q
Exit column view.
@ -4270,8 +4276,8 @@ the scheduling date from the entry.
@subsection Repeated Tasks
Some tasks need to be repeated again and again. Org-mode helps to
organize such tasks using a so-called repeater in a DEADLINE or
SCHEDULED time stamp. In the following example
organize such tasks using a so-called repeater in a DEADLINE, SCHEDULED,
or plain time stamp. In the following example
@example
** TODO Pay the rent
DEADLINE: <2005-10-01 Sat +1m>
@ -4284,7 +4290,7 @@ Deadlines and scheduled items produce entries in the agenda when they
are over-due, so it is important to be able to mark such an entry as
completed once you have done so. When you mark a DEADLINE or a SCHEDULE
with the todo keyword DONE, it will no longer produce entries in the
agenda. The problem with this is, however, that then also the
agenda. The problem with this is, however, that then also the
@emph{next} instance of the repeated entry will not be active. Org-mode
deals with this in the following way: When you try to mark such an entry
DONE (using @kbd{C-c C-t}), it will shift the base date of the repeating
@ -4393,6 +4399,7 @@ new table. The @samp{BEGIN} line can specify options:
@r{@code{thismonth}, @code{lastmonth}, @code{thisyear}, or @code{lastyear}}.
:tstart @r{A time string specifying when to start considering times}
:tend @r{A time string specifying when to stop considering times}
:step @r{@code{week} or @code{day}, to split the table into chunks}
@end example
So to get a clock summary of the current level 1 tree, for the current
day, you could write
@ -4466,7 +4473,9 @@ suggestion.}. @code{org-remember} basically just calls @code{remember},
but it makes a few things easier: If there is an active region, it will
automatically copy the region into the remember buffer. It also allows
to jump to the buffer and location where remember notes are being
stored: Just call @code{org-remember} with a prefix argument.
stored: Just call @code{org-remember} with a prefix argument. If you
use two prefix arguments, Org-mode jumps to the location where the last
remember note was stored.
@node Remember templates, Storing notes, Setting up remember, Remember
@section Remember templates
@ -4633,13 +4642,16 @@ Refile the entry at point. This command offers possible locations for
refiling the entry and lets you select one with completion. The item is
filed below the target heading as a subitem. Depending on
@code{org-reverse-note-order}, it will be either the first of last
subitem, and you can toggle the value of this variable for the duration
of the command by using a @kbd{C-u} prefix.@* By default, all level 1
headlines in the current buffer are considered to be targets, but you
can have more complex definitions across a number of files. See the
variable @code{org-refile-targets} for details. The list of targets is
compiled upon first use, you can update it by using a double prefix
argument (@kbd{C-u C-u}) to this command.
subitem.@* By default, all level 1 headlines in the current buffer are
considered to be targets, but you can have more complex definitions
across a number of files. See the variable @code{org-refile-targets}
for details.
@kindex C-u C-c C-w
@item C-u C-c C-w
Use the refile interface to jump to a heading.
@kindex C-u C-u C-c C-w
@item C- C-u C-c C-w
Jump to the location where @code{org-refile} last moved a tree to.
@end table
@node Agenda views, Embedded LaTeX, Remember, Top
@ -5281,8 +5293,8 @@ month and year views are slow to create, the do not become the default.
@item D
Toggle the inclusion of diary entries. See @ref{Weekly/Daily agenda}.
@c
@kindex g
@item g
@kindex G
@item G
Toggle the time grid on and off. See also the variables
@code{org-agenda-use-time-grid} and @code{org-agenda-time-grid}.
@c
@ -5293,6 +5305,9 @@ after modification of the time stamps of items with S-@key{left} and
S-@key{right}. When the buffer is the global todo list, a prefix
argument is interpreted to create a selective list for a specific TODO
keyword.
@kindex g
@item g
Same as @kbd{r}.
@c
@kindex s
@kindex C-x C-s

6
orgcard.tex
View File

@ -1,5 +1,5 @@
% Reference Card for Org Mode
\def\orgversionnumber{5.19}
\def\orgversionnumber{5.20}
\def\versionyear{2008} % latest update
\def\year{2008} % latest copyright year
@ -635,9 +635,9 @@ after ``{\tt :}'', and dictionary words elsewhere.
\key{delete other windows}{o}
\key{switch to day/week/month/year view}{d w m y}
\key{toggle inclusion of diary entries}{D}
\key{toggle time grid for daily schedule}{g}
\key{toggle time grid for daily schedule}{G}
\key{toggle display of logbook entries}{l}
\key{refresh agenda buffer with any changes}{r}
\key{refresh agenda buffer with any changes}{r / g}
\key{save all org-mode buffers}{s}
\key{display the following \kbd{org-agenda-ndays}}{RIGHT}
\key{display the previous \kbd{org-agenda-ndays}}{LEFT}

457
orgcard.txt Normal file
View File

@ -0,0 +1,457 @@
================================================================================
Org-Mode Reference Card (for version 4.79)
================================================================================
================================================================================
Getting Started
================================================================================
(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
(define-key global-map "\C-cl" 'org-store-link) [1]
(define-key global-map "\C-ca" 'org-agenda) [1]
For the many customization options try M-x org-customize
To read the on-line documentation try M-x org-info
================================================================================
Visibility Cycling
================================================================================
rotate current subtree between states TAB
rotate entire buffer between states S-TAB
show the whole file C-c C-a
reveal context around point C-c C-r
show subtree in indirect buffer, ded. frame C-c C-k
================================================================================
Motion
================================================================================
next/previous heading C-c C-n/p
next/previous heading, same level C-c C-f/b
backward to higher level heading C-c C-u
jump to another place in document C-c C-j
previous/next plain list item S-UP/DOWN [3]
================================================================================
Structure Editing
================================================================================
insert new heading/item at current level M-RET
insert new TODO entry/checkbox item M-S-RET
promote current heading up one level M-LEFT
demote current heading down one level M-RIGHT
promote current subtree up one level M-S-LEFT
demote current subtree down one level M-S-RIGHT
move subtree/list item up/down M-S-UP/DOWN
kill subtree C-c C-x C-w
copy subtree C-c C-x M-w
yank subtree C-c C-x C-y
narrow buffer to current subtree C-x n s
================================================================================
Archiving
================================================================================
toggle ARCHIVE tag C-c C-x C-a
force cycling of an ARCHIVEd tree C-TAB
move subtree to archive file C-c C-x C-s
================================================================================
Filtering and Sparse Trees
================================================================================
show sparse tree for all matches of a regexp C-c /
view TODO's in sparse tree C-c C-v
global TODO list in agenda mode C-c t [1]
create sparse tree with all deadlines due C-c C-w
time sorted view of current org file C-c a L
================================================================================
Tables
================================================================================
--------------------------------------------------------------------------------
Creating a table
--------------------------------------------------------------------------------
just start typing, e.g. |Name|Phone|Age RET |- TAB
convert region to table C-c |
... separator at least 3 spaces C-3 C-c |
--------------------------------------------------------------------------------
Commands available inside tables
--------------------------------------------------------------------------------
The following commands work when the cursor is inside a table. Outside of
tables, the same keys may have other functionality.
--------------------------------------------------------------------------------
Re-aligning and field motion
--------------------------------------------------------------------------------
re-align the table without moving the cursor C-c C-c
re-align the table, move to next field TAB
move to previous field S-TAB
re-align the table, move to next row RET
--------------------------------------------------------------------------------
Row and column editing
--------------------------------------------------------------------------------
move the current column left M-LEFT/RIGHT
kill the current column M-S-LEFT
insert new column to left of cursor position M-S-RIGHT
move the current row up/down M-UP/DOWN
kill the current row or horizontal line M-S-UP
insert new row above the current row M-S-DOWN
insert hline below (C-u : above) current row C-c -
sort lines in region C-c ^
--------------------------------------------------------------------------------
Regions
--------------------------------------------------------------------------------
cut rectangular region C-c C-x C-w
copy rectangular region C-c C-x M-w
paste rectangular region C-c C-x C-y
fill paragraph across selected cells C-c C-q
--------------------------------------------------------------------------------
Miscellaneous
--------------------------------------------------------------------------------
to limit column width to N characters, use ...| <N> |...
edit the current field in a separate window C-c `
make current field fully visible C-u TAB
export as tab-separated file M-x org-table-export
import tab-separated file M-x org-table-import
sum numbers in current column/rectangle C-c +
--------------------------------------------------------------------------------
Tables created with the table.el package
--------------------------------------------------------------------------------
insert a new table.el table C-c ~
recognize existing table.el table C-c C-c
convert table (Org-mode <-> table.el) C-c ~
--------------------------------------------------------------------------------
Spreadsheet
--------------------------------------------------------------------------------
Formulas typed in field are executed by TAB, RET and C-c C-c. = introduces a
column formula, := a field formula.
Example: Add Col1 and Col2 |=$1+$2 |
... with printf format specification |=$1+$2;%.2f|
... with constants from constants.el |=$1/$c/$cm |
sum from 2nd to 3rd hline |:=vsum(@II..@III)|
apply current column formula | = |
set and eval column formula C-c =
set and eval field formula C-u C-c =
re-apply all stored equations to current line C-c *
re-apply all stored equations to entire table C-u C-c *
iterate table to stability C-u C-u C-c *
rotate calculation mark through # * ! $ C-#
show line, column, formula reference C-c ?
toggle coordinate grid C-c }
toggle formula debugger C-c {
--------------------------------------------------------------------------------
Formula Editor
--------------------------------------------------------------------------------
edit formulas in separate buffer C-c '
exit and install new formulas C-c C-c
exit, install, and apply new formulas C-u C-c C-c
abort C-c C-q
toggle reference style C-c C-r
pretty-print Lisp formula TAB
complete Lisp symbol M-TAB
shift reference point S-cursor
shift test line for column references M-up/down
scroll the window showing the table M-S-up/down
toggle table coordinate grid C-c }
================================================================================
Links
================================================================================
globally store link to the current location C-c l [1]
insert a link (TAB completes stored links) C-c C-l
insert file link with file name completion C-u C-c C-l
edit (also hidden part of) link at point C-c C-l
open file links in emacs C-c C-o
... force open in emacs/other window C-u C-c C-o
open link at point mouse-1/2
... force open in emacs/other window mouse-3
record a position in mark ring C-c %
jump back to last followed link(s) C-c &
find next link C-c C-x C-n
find previous link C-c C-x C-p
--------------------------------------------------------------------------------
Internal Links
--------------------------------------------------------------------------------
<<My Target>> target
<<<My Target>>> radio target [2]
[[*this text]] find headline
[[this text]] find target or text in buffer
[[this text][description]] optional link text
--------------------------------------------------------------------------------
External Links
--------------------------------------------------------------------------------
file:/home/dominik/img/mars.jpg file, absolute
file:papers/last.pdf file, relative
file:projects.org::*that text find headline
file:projects.org::find me find trgt/string
http://www.astro.uva.nl/dominik on the web
mailto:adent@galaxy.net Email address
news:comp.emacs Usenet group
bbdb:Richard Stallman BBDB person
gnus:group GNUS group
gnus:group#id GNUS message
vm|wl|mhe|rmail:folder Mail folder
vm|wl|mhe|rmail:folder#id Mail message
info:emacs:Regexps Info file:node
shell:ls *.org shell command
elisp:(calendar) elisp form
[[external link][description]] optional link text
================================================================================
Completion
================================================================================
In-buffer completion completes TODO keywords at headline start, TeX macros
after `\', option keywords after `#-â', TAGS after `:', and dictionary words
elsewhere.
complete word at point M-TAB
================================================================================
TODO Items and Checkboxes
================================================================================
rotate the state of the current item C-c C-t
select next/previous state S-LEFT/RIGHT
select next/previous set C-S-LEFT/RIGHT
view TODO items in a sparse tree C-c C-v
view 3rd TODO keyword's sparse tree C-3 C-c C-v
set the priority of the current item C-c , [ABC]
remove priority cookie from current item C-c , SPC
raise/lower priority of current item S-UP/DOWN [3]
insert new checkbox item in plain list M-S-RET
toggle checkbox(es) in region/entry/at point C-c C-x C-b
toggle checkbox at point C-c C-c
checkbox statistics cookies insert [/] or [%]
update checkbox statistics (C-u : whole file) C-c #
================================================================================
Tags
================================================================================
set tags for current heading C-c C-c
realign tags in all headings C-u C-c C-c
create sparse tree with matching tags C-c \
globally (agenda) match tags at cursor C-c C-o
================================================================================
Timestamps
================================================================================
prompt for date and insert timestamp C-c .
like C-c . but insert date and time format C-u C-c .
like C-c . but make stamp inactive C-c !
insert DEADLINE timestamp C-c C-d
insert SCHEDULED timestamp C-c C-s
create sparse tree with all deadlines due C-c C-w
the time between 2 dates in a time range C-c C-y
change timestamp at cursor by ±1 day S-RIGHT/LEFT [3]
change year/month/day at cursor by ±1 S-UP/DOWN [3]
access the calendar for the current date C-c >
insert timestamp matching date in calendar C-c <
access agenda for current date C-c C-o
select date while prompted mouse-1/RET
toggle custom format display for dates/times C-c C-x C-t
--------------------------------------------------------------------------------
Clocking time
--------------------------------------------------------------------------------
start clock on current item C-c C-x C-i
stop clock on current item C-c C-x C-o
cancel current clock C-c C-x C-x
display total subtree times C-c C-x C-d
remove displayed times C-c C-c
insert/update table with clock report C-c C-x C-r
================================================================================
LaTeX and cdlatex-mode
================================================================================
preview LaTeX fragment C-c C-x C-l
expand abbreviation (cdlatex-mode) TAB
insert/modify math symbol (cdlatex-mode) ` / '
================================================================================
Agenda Views
================================================================================
add/move current file to front of agenda C-c [
remove current file from your agenda C-c ]
cycle through agenda file list C-'
compile agenda for the current week C-c a a [1]
compile global TODO list C-c a t [1]
compile TODO list for specific keyword C-c a T [1]
match tags in agenda files C-c a m [1]
match tags in TODO entries C-c a M [1]
find stuck projects C-c a # [1]
show timeline of current org file C-c a L [1]
configure custom commands C-c a C [1]
configure stuck projects C-c a ! [1]
agenda for date at cursor C-c C-o
To set categories, add lines like [2]:
#+CATEGORY: MyCateg
--------------------------------------------------------------------------------
Commands available in an agenda buffer
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
View Org file
--------------------------------------------------------------------------------
show original location of item SPC/mouse-3
show and recenter window L
goto original location in other window TAB/mouse-2
goto original location, delete other windows RET
show subtree in indirect buffer, ded. frame b
toggle follow-mode f
--------------------------------------------------------------------------------
Change display
--------------------------------------------------------------------------------
delete other windows o
switch to daily / weekly view d / w
toggle inclusion of diary entries D
toggle time grid for daily schedule g
toggle display of logbook entries l
refresh agenda buffer with any changes r
save all org-mode buffers s
display the following org-agenda-ndays RIGHT
display the previous org-agenda-ndays LEFT
goto today .
--------------------------------------------------------------------------------
Remote editing
--------------------------------------------------------------------------------
digit argument 0-9
change state of current TODO item t
kill item and source C-k
archive the subtree $
show tags of current headline T
set tags for current headline :
toggle ARCHIVE tag a
set priority of current item p
raise/lower priority of current item S-UP/DOWN [3]
display weighted priority of current item P
schedule/set deadline for this item C-c C-s/d
change timestamp to one day earlier/later S-LEFT/RIGHT [3]
change timestamp to today >
insert new entry into diary i
start the clock on current item (clock-in) I
stop the clock (clock-out) O
cancel current clock X
--------------------------------------------------------------------------------
Misc
--------------------------------------------------------------------------------
Open link in current line C-c C-o
--------------------------------------------------------------------------------
Calendar commands
--------------------------------------------------------------------------------
find agenda cursor date in calendar c
compute agenda for calendar cursor date c
show phases of the moon M
show sunrise/sunset times S
show holidays H
convert date to other calendars C
--------------------------------------------------------------------------------
Quit and Exit
--------------------------------------------------------------------------------
quit agenda, remove agenda buffer q
exit agenda, remove all agenda buffers x
================================================================================
Calendar and Diary Integration
================================================================================
Include Emacs diary entries into Org-mode agenda with:
(setq org-agenda-include-diary t)
================================================================================
Exporting and Publishing
================================================================================
Exporting creates files with extensions .txt and .html in the current
directory. Publishing puts the resulting file into some other place.
export/publish dispatcher C-c C-e
export visible part only C-c C-e v
insert template of export options C-c C-x t
toggle fixed width for entry or region C-c :
--------------------------------------------------------------------------------
HTML formatting
--------------------------------------------------------------------------------
make words bold *bold*
make words italic /italic/
make words underlined _underlined_
sub- and superscripts x^3, J_dust
TeX-like macros \alpha, \to
typeset lines in fixed width font start with :
tables are exported as HTML tables start with |
links become HTML links http:... etc
include html tags @<b>...@</b>
--------------------------------------------------------------------------------
Comments: Text not being exported
--------------------------------------------------------------------------------
Text before the first headline is not considered part of the document and is
therefore never exported. Lines starting with # are comments and are not
exported. Subtrees whose header starts with COMMENT are never exported.
toggle COMMENT keyword on entry C-c ;
================================================================================
Dynamic Blocks
================================================================================
update dynamic block at point C-c C-x C-u
update all dynamic blocks C-u C-c C-x C-u
================================================================================
Notes
================================================================================
[1] This is only a suggestion for a binding of this command. Choose you own
key as shown under INSTALLATION.
[2] After changing a #+KEYWORD or <<<target>>> line, press C-c C-c with the
cursor still in the line to update.
[3] Keybinding affected by org-CUA-compatibility.

6688
texinfo.tex Normal file
View File

File diff suppressed because it is too large Load Diff