summaryrefslogtreecommitdiffstats
path: root/emacs.d
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--emacs.d/lisp/deft.el764
1 files changed, 764 insertions, 0 deletions
diff --git a/emacs.d/lisp/deft.el b/emacs.d/lisp/deft.el
new file mode 100644
index 0000000..9b010b8
--- /dev/null
+++ b/emacs.d/lisp/deft.el
@@ -0,0 +1,764 @@
+;;; deft.el --- quickly browse, filter, and edit plain text notes
+
+;; Copyright (C) 2011 Jason R. Blevins <jrblevin@sdf.org>
+;; All rights reserved.
+
+;; Redistribution and use in source and binary forms, with or without
+;; modification, are permitted provided that the following conditions are met:
+;; 1. Redistributions of source code must retain the above copyright
+;; notice, this list of conditions and the following disclaimer.
+;; 2. Redistributions in binary form must reproduce the above copyright
+;; notice, this list of conditions and the following disclaimer in the
+;; documentation and/or other materials provided with the distribution.
+;; 3. Neither the names of the copyright holders nor the names of any
+;; contributors may be used to endorse or promote products derived from
+;; this software without specific prior written permission.
+
+;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+;; POSSIBILITY OF SUCH DAMAGE.
+
+;; Version: 0.3
+;; Author: Jason R. Blevins <jrblevin@sdf.org>
+;; Keywords: plain text, notes, Simplenote, Notational Velocity
+;; URL: http://jblevins.org/projects/deft/
+
+;; This file is not part of GNU Emacs.
+
+;;; Commentary:
+
+;; Deft is an Emacs mode for quickly browsing, filtering, and editing
+;; directories of plain text notes, inspired by Notational Velocity.
+;; It was designed for increased productivity when writing and taking
+;; notes by making it fast and simple to find the right file at the
+;; right time and by automating many of the usual tasks such as
+;; creating new files and saving files.
+
+;; Deft is open source software and may be freely distributed and
+;; modified under the BSD license. Version 0.3 is the latest stable
+;; version, released on September 11, 2011. You may download it
+;; directly here:
+
+;; * [deft.el](http://jblevins.org/projects/deft/deft.el)
+
+;; To follow or contribute to Deft development, you can either
+;; [browse](http://jblevins.org/git/deft.git) or clone the Git
+;; repository:
+
+;; git clone git://jblevins.org/git/deft.git
+
+;; ![File Browser](http://jblevins.org/projects/deft/browser.png)
+
+;; The Deft buffer is simply a file browser which lists the titles of
+;; all text files in the Deft directory followed by short summaries
+;; and last modified times. The title is taken to be the first line
+;; of the file and the summary is extracted from the text that
+;; follows. Files are sorted in terms of the last modified date, from
+;; newest to oldest.
+
+;; All Deft files or notes are simple plain text files where the first
+;; line contains a title. As an example, the following directory
+;; structure generated the screenshot above.
+;;
+;; % ls ~/.deft
+;; about.txt browser.txt directory.txt operations.txt
+;; ack.txt completion.txt extensions.txt text-mode.txt
+;; binding.txt creation.txt filtering.txt
+;;
+;; % cat ~/.deft/about.txt
+;; About
+;;
+;; An Emacs mode for slicing and dicing plain text files.
+
+;; ![Filtering](http://jblevins.org/projects/deft/filter.png)
+
+;; Deft's primary operation is searching and filtering. The list of
+;; files can be limited or filtered using a search string, which will
+;; match both the title and the body text. To initiate a filter,
+;; simply start typing. Filtering happens on the fly. As you type,
+;; the file browser is updated to include only files that match the
+;; current string.
+
+;; To open the first matching file, simply press `RET`. If no files
+;; match your search string, pressing `RET` will create a new file
+;; using the string as the title. This is a very fast way to start
+;; writing new notes. The filename will be generated automatically.
+;; If you prefer to provide a specific filename, use `C-RET` instead.
+
+;; To open files other than the first match, navigate up and down
+;; using `C-p` and `C-n` and press `RET` on the file you want to open.
+
+;; Press `C-c C-c` to clear the filter string and display all files
+;; and `C-c C-g` to refresh the file browser using the current filter
+;; string.
+
+;; Static filtering is also possible by pressing `C-c C-l`. This is
+;; sometimes useful on its own, and it may be preferable in some
+;; situations, such as over slow connections or on older systems,
+;; where interactive filtering performance is poor.
+
+;; Common file operations can also be carried out from within Deft.
+;; Files can be renamed using `C-c C-r` or deleted using `C-c C-d`.
+;; New files can also be created using `C-c C-n` for quick creation or
+;; `C-c C-m` for a filename prompt. You can leave Deft at any time
+;; with `C-c C-q`.
+
+;; Files opened with deft are automatically saved after Emacs has been
+;; idle for a customizable number of seconds. This value is a floating
+;; point number given by `deft-auto-save-interval' (default: 1.0).
+
+;; Getting Started
+;; ---------------
+
+;; To start using it, place it somewhere in your Emacs load-path and
+;; add the line
+
+;; (require 'deft)
+
+;; in your `.emacs` file. Then run `M-x deft` to start. It is useful
+;; to create a global keybinding for the `deft` function (e.g., a
+;; function key) to start it quickly (see below for details).
+
+;; When you first run Deft, it will complain that it cannot find the
+;; `~/.deft` directory. You can either create a symbolic link to
+;; another directory where you keep your notes or run `M-x deft-setup`
+;; to create the `~/.deft` directory automatically.
+
+;; One useful way to use Deft is to keep a directory of notes in a
+;; Dropbox folder. This can be used with other applications and
+;; mobile devices, for example, Notational Velocity or Simplenote
+;; on OS X, Elements on iOS, or Epistle on Android.
+
+;; Customization
+;; -------------
+
+;; Customize the `deft` group to change the functionality.
+
+;; By default, Deft looks for notes by searching for files with the
+;; extension `.txt` in the `~/.deft` directory. You can customize
+;; both the file extension and the Deft directory by running
+;; `M-x customize-group` and typing `deft`. Alternatively, you can
+;; configure them in your `.emacs` file:
+
+;; (setq deft-extension "txt")
+;; (setq deft-directory "~/Dropbox/notes")
+
+;; You can also customize the major mode that Deft uses to edit files,
+;; either through `M-x customize-group` or by adding something like
+;; the following to your `.emacs` file:
+
+;; (setq deft-text-mode 'markdown-mode)
+
+;; Note that the mode need not be a traditional text mode. If you
+;; prefer to write notes as LaTeX fragments, for example, you could
+;; set `deft-extension' to "tex" and `deft-text-mode' to `latex-mode'.
+
+;; You can easily set up a global keyboard binding for Deft. For
+;; example, to bind it to F8, add the following code to your `.emacs`
+;; file:
+
+;; (global-set-key [f8] 'deft)
+
+;; The faces used for highlighting various parts of the screen can
+;; also be customized. By default, these faces inherit their
+;; properties from the standard font-lock faces defined by your current
+;; color theme.
+
+;; Acknowledgments
+;; ---------------
+
+;; Thanks to Konstantinos Efstathiou for writing simplnote.el, from
+;; which I borrowed liberally, and to Zachary Schneirov for writing
+;; Notational Velocity, which I have never had the pleasure of using,
+;; but whose functionality and spirit I wanted to bring to other
+;; platforms, such as Linux, via Emacs.
+
+;; History
+;; -------
+
+;; Version 0.3 (2011-09-11):
+
+;; * Internationalization: support filtering with multibyte characters.
+
+;; Version 0.2 (2011-08-22):
+
+;; * Match filenames when filtering.
+;; * Automatically save opened files (optional).
+;; * Address some byte-compilation warnings.
+
+;; Deft was originally written by Jason Blevins.
+;; The initial version, 0.1, was released on August 6, 2011.
+
+;;; Code:
+
+(require 'widget)
+
+;; Customization
+
+(defgroup deft nil
+ "Emacs Deft mode."
+ :group 'local)
+
+(defcustom deft-directory (expand-file-name "~/.deft/")
+ "Deft directory."
+ :type 'directory
+ :safe 'stringp
+ :group 'deft)
+
+(defcustom deft-extension "txt"
+ "Deft file extension."
+ :type 'string
+ :safe 'stringp
+ :group 'deft)
+
+(defcustom deft-text-mode 'text-mode
+ "Default mode used for editing files."
+ :type 'function
+ :group 'deft)
+
+(defcustom deft-auto-save-interval 1.0
+ "Idle time in seconds before automatically saving buffers opened by Deft.
+Set to zero to disable."
+ :type 'float
+ :group 'deft)
+
+;; Faces
+
+(defgroup deft-faces nil
+ "Faces used in Deft mode"
+ :group 'deft
+ :group 'faces)
+
+(defface deft-header-face
+ '((t :inherit font-lock-keyword-face :bold t))
+ "Face for Deft header."
+ :group 'deft-faces)
+
+(defface deft-filter-string-face
+ '((t :inherit font-lock-string-face))
+ "Face for Deft filter string."
+ :group 'deft-faces)
+
+(defface deft-title-face
+ '((t :inherit font-lock-function-name-face :bold t))
+ "Face for Deft file titles."
+ :group 'deft-faces)
+
+(defface deft-separator-face
+ '((t :inherit font-lock-comment-delimiter-face))
+ "Face for Deft separator string."
+ :group 'deft-faces)
+
+(defface deft-summary-face
+ '((t :inherit font-lock-comment-face))
+ "Face for Deft file summary strings."
+ :group 'deft-faces)
+
+(defface deft-time-face
+ '((t :inherit font-lock-variable-name-face))
+ "Face for Deft last modified times."
+ :group 'deft-faces)
+
+;; Constants
+
+(defconst deft-version "0.3")
+
+(defconst deft-buffer "*Deft*"
+ "Deft buffer name.")
+
+(defconst deft-separator " --- "
+ "Text used to separate file titles and summaries.")
+
+(defconst deft-line-width 63
+ "Total width of lines in file browser, not including modified time.")
+
+;; Global variables
+
+(defvar deft-mode-hook nil
+ "Hook run when entering Deft mode.")
+
+(defvar deft-filter-regexp nil
+ "Current filter regexp used by Deft.")
+
+(defvar deft-current-files nil
+ "List of files matching current filter.")
+
+(defvar deft-all-files nil
+ "List of files matching current filter.")
+
+(defvar deft-hash-contents nil
+ "Hash containing complete cached file contents, keyed by filename.")
+
+(defvar deft-hash-mtimes nil
+ "Hash containing cached file modification times, keyed by filename.")
+
+(defvar deft-hash-titles nil
+ "Hash containing cached file titles, keyed by filename.")
+
+(defvar deft-hash-summaries nil
+ "Hash containing cached file summaries, keyed by filename.")
+
+(defvar deft-auto-save-buffers nil
+ "List of buffers that will be automatically saved.")
+
+;; File processing
+
+(defun deft-chomp (str)
+ "Trim leading and trailing whitespace from STR."
+ (let ((s str))
+ (replace-regexp-in-string "\\(^[[:space:]\n]*\\|[[:space:]\n]*$\\)" "" s)))
+
+(defun deft-base-filename (file)
+ "Strip the path and extension from filename FILE."
+ (setq file (file-name-nondirectory file))
+ (setq file (replace-regexp-in-string (concat "\." deft-extension "$") "" file)))
+
+(defun deft-find-all-files ()
+ "Return a list of all files in the Deft directory."
+ (if (file-exists-p deft-directory)
+ (let (files result)
+ ;; List all files
+ (setq files
+ (directory-files deft-directory t
+ (concat "\." deft-extension "$") t))
+ ;; Filter out files that are not readable or are directories
+ (dolist (file files)
+ (when (and (file-readable-p file)
+ (not (file-directory-p file)))
+ (setq result (cons file result))))
+ result)))
+
+(defun deft-parse-title (contents)
+ "Parse the given file CONTENTS and determine the title.
+The title is taken to be the first non-empty line of a file."
+ (let ((begin (string-match "^.+$" contents)))
+ (when begin
+ (substring contents begin (min (match-end 0)
+ (+ begin deft-line-width))))))
+
+(defun deft-parse-summary (contents title)
+ "Parse the file CONTENTS, given the TITLE, and extract a summary.
+The summary is a string extracted from the contents following the
+title."
+ (let* ((contents (replace-regexp-in-string "\n" " " contents))
+ (begin (when title (string-match (regexp-quote title) contents)))
+ (size (- deft-line-width (length deft-separator) (match-end 0))))
+ (when begin
+ (when (< 0 size)
+ (setq contents (substring contents (match-end 0) (length contents)))
+ (setq contents (deft-chomp contents))
+ (substring contents 0 (min size (length contents)))))))
+
+(defun deft-cache-file (file)
+ "Update file cache if FILE exists."
+ (when (file-exists-p file)
+ (let ((mtime-cache (deft-file-mtime file))
+ (mtime-file (nth 5 (file-attributes file))))
+ (if (or (not mtime-cache)
+ (time-less-p mtime-cache mtime-file))
+ (deft-cache-newer-file file mtime-file)))))
+
+(defun deft-cache-newer-file (file mtime)
+ "Update cached information for FILE with given MTIME."
+ ;; Modification time
+ (puthash file mtime deft-hash-mtimes)
+ (let (contents title)
+ ;; Contents
+ (with-current-buffer (get-buffer-create "*Deft temp*")
+ (insert-file-contents file nil nil nil t)
+ (setq contents (concat (buffer-string))))
+ (puthash file contents deft-hash-contents)
+ ;; Title
+ (setq title (deft-parse-title contents))
+ (puthash file title deft-hash-titles)
+ ;; Summary
+ (puthash file (deft-parse-summary contents title) deft-hash-summaries))
+ (kill-buffer "*Deft temp*"))
+
+(defun deft-file-newer-p (file1 file2)
+ "Return non-nil if FILE1 was modified since FILE2 and nil otherwise."
+ (let (time1 time2)
+ (setq time1 (deft-file-mtime file1))
+ (setq time2 (deft-file-mtime file2))
+ (time-less-p time2 time1)))
+
+(defun deft-cache-initialize ()
+ "Initialize hash tables for caching files."
+ (setq deft-hash-contents (make-hash-table :test 'equal))
+ (setq deft-hash-mtimes (make-hash-table :test 'equal))
+ (setq deft-hash-titles (make-hash-table :test 'equal))
+ (setq deft-hash-summaries (make-hash-table :test 'equal)))
+
+(defun deft-cache-update ()
+ "Update cached file information."
+ (setq deft-all-files (deft-find-all-files)) ; List all files
+ (mapc 'deft-cache-file deft-all-files) ; Cache contents
+ (setq deft-all-files (deft-sort-files deft-all-files))) ; Sort by mtime
+
+;; Cache access
+
+(defun deft-file-contents (file)
+ "Retrieve complete contents of FILE from cache."
+ (gethash file deft-hash-contents))
+
+(defun deft-file-mtime (file)
+ "Retrieve modified time of FILE from cache."
+ (gethash file deft-hash-mtimes))
+
+(defun deft-file-title (file)
+ "Retrieve title of FILE from cache."
+ (gethash file deft-hash-titles))
+
+(defun deft-file-summary (file)
+ "Retrieve summary of FILE from cache."
+ (gethash file deft-hash-summaries))
+
+;; File list display
+
+(defun deft-print-header ()
+ "Prints the *Deft* buffer header."
+ (if deft-filter-regexp
+ (progn
+ (widget-insert
+ (propertize "Deft: " 'face 'deft-header-face))
+ (widget-insert
+ (propertize deft-filter-regexp 'face 'deft-filter-string-face)))
+ (widget-insert
+ (propertize "Deft" 'face 'deft-header-face)))
+ (widget-insert "\n\n"))
+
+(defun deft-buffer-setup ()
+ "Render the file browser in the *Deft* buffer."
+ (let ((inhibit-read-only t))
+ (erase-buffer))
+ (remove-overlays)
+ (deft-print-header)
+
+ ;; Print the files list
+ (if (not (file-exists-p deft-directory))
+ (widget-insert (deft-no-directory-message))
+ (if deft-current-files
+ (progn
+ (mapc 'deft-file-widget deft-current-files))
+ (widget-insert (deft-no-files-message))))
+
+ (use-local-map deft-mode-map)
+ (widget-setup)
+ (goto-char 1)
+ (forward-line 2))
+
+(defun deft-file-widget (file)
+ "Add a line to the file browser for the given FILE."
+ (when file
+ (let ((key (file-name-nondirectory file))
+ (text (deft-file-contents file))
+ (title (deft-file-title file))
+ (summary (deft-file-summary file))
+ (mtime (deft-file-mtime file)))
+ (widget-create 'link
+ :button-prefix ""
+ :button-suffix ""
+ :button-face 'deft-title-face
+ :format "%[%v%]"
+ :tag file
+ :help-echo "Edit this file"
+ :notify (lambda (widget &rest ignore)
+ (deft-open-file (widget-get widget :tag)))
+ (or title "[Empty file]"))
+ (when summary
+ (widget-insert (propertize deft-separator 'face 'deft-separator-face))
+ (widget-insert (propertize summary 'face 'deft-summary-face)))
+ (while (< (current-column) deft-line-width)
+ (widget-insert " "))
+ (widget-insert (propertize (format-time-string " %Y-%m-%d %H:%M" mtime)
+ 'face 'deft-time-face))
+ (widget-insert "\n"))))
+
+(defun deft-refresh ()
+ "Refresh the *Deft* buffer in the background."
+ (interactive)
+ (when (get-buffer deft-buffer)
+ (set-buffer deft-buffer)
+ (deft-cache-update)
+ (deft-filter-update)
+ (deft-buffer-setup)))
+
+(defun deft-no-directory-message ()
+ "Return a short message to display when the Deft directory does not exist."
+ (concat "Directory " deft-directory " does not exist.\n"))
+
+(defun deft-no-files-message ()
+ "Return a short message to display if no files are found."
+ (if deft-filter-regexp
+ "No files match the current filter string.\n"
+ "No files found."))
+
+;; File list file management actions
+
+(defun deft-open-file (file)
+ "Open FILE in a new buffer and setting its mode."
+ (prog1 (find-file file)
+ (funcall deft-text-mode)
+ (add-to-list 'deft-auto-save-buffers (buffer-name))
+ (add-hook 'after-save-hook
+ (lambda () (save-excursion (deft-refresh)))
+ nil t)))
+
+(defun deft-find-file (file)
+ "Find FILE interactively using the minibuffer."
+ (interactive "F")
+ (deft-open-file file))
+
+(defun deft-new-file-named (file)
+ "Create a new file named FILE (or interactively prompt for a filename).
+If the filter string is non-nil, use it as the title."
+ (interactive "sNew filename (without extension): ")
+ (setq file (concat (file-name-as-directory deft-directory)
+ file "." deft-extension))
+ (if (file-exists-p file)
+ (message (concat "Aborting, file already exists: " file))
+ (when deft-filter-regexp
+ (write-region deft-filter-regexp nil file nil))
+ (deft-open-file file)))
+
+(defun deft-new-file ()
+ "Create a new file quickly, with an automatically generated filename.
+If the filter string is non-nil, use it as the title."
+ (interactive)
+ (let (fmt filename counter temp-buffer)
+ (setq counter 0)
+ (setq fmt (concat "deft-%d." deft-extension))
+ (setq filename (concat deft-directory (format fmt counter)))
+ (while (or (file-exists-p filename)
+ (get-file-buffer filename))
+ (setq counter (1+ counter))
+ (setq filename (concat deft-directory (format fmt counter))))
+ (when deft-filter-regexp
+ (write-region (concat deft-filter-regexp "\n\n") nil filename nil))
+ (deft-open-file filename)
+ (with-current-buffer (get-file-buffer filename)
+ (goto-char (point-max)))))
+
+(defun deft-delete-file ()
+ "Delete the file represented by the widget at the point.
+If the point is not on a file widget, do nothing. Prompts before
+proceeding."
+ (interactive)
+ (let ((filename (widget-get (widget-at) :tag)))
+ (when filename
+ (when (y-or-n-p
+ (concat "Delete file " (file-name-nondirectory filename) "? "))
+ (delete-file filename)
+ (delq filename deft-current-files)
+ (delq filename deft-all-files)
+ (deft-refresh)))))
+
+(defun deft-rename-file ()
+ "Rename the file represented by the widget at the point.
+If the point is not on a file widget, do nothing."
+ (interactive)
+ (let (old-filename new-filename old-name new-name)
+ (setq old-filename (widget-get (widget-at) :tag))
+ (when old-filename
+ (setq old-name (deft-base-filename old-filename))
+ (setq new-name (read-string
+ (concat "Rename " old-name " to (without extension): ")))
+ (setq new-filename
+ (concat (file-name-as-directory deft-directory)
+ new-name "." deft-extension))
+ (rename-file old-filename new-filename)
+ (deft-refresh))))
+
+;; File list filtering
+
+(defun deft-sort-files (files)
+ "Sort FILES in reverse order by modified time."
+ (sort files (lambda (f1 f2) (deft-file-newer-p f1 f2))))
+
+(defun deft-filter-initialize ()
+ "Initialize the filter string (nil) and files list (all files)."
+ (interactive)
+ (setq deft-filter-regexp nil)
+ (setq deft-current-files deft-all-files))
+
+(defun deft-filter-update ()
+ "Update the filtered files list using the current filter regexp."
+ (if (not deft-filter-regexp)
+ (setq deft-current-files deft-all-files)
+ (setq deft-current-files (mapcar 'deft-filter-match-file deft-all-files))
+ (setq deft-current-files (delq nil deft-current-files))))
+
+(defun deft-filter-match-file (file)
+ "Return FILE if FILE matches the current filter regexp."
+ (if (or (string-match deft-filter-regexp (deft-file-title file))
+ (string-match deft-filter-regexp file)
+ (string-match deft-filter-regexp (deft-file-contents file)))
+ file))
+
+;; Filters that cause a refresh
+
+(defun deft-filter-clear ()
+ "Clear the current filter string and refresh the file browser."
+ (interactive)
+ (when deft-filter-regexp
+ (setq deft-filter-regexp nil)
+ (setq deft-current-files deft-all-files)
+ (deft-refresh))
+ (message "Filter cleared."))
+
+(defun deft-filter (str)
+ "Set the filter string to STR and update the file browser."
+ (interactive "sFilter: ")
+ (if (= (length str) 0)
+ (setq deft-filter-regexp nil)
+ (setq deft-filter-regexp str)
+ (setq deft-current-files (mapcar 'deft-filter-match-file deft-all-files))
+ (setq deft-current-files (delq nil deft-current-files)))
+ (deft-refresh))
+
+(defun deft-filter-increment ()
+ "Append character to the filter regexp and update `deft-current-files'."
+ (interactive)
+ (let ((char last-command-event))
+ (if (= char ?\S-\ )
+ (setq char ?\s))
+ (setq char (char-to-string char))
+ (setq deft-filter-regexp (concat deft-filter-regexp char))
+ (setq deft-current-files (mapcar 'deft-filter-match-file deft-current-files))
+ (setq deft-current-files (delq nil deft-current-files)))
+ (deft-refresh))
+
+(defun deft-filter-decrement ()
+ "Remove last character from the filter regexp and update `deft-current-files'."
+ (interactive)
+ (if (> (length deft-filter-regexp) 1)
+ (deft-filter (substring deft-filter-regexp 0 -1))
+ (deft-filter-clear)))
+
+(defun deft-complete ()
+ "Complete the current action.
+If there is a widget at the point, press it. If a filter is
+applied and there is at least one match, open the first matching
+file. If there is an active filter but there are no matches,
+quick create a new file using the filter string as the title.
+Otherwise, quick create a new file."
+ (interactive)
+ (cond
+ ;; Activate widget
+ ((widget-at)
+ (widget-button-press (point)))
+ ;; Active filter string with match
+ ((and deft-filter-regexp deft-current-files)
+ (deft-open-file (car deft-current-files)))
+ ;; Default
+ (t
+ (deft-new-file))))
+
+;;; Automatic File Saving
+
+(defun deft-auto-save ()
+ (save-excursion
+ (dolist (buf deft-auto-save-buffers)
+ (if (get-buffer buf)
+ ;; Save open buffers that have been modified.
+ (progn
+ (set-buffer buf)
+ (when (buffer-modified-p)
+ (basic-save-buffer)))
+ ;; If a buffer is no longer open, remove it from auto save list.
+ (delq buf deft-auto-save-buffers)))))
+
+;;; Mode definition
+
+(defun deft-show-version ()
+ "Show the version number in the minibuffer."
+ (interactive)
+ (message "Deft %s" deft-version))
+
+(defun deft-setup ()
+ "Prepare environment by creating the Deft notes directory."
+ (interactive)
+ (when (not (file-exists-p deft-directory))
+ (make-directory deft-directory t))
+ (deft-refresh))
+
+(defvar deft-mode-map
+ (let ((i 0)
+ (map (make-keymap)))
+ ;; Make multibyte characters extend the filter string.
+ (set-char-table-range (nth 1 map) (cons #x100 (max-char))
+ 'deft-filter-increment)
+ ;; Extend the filter string by default.
+ (setq i ?\s)
+ (while (< i 256)
+ (define-key map (vector i) 'deft-filter-increment)
+ (setq i (1+ i)))
+ ;; Handle backspace and delete
+ (define-key map (kbd "DEL") 'deft-filter-decrement)
+ ;; Handle return via completion or opening file
+ (define-key map (kbd "RET") 'deft-complete)
+ ;; Filtering
+ (define-key map (kbd "C-c C-l") 'deft-filter)
+ (define-key map (kbd "C-c C-c") 'deft-filter-clear)
+ ;; File creation
+ (define-key map (kbd "C-c C-n") 'deft-new-file)
+ (define-key map (kbd "C-c C-m") 'deft-new-file-named)
+ (define-key map (kbd "<C-return>") 'deft-new-file-named)
+ ;; File management
+ (define-key map (kbd "C-c C-d") 'deft-delete-file)
+ (define-key map (kbd "C-c C-r") 'deft-rename-file)
+ (define-key map (kbd "C-c C-f") 'deft-find-file)
+ ;; Miscellaneous
+ (define-key map (kbd "C-c C-g") 'deft-refresh)
+ (define-key map (kbd "C-c C-q") 'quit-window)
+ ;; Widgets
+ (define-key map [down-mouse-1] 'widget-button-click)
+ (define-key map [down-mouse-2] 'widget-button-click)
+ (define-key map (kbd "<tab>") 'widget-forward)
+ (define-key map (kbd "<backtab>") 'widget-backward)
+ (define-key map (kbd "<S-tab>") 'widget-backward)
+ map)
+ "Keymap for Deft mode.")
+
+(defun deft-mode ()
+ "Major mode for quickly browsing, filtering, and editing plain text notes.
+Turning on `deft-mode' runs the hook `deft-mode-hook'.
+
+\\{deft-mode-map}."
+ (interactive)
+ (kill-all-local-variables)
+ (setq truncate-lines t)
+ (setq buffer-read-only t)
+ (setq default-directory deft-directory)
+ (use-local-map deft-mode-map)
+ (deft-cache-initialize)
+ (deft-cache-update)
+ (deft-filter-initialize)
+ (setq major-mode 'deft-mode)
+ (setq mode-name "Deft")
+ (deft-buffer-setup)
+ (when (> deft-auto-save-interval 0)
+ (run-with-idle-timer deft-auto-save-interval t 'deft-auto-save))
+ (run-mode-hooks 'deft-mode-hook))
+
+(put 'deft-mode 'mode-class 'special)
+
+;;;###autoload
+(defun deft ()
+ "Switch to *Deft* buffer and load files."
+ (interactive)
+ (switch-to-buffer deft-buffer)
+ (if (not (eq major-mode 'deft-mode))
+ (deft-mode)))
+
+(provide 'deft)
+
+;;; deft.el ends here