36367dfe670d984ba064194dcc10112854295650
[worg.git] / code / elisp / org-index.el
1 ;;; org-index.el --- A personal index for org and beyond\r
2 \r
3 ;; Copyright (C) 2011-2013 Free Software Foundation, Inc.\r
4 \r
5 ;; Author: Marc Ihm <org-index@ferntreffer.de>\r
6 ;; Keywords: hypermedia, matching\r
7 ;; Requires: org\r
8 ;; Download: http://orgmode.org/worg/code/elisp/org-index.el\r
9 ;; Version: 2.3.1\r
10 \r
11 ;; This file is not part of GNU Emacs.\r
12 \r
13 ;;; License:\r
14 \r
15 ;; This program is free software; you can redistribute it and/or modify\r
16 ;; it under the terms of the GNU General Public License as published by\r
17 ;; the Free Software Foundation; either version 3, or (at your option)\r
18 ;; any later version.\r
19 ;;\r
20 ;; This program is distributed in the hope that it will be useful,\r
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of\r
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
23 ;; GNU General Public License for more details.\r
24 ;;\r
25 ;; You should have received a copy of the GNU General Public License\r
26 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.\r
27 \r
28 ;;; Commentary:\r
29 \r
30 ;; Purpose:\r
31 ;;\r
32 ;;  Mark and find your favorite org-locations and other things easily:\r
33 ;;  Create and update a lookup table of references and links. Frequently\r
34 ;;  used entries bubble to the top. Entering some keywords narrows down the\r
35 ;;  displayed results to matching entries only, so that the right one can\r
36 ;;  be spotted easily.\r
37 ;;\r
38 ;;  References are essentially small numbers (e.g. "R237" or "-455-"),\r
39 ;;  which are created by this package; they are well suited to be used\r
40 ;;  outside org. Links are normal org-mode links.;;\r
41 ;;\r
42 ;; Setup:\r
43 ;;\r
44 ;;  - Add these lines to your .emacs:\r
45 ;;\r
46 ;;    (require 'org-index)\r
47 ;;\r
48 ;;    ;; Optionally assign a key. Pick your own.\r
49 ;;    (global-set-key (kbd "C-+") 'org-index)\r
50 ;;\r
51 ;;  - Invoke `org-index', which will assist you to create your \r
52 ;;    index table.\r
53 ;;\r
54 ;;  - Do not forget to restart emacs to make these lines effective.\r
55 ;;\r
56 ;;\r
57 ;; Further reading:\r
58 ;;\r
59 ;;  See the documentation of `org-index', which can also be read\r
60 ;;  by invoking `org-index' and and choosing the help-command.\r
61 ;;\r
62 ;;  For more documentation and working examples, see:\r
63 ;;\r
64 ;;    http://orgmode.org/worg/org-contrib/org-index.html\r
65 ;;\r
66 \r
67 ;;; Change Log:\r
68 \r
69 ;;   [2013-07-20 Sa] Version 2.3.0:\r
70 ;;    - Renamed from "org-favtable" to "org-index"\r
71 ;;    - Added an assistent to set up the index table\r
72 ;;    - occur is now incremental, searching as you type\r
73 ;;    - simplified the documentation and help-system\r
74 ;;    - Saving keystrokes, as "+g237" is now valid input\r
75 \r
76 ;;    - Many bugfixes\r
77 ;;\r
78 ;;   [2013-02-28 Th] Version 2.2.0:\r
79 ;;    - Allowed shortcuts like "h237" for command "head" with argument "237"\r
80 ;;    - Integrated with org-mark-ring-goto\r
81 ;;\r
82 ;;   [2013-01-25 Fr] Version 2.1.0:\r
83 ;;    - Added full support for links\r
84 ;;    - New commands "missing" and "statistics"\r
85 ;;    - Renamed the package from "org-reftable" to "org-favtable"\r
86 ;;    - Additional columns are required (e.g. "link"). Error messages will\r
87 ;;      guide you\r
88 ;;\r
89 ;;   [2012-12-07 Fr] Version 2.0.0:\r
90 ;;    - The format of the table of favorites has changed ! You need to bring\r
91 ;;      your existing table into the new format by hand (which however is\r
92 ;;      easy and explained below)\r
93 ;;    - Reference table can be sorted after usage count or date of last access\r
94 ;;    - Ask user explicitly, which command to invoke\r
95 ;;    - Renamed the package from "org-refer-by-number" to "org-reftable"\r
96 \r
97 ;;   [2012-09-22 Sa] Version 1.5.0:\r
98 ;;    - New command "sort" to sort a buffer or region by reference number\r
99 ;;    - New commands "highlight" and "unhighlight" to mark references\r
100 \r
101 ;;   [2012-07-13 Fr] Version 1.4.0:\r
102 ;;    - New command "head" to find a headline with a reference number\r
103 \r
104 ;;   [2012-04-28 Sa] Version 1.3.0:\r
105 ;;    - New commands occur and multi-occur\r
106 ;;    - All commands can now be invoked explicitly\r
107 ;;    - New documentation\r
108 ;;    - Many bugfixes\r
109 \r
110 ;;   [2011-12-10 Sa] Version 1.2.0:\r
111 ;;    - Fixed a bug, which lead to a loss of newly created reference numbers\r
112 ;;    - Introduced single and double prefix arguments\r
113 ;;    - Started this Change Log\r
114 \r
115 ;;; Code:\r
116 \r
117 (require 'org-table)\r
118 (require 'cl)\r
119 \r
120 (defvar org-index--preferred-command nil)\r
121 \r
122 (defvar org-index--commands \r
123   '(occur head ref link leave enter goto help + reorder fill sort update highlight unhighlight missing statistics)\r
124   "List of commands known to org-index.")\r
125 \r
126 (defvar org-index--commands-some '(occur head ref link leave enter goto help +))  \r
127 \r
128 \r
129 (defvar org-index--columns nil)\r
130 \r
131 (defcustom org-index-id nil \r
132   "Id of the Org-mode node, which contains the index table."\r
133   :group 'org\r
134   :group 'org-index\r
135   :set (lambda (var val)))\r
136 \r
137 \r
138 (defvar org-index--text-to-yank nil)\r
139 (defvar org-index--last-action nil)\r
140 (defvar org-index--ref-regex nil)\r
141 (defvar org-index--ref-format nil)\r
142 (defvar org-index--buffer nil "buffer of index table")\r
143 (defvar org-index--point nil "position at start of headline of index table")\r
144 (defvar org-index--below-hline nil "position of first cell in first line below hline") \r
145 (defvar org-index--point-before nil "point in buffer with index table")     \r
146 \r
147 \r
148 (defun org-index (&optional ARG)\r
149   "Mark and find your favorite things and org-locations easily:\r
150 Create and update a lookup table of references and links. Often\r
151 used entries bubble to the top; entering some keywords narrows\r
152 down to matching entries only, so that the right one can be\r
153 spotted easily.\r
154 \r
155 References are essentially small numbers (e.g. \"R237\" or \"-455-\"),\r
156 which are created by this package; they are well suited to be used\r
157 outside of org. Links are normal org-mode links.\r
158 \r
159 This is version 2.3.1 of org-index.\r
160 \r
161 The function `org-index' operates on a dedicated table, the index\r
162 table, which lives within its own Org-mode node. The table and\r
163 its node will be created, when you first invoke org-index.\r
164 \r
165 Each line in the index table contains:\r
166 \r
167  - A reference\r
168 \r
169  - A link\r
170 \r
171  - A number; counting, how often each reference has been\r
172    used. This number is updated automatically and the table can\r
173    be sorted after it, so that most frequently used references\r
174    appear at the top of the table and can be spotted easily.\r
175 \r
176  - The creation date of the line.\r
177 \r
178  - Date and time of last access. This column can alternatively be\r
179    used to sort the table.\r
180 \r
181  - A column for your own comments, which allows lines to be selected by\r
182    keywords.\r
183 \r
184 The index table is found through the id of the containing\r
185 node; this id is stored within `org-index-id'.\r
186 \r
187 \r
188 The function `org-index' is the only interactive function of this\r
189 package and its sole entry point; it offers several commands to\r
190 create, find and look up these favorites (references and links).\r
191 \r
192 Commands known:\r
193 \r
194   occur: Incremental search, that after each keystroke shows\r
195     matching lines from index table. You may enter a list of words\r
196     seperated by comma (\",\"), to select lines that contain all\r
197     of the given words.\r
198 \r
199     If you supply a number (e.g. \"237\"): Apply emacs standard\r
200     multi-occur operation on all org-mode buffers to search for\r
201     this specific reference.\r
202 \r
203     You may also read the note at the end of this help on saving\r
204     the keystroke RET with this frequent default command.\r
205 \r
206   head: If invoked outside the index table, ask for a\r
207     reference number and search for a heading containing it. If\r
208     invoked within index table dont ask; rather use the reference or\r
209     link from the current line.\r
210 \r
211   ref: Create a new reference, copy any previously selected text.\r
212     If already within index table, fill in ref-column.\r
213 \r
214   link: Create a new line in index table with a link to the\r
215     current node.  Do not populate the ref column; this can later\r
216     be populated by calling the \"fill\" command from within the\r
217     index table.\r
218 \r
219   leave: Leave the index table. If the last command has\r
220     been \"ref\", the new reference is copied and ready to yank.\r
221     This \"org-mark-ring-goto\" and can be called several times\r
222     in succession. If you invoke org-index with a prefix argument,\r
223     this command \"leave\" is executed without further questions.\r
224 \r
225   enter: Just enter the node with the index table.\r
226 \r
227   goto: Search for a specific reference within the index table.\r
228 \r
229   help: Show this text.\r
230 \r
231   +: Show all commands including the less frequently used ones\r
232     given below. If \"+\" is followd by enough letters of such a\r
233     command (e.g. \"+fi\"), then this command is invoked\r
234     directly.\r
235 \r
236   reorder: Temporarily reorder the index table, e.g. by\r
237     count, reference or last access.\r
238 \r
239   fill: If either ref or link is missing, fill it.\r
240 \r
241   sort: Sort a set of lines (either the active region or the\r
242     whole buffer) by the references found in each line.\r
243 \r
244   update: For the given reference, update the line in the\r
245     index table.\r
246 \r
247   highlight: Highlight references in region or buffer.\r
248 \r
249   unhighlight: Remove highlights.\r
250 \r
251   missing : Search for missing reference numbers (which do not\r
252     appear in the reference table). If requested, add additional\r
253     lines for them, so that the command \"ref\" is able to reuse\r
254     them.\r
255 \r
256   statistics : Show some statistics (e.g. minimum and maximum\r
257     reference) about index table.\r
258 \r
259 \r
260 \r
261 Two ways to save keystrokes:\r
262 \r
263 When prompting for a command, org-index puts the most likely\r
264 one (e.g. \"occur\" or \"ref\") in front of the list, so that\r
265 you may just type RET.\r
266 \r
267 If this command needs additional input (like e.g. \"occur\"), you\r
268 may supply this input right away, although you are still beeing\r
269 prompted for the command. So, to do an occur for the string\r
270 \"foo\", you can just enter \"foo\" RET, without even typing\r
271 \"occur\".\r
272 \r
273 \r
274 Another way to save keystrokes applies if you want to choose a\r
275 command, that requrires a reference number (and would normally\r
276 prompt for it): In that case you may just enter enough characters\r
277 from your command, so that it appears first in the list of\r
278 matches; then immediately enter the number of the reference you\r
279 are searching for. So the input \"h237\" would execute the\r
280 command \"head\" for reference \"237\" right away.\r
281 \r
282 "\r
283 \r
284   (interactive "P")\r
285 \r
286   (org-index-1 (if (equal ARG '(4)) 'leave nil) )\r
287 )\r
288 \r
289 \r
290 (defun org-index-1 (&optional what search search-is-link) \r
291 "Do the actual worg for org-index; its optional arguments are:\r
292 \r
293          search : string to search for\r
294            what : symbol of the command to invoke\r
295  search-is-link : t, if argument search is actually a link\r
296 \r
297 An example would be:\r
298 \r
299  (org-index \"237\" 'head)   ;; find heading with ref 237\r
300 "\r
301   (let (within-node        ; True, if we are within node of the index table\r
302         active-window-index    ; active window with index table (if any)\r
303         below-cursor              ; word below cursor\r
304         active-region             ; active region (if any)\r
305         link-id                   ; link of starting node, if required\r
306         guarded-search            ; with guard against additional digits\r
307         search-is-ref             ; true, if search is a reference\r
308         commands                ; currently active set of selectable commands\r
309         what-adjusted           ; True, if we had to adjust what\r
310         what-input    ; Input on what question (need not necessary be "what")\r
311         trailing-digits ; any digits, that are are appended to what-input\r
312         reorder-once  ; Column to use for single time sorting\r
313         parts         ; Parts of a typical reference number (which\r
314                       ; need not be a plain number); these are:\r
315         head               ; Any header before number (e.g. "R")\r
316         maxref             ; Maximum number from reference table (e.g. "153")\r
317         tail               ; Tail after number (e.g. "}" or "")\r
318         ref-regex          ; Regular expression to match a reference\r
319         has-reuse          ; True, if table contains a line for reuse\r
320         numcols            ; Number of columns in index table\r
321         kill-new-text      ; Text that will be appended to kill ring\r
322         message-text       ; Text that will be issued as an explanation,\r
323                            ; what we have done\r
324         initial-ref-or-link      ; Initial position in index table\r
325         )\r
326 \r
327     ;;\r
328     ;; Examine current buffer and location, before turning to index table\r
329     ;;\r
330     \r
331     (unless (boundp 'org-index-id)\r
332       (setq org-index-id nil)\r
333       (org-index--create-new-index \r
334        t\r
335        (format "No index table has been created yet." org-index-id)))\r
336 \r
337     ;; Bail out, if new index has been created\r
338     (catch 'created-new-index\r
339 \r
340       ;; Get the content of the active region or the word under cursor\r
341       (if (and transient-mark-mode\r
342                mark-active)\r
343           (setq active-region (buffer-substring (region-beginning) (region-end))))\r
344       (setq below-cursor (thing-at-point 'symbol))\r
345 \r
346 \r
347       ;; Find out, if we are within favable or not\r
348       (setq within-node (string= (org-id-get) org-index-id))\r
349 \r
350 \r
351       ;;\r
352       ;; Get decoration of references and highest reference from index table\r
353       ;;\r
354 \r
355 \r
356       ;; Save initial ref or link\r
357       (if (and within-node\r
358                (org-at-table-p))\r
359           (setq initial-ref-or-link \r
360                 (or (org-index--get-field 'ref)\r
361                     (org-index--get-field 'link))))\r
362 \r
363       ;; Find node\r
364       (let ((marker (org-id-find org-index-id 'marker)) initial)      \r
365         (if marker \r
366             (progn\r
367               (setq org-index--buffer (marker-buffer marker) \r
368                     org-index--point (marker-position marker))\r
369               (move-marker marker nil))\r
370           (org-index--create-new-index \r
371            t\r
372            (format "Cannot find node with id \"%s\"" org-index-id))))\r
373       \r
374       ;; Check and remember, if active window contains buffer with index table\r
375       (if (eq (window-buffer) org-index--buffer)\r
376           (setq active-window-index (selected-window)))\r
377 \r
378       ;; Get configuration of index table; catch errors\r
379       (let ((error-message\r
380              (catch 'content-error\r
381 \r
382                (with-current-buffer org-index--buffer\r
383                  (unless org-index--point-before \r
384                    (setq org-index--point-before (point)))\r
385 \r
386                  (unless (string= (org-id-get) org-index-id)\r
387                    (goto-char org-index--point))\r
388 \r
389                  ;; parse table while still within buffer\r
390                  (setq parts (org-index--parse-and-adjust-table))\r
391                  \r
392                  ;; go back\r
393                  (goto-char org-index--point-before)\r
394 \r
395                  nil))))\r
396 \r
397         (when error-message \r
398           (org-pop-to-buffer-same-window org-index--buffer)\r
399           (org-reveal)\r
400           (error error-message)))\r
401 \r
402       ;; Give names to parts of configuration\r
403       (setq head (nth 0 parts))\r
404       (setq maxref (nth 1 parts))\r
405       (setq tail (nth 2 parts))\r
406       (setq numcols (nth 3 parts))\r
407       (setq ref-regex (nth 4 parts))\r
408       (setq has-reuse (nth 5 parts))\r
409       (setq org-index--ref-regex ref-regex)\r
410       (setq org-index--ref-format (concat head "%d" tail))\r
411 \r
412       ;;\r
413       ;; Find out, what we are supposed to do\r
414       ;;\r
415 \r
416       ;; Set preferred action, that will be the default choice\r
417       (setq org-index--preferred-command\r
418             (if within-node\r
419                 (if (memq org-index--last-action '(ref link))\r
420                     'leave\r
421                   'goto)\r
422               (if active-region\r
423                   'ref\r
424                 (if (and below-cursor (string-match ref-regex below-cursor))\r
425                     'occur\r
426                   nil))))\r
427       \r
428       ;; Ask user, what to do\r
429       (unless what\r
430         (setq commands (copy-list org-index--commands-some))\r
431         (while (let (completions starts-with-plus is-only-plus)\r
432 \r
433                  (setq what-input\r
434                        (org-completing-read \r
435                         "Please choose: " \r
436                         (mapcar 'symbol-name \r
437                                 ;; Construct unique list of commands with\r
438                                 ;; preferred one at front\r
439                                 (delq nil (delete-dups \r
440                                            (append \r
441                                             (list org-index--preferred-command)\r
442                                             (copy-list commands)))))\r
443                         nil nil))\r
444 \r
445                  ;; if input ends in digits, save them away and do completions on head of input\r
446                  ;; this allows input like "h224" to be accepted\r
447                  (when (string-match "^\\([^0-9]+\\)\\([0-9]+\\)\\s *$" what-input)\r
448                    ;; remember digits\r
449                    (setq trailing-digits (string-to-number (match-string 2 what-input)))\r
450                    ;; and use non-digits-part to find match\r
451                    (setq what-input (match-string 1 what-input)))\r
452 \r
453                  ;; if input starts with "+", any command (not only some) may follow\r
454                  ;; this allows input like "+sort" to be accepted\r
455                  (when (string= (substring what-input 0 1) "+")\r
456                    ;; make all commands available for selection\r
457                    (setq commands (copy-list org-index--commands))\r
458                    (setq what-input (substring what-input 1))\r
459                    (setq starts-with-plus (> (length what-input) 0))\r
460                    (setq is-only-plus (not starts-with-plus)))\r
461 \r
462                  ;; get list of possible completions for what-input; i.e.\r
463                  ;; all commands, that start with what-input                   \r
464                  (setq completions (delq nil (mapcar \r
465                                               (lambda (x) \r
466                                                 (let ((where (search what-input (symbol-name x))))\r
467                                                   (if (and where \r
468                                                            (= where 0))\r
469                                                       x\r
470                                                     nil))) commands)))\r
471 \r
472                  ;; if input starts with "+" and not just "+"\r
473                  (when starts-with-plus\r
474                    ;; use first completion, if unambigously\r
475                    (if (= (length completions) 1)\r
476                        (setq what-input (symbol-name (car completions)))\r
477                      (if completions\r
478                          (error "Input \"+%s\" matches multiple commands: %s" \r
479                                 what-input \r
480                                 (mapconcat 'symbol-name completions ", "))\r
481                        (error "Input \"+%s\" matches no commands" what-input))))\r
482 \r
483                  ;; if input ends in digits, use first completion, even if ambigous\r
484                  ;; this allows input like "h224" to be accepted\r
485                  (when (and trailing-digits completions)\r
486                    ;; use first match as input, even if ambigously\r
487                    (setq org-index--preferred-command (first completions))\r
488                    (setq what-input (number-to-string trailing-digits)))\r
489 \r
490                  ;; convert to symbol\r
491                  (setq what (intern what-input))\r
492                  (if is-only-plus (setq what '+))\r
493                  \r
494                  ;; user is not required to input one of the commands; if\r
495                  ;; not, take the first one and use the original input for\r
496                  ;; next question\r
497                  (if (memq what commands)\r
498                      ;; input matched one element of list, dont need original\r
499                      ;; input any more\r
500                      (setq what-input nil)\r
501                    ;; what-input will be used for next question, use first\r
502                    ;; command for what\r
503                    (setq what (or org-index--preferred-command\r
504                                   (first commands)))\r
505                    ;; remove any trailing dot, that user might have added to\r
506                    ;; disambiguate his input\r
507                    (if (and (> (length what-input) 0) \r
508                             (equal (substring what-input -1) "."))\r
509                        ;; but do this only, if dot was really necessary to\r
510                        ;; disambiguate\r
511                        (let ((shortened-what-input (substring what-input 0 -1)))\r
512                          (unless (test-completion shortened-what-input \r
513                                                   (mapcar 'symbol-name \r
514                                                           commands))\r
515                            (setq what-input shortened-what-input)))))\r
516                  \r
517                  ;; ask for reorder in loop, because we have to ask for\r
518                  ;; what right again\r
519                  (if (eq what 'reorder)\r
520                      (setq reorder-once\r
521                            (intern\r
522                             (org-icompleting-read \r
523                              "Please choose column to reorder index table once: " \r
524                              (mapcar 'symbol-name '(ref count last-accessed))\r
525                              nil t))))\r
526                  \r
527                  ;; maybe ask initial question again\r
528                  (memq what '(reorder +)))))\r
529 \r
530 \r
531       ;;\r
532       ;; Get search, if required\r
533       ;;\r
534 \r
535       ;; These actions need a search string:\r
536       (when (memq what '(goto occur head update))\r
537 \r
538         ;; Maybe we've got a search string from the arguments\r
539         (unless search\r
540           (let (search-from-table\r
541                 search-from-cursor)\r
542             \r
543             ;; Search string can come from several sources:\r
544             ;; From link or ref columns of table\r
545             (when within-node\r
546               (setq search-from-table (org-index--get-field 'link))\r
547               (if search-from-table \r
548                   (setq search-is-link t)\r
549                 (setq search-from-table (org-index--get-field 'ref))))      \r
550             \r
551             ;; From string below cursor\r
552             (when (and (not within-node)\r
553                        below-cursor\r
554                        (string-match (concat "\\(" ref-regex "\\)") \r
555                                      below-cursor))\r
556               (setq search-from-cursor (match-string 1 below-cursor)))\r
557             \r
558             ;; Depending on requested action, get search from one of the sources above\r
559             (cond ((eq what 'goto)\r
560                    (setq search (or what-input search-from-cursor)))\r
561                   ((memq what '(head occur))\r
562                    (setq search (or what-input search-from-table search-from-cursor))))))\r
563 \r
564 \r
565         ;; If we still do not have a search string, ask user explicitly\r
566         (unless search\r
567           (unless (eq what 'occur)\r
568             \r
569             (if what-input \r
570                 (setq search what-input)\r
571               (setq search (read-from-minibuffer\r
572                             (cond ((eq what 'head)\r
573                                    "Text or reference number to search for: ")\r
574                                   ((eq what 'goto)\r
575                                    "Reference number to search for, or enter \".\" for id of current node: ")\r
576                                   ((eq what 'update)\r
577                                    "Reference number to update: ")))))\r
578 \r
579             (if (string-match "^\\s *[0-9]+\\s *$" search)\r
580                 (setq search (format "%s%s%s" head (org-trim search) tail))))))\r
581       \r
582       ;; Clean up and examine search string\r
583       (when search \r
584         (setq search (org-trim search))\r
585         (if (string= search "") (setq search nil))\r
586         (when search\r
587           (if (string-match "^[0-9]+$" search)\r
588               (setq search (concat head search tail)))\r
589           (setq search-is-ref (string-match ref-regex search))))\r
590       \r
591       ;; Check for special case\r
592       (when (and (memq what '(head goto))\r
593                  (string= search "."))\r
594         (setq search (org-id-get))\r
595         (setq search-is-link t))\r
596       \r
597       (when search-is-ref\r
598         (setq guarded-search (org-index--make-guarded-search search)))\r
599       \r
600       ;;\r
601       ;; Do some sanity checking before really starting\r
602       ;;\r
603       \r
604       ;; Correct requested action, if nothing to search\r
605       (when (and (not search)\r
606                  (memq what '(search head)))\r
607         (setq what 'enter)\r
608         (setq what-adjusted t))\r
609       \r
610       ;; For a proper reference as input, we do multi-occur\r
611       (if (and search\r
612                (string-match ref-regex search)\r
613                (eq what 'occur))\r
614           (setq what 'multi-occur))\r
615       \r
616       ;; Check for invalid combinations of arguments; try to be helpful\r
617       (when (and (memq what '(head goto))\r
618                  (not search-is-link)\r
619                  (not search-is-ref))\r
620         (error "Can do '%s' only for a reference or link (not '%s'), try 'occur' to search for text" what search))\r
621 \r
622       \r
623       ;;\r
624       ;; Prepare\r
625       ;;\r
626 \r
627       ;; Get link if required before moving in\r
628       (if (eq what 'link)\r
629           (let ((org-id-link-to-org-use-id t))\r
630             (setq link-id (org-id-get-create))))\r
631 \r
632       ;; Move into table, if outside\r
633 \r
634       ;; These commands enter index table only temporarily\r
635       (when (memq what '(occur multi-occur statistics))\r
636 \r
637         ;; Switch to index table\r
638         (set-buffer org-index--buffer)\r
639         (goto-char org-index--point)\r
640 \r
641         ;; sort index table\r
642         (org-index--sort-table reorder-once))\r
643 \r
644       ;; These commands will leave user in index table after they are finished\r
645       (when (memq what '(enter ref link goto missing))\r
646 \r
647         ;; Support orgmode-standard of going back (buffer and position)\r
648         (org-mark-ring-push)\r
649 \r
650         ;; Switch to index table\r
651         (org-pop-to-buffer-same-window org-index--buffer)\r
652         (goto-char org-index--point)\r
653         (show-subtree)\r
654         (org-show-context)\r
655         (setq org-index--point-before nil) ;; dont want to go back\r
656 \r
657         ;; sort index table\r
658         (org-index--sort-table reorder-once))\r
659 \r
660       ;; Goto back to initial ref, because reformatting of table above might\r
661       ;; have moved point\r
662       (when initial-ref-or-link\r
663         (while (and (org-at-table-p)\r
664                     (not (or\r
665                           (string= initial-ref-or-link (org-index--get-field 'ref))\r
666                           (string= initial-ref-or-link (org-index--get-field 'link)))))\r
667           (forward-line))\r
668         ;; did not find ref, go back to top\r
669         (if (not (org-at-table-p)) (goto-char org-index--point)))\r
670       \r
671       \r
672       ;;\r
673       ;; Actually do, what is requested\r
674       ;;\r
675 \r
676       (cond\r
677 \r
678 \r
679        ((eq what 'help)\r
680         \r
681         ;; bring up help-buffer for this function\r
682         (describe-function 'org-index))\r
683 \r
684 \r
685        ((eq what 'multi-occur) \r
686         \r
687         ;; Conveniently position cursor on number to search for\r
688         (goto-char org-index--below-hline)\r
689         (let (found (initial (point)))\r
690           (while (and (not found)\r
691                       (forward-line)\r
692                       (org-at-table-p))\r
693             (save-excursion \r
694               (setq found (string= search \r
695                                    (org-index--get-field 'ref)))))\r
696           (if found \r
697               (org-index--update-line nil)\r
698             (goto-char initial)))\r
699 \r
700         ;; Construct list of all org-buffers\r
701         (let (buff org-buffers)\r
702           (dolist (buff (buffer-list))\r
703             (set-buffer buff)\r
704             (if (string= major-mode "org-mode")\r
705                 (setq org-buffers (cons buff org-buffers))))\r
706 \r
707           ;; Do multi-occur\r
708           (multi-occur org-buffers guarded-search)\r
709           (if (get-buffer "*Occur*")\r
710               (progn \r
711                 (setq message-text (format "multi-occur for '%s'" search))\r
712                 (other-window 1)\r
713                 (toggle-truncate-lines 1))\r
714             (setq message-text (format "Did not find '%s'" search)))))\r
715 \r
716 \r
717        ((eq what 'head)\r
718 \r
719         (let (link)\r
720           ;; link either from table or passed in as argument\r
721           \r
722           ;; try to get link\r
723           (if search-is-link \r
724               (setq link (org-trim search))\r
725             (if (and within-node\r
726                      (org-at-table-p))\r
727                 (setq link (org-index--get-field 'link))))\r
728 \r
729           ;; use link if available\r
730           (if (and link\r
731                    (not (string= link "")))\r
732               (progn \r
733                 (org-index--update-line search)\r
734                 (org-id-goto link)\r
735                 (org-reveal)\r
736                 (if (eq (current-buffer) org-index--buffer)\r
737                     (setq org-index--point-before nil))\r
738                 (setq message-text "Followed link"))\r
739 \r
740             (message (format "Scanning headlines for '%s' ..." search))\r
741             (org-index--update-line search)\r
742             (let (buffer point)\r
743               (if (catch 'found\r
744                     (progn\r
745                       ;; loop over all headlines, stop on first match\r
746                       (org-map-entries \r
747                        (lambda () \r
748                          (when (looking-at (concat ".*" guarded-search))\r
749                            ;; If this is not an inlinetask ...\r
750                            (when (< (org-element-property :level (org-element-at-point))\r
751                                     org-inlinetask-min-level)\r
752                              ;; ... remember location and bail out\r
753                              (setq buffer (current-buffer))\r
754                              (setq point (point))\r
755                              (throw 'found t))))          \r
756                        nil 'agenda)\r
757                       nil))\r
758 \r
759                   (progn\r
760                     (if (eq buffer org-index--buffer)\r
761                         (setq org-index--point-before nil))\r
762                     (setq message-text (format "Found '%s'" search))\r
763                     (org-pop-to-buffer-same-window buffer)\r
764                     (goto-char point)\r
765                     (org-reveal))\r
766                 (setq message-text (format "Did not find '%s'" search)))))))\r
767 \r
768 \r
769        ((eq what 'leave)\r
770 \r
771         (setq kill-new-text org-index--text-to-yank)\r
772         (setq org-index--text-to-yank nil)\r
773         \r
774         ;; If "leave" has been called two times in succession, make\r
775         ;; org-mark-ring-goto believe it has been called two times too\r
776         (if (eq org-index--last-action 'leave) \r
777             (let ((this-command nil) (last-command nil))\r
778               (org-mark-ring-goto 1))\r
779           (org-mark-ring-goto)))\r
780 \r
781 \r
782        ((eq what 'goto)\r
783 \r
784         ;; Go downward in table to requested reference\r
785         (let (found (initial (point)))\r
786           (goto-char org-index--below-hline)\r
787           (while (and (not found)\r
788                       (forward-line)\r
789                       (org-at-table-p))\r
790             (save-excursion \r
791               (setq found \r
792                     (string= search \r
793                              (org-index--get-field \r
794                               (if search-is-link 'link 'ref))))))\r
795           (if found\r
796               (progn\r
797                 (setq message-text (format "Found '%s'" search))\r
798                 (org-index--update-line nil)\r
799                 (org-table-goto-column (org-index--column-num 'ref))\r
800                 (if (looking-back " ") (backward-char))\r
801                 ;; remember string to copy\r
802                 (setq org-index--text-to-yank \r
803                       (org-trim (org-table-get-field (org-index--column-num 'copy)))))\r
804             (setq message-text (format "Did not find '%s'" search))\r
805             (goto-char initial)\r
806             (forward-line)\r
807             (setq what 'missed))))\r
808 \r
809 \r
810        ((eq what 'occur)\r
811 \r
812         (org-index--do-occur what-input))\r
813 \r
814 \r
815        ((memq what '(ref link))\r
816 \r
817         ;; add a new row (or reuse existing one)\r
818         (let (new)\r
819 \r
820           (when (eq what 'ref)\r
821             ;; go through table to find first entry to be reused\r
822             (when has-reuse\r
823               (goto-char org-index--below-hline)\r
824               ;; go through table\r
825               (while (and (org-at-table-p)\r
826                           (not new))\r
827                 (when (string= \r
828                        (org-index--get-field 'count)\r
829                        ":reuse:")\r
830                   (setq new (org-index--get-field 'ref))\r
831                   (if new (org-table-kill-row)))\r
832                 (forward-line)))\r
833             \r
834             ;; no ref to reuse; construct new reference\r
835             (unless new \r
836               (setq new (format "%s%d%s" head (1+ maxref) tail)))\r
837 \r
838             ;; remember for org-mark-ring-goto\r
839             (setq org-index--text-to-yank new))\r
840           \r
841           ;; insert ref or link as very first row\r
842           (goto-char org-index--below-hline)\r
843           (org-table-insert-row)\r
844           \r
845           ;; fill special columns with standard values\r
846           (when (eq what 'ref)\r
847             (org-table-goto-column (org-index--column-num 'ref))\r
848             (insert new))\r
849           (when (eq what 'link)\r
850             (org-table-goto-column (org-index--column-num 'link))\r
851             (insert link-id))\r
852           (org-table-goto-column (org-index--column-num 'created))\r
853           (org-insert-time-stamp nil nil t)\r
854           (org-table-goto-column (org-index--column-num 'count))\r
855           (insert "1")\r
856 \r
857           ;; goto copy-field or first empty one\r
858           (if (org-index--column-num 'copy)\r
859               (org-table-goto-column (org-index--column-num 'copy))\r
860             (unless (catch 'empty\r
861                       (dotimes (col numcols)\r
862                         (org-table-goto-column (+ col 1))\r
863                         (if (string= (org-trim (org-table-get-field)) "")\r
864                             (throw 'empty t))))\r
865               ;; none found, goto first\r
866               (org-table-goto-column 1)))\r
867 \r
868           (org-table-align)\r
869           (if active-region (setq kill-new-text active-region))\r
870           (if (eq what 'ref)\r
871               (setq message-text (format "Adding a new row with ref '%s'" new))\r
872             (setq message-text (format "Adding a new row linked to '%s'" link-id)))))\r
873 \r
874 \r
875        ((eq what 'enter)\r
876 \r
877         ;; simply go into table\r
878         (goto-char org-index--below-hline)\r
879         (show-subtree)\r
880         (recenter)\r
881         (if what-adjusted\r
882             (setq message-text "Nothing to search for; at index table")\r
883           (setq message-text "At index table")))\r
884 \r
885        \r
886        ((eq what 'fill)\r
887 \r
888         ;; check, if within index table\r
889         (unless (and within-node\r
890                      (org-at-table-p))\r
891           (error "Not within index table"))\r
892 \r
893         ;; applies to missing refs and missing links alike\r
894         (let ((ref (org-index--get-field 'ref))\r
895               (link (org-index--get-field 'link)))\r
896 \r
897           (if (and (not ref)\r
898                    (not link))\r
899               ;; have already checked this during parse, check here anyway\r
900               (error "Columns ref and link are both empty in this line"))\r
901 \r
902           ;; fill in new ref\r
903           (if (not ref)\r
904               (progn \r
905                 (setq kill-new-text (format "%s%d%s" head (1+ maxref) tail))\r
906                 (org-index--get-field 'ref kill-new-text)\r
907                 ;; remember for org-mark-ring-goto\r
908                 (setq org-index--text-to-yank kill-new-text)\r
909                 (org-id-goto link)\r
910                 (setq message-text "Filled field of index table with new reference"))\r
911 \r
912             ;; fill in new link\r
913             (if (not link)\r
914                 (progn\r
915                   (setq guarded-search (org-index--make-guarded-search ref))\r
916                   (message (format "Scanning headlines for '%s' ..." ref))\r
917                   (let (link)\r
918                     (if (catch 'found\r
919                           (org-map-entries \r
920                            (lambda () \r
921                              (when (looking-at (concat ".*" guarded-search))\r
922                                (setq link (org-id-get-create))\r
923                                (throw 'found t)))   \r
924                            nil 'agenda)\r
925                           nil)\r
926 \r
927                         (progn\r
928                           (org-index--get-field 'link link)\r
929                           (setq message-text "Inserted link"))\r
930 \r
931                       (setq message-text (format "Did not find reference '%s'" ref)))))\r
932               \r
933               ;; nothing is missing\r
934               (setq message-text "Columns 'ref' and 'link' are already filled; nothing to do")))))\r
935        \r
936 \r
937        ((eq what 'sort)\r
938 \r
939         ;; sort lines according to contained reference\r
940         (let (begin end where)\r
941           (catch 'aborted\r
942             ;; either active region or whole buffer\r
943             (if (and transient-mark-mode\r
944                      mark-active)\r
945                 ;; sort only region\r
946                 (progn\r
947                   (setq begin (region-beginning))\r
948                   (setq end (region-end))\r
949                   (setq where "region"))\r
950               ;; sort whole buffer\r
951               (setq begin (point-min))\r
952               (setq end (point-max))\r
953               (setq where "whole buffer")\r
954               ;; make sure\r
955               (unless (y-or-n-p "Sort whole buffer ")\r
956                 (setq message-text "Sort aborted")\r
957                 (throw 'aborted nil)))\r
958             \r
959             (save-excursion\r
960               (save-restriction\r
961                 (goto-char (point-min))\r
962                 (narrow-to-region begin end)\r
963                 (sort-subr nil 'forward-line 'end-of-line \r
964                            (lambda ()\r
965                              (if (looking-at (concat ".*" \r
966                                                      (org-index--make-guarded-search ref-regex 'dont-quote)))\r
967                                  (string-to-number (match-string 1))\r
968                                0))))\r
969               (highlight-regexp ref-regex 'isearch)\r
970               (setq message-text (format "Sorted %s from character %d to %d, %d lines" \r
971                                          where begin end\r
972                                          (count-lines begin end)))))))\r
973        \r
974 \r
975        ((eq what 'update)\r
976 \r
977         ;; simply update line in index table\r
978         (save-excursion\r
979           (let ((ref-or-link (if search-is-link "link" "reference")))\r
980             (beginning-of-line)\r
981             (if (org-index--update-line search)\r
982                 (setq message-text (format "Updated %s '%s'" ref-or-link search))\r
983               (setq message-text (format "Did not find %s '%s'" ref-or-link search))))))\r
984 \r
985 \r
986        ((eq what 'parse)\r
987         ;; Just parse the index table, which is already done, so nothing to do\r
988         )\r
989 \r
990 \r
991        ((memq what '(highlight unhighlight))\r
992 \r
993         (let ((where "buffer"))\r
994           (save-excursion\r
995             (save-restriction\r
996               (when (and transient-mark-mode\r
997                          mark-active)\r
998                 (narrow-to-region (region-beginning) (region-end))\r
999                 (setq where "region"))\r
1000 \r
1001               (if (eq what 'highlight)\r
1002                   (progn\r
1003                     (highlight-regexp ref-regex 'isearch)\r
1004                     (setq message-text (format "Highlighted references in %s" where)))\r
1005                 (unhighlight-regexp ref-regex)\r
1006                 (setq message-text (format "Removed highlights for references in %s" where)))))))\r
1007 \r
1008 \r
1009        ((memq what '(missing statistics))\r
1010 \r
1011         (goto-char org-index--below-hline)\r
1012         (let (missing \r
1013               ref-field\r
1014               ref\r
1015               min\r
1016               max \r
1017               (total 0))\r
1018 \r
1019           ;; start with list of all references\r
1020           (setq missing (mapcar (lambda (x) (format "%s%d%s" head x tail)) \r
1021                                 (number-sequence 1 maxref)))\r
1022 \r
1023           ;; go through table and remove all refs, that we see\r
1024           (while (and (forward-line)\r
1025                       (org-at-table-p))\r
1026 \r
1027             ;; get ref-field and number\r
1028             (setq ref-field (org-index--get-field 'ref))\r
1029             (if (and ref-field \r
1030                      (string-match ref-regex ref-field))\r
1031                 (setq ref (string-to-number (match-string 1 ref-field))))\r
1032 \r
1033             ;; remove existing refs from list\r
1034             (if ref-field (setq missing (delete ref-field missing)))\r
1035 \r
1036             ;; record min and max            \r
1037             (if (or (not min) (< ref min)) (setq min ref))\r
1038             (if (or (not max) (> ref max)) (setq max ref))\r
1039 \r
1040             ;; count\r
1041             (setq total (1+ total)))\r
1042 \r
1043           ;; insert them, if requested\r
1044           (forward-line -1)\r
1045           (if (eq what 'statistics)\r
1046               \r
1047               (setq message-text (format "Found %d references from %s to %s. %d references below highest do not appear in table. "\r
1048                                          total \r
1049                                          (format org-index--ref-format min)   \r
1050                                          (format org-index--ref-format max)\r
1051                                          (length missing)))\r
1052 \r
1053             (if (y-or-n-p (format "Found %d missing references; do you wish to append them to the index table" \r
1054                                   (length missing)))\r
1055                 (let (type)\r
1056                   (setq type (org-icompleting-read \r
1057                               "Insert new lines for reuse by command \"new\" or just as missing ? " '("reuse" "missing")))\r
1058                   (mapc (lambda (x) \r
1059                           (let (org-table-may-need-update) (org-table-insert-row t))\r
1060                           (org-index--get-field 'ref x)\r
1061                           (org-index--get-field 'count (format ":%s:" type)))\r
1062                         missing)\r
1063                   (org-table-align)\r
1064                   (setq message-text (format "Inserted %d new lines for missing refernces" (length missing))))\r
1065               (setq message-text (format "%d missing references." (length missing)))))))\r
1066        \r
1067        \r
1068        (t (error "This is a bug: unmatched case '%s'" what)))\r
1069 \r
1070 \r
1071       ;; restore point in buffer or window with index table\r
1072       (if org-index--point-before\r
1073           ;; buffer displayed in window need to set point there first\r
1074           (if (eq (window-buffer active-window-index)\r
1075                   org-index--buffer)\r
1076               (set-window-point active-window-index org-index--point-before)\r
1077             ;; set position in buffer in any case and second\r
1078             (with-current-buffer org-index--buffer\r
1079               (goto-char org-index--point-before)\r
1080               (setq org-index--point-before nil))))\r
1081 \r
1082 \r
1083       ;; remember what we have done for next time\r
1084       (setq org-index--last-action what)\r
1085       \r
1086       ;; tell, what we have done and what can be yanked\r
1087       (if kill-new-text (setq kill-new-text \r
1088                               (substring-no-properties kill-new-text)))\r
1089       (if (string= kill-new-text "") (setq kill-new-text nil))\r
1090       (let ((m (concat \r
1091                 message-text\r
1092                 (if (and message-text kill-new-text) \r
1093                     " and r" \r
1094                   (if kill-new-text "R" ""))\r
1095                 (if kill-new-text (format "eady to yank '%s'" kill-new-text) ""))))\r
1096         (unless (string= m "") (message m)))\r
1097       (if kill-new-text (kill-new kill-new-text)))))\r
1098 \r
1099 \r
1100 \r
1101 (defun org-index--parse-and-adjust-table ()\r
1102 \r
1103   (let ((maxref 0)\r
1104         top\r
1105         bottom\r
1106         ref-field\r
1107         link-field\r
1108         parts\r
1109         numcols\r
1110         head\r
1111         tail\r
1112         ref-regex\r
1113         has-reuse\r
1114         initial-point)\r
1115 \r
1116     (setq initial-point (point))\r
1117     (org-index--go-below-hline)\r
1118     (setq org-index--below-hline (point))\r
1119     (setq top (point))\r
1120     \r
1121     ;; count columns\r
1122     (org-table-goto-column 100)\r
1123     (setq numcols (- (org-table-current-column) 1))\r
1124     \r
1125     ;; get contents of columns\r
1126     (forward-line -2)\r
1127     (unless (org-at-table-p)\r
1128       (org-index--create-new-index \r
1129        nil\r
1130        "Index table starts with a hline"))\r
1131 \r
1132     ;; check for optional line consisting solely of width specifications\r
1133     (beginning-of-line)\r
1134     (if (looking-at "\\s *|\\(\\(\\s *|\\)\\|\\(\\s *<[0-9]+>\\s *|\\)\\)+\\s *$")\r
1135         (forward-line -1))\r
1136     (org-table-goto-column 1)\r
1137 \r
1138     (setq org-index--columns (org-index--parse-headings numcols))\r
1139     \r
1140     ;; Go beyond end of table\r
1141     (while (org-at-table-p) (forward-line 1))\r
1142     \r
1143     ;; Kill all empty rows at bottom\r
1144     (while (progn\r
1145              (forward-line -1)\r
1146              (org-table-goto-column 1)\r
1147              (and\r
1148               (not (org-index--get-field 'ref))\r
1149               (not (org-index--get-field 'link))))\r
1150       (org-table-kill-row))\r
1151     (forward-line)\r
1152     (setq bottom (point))\r
1153     (forward-line -1)\r
1154     \r
1155     ;; Retrieve any decorations around the number within the first nonempty ref-field\r
1156     (goto-char top)\r
1157     (while (and (org-at-table-p)\r
1158                 (not (setq ref-field (org-index--get-field 'ref))))\r
1159       (forward-line))\r
1160 \r
1161     ;; Some Checking\r
1162     (unless ref-field\r
1163       (org-index--create-new-index \r
1164        nil\r
1165        "Reference column is empty"))\r
1166     \r
1167     (unless (string-match "^\\([^0-9]*\\)\\([0-9]+\\)\\([^0-9]*\\)$" ref-field)\r
1168       (org-index--create-new-index \r
1169        nil \r
1170        (format "First reference in index table ('%s') does not contain a number" ref-field)))\r
1171     \r
1172 \r
1173     ;; These are the decorations used within the first ref of index\r
1174     (setq head (match-string 1 ref-field))\r
1175     (setq tail (match-string 3 ref-field))\r
1176     (setq ref-regex (concat (regexp-quote head)\r
1177                             "\\([0-9]+\\)" \r
1178                             (regexp-quote tail)))\r
1179 \r
1180     ;; Go through table to find maximum number and do some checking\r
1181     (let ((ref 0))\r
1182 \r
1183       (while (org-at-table-p) \r
1184 \r
1185         (setq ref-field (org-index--get-field 'ref))\r
1186         (setq link-field (org-index--get-field 'link))\r
1187 \r
1188         (if (and (not ref-field)\r
1189                  (not link-field))\r
1190             (throw 'content-error "Columns ref and link are both empty in this line"))\r
1191 \r
1192         (if ref-field\r
1193             (if (string-match ref-regex ref-field)\r
1194                 ;; grab number\r
1195                 (setq ref (string-to-number (match-string 1 ref-field)))\r
1196               (throw 'content-error "Column ref does not contain a number")))\r
1197 \r
1198         ;; check, if higher ref\r
1199         (if (> ref maxref) (setq maxref ref))\r
1200 \r
1201         ;; check if ref is ment for reuse\r
1202         (if (string= (org-index--get-field 'count) ":reuse:")\r
1203             (setq has-reuse 1))\r
1204 \r
1205         (forward-line 1)))\r
1206     \r
1207     ;; sort used to be here\r
1208     \r
1209     (setq parts (list head maxref tail numcols ref-regex has-reuse))\r
1210         \r
1211     ;; go back to top of table\r
1212     (goto-char top)\r
1213 \r
1214     parts))\r
1215 \r
1216 \r
1217 \r
1218 (defun org-index--sort-table (sort-column)\r
1219 \r
1220   (unless sort-column (setq sort-column (org-index--column-num 'sort)))\r
1221 \r
1222   (let (top \r
1223         bottom\r
1224         ref-field\r
1225         count-field\r
1226         count-special)\r
1227 \r
1228 \r
1229     ;; get boundaries of table\r
1230     (goto-char org-index--below-hline)\r
1231     (forward-line 0)\r
1232     (setq top (point))\r
1233     (while (org-at-table-p) (forward-line))\r
1234     (setq bottom (point))\r
1235     \r
1236     (save-restriction\r
1237       (narrow-to-region top bottom)\r
1238       (goto-char top)\r
1239       (sort-subr t\r
1240                  'forward-line \r
1241                  'end-of-line \r
1242                  (lambda ()\r
1243                    (let (ref\r
1244                          (ref-field (or (org-index--get-field 'ref) ""))\r
1245                          (count-field (or (org-index--get-field 'count) ""))\r
1246                          (count-special 0))\r
1247 \r
1248                      ;; get reference with leading zeroes, so it can be\r
1249                      ;; sorted as text\r
1250                      (string-match org-index--ref-regex ref-field)\r
1251                      (setq ref (format \r
1252                                 "%06d" \r
1253                                 (string-to-number \r
1254                                  (or (match-string 1 ref-field)\r
1255                                      "0"))))\r
1256 \r
1257                      ;; find out, if special token in count-column\r
1258                      (setq count-special (format "%d" \r
1259                                                  (- 2\r
1260                                                     (length (member count-field '(":missing:" ":reuse:"))))))\r
1261                    \r
1262                      ;; Construct different sort-keys according to\r
1263                      ;; requested sort column; prepend count-special to\r
1264                      ;; sort special entries at bottom of table, append ref\r
1265                      ;; as a secondary sort key\r
1266                      (cond \r
1267 \r
1268                       ((eq sort-column 'count)\r
1269                        (concat count-special\r
1270                                (format \r
1271                                 "%08d" \r
1272                                 (string-to-number (or (org-index--get-field 'count)\r
1273                                                       ""))) \r
1274                                ref))\r
1275                     \r
1276                       ((eq sort-column 'last-accessed)\r
1277                        (concat count-special\r
1278                                (org-index--get-field 'last-accessed) \r
1279                                " " \r
1280                                ref))\r
1281                     \r
1282                       ((eq sort-column 'ref)\r
1283                        (concat count-special\r
1284                                ref))\r
1285                     \r
1286                       (t (error "This is a bug: unmatched case '%s'" sort-column)))))\r
1287                \r
1288                  nil 'string<)))\r
1289     \r
1290   ;; align table\r
1291   (org-table-align)) \r
1292 \r
1293 \r
1294 (defun org-index--go-below-hline ()\r
1295 \r
1296   ;; go to heading of node\r
1297   (while (not (org-at-heading-p)) (forward-line -1))\r
1298   (forward-line 1)\r
1299   ;; go to table within node, but make sure we do not get into another node\r
1300   (while (and (not (org-at-heading-p))\r
1301               (not (org-at-table-p))\r
1302               (not (eq (point) (point-max)))) \r
1303     (forward-line 1))\r
1304   \r
1305   ;; check, if there really is a table\r
1306   (unless (org-at-table-p)\r
1307     (org-index--create-new-index \r
1308      t\r
1309      (format "Cannot find index table within node %s" org-index-id)))\r
1310 \r
1311   ;; go to first hline\r
1312   (while (and (not (org-at-table-hline-p))\r
1313               (org-at-table-p))\r
1314     (forward-line 1))\r
1315   \r
1316   ;; and check\r
1317   (unless (org-at-table-hline-p)\r
1318     (org-index--create-new-index \r
1319      nil \r
1320      "Cannot find hline within index table"))      \r
1321 \r
1322   (forward-line 1)\r
1323   (org-table-goto-column 1))\r
1324 \r
1325 \r
1326 \r
1327 (defun org-index--parse-headings (numcols)\r
1328 \r
1329   (let (columns)\r
1330 \r
1331     ;; Associate names of special columns with column-numbers\r
1332     (setq columns (copy-tree '((ref . 0) (link . 0) (created . 0) (last-accessed . 0) \r
1333                                (count . 0) (sort . nil) (copy . nil))))\r
1334 \r
1335     ;; For each column\r
1336     (dotimes (col numcols)\r
1337       (let* (field-flags ;; raw heading, consisting of file name and maybe\r
1338                          ;; flags (seperated by ";")\r
1339              field       ;; field name only\r
1340              field-symbol ;; and as a symbol\r
1341              flags       ;; flags from field-flags\r
1342              found)\r
1343 \r
1344         ;; parse field-flags into field and flags\r
1345         (setq field-flags (org-trim (org-table-get-field (+ col 1))))\r
1346         (if (string-match "^\\([^;]*\\);\\([a-z]+\\)$" field-flags)\r
1347             (progn \r
1348               (setq field (downcase (or (match-string 1 field-flags) "")))\r
1349               ;; get flags as list of characters\r
1350               (setq flags (mapcar 'string-to-char \r
1351                                   (split-string \r
1352                                    (downcase (match-string 2 field-flags)) \r
1353                                    "" t))))\r
1354           ;; no flags\r
1355           (setq field field-flags))\r
1356 \r
1357         (unless (string= field "") (setq field-symbol (intern (downcase field))))\r
1358 \r
1359         ;; Check, that no flags appear twice\r
1360         (mapc (lambda (x)\r
1361                 (when (memq (car x) flags)\r
1362                   (if (cdr (assoc (cdr x) columns))\r
1363                       (org-index--create-new-index \r
1364                        nil\r
1365                        (format "More than one heading is marked with flag '%c'" (car x))))))\r
1366               '((?s . sort)\r
1367                 (?c . copy)))\r
1368         \r
1369         ;; Process flags\r
1370         (if (memq ?s flags)\r
1371             (setcdr (assoc 'sort columns) field-symbol))\r
1372         (if (memq ?c flags)\r
1373             (setcdr (assoc 'copy columns) (+ col 1)))\r
1374         \r
1375         ;; Store columns in alist\r
1376         (setq found (assoc field-symbol columns))\r
1377         (when found\r
1378           (if (> (cdr found) 0) \r
1379               (org-index--create-new-index \r
1380                nil\r
1381                (format "'%s' appears two times as column heading" (downcase field))))\r
1382           (setcdr found (+ col 1)))))\r
1383 \r
1384     ;; check if all necessary informations have been specified\r
1385     (mapc (lambda (col) \r
1386             (unless (> (cdr (assoc col columns)) 0)\r
1387               (org-index--create-new-index \r
1388                nil\r
1389                (format "column '%s' has not been set" col))))\r
1390           '(ref link count created last-accessed))\r
1391 \r
1392     ;; use ref as a default sort-column\r
1393     (unless (cdr (assoc 'sort columns))\r
1394       (setcdr (assoc 'sort columns) 'ref))\r
1395     columns))\r
1396 \r
1397 \r
1398 \r
1399 (defun org-index--create-new-index (create-new-index reason)\r
1400   "Create a new empty index table with detailed explanation."\r
1401   (let (prompt buffer-name title firstref id)\r
1402 \r
1403     (setq prompt\r
1404           (if create-new-index\r
1405               (concat "There is this problem with the existing index table:\n\n   " reason "\n\nThis assistant will guide you to create a new one.\n\nDo you want to proceed ?")        \r
1406             (concat "The existing index table contains this error:\n\n   " reason "\n\nYou need to correct this error manually before proceeding. However, this assistant will help you to create an new initial index table with detailed comments, so that you may fix the errors in your existing table more easily.\n\nDo you want to proceed ?")))\r
1407     \r
1408     (unless (y-or-n-p prompt) \r
1409       (message "Cannot proceed without a valid index table: %s" reason)\r
1410       ;; show existing index\r
1411       (when (and org-index--buffer\r
1412                  org-index--point)\r
1413         (org-pop-to-buffer-same-window org-index--buffer)\r
1414         (goto-char org-index--point)\r
1415         (org-show-context)\r
1416         (show-subtree)\r
1417         (recenter 1)\r
1418         (delete-other-windows))\r
1419       (throw 'created-new-index nil))\r
1420   \r
1421     (setq buffer-name (org-completing-read "Please choose the buffer, where the new node for the index table should be created; the new node will be inserted at its end.\n\nBuffer: " (mapcar 'buffer-name (org-buffer-list)) nil nil))\r
1422 \r
1423     (setq title (read-from-minibuffer "Please enter the title of the index node: "))\r
1424 \r
1425     (while (progn\r
1426              (setq firstref (read-from-minibuffer "Please enter your first reference-number. This is a number preceeded by some non-digit chars and optionally followed by some more non-digit chars, e.g. 'R1', '-1-' or '#1#' (and your initial number does not need to be '1'). The format of your reference-numbers only needs to make sense for yourself, so that you can spot it easily in your texts or write it on a piece of paper; it should however not already appear to frequently within your existing notes, to avoid too many false hits when searching.\n\nPlease choose: "))\r
1427              (if (string-match "^[^0-9]+[0-9]+[^0-9]*$" firstref)\r
1428                  nil\r
1429                (let (desc)\r
1430                  ;; firstref not okay, report details\r
1431                  (setq desc\r
1432                        (cond ((string= firstref "") "is empty") \r
1433                              ((not (string-match "^[^0-9]+" firstref)) "starts with a digit")\r
1434                              ((not (string-match "^[^0-9]+[0-9]+" firstref)) "does not contain a number")\r
1435                              ((not (string-match "^[^0-9]+[0-9]+[^0-9]*$" firstref)) "contains more than one sequence of digits")))\r
1436                  (read-from-minibuffer (format "Your input '%s' does not meet the requirements because it %s. Please hit RET and try again " firstref desc)))\r
1437                t)))\r
1438 \r
1439     (with-current-buffer buffer-name\r
1440       (goto-char (point-max))\r
1441       (insert (format "\n\n* %s %s\n" firstref title))\r
1442       (insert "\n\n  Below you find your initial index table, which will grow over time.\n"\r
1443               "  Following that your may read its detailed explanation, which will help you,\n"\r
1444               "  to adopt org-index to your needs. This however is optional reading and not\n" \r
1445               "  required to start using org-index.\n\n")\r
1446 \r
1447       (setq id (org-id-get-create))\r
1448       (insert (format "\r
1449 \r
1450   |     |      |         |         |               | comment |\r
1451   | ref | link | created | count;s | last-accessed | ;c      |\r
1452   |     | <4>  |         |         |               |         |\r
1453   |-----+------+---------+---------+---------------+---------|\r
1454   | %s  | %s   | %s      |         |               | %s      |\r
1455 \r
1456\r
1457                       firstref\r
1458                       id\r
1459                       (with-temp-buffer (org-insert-time-stamp nil nil t))\r
1460                       "This node"))\r
1461 \r
1462 \r
1463       (insert "\r
1464 \r
1465   Detailed explanation:\r
1466 \r
1467 \r
1468   The index table above has three lines of headings above the first\r
1469   hline:\r
1470 \r
1471   - The first one is ignored by org-index, and you can use it to\r
1472     give meaningful names to columns. In the table above only one\r
1473     column has a name (\"comment\"). This line is optional.\r
1474 \r
1475   - The second line is the most important one, because it\r
1476     contains the configuration information for org-index; please\r
1477     read further below for its format.\r
1478 \r
1479   - The third line is again optional; it may only specify the\r
1480     widths of the individual columns (e.g. <4>).\r
1481 \r
1482   The columns get their meaning by the second line of headings;\r
1483   specifically by one of the keywords (e.g. \"ref\") or a flag\r
1484   seperated by a semicolon (e.g. \";s\").\r
1485 \r
1486 \r
1487 \r
1488   The keywords and flags are:\r
1489 \r
1490 \r
1491   - ref: This contains the reference, which consists of a decorated\r
1492     number, which is incremented for each new line. References are\r
1493     meant to be used in org-mode headlines or outside of orgĀ“,\r
1494     e.g. within folder names.\r
1495 \r
1496   - link: org-mode link pointing to the matching location within org.\r
1497 \r
1498   - created: When has this line been created ?\r
1499 \r
1500   - count: How many times has this line accessed ? The trailing\r
1501     flag \"s\" makes the table beeing sorted after\r
1502     this column, so that often used entries appear at the top of\r
1503     the table.\r
1504 \r
1505   - last-accessed: When has this line ben accessed\r
1506 \r
1507   - The last column above has no keyword, only the flag \"c\",\r
1508     which makes its content beeing copied under certain\r
1509     conditions. It is typically used for comments.\r
1510 \r
1511   The sequence of columns does not matter. You may reorder them any\r
1512   way you like. Columns are found by their name, which appears in\r
1513   the second line of headings.\r
1514 \r
1515   You can add further columns or even remove the last column. All\r
1516   other columns are required.\r
1517 \r
1518 \r
1519   Finally: This node needs not be a top level node; its name is\r
1520   completely at you choice; it is found through its ID only.\r
1521 \r
1522 ")\r
1523 \r
1524 \r
1525       (while (not (org-at-table-p)) (forward-line -1))\r
1526       (org-table-align)\r
1527       (while (not (org-at-heading-p)) (forward-line -1))\r
1528       \r
1529       ;; present results to user\r
1530       (if (and (not create-new-index)\r
1531                org-index--buffer\r
1532                org-index--point)\r
1533           \r
1534           ;; we had an error with the existing table, so present old and new one\r
1535           (progn\r
1536             ;; show existing index\r
1537             (org-pop-to-buffer-same-window org-index--buffer)\r
1538             (goto-char org-index--point)\r
1539             (org-show-context)\r
1540             (show-subtree)\r
1541             (recenter 1)\r
1542             (delete-other-windows)\r
1543             ;; show new index\r
1544             (select-window (split-window-vertically))\r
1545             (org-pop-to-buffer-same-window buffer-name)\r
1546             (org-id-goto id)\r
1547             (org-show-context)    \r
1548             (show-subtree)\r
1549             (recenter 1)\r
1550             (message "Please compare your existing index (upper window) and a temporary new one (lower window) to correct the previous error (\"%s\"); the explanations following the new index table should help." reason))\r
1551 \r
1552         ;; Only show the new index\r
1553         (org-pop-to-buffer-same-window buffer-name)\r
1554         (delete-other-windows)\r
1555         (org-id-goto id)\r
1556         (org-show-context)    \r
1557         (show-subtree)\r
1558         (recenter 1)\r
1559         (setq org-index-id id)\r
1560         (if (y-or-n-p "This is your new index table; Do you want to save its id to make it permanent ? ")\r
1561             (progn\r
1562               (customize-save-variable 'org-index-id id)\r
1563               (message "Saved org-index-id '%s' to %s" org-index-id custom-file))\r
1564           (let (sq)\r
1565             (setq sq (format "(setq org-index-id \"%s\")" org-index-id))\r
1566             (kill-new sq)\r
1567             (message "Did not make the id of the new index permamanent; you may want to put\n\n   %s\n\ninto your own initialization; it is copied already, just yank it." sq)))))\r
1568     ;; cannot handle this situation in higher code, but do not want to finish with an error\r
1569     (throw 'created-new-index nil)))\r
1570 \r
1571 \r
1572 \r
1573 \r
1574 (defun org-index--update-line (ref-or-link)\r
1575 \r
1576   (let (initial\r
1577         found\r
1578         count-field)\r
1579 \r
1580     (with-current-buffer org-index--buffer\r
1581       \r
1582       ;; search reference or link, if given (or assume, that we are already positioned right)\r
1583       (when ref-or-link\r
1584         (setq initial (point))\r
1585         (goto-char org-index--below-hline)\r
1586         (while (and (org-at-table-p)\r
1587                     (not (or (string= ref-or-link (org-index--get-field 'ref))\r
1588                              (string= ref-or-link (org-index--get-field 'link)))))\r
1589           (forward-line)))\r
1590       \r
1591       (if (not (org-at-table-p))\r
1592           (error "Did not find reference or link '%s'" ref-or-link)\r
1593         (setq count-field (org-index--get-field 'count))\r
1594 \r
1595         ;; update count field only if number or empty; leave :missing: and :reuse: as is\r
1596         (if (or (not count-field)\r
1597                 (string-match "^[0-9]+$" count-field))\r
1598             (org-index--get-field 'count\r
1599                                     (number-to-string \r
1600                                      (+ 1 (string-to-number (or count-field "0"))))))\r
1601 \r
1602         ;; update timestamp\r
1603         (org-table-goto-column (org-index--column-num 'last-accessed))\r
1604         (org-table-blank-field)\r
1605         (org-insert-time-stamp nil t t)\r
1606 \r
1607         (setq found t))\r
1608       \r
1609       (if initial (goto-char initial))\r
1610       \r
1611       found)))\r
1612 \r
1613 \r
1614 \r
1615 (defun org-index--get-field (key &optional value)\r
1616   (let (field)\r
1617     (setq field (org-trim (org-table-get-field (cdr (assoc key org-index--columns)) value)))\r
1618     (if (string= field "") (setq field nil))\r
1619     \r
1620     field))\r
1621 \r
1622 \r
1623 (defun org-index--column-num (key)\r
1624   (cdr (assoc key org-index--columns)))\r
1625 \r
1626 \r
1627 (defun org-index--make-guarded-search (ref &optional dont-quote)\r
1628   (concat "\\b" (if dont-quote ref (regexp-quote ref)) "\\b"))\r
1629 \r
1630 \r
1631 (defun org-index-get-ref-regex-format ()\r
1632   "return cons-cell with regular expression and format for references"\r
1633   (unless org-index--ref-regex\r
1634     (org-index-1 'parse))\r
1635   (cons (org-index--make-guarded-search org-index--ref-regex 'dont-quote) org-index--ref-format))\r
1636   \r
1637 \r
1638 (defun org-index--do-occur (initial-search)\r
1639   (let (\r
1640         (occur-buffer-name "*org-index-occur*")\r
1641         (word "") ; last word to search for growing and shrinking on keystrokes\r
1642         (prompt "Search for: ")\r
1643         words     ; list of other words that must match too\r
1644         occur-buffer \r
1645         lines-to-show                 ; number of lines to show in window\r
1646         start-of-lines                ; position, where lines begin\r
1647         left-off-at                   ; stack of last positions in index table\r
1648         after-inserted                ; in occur-buffer\r
1649         lines-visible                 ; in occur-buffer\r
1650         below-hline-bol               ; below-hline and at bol\r
1651         exit-gracefully               ; true if normal exit\r
1652         in-c-backspace                ; true while processing C-backspace\r
1653         ret from to key)\r
1654         \r
1655     ;; clear buffer\r
1656     (if (get-buffer "*org-index-occur*")\r
1657         (kill-buffer occur-buffer-name))\r
1658     (setq occur-buffer (get-buffer-create "*org-index-occur*"))\r
1659 \r
1660     (with-current-buffer org-index--buffer\r
1661       (let ((initial (point)))\r
1662         (goto-char org-index--below-hline)\r
1663         (forward-line 0)\r
1664         (setq below-hline-bol (point))\r
1665         (goto-char initial)))\r
1666     \r
1667     (org-pop-to-buffer-same-window occur-buffer)\r
1668     (toggle-truncate-lines 1)\r
1669 \r
1670     (unwind-protect          ; to reset cursor-shape even in case of errors\r
1671         (progn\r
1672           \r
1673           ;; fill in header\r
1674           (erase-buffer)\r
1675           (insert (concat "Incremental search, showing one window of matches.\n"\r
1676                           "Use DEL and C-DEL to erase, cursor keys to move, RET to find heading.\n\n"))\r
1677           (setq start-of-lines (point))\r
1678           (setq cursor-type 'hollow)\r
1679           \r
1680           ;; get window size of occur-buffer as number of lines to be searched\r
1681           (setq lines-to-show (+ (- (window-body-height) (line-number-at-pos)) 1))\r
1682           \r
1683 \r
1684           ;; fill initially\r
1685           (setq ret (org-index--get-matching-lines nil lines-to-show below-hline-bol))\r
1686           (when (car ret)\r
1687             (insert (cdr ret))\r
1688             (setq left-off-at (cons (car ret) nil))\r
1689             (setq after-inserted (cons (point) nil)))\r
1690 \r
1691           ;; read keys\r
1692           (while \r
1693               (progn\r
1694                 (goto-char start-of-lines)\r
1695                 (setq lines-visible 0)\r
1696                 \r
1697                 ;; use initial-search (if present) to simulate keyboard input\r
1698                 (if (and initial-search \r
1699                          (> (length initial-search) 0))\r
1700                     (progn \r
1701                       (setq key (string-to-char (substring initial-search 0 1)))\r
1702                       (if (length initial-search) \r
1703                           (setq initial-search (substring initial-search 1))))\r
1704                   (if in-c-backspace \r
1705                       (setq key 'backspace)\r
1706                     (setq key (read-event\r
1707                                (format "%s %s" \r
1708                                        prompt \r
1709                                        (mapconcat 'identity (reverse (cons word words)) ","))))\r
1710 \r
1711                     (setq exit-gracefully (memq key (list 'return 'up 'down 'left 'right)))))\r
1712                 \r
1713                 (not exit-gracefully))\r
1714             \r
1715             (cond \r
1716 \r
1717              ((eq key 'C-backspace)\r
1718 \r
1719               (setq in-c-backspace t))\r
1720 \r
1721              ((eq key 'backspace)              ; erase last char\r
1722 \r
1723               (if (= (length word) 0)\r
1724 \r
1725                   ;; nothing more to delete\r
1726                   (setq in-c-backspace nil)\r
1727 \r
1728                 ;; unhighlight longer match\r
1729                 (let ((case-fold-search t))\r
1730                 (unhighlight-regexp (regexp-quote word)))\r
1731 \r
1732                 ;; chars left shorten word\r
1733                 (setq word (substring word 0 -1))\r
1734                 (when (= (length word) 0) ; when nothing left, use next word from list\r
1735                   (setq word (car words))\r
1736                   (setq words (cdr words))\r
1737                   (setq in-c-backspace nil))\r
1738                 \r
1739                 ;; remove everything, that has been added for char just deleted\r
1740                 (when (cdr after-inserted)\r
1741                   (setq after-inserted (cdr after-inserted))\r
1742                   (goto-char (car after-inserted))\r
1743                   (delete-region (point) (point-max)))\r
1744 \r
1745                 ;; back up last position in index table too\r
1746                 (when (cdr left-off-at) \r
1747                   (setq left-off-at (cdr left-off-at)))\r
1748 \r
1749                 ;; go through buffer and check, if any invisible line should now be shown\r
1750                 (goto-char start-of-lines)\r
1751                 (while (< (point) (point-max))\r
1752                   (if (outline-invisible-p)\r
1753                       (progn\r
1754                         (setq from (line-beginning-position) \r
1755                               to (line-beginning-position 2))\r
1756 \r
1757                         ;; check for matches\r
1758                         (when (org-index--test-words (cons word words) (buffer-substring from to))\r
1759                           (when (<= lines-visible lines-to-show) ; show, if more lines required\r
1760                             (outline-flag-region from to nil) \r
1761                             (incf lines-visible))))\r
1762 \r
1763                     ;; already visible, just count\r
1764                     (incf lines-visible))\r
1765 \r
1766                   (forward-line 1))\r
1767 \r
1768                 ;; highlight shorter word\r
1769                 (unless (= (length word) 0)\r
1770                   (let ((case-fold-search t))\r
1771                     (highlight-regexp (regexp-quote word) 'isearch)))))\r
1772 \r
1773 \r
1774              ((eq key ?,)         ; comma: enter an additional search word\r
1775 \r
1776               ;; push current word and clear, no need to change display\r
1777               (setq words (cons word words))\r
1778               (setq word ""))\r
1779 \r
1780 \r
1781              ((and (characterp key)\r
1782                    (aref printable-chars key)) ; any other char: add to current search word\r
1783 \r
1784 \r
1785               ;; unhighlight short word\r
1786               (unless (= (length word) 0)\r
1787                 (let ((case-fold-search t))\r
1788                   (unhighlight-regexp (regexp-quote word))))\r
1789 \r
1790               ;; add to word\r
1791               (setq word (concat word (downcase (string key))))\r
1792 \r
1793               ;; hide lines, that do not match longer word any more\r
1794               (while (< (point) (point-max))\r
1795                 (unless (outline-invisible-p)\r
1796                   (setq from (line-beginning-position) \r
1797                         to (line-beginning-position 2))\r
1798 \r
1799                   ;; check for matches\r
1800                   (if (org-index--test-words (list word) (buffer-substring from to))\r
1801                       (incf lines-visible)            ; count as visible\r
1802                     (outline-flag-region from to t))) ; hide\r
1803 \r
1804                 (forward-line 1))\r
1805 \r
1806               ;; duplicate top of stacks; eventually overwritten below\r
1807               (setq left-off-at (cons (car left-off-at) left-off-at))\r
1808               (setq after-inserted (cons (car after-inserted) after-inserted))\r
1809 \r
1810               ;; get new lines from index table\r
1811               (when (< lines-visible lines-to-show)\r
1812                 (setq ret (org-index--get-matching-lines (cons word words) \r
1813                                                             (- lines-to-show lines-visible) \r
1814                                                             (car left-off-at)))\r
1815 \r
1816                 (when (car ret)\r
1817                   (insert (cdr ret))\r
1818                   (setcar left-off-at (car ret))\r
1819                   (setcar after-inserted (point))))\r
1820 \r
1821               ;; highlight longer word\r
1822               (let ((case-fold-search t))\r
1823                 (highlight-regexp (regexp-quote word) 'isearch)))))\r
1824           \r
1825           ;; search is done collect and brush up results\r
1826           ;; remove any lines, that are still invisible\r
1827           (goto-char start-of-lines)\r
1828           (while (< (point) (point-max))\r
1829             (if (outline-invisible-p)\r
1830                 (delete-region (line-beginning-position) (line-beginning-position 2))\r
1831               (forward-line 1)))\r
1832 \r
1833           ;; get all the rest\r
1834           (message "Getting all matches ...")\r
1835           (setq ret (org-index--get-matching-lines (cons word words) 0 (car left-off-at)))\r
1836           (message "done.")\r
1837           (insert (cdr ret)))\r
1838       \r
1839       ;; postprocessing even for non graceful exit\r
1840       (setq cursor-type t)\r
1841       ;; replace previous heading\r
1842       (let ((numlines (count-lines (point) start-of-lines)))\r
1843         (goto-char start-of-lines)\r
1844         (forward-line -1)\r
1845         (delete-region (point-min) (point))\r
1846         (insert (format  (concat (if exit-gracefully \r
1847                                      "Search is done; showing all %d matchs.\n"\r
1848                                    "Search aborted; showing only some matches.\n")\r
1849                                  "Use cursor keys to move, press RET to find heading.\n")\r
1850                          numlines)))\r
1851       (forward-line))\r
1852 \r
1853     ;; install keyboard-shortcuts within occur-buffer\r
1854     (let ((keymap (make-sparse-keymap))\r
1855           fun-on-ret)\r
1856       (set-keymap-parent keymap text-mode-map)\r
1857 \r
1858       (setq fun-on-ret (lambda () (interactive) \r
1859                          (let ((ref (org-index--get-field 'ref)) \r
1860                                (link (org-index--get-field 'link)))\r
1861                            (org-index-1 'head\r
1862                                          (or link ref) ;; prefer link\r
1863                                          (if link t nil)))))      \r
1864 \r
1865       (define-key keymap (kbd "RET") fun-on-ret)\r
1866       (use-local-map keymap)\r
1867     \r
1868       ;; perform action according to last char\r
1869       (cond \r
1870        ((eq key 'return)\r
1871         (funcall fun-on-ret))\r
1872 \r
1873        ((eq key 'up)\r
1874          (forward-line -1))\r
1875 \r
1876        ((eq key 'down)\r
1877          (forward-line 1))\r
1878 \r
1879        ((eq key 'left)\r
1880          (forward-char -1))\r
1881 \r
1882        ((eq key 'right)\r
1883          (forward-char 1))))))\r
1884 \r
1885 \r
1886 (defun org-index--get-matching-lines (words numlines start-from)\r
1887   (let ((numfound 0)\r
1888         pos\r
1889         initial line lines)\r
1890     \r
1891     (with-current-buffer org-index--buffer\r
1892 \r
1893       ;; remember initial pos and start at requested\r
1894       (setq initial (point))\r
1895       (goto-char start-from) \r
1896       \r
1897       ;; loop over buffer until we have found enough lines\r
1898       (while (and (or (< numfound numlines)\r
1899                       (= numlines 0))\r
1900                   (org-at-table-p))\r
1901 \r
1902         ;; check each word\r
1903         (setq line (buffer-substring (line-beginning-position) (line-beginning-position 2)))\r
1904         (when (org-index--test-words words line) \r
1905           (setq lines (concat lines line))\r
1906           (incf numfound))\r
1907         (forward-line 1)\r
1908         (setq pos (point)))\r
1909 \r
1910       ;; return to initial position\r
1911       (goto-char initial))\r
1912 \r
1913     (unless lines (setq lines ""))\r
1914     (cons pos lines)))\r
1915 \r
1916 \r
1917 (defun org-index--test-words (words line)\r
1918   (let ((found-all t))\r
1919     (setq line (downcase line))\r
1920     (catch 'not-found\r
1921         (dolist (w words)\r
1922           (or (search w line)\r
1923               (throw 'not-found nil)))\r
1924         t)))\r
1925 \r
1926 \r
1927 (defadvice org-mark-ring-goto (after org-index--advice-text-to-yank activate)\r
1928   "Make text from org-index available for yank."\r
1929   (when org-index--text-to-yank\r
1930       (kill-new org-index--text-to-yank)\r
1931       (message (format "Ready to yank '%s'" org-index--text-to-yank))\r
1932       (setq org-index--text-to-yank nil)))\r
1933 \r
1934 \r
1935 (provide 'org-index)\r
1936 \r
1937 ;; Local Variables:\r
1938 ;; fill-column: 75\r
1939 ;; comment-column: 50\r
1940 ;; End:\r
1941 \r
1942 ;;; org-index.el ends here\r