# HG changeset patch # User Luke Hoersten # Date 1285734430 18000 # Node ID a7906973ceb5775672e25432e92371945fc3d7cc # Parent a48713acd5c11206ee7e137871b12ce724aa617d Added some old files. diff -r a48713acd5c1 -r a7906973ceb5 .hgignore --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Tue Sep 28 23:27:10 2010 -0500 @@ -0,0 +1,7 @@ +syntax: regexp +yasnippet\/ +nav\/ +url\/ + +~$ +\#.*\#$ diff -r a48713acd5c1 -r a7906973ceb5 color-theme-twilight.el --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/color-theme-twilight.el Tue Sep 28 23:27:10 2010 -0500 @@ -0,0 +1,69 @@ +;; Twilight Colour Theme for Emacs. +;; +;; Defines a colour scheme resembling that of the original TextMate Twilight colour theme. +;; To use add the following to your .emacs file (requires the color-theme package): +;; +;; (require 'color-theme) +;; (color-theme-initialize) +;; (load-file "~/.emacs.d/twilight-emacs/color-theme-twilight.el") +;; +;; And then (color-theme-twilight) to activate it. +;; +;; Several areas still require improvement such as recognition of code that ruby-mode doesn't +;; yet pick up (eg. parent classes), Rails/Merb keywords, or non Ruby code related areas +;; (eg. dired, HTML, etc). Please feel free to customize further and send in any improvements, +;; patches most welcome. +;; +;; MIT License Copyright (c) 2008 Marcus Crafter +;; Credits due to the excellent TextMate Twilight theme +;; +;; Thanks to Travis Jeffery for ido-mode and fixes to the minibuffer-prompt to fit in with the rest of the theme +;; + +(defun color-theme-twilight () + "Color theme by Marcus Crafter, based off the TextMate Twilight theme, created 2008-04-18" + (interactive) + (color-theme-install + '(color-theme-twilight + ((background-color . "#141414") + (background-mode . dark) + (border-color . "black") + (cursor-color . "#A7A7A7") + (foreground-color . "#F8F8F8") + (mouse-color . "sienna1")) + (default ((t (:background "#141414" :foreground "#CACACA")))) + (blue ((t (:foreground "blue")))) + (border-glyph ((t (nil)))) + (buffers-tab ((t (:background "#141414" :foreground "#CACACA")))) + (font-lock-builtin-face ((t (:foreground "#CACACA")))) + (font-lock-comment-face ((t (:foreground "#5F5A60")))) + (font-lock-constant-face ((t (:foreground "#CF6A4C")))) + (font-lock-doc-string-face ((t (:foreground "DarkOrange")))) + (font-lock-function-name-face ((t (:foreground "#9B703F")))) + (font-lock-keyword-face ((t (:foreground "#CDA869")))) + (font-lock-preprocessor-face ((t (:foreground "Aquamarine")))) + (font-lock-reference-face ((t (:foreground "SlateBlue")))) + + (font-lock-regexp-grouping-backslash ((t (:foreground "#E9C062")))) + (font-lock-regexp-grouping-construct ((t (:foreground "red")))) + + (minibuffer-prompt ((t (:foreground "#5F5A60")))) + (ido-subdir ((t (:foreground "#CF6A4C")))) + (ido-first-match ((t (:foreground "#8F9D6A")))) + (ido-only-match ((t (:foreground "#8F9D6A")))) + (mumamo-background-chunk-submode ((t (:background "#222222")))) + + (font-lock-string-face ((t (:foreground "#8F9D6A")))) + (font-lock-type-face ((t (:foreground "#9B703F")))) + (font-lock-variable-name-face ((t (:foreground "#7587A6")))) + (font-lock-warning-face ((t (:background "#EE799F" :foreground "red")))) + (gui-element ((t (:background "#D4D0C8" :foreground "black")))) + (region ((t (:background "#27292A")))) + (mode-line ((t (:background "grey75" :foreground "black")))) + (highlight ((t (:background "#111111")))) + (highline-face ((t (:background "SeaGreen")))) + (left-margin ((t (nil)))) + (text-cursor ((t (:background "yellow" :foreground "black")))) + (toolbar ((t (nil)))) + (underline ((nil (:underline nil)))) + (zmacs-region ((t (:background "snow" :foreground "blue"))))))) diff -r a48713acd5c1 -r a7906973ceb5 hide-lines.el --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hide-lines.el Tue Sep 28 23:27:10 2010 -0500 @@ -0,0 +1,96 @@ +;;; hide-lines.el --- Commands for hiding lines based on a regexp +;; +;;; Author: Mark Hulme-Jones +;; +;;; History +;; +;; 24/03/2004 - Incorporate fix for infinite loop bug from David +;; Hansen +;; +;;; Commentary +;; +;; The simplest way to make hide-lines work is to add the following +;; lines to your .emacs file: +;; +;; (autoload 'hide-lines "hide-lines" "Hide lines based on a regexp" t) +;; (global-set-key "\C-ch" 'hide-lines) +;; +;; Now, when you type C-c h, you will be prompted for a regexp +;; (regular expression). All lines matching this regexp will be +;; hidden in the buffer. +;; +;; Alternatively, you can type C-u C-c h (ie. provide a prefix +;; argument to the hide-lines command) to hide all lines that *do not* +;; match the specified regexp. +;; +;; If you want to make all of the hidden areas re-appear again, type: +;; M-x show-all-invisible +;; Or you can bind show-all-invisible to a key and use that to show +;; all the hidden areas again. + +(defvar invisible-areas-list () + "List of invisible overlays used by hidelines") + +(add-to-invisibility-spec 'hl) + +(defun hide-lines (&optional arg) + "Hide lines matching the specified regexp. +With prefix arg: Hide lines that do not match the specified regexp" + (interactive "p") + (if (> arg 1) + (call-interactively 'hide-non-matching-lines) + (call-interactively 'hide-matching-lines))) + +(defun add-invisible-overlay (start end) + "Add an overlay from `start' to `end' in the current buffer. Push the +overlay onto the invisible-areas-list list" + (let ((overlay (make-overlay start end))) + (setq invisible-areas-list (cons overlay invisible-areas-list)) + (overlay-put overlay 'invisible 'hl))) + +(defun hide-non-matching-lines (search-text) + "Hide lines that don't match the specified regexp." + (interactive "MHide lines not matched by regexp: ") + (make-variable-buffer-local 'line-move-ignore-invisible) + (setq line-move-ignore-invisible t) + (save-excursion + (goto-char (point-min)) + (let ((start-position (point-min)) + (pos (re-search-forward search-text nil t))) + (while pos + (beginning-of-line) + (add-invisible-overlay start-position (point)) + (forward-line 1) + (setq start-position (point)) + (if (eq (point) (point-max)) + (setq pos nil) + (setq pos (re-search-forward search-text nil t)))) + (add-invisible-overlay start-position (point-max))))) + +(defun hide-matching-lines (search-text) + "Hide lines matching the specified regexp." + (interactive "MHide lines matching regexp: ") + (make-variable-buffer-local 'line-move-ignore-invisible) + (setq line-move-ignore-invisible t) + (save-excursion + (goto-char (point-min)) + (let ((pos (re-search-forward search-text nil t)) + start-position) + (while pos + (beginning-of-line) + (setq start-position (point)) + (end-of-line) + (add-invisible-overlay start-position (+ 1 (point))) + (forward-line 1) + (if (eq (point) (point-max)) + (setq pos nil) + (setq pos (re-search-forward search-text nil t))))))) + +(defun show-all-invisible () + "Show all areas hidden by the filter-buffer command" + (interactive) + (mapcar (lambda (overlay) (delete-overlay overlay)) + invisible-areas-list) + (setq invisible-areas-list ())) + +(provide 'hide-lines) diff -r a48713acd5c1 -r a7906973ceb5 init.el --- a/init.el Tue Sep 28 17:03:53 2010 -0500 +++ b/init.el Tue Sep 28 23:27:10 2010 -0500 @@ -31,9 +31,9 @@ (add-hook 'before-save-hook 'whitespace-cleanup) ; cleanup whitespace on exit (setq-default whitespace-line-column 120 ; column width - whitespace-style '(trailing lines-tail empty - indentation space-before-tab - space-after-tab)) + whitespace-style ; whitespace to highlight + '(trailing lines-tail empty indentation + space-before-tab space-after-tab)) ;; coding (which-func-mode t) ; show current function @@ -47,7 +47,6 @@ 'comment-or-uncomment-region) ;; line numbers -;;(global-linum-mode t) (mapc (lambda (x) (add-hook x 'linum-mode)) @@ -104,10 +103,6 @@ ;; (setq exec-path (cons "~/xref" exec-path)) ;; (load "xrefactory") -;; iedit mode -(require 'iedit) ; interactive edit mode -(define-key global-map (kbd "C-;") 'iedit-mode) - ;; nav mode (add-to-list 'load-path "~/.emacs.d/nav/") (require 'nav) diff -r a48713acd5c1 -r a7906973ceb5 vala-mode.el --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vala-mode.el Tue Sep 28 23:27:10 2010 -0500 @@ -0,0 +1,395 @@ +;;; vala-mode.el --- Vala mode derived mode + +;; Author: 2005 Dylan R. E. Moonfire +;; 2008 Étienne BERSAC +;; Maintainer: Étienne BERSAC +;; Created: 2008 May the 4th +;; Modified: May 2008 +;; Version: 0.1 +;; Keywords: vala languages oop + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2 of the License, or +;; (at your option) any later version. +;; +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with this program; see the file COPYING. If not, write to +;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;; Commentary: +;; +;; See http://live.gnome.org/Vala for details about Vala language. +;; +;; This is a separate mode to implement the Vala constructs and +;; font-locking. It is mostly the csharp-mode from +;; http://mfgames.com/linux/csharp-mode with vala specific keywords +;; and filename suffixes. +;; +;; Note: The interface used in this file requires CC Mode 5.30 or +;; later. + +;;; .emacs (don't put in (require 'vala-mode)) +;; (autoload 'vala-mode "vala-mode" "Major mode for editing Vala code." t) +;; (setq auto-mode-alist +;; (append '(("\\.vala$" . vala-mode)) auto-mode-alist)) + +;;; Versions: +;; +;; 0.1 : Initial version based on csharp-mode +;; + +;; This is a copy of the function in cc-mode which is used to handle +;; the eval-when-compile which is needed during other times. +(defun c-filter-ops (ops opgroup-filter op-filter &optional xlate) + ;; See cc-langs.el, a direct copy. + (unless (listp (car-safe ops)) + (setq ops (list ops))) + (cond ((eq opgroup-filter t) + (setq opgroup-filter (lambda (opgroup) t))) + ((not (functionp opgroup-filter)) + (setq opgroup-filter `(lambda (opgroup) + (memq opgroup ',opgroup-filter))))) + (cond ((eq op-filter t) + (setq op-filter (lambda (op) t))) + ((stringp op-filter) + (setq op-filter `(lambda (op) + (string-match ,op-filter op))))) + (unless xlate + (setq xlate 'identity)) + (c-with-syntax-table (c-lang-const c-mode-syntax-table) + (delete-duplicates + (mapcan (lambda (opgroup) + (when (if (symbolp (car opgroup)) + (when (funcall opgroup-filter (car opgroup)) + (setq opgroup (cdr opgroup)) + t) + t) + (mapcan (lambda (op) + (when (funcall op-filter op) + (let ((res (funcall xlate op))) + (if (listp res) res (list res))))) + opgroup))) + ops) + :test 'equal))) + +;; This inserts the bulk of the code. +(require 'cc-mode) + +;; These are only required at compile time to get the sources for the +;; language constants. (The cc-fonts require and the font-lock +;; related constants could additionally be put inside an +;; (eval-after-load "font-lock" ...) but then some trickery is +;; necessary to get them compiled.) +(eval-when-compile + (let ((load-path + (if (and (boundp 'byte-compile-dest-file) + (stringp byte-compile-dest-file)) + (cons (file-name-directory byte-compile-dest-file) load-path) + load-path))) + (load "cc-mode" nil t) + (load "cc-fonts" nil t) + (load "cc-langs" nil t))) + +(eval-and-compile + ;; Make our mode known to the language constant system. Use Java + ;; mode as the fallback for the constants we don't change here. + ;; This needs to be done also at compile time since the language + ;; constants are evaluated then. + (c-add-language 'vala-mode 'java-mode)) + +;; Java uses a series of regexes to change the font-lock for class +;; references. The problem comes in because Java uses Pascal (leading +;; space in names, SomeClass) for class and package names, but +;; Camel-casing (initial lowercase, upper case in words, +;; i.e. someVariable) for variables. +;;(error (byte-compile-dest-file)) +;;(error (c-get-current-file)) +(c-lang-defconst c-opt-after-id-concat-key + vala (if (c-lang-const c-opt-identifier-concat-key) + (c-lang-const c-symbol-start))) + +(c-lang-defconst c-basic-matchers-before + vala `( +;;;; Font-lock the attributes by searching for the +;;;; appropriate regex and marking it as TODO. + ;;,`(,(concat "\\(" vala-attribute-regex "\\)") + ;; 0 font-lock-function-name-face) + + ;; Put a warning face on the opener of unclosed strings that + ;; can't span lines. Later font + ;; lock packages have a `font-lock-syntactic-face-function' for + ;; this, but it doesn't give the control we want since any + ;; fontification done inside the function will be + ;; unconditionally overridden. + ,(c-make-font-lock-search-function + ;; Match a char before the string starter to make + ;; `c-skip-comments-and-strings' work correctly. + (concat ".\\(" c-string-limit-regexp "\\)") + '((c-font-lock-invalid-string))) + + ;; Fontify keyword constants. + ,@(when (c-lang-const c-constant-kwds) + (let ((re (c-make-keywords-re nil + (c-lang-const c-constant-kwds)))) + `((eval . (list ,(concat "\\<\\(" re "\\)\\>") + 1 c-constant-face-name))))) + + ;; Fontify all keywords except the primitive types. + ,`(,(concat "\\<" (c-lang-const c-regular-keywords-regexp)) + 1 font-lock-keyword-face) + + ;; Fontify leading identifiers in fully + ;; qualified names like "Foo.Bar". + ,@(when (c-lang-const c-opt-identifier-concat-key) + `((,(byte-compile + `(lambda (limit) + (while (re-search-forward + ,(concat "\\(\\<" ; 1 + "\\(" (c-lang-const c-symbol-key) + "\\)" ; 2 + "[ \t\n\r\f\v]*" + (c-lang-const + c-opt-identifier-concat-key) + "[ \t\n\r\f\v]*" + "\\)" + "\\(" + (c-lang-const + c-opt-after-id-concat-key) + "\\)") + limit t) + (unless (progn + (goto-char (match-beginning 0)) + (c-skip-comments-and-strings limit)) + (or (get-text-property (match-beginning 2) 'face) + (c-put-font-lock-face (match-beginning 2) + (match-end 2) + c-reference-face-name)) + (goto-char (match-end 1))))))))) + )) + +;; Vala does not allow a leading qualifier operator. It also doesn't +;; allow the ".*" construct of Java. So, we redo this regex without +;; the "\\|\\*" regex. +(c-lang-defconst c-identifier-key + vala (concat "\\(" (c-lang-const c-symbol-key) "\\)" ; 1 + (concat "\\(" + "[ \t\n\r\f\v]*" + (c-lang-const c-opt-identifier-concat-key) + "[ \t\n\r\f\v]*" + (concat "\\(" + "\\(" (c-lang-const c-symbol-key) "\\)" + "\\)") + "\\)*"))) + +;; Vala has a few rules that are slightly different than Java for +;; operators. This also removed the Java's "super" and replaces it +;; with the Vala's "base". +(c-lang-defconst c-operators + vala `((prefix "base"))) + +;; Vala directives ? +;; (c-lang-defconst c-opt-cpp-prefix +;; csharp "^\\s *#.*") + + +;; Vala uses the following assignment operators +(c-lang-defconst c-assignment-operators + vala '("=" "*=" "/=" "%=" "+=" "-=" ">>=" "<<=" + "&=" "^=" "|=" "++" "--")) + +;; This defines the primative types for Vala +(c-lang-defconst c-primitive-type-kwds + vala '("void" "char" "int" "float" "double" "string")) + +;; The keywords that define that the following is a type, such as a +;; class definition. +(c-lang-defconst c-type-prefix-kwds + vala '("class" "interface" "struct" "enum" "signal")) + +;; Type modifier keywords. They appear anywhere in types, but modifiy +;; instead create one. +(c-lang-defconst c-type-modifier-kwds + vala '("const")) + +;; Structures that are similiar to classes. +(c-lang-defconst c-class-decl-kwds + vala '("class" "interface")) + +;; The various modifiers used for class and method descriptions. +(c-lang-defconst c-modifier-kwds + vala '("public" "partial" "private" "const" "abstract" + "protected" "ref" "in" "out" "static" "virtual" + "override" "params" "internal" "weak" "owned" + "unowned")) + +;; We don't use the protection level stuff because it breaks the +;; method indenting. Not sure why, though. +(c-lang-defconst c-protection-kwds + vala nil) + +;; Define the keywords that can have something following after them. +(c-lang-defconst c-type-list-kwds + vala '("struct" "class" "interface" "is" "as" + "delegate" "event" "set" "get" "add" "remove" + "callback" "signal" "var" "default")) + +;; This allows the classes after the : in the class declartion to be +;; fontified. +(c-lang-defconst c-typeless-decl-kwds + vala '(":")) + +;; Sets up the enum to handle the list properly +(c-lang-defconst c-brace-list-decl-kwds + vala '("enum" "errordomain")) + +;; We need to remove Java's package keyword +(c-lang-defconst c-ref-list-kwds + vala '("using" "namespace" "construct")) + +;; Follow-on blocks that don't require a brace +(c-lang-defconst c-block-stmt-2-kwds + vala '("for" "if" "switch" "while" "catch" "foreach" "lock")) + +;; Statements that break out of braces +(c-lang-defconst c-simple-stmt-kwds + vala '("return" "continue" "break" "throw")) + +;; Statements that allow a label +;; TODO? +(c-lang-defconst c-before-label-kwds + vala nil) + +;; Constant keywords +(c-lang-defconst c-constant-kwds + vala '("true" "false" "null")) + +;; Keywords that start "primary expressions." +(c-lang-defconst c-primary-expr-kwds + vala '("this" "base")) + +;; We need to treat namespace as an outer block to class indenting +;; works properly. +(c-lang-defconst c-other-block-decl-kwds + vala '("namespace")) + +;; We need to include the "in" for the foreach +(c-lang-defconst c-other-kwds + vala '("in" "sizeof" "typeof")) + +(require 'cc-awk) + +(c-lang-defconst c-at-vsemi-p-fn + vala 'c-awk-at-vsemi-p) + + +(defcustom vala-font-lock-extra-types nil + "*List of extra types (aside from the type keywords) to recognize in Vala mode. +Each list item should be a regexp matching a single identifier.") + +(defconst vala-font-lock-keywords-1 (c-lang-const c-matchers-1 vala) + "Minimal highlighting for Vala mode.") + +(defconst vala-font-lock-keywords-2 (c-lang-const c-matchers-2 vala) + "Fast normal highlighting for Vala mode.") + +(defconst vala-font-lock-keywords-3 (c-lang-const c-matchers-3 vala) + "Accurate normal highlighting for Vala mode.") + +(defvar vala-font-lock-keywords vala-font-lock-keywords-3 + "Default expressions to highlight in Vala mode.") + +(defvar vala-mode-syntax-table + nil + "Syntax table used in vala-mode buffers.") +(or vala-mode-syntax-table + (setq vala-mode-syntax-table + (funcall (c-lang-const c-make-mode-syntax-table vala)))) + +(defvar vala-mode-abbrev-table nil + "Abbreviation table used in vala-mode buffers.") +(c-define-abbrev-table 'vala-mode-abbrev-table + ;; Keywords that if they occur first on a line + ;; might alter the syntactic context, and which + ;; therefore should trig reindentation when + ;; they are completed. + '(("else" "else" c-electric-continued-statement 0) + ("while" "while" c-electric-continued-statement 0) + ("catch" "catch" c-electric-continued-statement 0) + ("finally" "finally" c-electric-continued-statement 0))) + +(defvar vala-mode-map (let ((map (c-make-inherited-keymap))) + ;; Add bindings which are only useful for Vala + map) + "Keymap used in vala-mode buffers.") + +;;(easy-menu-define vala-menu vala-mode-map "Vala Mode Commands" +;; ;; Can use `vala' as the language for `c-mode-menu' +;; ;; since its definition covers any language. In +;; ;; this case the language is used to adapt to the +;; ;; nonexistence of a cpp pass and thus removing some +;; ;; irrelevant menu alternatives. +;; (cons "Vala" (c-lang-const c-mode-menu vala))) + +;;; Autoload mode trigger +(add-to-list 'auto-mode-alist '("\\.vala$" . vala-mode)) +(add-to-list 'auto-mode-alist '("\\.vapi$" . vala-mode)) + +;; Custom variables +(defcustom vala-mode-hook nil + "*Hook called by `vala-mode'." + :type 'hook + :group 'c) + +;;; The entry point into the mode +;;;###autoload +(defun vala-mode () + "Major mode for editing Vala code. +This is a simple example of a separate mode derived from CC Mode +to support a language with syntax similar to +C#/C/C++/ObjC/Java/IDL/Pike. + +The hook `c-mode-common-hook' is run with no args at mode +initialization, then `vala-mode-hook'. + +Key bindings: +\\{vala-mode-map}" + (interactive) + (kill-all-local-variables) + (c-initialize-cc-mode t) + (set-syntax-table vala-mode-syntax-table) + (setq major-mode 'vala-mode + mode-name "Vala" + local-abbrev-table vala-mode-abbrev-table + abbrev-mode t) + (use-local-map c-mode-map) + ;; `c-init-language-vars' is a macro that is expanded at compile + ;; time to a large `setq' with all the language variables and their + ;; customized values for our language. + (c-init-language-vars vala-mode) + ;; `c-common-init' initializes most of the components of a CC Mode + ;; buffer, including setup of the mode menu, font-lock, etc. + ;; There's also a lower level routine `c-basic-common-init' that + ;; only makes the necessary initialization to get the syntactic + ;; analysis and similar things working. + (c-common-init 'vala-mode) + ;;(easy-menu-add vala-menu) + (c-set-style "linux") + (setq indent-tabs-mode t) + (setq c-basic-offset 4) + (setq tab-width 4) + (c-toggle-auto-newline -1) + (c-toggle-hungry-state -1) + (run-hooks 'c-mode-common-hook) + (run-hooks 'vala-mode-hook) + (c-update-modeline)) + +(provide 'vala-mode) + +;;; vala-mode.el ends here diff -r a48713acd5c1 -r a7906973ceb5 zencoding-mode.el --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/zencoding-mode.el Tue Sep 28 23:27:10 2010 -0500 @@ -0,0 +1,798 @@ +;;; zencoding-mode.el --- Unfold CSS-selector-like expressions to markup +;; +;; Copyright (C) 2009, Chris Done +;; +;; Author: Chris Done +(defconst zencoding-mode:version "0.5") +;; Last-Updated: 2009-11-20 Fri +;; Keywords: convenience +;; +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. +;; +;; This file is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to +;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +;; Boston, MA 02110-1301, USA. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; Commentary: +;; +;; Unfold CSS-selector-like expressions to markup. Intended to be used +;; with sgml-like languages; xml, html, xhtml, xsl, etc. +;; +;; See `zencoding-mode' for more information. +;; +;; Copy zencoding-mode.el to your load-path and add to your .emacs: +;; +;; (require 'zencoding-mode) +;; +;; Example setup: +;; +;; (add-to-list 'load-path "~/Emacs/zencoding/") +;; (require 'zencoding-mode) +;; (add-hook 'sgml-mode-hook 'zencoding-mode) ;; Auto-start on any markup modes +;; +;; Enable the minor mode with M-x zencoding-mode. +;; +;; See ``Test cases'' section for a complete set of expression types. +;; +;; If you are hacking on this project, eval (zencoding-test-cases) to +;; ensure that your changes have not broken anything. Feel free to add +;; new test cases if you add new features. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; History: +;; +;; Modified by Lennart Borgman. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; Code: + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Generic parsing macros and utilities + +(defmacro zencoding-aif (test-form then-form &rest else-forms) + "Anaphoric if. Temporary variable `it' is the result of test-form." + `(let ((it ,test-form)) + (if it ,then-form ,@(or else-forms '(it))))) + +(defmacro zencoding-pif (test-form then-form &rest else-forms) + "Parser anaphoric if. Temporary variable `it' is the result of test-form." + `(let ((it ,test-form)) + (if (not (eq 'error (car it))) ,then-form ,@(or else-forms '(it))))) + +(defmacro zencoding-parse (regex nums label &rest body) + "Parse according to a regex and update the `input' variable." + `(zencoding-aif (zencoding-regex ,regex input ',(number-sequence 0 nums)) + (let ((input (elt it ,nums))) + ,@body) + `,`(error ,(concat "expected " ,label)))) + +(defmacro zencoding-run (parser then-form &rest else-forms) + "Run a parser and update the input properly, extract the parsed + expression." + `(zencoding-pif (,parser input) + (let ((input (cdr it)) + (expr (car it))) + ,then-form) + ,@(or else-forms '(it)))) + +(defmacro zencoding-por (parser1 parser2 then-form &rest else-forms) + "OR two parsers. Try one parser, if it fails try the next." + `(zencoding-pif (,parser1 input) + (let ((input (cdr it)) + (expr (car it))) + ,then-form) + (zencoding-pif (,parser2 input) + (let ((input (cdr it)) + (expr (car it))) + ,then-form) + ,@else-forms))) + +(defun zencoding-regex (regexp string refs) + "Return a list of (`ref') matches for a `regex' on a `string' or nil." + (if (string-match (concat "^" regexp "\\([^\n]*\\)$") string) + (mapcar (lambda (ref) (match-string ref string)) + (if (sequencep refs) refs (list refs))) + nil)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Zen coding parsers + +(defun zencoding-expr (input) + "Parse a zen coding expression. This pretty much defines precedence." + (zencoding-run zencoding-siblings + it + (zencoding-run zencoding-parent-child + it + (zencoding-run zencoding-multiplier + it + (zencoding-run zencoding-pexpr + it + (zencoding-run zencoding-tag + it + '(error "no match, expecting ( or a-zA-Z0-9"))))))) + +(defun zencoding-multiplier (input) + (zencoding-por zencoding-pexpr zencoding-tag + (let ((multiplier expr)) + (zencoding-parse "\\*\\([0-9]+\\)" 2 "*n where n is a number" + (let ((multiplicand (read (elt it 1)))) + `((list ,(make-list multiplicand multiplier)) . ,input)))) + '(error "expected *n multiplier"))) + +(defun zencoding-tag (input) + "Parse a tag." + (zencoding-run zencoding-tagname + (let ((result it) + (tagname (cdr expr))) + (zencoding-pif (zencoding-run zencoding-identifier + (zencoding-tag-classes + `(tag ,tagname ((id ,(cddr expr)))) input) + (zencoding-tag-classes `(tag ,tagname ()) input)) + (let ((expr-and-input it) (expr (car it)) (input (cdr it))) + (zencoding-pif (zencoding-tag-props expr input) + it + expr-and-input)))) + '(error "expected tagname"))) + +(defun zencoding-tag-props (tag input) + (zencoding-run zencoding-props + (let ((tagname (cadr tag)) + (existing-props (caddr tag)) + (props (cdr expr))) + `((tag ,tagname + ,(append existing-props props)) + . ,input)))) + +(defun zencoding-props (input) + "Parse many props." + (zencoding-run zencoding-prop + (zencoding-pif (zencoding-props input) + `((props . ,(cons expr (cdar it))) . ,(cdr it)) + `((props . ,(list expr)) . ,input)))) + +(defun zencoding-prop (input) + (zencoding-parse + " " 1 "space" + (zencoding-run + zencoding-name + (let ((name (cdr expr))) + (zencoding-parse "=\\([^\\,\\+\\>\\ )]*\\)" 2 + "=property value" + (let ((value (elt it 1)) + (input (elt it 2))) + `((,(read name) ,value) . ,input))))))) + +(defun zencoding-tag-classes (tag input) + (zencoding-run zencoding-classes + (let ((tagname (cadr tag)) + (props (caddr tag)) + (classes `(class ,(mapconcat + (lambda (prop) + (cdadr prop)) + (cdr expr) + " ")))) + `((tag ,tagname ,(append props (list classes))) . ,input)) + `(,tag . ,input))) + +(defun zencoding-tagname (input) + "Parse a tagname a-zA-Z0-9 tagname (e.g. html/head/xsl:if/br)." + (zencoding-parse "\\([a-zA-Z][a-zA-Z0-9:-]*\\)" 2 "tagname, a-zA-Z0-9" + `((tagname . ,(elt it 1)) . ,input))) + +(defun zencoding-pexpr (input) + "A zen coding expression with parentheses around it." + (zencoding-parse "(" 1 "(" + (zencoding-run zencoding-expr + (zencoding-aif (zencoding-regex ")" input '(0 1)) + `(,expr . ,(elt it 1)) + '(error "expecting `)'"))))) + +(defun zencoding-parent-child (input) + "Parse an tag>e expression, where `n' is an tag and `e' is any + expression." + (zencoding-run zencoding-multiplier + (let* ((items (cadr expr)) + (rest (zencoding-child-sans expr input))) + (if (not (eq (car rest) 'error)) + (let ((child (car rest)) + (input (cdr rest))) + (cons (cons 'list + (cons (mapcar (lambda (parent) + `(parent-child ,parent ,child)) + items) + nil)) + input)) + '(error "expected child"))) + (zencoding-run zencoding-tag + (zencoding-child expr input) + '(error "expected parent")))) + +(defun zencoding-child-sans (parent input) + (zencoding-parse ">" 1 ">" + (zencoding-run zencoding-expr + it + '(error "expected child")))) + +(defun zencoding-child (parent input) + (zencoding-parse ">" 1 ">" + (zencoding-run zencoding-expr + (let ((child expr)) + `((parent-child ,parent ,child) . ,input)) + '(error "expected child")))) + +(defun zencoding-sibling (input) + (zencoding-por zencoding-pexpr zencoding-multiplier + it + (zencoding-run zencoding-tag + it + '(error "expected sibling")))) + +(defun zencoding-siblings (input) + "Parse an e+e expression, where e is an tag or a pexpr." + (zencoding-run zencoding-sibling + (let ((parent expr)) + (zencoding-parse "\\+" 1 "+" + (zencoding-run zencoding-expr + (let ((child expr)) + `((zencoding-siblings ,parent ,child) . ,input)) + '(error "expected second sibling")))) + '(error "expected first sibling"))) + +(defun zencoding-name (input) + "Parse a class or identifier name, e.g. news, footer, mainimage" + (zencoding-parse "\\([a-zA-Z][a-zA-Z0-9-_]*\\)" 2 "class or identifer name" + `((name . ,(elt it 1)) . ,input))) + +(defun zencoding-class (input) + "Parse a classname expression, e.g. .foo" + (zencoding-parse "\\." 1 "." + (zencoding-run zencoding-name + `((class ,expr) . ,input) + '(error "expected class name")))) + +(defun zencoding-identifier (input) + "Parse an identifier expression, e.g. #foo" + (zencoding-parse "#" 1 "#" + (zencoding-run zencoding-name + `((identifier . ,expr) . ,input)))) + +(defun zencoding-classes (input) + "Parse many classes." + (zencoding-run zencoding-class + (zencoding-pif (zencoding-classes input) + `((classes . ,(cons expr (cdar it))) . ,(cdr it)) + `((classes . ,(list expr)) . ,input)) + '(error "expected class"))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Zen coding transformer from AST to HTML + +;; Fix-me: make mode specific +(defvar zencoding-single-tags + '("br" + "img")) + +(defvar zencoding-inline-tags + '("a" + "abbr" + "acronym" + "cite" + "code" + "dfn" + "em" + "h1" "h2" "h3" "h4" "h5" "h6" + "kbd" + "q" + "span" + "strong" + "var")) + +(defvar zencoding-block-tags + '("p")) + +;; li +;; a +;; em +;; p + +(defvar zencoding-leaf-function nil + "Function to execute when expanding a leaf node in the + Zencoding AST.") + +(defun zencoding-make-tag (tag &optional content) + (let* ((name (car tag)) + (lf (if + (or + (member name zencoding-block-tags) + (and + (> (length name) 1) + (not (member name zencoding-inline-tags)) + )) + "\n" "")) + (single (member name zencoding-single-tags)) + (props (apply 'concat (mapcar + (lambda (prop) + (concat " " (symbol-name (car prop)) + "=\"" (cadr prop) "\"")) + (cadr tag))))) + (concat lf "<" name props ">" lf + (if single + "" + (concat + (if content content + (if zencoding-leaf-function + (funcall zencoding-leaf-function) + "")) + lf ""))))) + +(defun zencoding-transform (ast) + (let ((type (car ast))) + (cond + ((eq type 'list) + (mapconcat 'zencoding-transform (cadr ast) "")) + ((eq type 'tag) + (zencoding-make-tag (cdr ast))) + ((eq type 'parent-child) + (let ((parent (cdadr ast)) + (children (zencoding-transform (caddr ast)))) + (zencoding-make-tag parent children))) + ((eq type 'zencoding-siblings) + (let ((sib1 (zencoding-transform (cadr ast))) + (sib2 (zencoding-transform (caddr ast)))) + (concat sib1 sib2)))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Test-cases + +(defun zencoding-test-cases () + (let ((tests '(;; Tags + ("a" "") + ("a.x" "") + ("a#q.x" "") + ("a#q.x.y.z" "") + ;; Siblings + ("a+b" "") + ("a+b+c" "") + ("a.x+b" "") + ("a#q.x+b" "") + ("a#q.x.y.z+b" "") + ("a#q.x.y.z+b#p.l.m.n" "") + ;; Parent > child + ("a>b" "") + ("a>b>c" "") + ("a.x>b" "") + ("a#q.x>b" "") + ("a#q.x.y.z>b" "") + ("a#q.x.y.z>b#p.l.m.n" "") + ("a>b+c" "") + ("a>b+c>d" "") + ;; Multiplication + ("a*1" "") + ("a*2" "") + ("a*2+b*2" "") + ("a*2>b*2" "") + ("a>b*2" "") + ("a#q.x>b#q.x*2" "") + ;; Properties + ("a x=y" "") + ("a x=y m=l" "") + ("a#foo x=y m=l" "") + ("a.foo x=y m=l" "") + ("a#foo.bar.mu x=y m=l" "") + ("a x=y+b" "") + ("a x=y+b x=y" "") + ("a x=y>b" "") + ("a x=y>b x=y" "") + ("a x=y>b x=y+c x=y" "") + ;; Parentheses + ("(a)" "") + ("(a)+(b)" "") + ("a>(b)" "") + ("(a>b)>c" "") + ("(a>b)+c" "") + ("z+(a>b)+c+k" "") + ("(a)*2" "") + ("((a)*2)" "") + ("((a)*2)" "") + ("(a>b)*2" "") + ("(a+b)*2" "") + ))) + (mapc (lambda (input) + (let ((expected (cadr input)) + (actual (zencoding-transform (car (zencoding-expr (car input)))))) + (if (not (equal expected actual)) + (error (concat "Assertion " (car input) " failed:" + expected + " == " + actual))))) + tests) + (concat (number-to-string (length tests)) " tests performed. All OK."))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Zencoding minor mode + +(defgroup zencoding nil + "Customization group for zencoding-mode." + :group 'convenience) + +(defun zencoding-expr-on-line () + "Extract a zencoding expression and the corresponding bounds + for the current line." + (let* ((start (line-beginning-position)) + (end (line-end-position)) + (line (buffer-substring-no-properties start end)) + (expr (zencoding-regex "\\([ \t]*\\)\\([^\n]+\\)" line 2))) + (if (first expr) + (list (first expr) start end)))) + +(defun zencoding-prettify (markup indent) + (save-match-data + ;;(setq markup (replace-regexp-in-string "><" ">\n<" markup)) + (setq markup (replace-regexp-in-string "\n\n" "\n" markup)) + (setq markup (replace-regexp-in-string "^\n" "" markup))) + (with-temp-buffer + (indent-to indent) + (insert "") + (insert "\n") + (let ((here (point))) + (insert markup) + (sgml-mode) + (indent-region here (point-max)) + (buffer-substring-no-properties here (point-max))))) + +;;;###autoload +(defun zencoding-expand-line (arg) + "Replace the current line's zencode expression with the corresponding expansion. +If prefix ARG is given or region is visible call `zencoding-preview' to start an +interactive preview. + +Otherwise expand line directly. + +For more information see `zencoding-mode'." + (interactive "P") + (let* ((here (point)) + (preview (if zencoding-preview-default (not arg) arg)) + (beg (if preview + (progn + (beginning-of-line) + (skip-chars-forward " \t") + (point)) + (when mark-active (region-beginning)))) + (end (if preview + (progn + (end-of-line) + (skip-chars-backward " \t") + (point)) + (when mark-active (region-end))))) + (if beg + (progn + (goto-char here) + (zencoding-preview beg end)) + (let ((expr (zencoding-expr-on-line))) + (if expr + (let* ((markup (zencoding-transform (car (zencoding-expr (first expr))))) + (pretty (zencoding-prettify markup (current-indentation)))) + (save-excursion + (delete-region (second expr) (third expr)) + (zencoding-insert-and-flash pretty)))))))) + +(defvar zencoding-mode-keymap nil + "Keymap for zencode minor mode.") + +(if zencoding-mode-keymap + nil + (progn + (setq zencoding-mode-keymap (make-sparse-keymap)) + (define-key zencoding-mode-keymap (kbd "") 'zencoding-expand-line))) + +;;;###autoload +(define-minor-mode zencoding-mode + "Minor mode for writing HTML and CSS markup. +With zen coding for HTML and CSS you can write a line like + + ul#name>li.item*2 + +and have it expanded to + +
    +
  • +
  • +
+ +This minor mode defines keys for quick access: + +\\{zencoding-mode-keymap} + +Home page URL `http://www.emacswiki.org/emacs/ZenCoding'. + +See also `zencoding-expand-line'." + :lighter " Zen" + :keymap zencoding-mode-keymap) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Zencoding yasnippet integration + +(defun zencoding-transform-yas (ast) + (let* ((leaf-count 0) + (zencoding-leaf-function + (lambda () + (format "$%d" (incf leaf-count))))) + (zencoding-transform ast))) + +;;;###autoload +(defun zencoding-expand-yas () + (interactive) + (let ((expr (zencoding-expr-on-line))) + (if expr + (let* ((markup (zencoding-transform-yas (car (zencoding-expr (first expr))))) + (filled (replace-regexp-in-string "><" ">\n<" markup))) + (delete-region (second expr) (third expr)) + (insert filled) + (indent-region (second expr) (point)) + (yas/expand-snippet + (buffer-substring (second expr) (point)) + (second expr) (point)))))) + + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Real-time preview +;; + +;;;;;;;;;; +;; Lennart's version + +(defvar zencoding-preview-input nil) +(make-local-variable 'zencoding-preview-input) +(defvar zencoding-preview-output nil) +(make-local-variable 'zencoding-preview-output) +(defvar zencoding-old-show-paren nil) +(make-local-variable 'zencoding-old-show-paren) + +(defface zencoding-preview-input + '((default :box t :inherit secondary-selection)) + "Face for preview input field." + :group 'zencoding) + +(defface zencoding-preview-output + '((default :inherit highlight)) + "Face for preview output field." + :group 'zencoding) + +(defvar zencoding-preview-keymap + (let ((map (make-sparse-keymap))) + (define-key map (kbd "") 'zencoding-preview-accept) + (define-key map [(control ?g)] 'zencoding-preview-abort) + map)) + +(defun zencoding-preview-accept () + (interactive) + (let ((ovli zencoding-preview-input)) + (if (not (and (overlayp ovli) + (bufferp (overlay-buffer ovli)))) + (message "Preview is not active") + (let* ((indent (current-indentation)) + (markup (zencoding-preview-transformed indent))) + (when markup + (delete-region (line-beginning-position) (overlay-end ovli)) + (zencoding-insert-and-flash markup))))) + (zencoding-preview-abort)) + +(defvar zencoding-flash-ovl nil) +(make-variable-buffer-local 'zencoding-flash-ovl) + +(defun zencoding-remove-flash-ovl (buf) + (with-current-buffer buf + (when (overlayp zencoding-flash-ovl) + (delete-overlay zencoding-flash-ovl)) + (setq zencoding-flash-ovl nil))) + +(defcustom zencoding-preview-default t + "If non-nil then preview is the default action. +This determines how `zencoding-expand-line' works by default." + :type 'boolean + :group 'zencoding) + +(defcustom zencoding-insert-flash-time 0.5 + "Time to flash insertion. +Set this to a negative number if you do not want flashing the +expansion after insertion." + :type '(number :tag "Seconds") + :group 'zencoding) + +(defun zencoding-insert-and-flash (markup) + (zencoding-remove-flash-ovl (current-buffer)) + (let ((here (point))) + (insert markup) + (setq zencoding-flash-ovl (make-overlay here (point))) + (overlay-put zencoding-flash-ovl 'face 'zencoding-preview-output) + (when (< 0 zencoding-insert-flash-time) + (run-with-idle-timer zencoding-insert-flash-time + nil 'zencoding-remove-flash-ovl (current-buffer))))) + +;;;###autoload +(defun zencoding-preview (beg end) + "Expand zencode between BEG and END interactively. +This will show a preview of the expanded zen code and you can +accept it or skip it." + (interactive (if mark-active + (list (region-beginning) (region-end)) + (list nil nil))) + (zencoding-preview-abort) + (if (not beg) + (message "Region not active") + (setq zencoding-old-show-paren show-paren-mode) + (show-paren-mode -1) + (let ((here (point))) + (goto-char beg) + (forward-line 1) + (unless (= 0 (current-column)) + (insert "\n")) + (let* ((opos (point)) + (ovli (make-overlay beg end nil nil t)) + (ovlo (make-overlay opos opos)) + (info (propertize " Zen preview. Choose with RET. Cancel by stepping out. \n" + 'face 'tooltip))) + (overlay-put ovli 'face 'zencoding-preview-input) + (overlay-put ovli 'keymap zencoding-preview-keymap) + (overlay-put ovlo 'face 'zencoding-preview-output) + (overlay-put ovlo 'before-string info) + (setq zencoding-preview-input ovli) + (setq zencoding-preview-output ovlo) + (add-hook 'before-change-functions 'zencoding-preview-before-change t t) + (goto-char here) + (add-hook 'post-command-hook 'zencoding-preview-post-command t t))))) + +(defvar zencoding-preview-pending-abort nil) +(make-variable-buffer-local 'zencoding-preview-pending-abort) + +(defun zencoding-preview-before-change (beg end) + (when + (or (> beg (overlay-end zencoding-preview-input)) + (< beg (overlay-start zencoding-preview-input)) + (> end (overlay-end zencoding-preview-input)) + (< end (overlay-start zencoding-preview-input))) + (setq zencoding-preview-pending-abort t))) + +(defun zencoding-preview-abort () + "Abort zen code preview." + (interactive) + (setq zencoding-preview-pending-abort nil) + (remove-hook 'before-change-functions 'zencoding-preview-before-change t) + (when (overlayp zencoding-preview-input) + (delete-overlay zencoding-preview-input)) + (setq zencoding-preview-input nil) + (when (overlayp zencoding-preview-output) + (delete-overlay zencoding-preview-output)) + (setq zencoding-preview-output nil) + (remove-hook 'post-command-hook 'zencoding-preview-post-command t) + (when zencoding-old-show-paren (show-paren-mode 1))) + +(defun zencoding-preview-post-command () + (condition-case err + (zencoding-preview-post-command-1) + (error (message "zencoding-preview-post: %s" err)))) + +(defun zencoding-preview-post-command-1 () + (if (and (not zencoding-preview-pending-abort) + (<= (point) (overlay-end zencoding-preview-input)) + (>= (point) (overlay-start zencoding-preview-input))) + (zencoding-update-preview (current-indentation)) + (zencoding-preview-abort))) + +(defun zencoding-preview-transformed (indent) + (let* ((string (buffer-substring-no-properties + (overlay-start zencoding-preview-input) + (overlay-end zencoding-preview-input))) + (ast (car (zencoding-expr string)))) + (when (not (eq ast 'error)) + (zencoding-prettify (zencoding-transform ast) + indent)))) + +(defun zencoding-update-preview (indent) + (let* ((pretty (zencoding-preview-transformed indent)) + (show (when pretty + (propertize pretty 'face 'highlight)))) + (when show + (overlay-put zencoding-preview-output 'after-string + (concat show "\n"))))) +;; a+bc + +;;;;;;;;;; +;; Chris's version + +;; (defvar zencoding-realtime-preview-keymap +;; (let ((map (make-sparse-keymap))) +;; (define-key map "\C-c\C-c" 'zencoding-delete-overlay-pair) + +;; map) +;; "Keymap used in zencoding realtime preview overlays.") + +;; ;;;###autoload +;; (defun zencoding-realtime-preview-of-region (beg end) +;; "Construct a real-time preview for the region BEG to END." +;; (interactive "r") +;; (let ((beg2) +;; (end2)) +;; (save-excursion +;; (goto-char beg) +;; (forward-line) +;; (setq beg2 (point) +;; end2 (point)) +;; (insert "\n")) +;; (let ((input-and-output (zencoding-make-overlay-pair beg end beg2 end2))) +;; (zencoding-handle-overlay-change (car input-and-output) nil nil nil))) +;; ) + +;; (defun zencoding-make-overlay-pair (beg1 end1 beg2 end2) +;; "Construct an input and an output overlay for BEG1 END1 and BEG2 END2" +;; (let ((input (make-overlay beg1 end1 nil t t)) +;; (output (make-overlay beg2 end2))) +;; ;; Setup input overlay +;; (overlay-put input 'face '(:underline t)) +;; (overlay-put input 'modification-hooks +;; (list #'zencoding-handle-overlay-change)) +;; (overlay-put input 'output output) +;; (overlay-put input 'keymap zencoding-realtime-preview-keymap) +;; ;; Setup output overlay +;; (overlay-put output 'face '(:overline t)) +;; (overlay-put output 'intangible t) +;; (overlay-put output 'input input) +;; ;; Return the overlays. +;; (list input output)) +;; ) + +;; (defun zencoding-delete-overlay-pair (&optional one) +;; "Delete a pair of input and output overlays based on ONE." +;; (interactive) ;; Since called from keymap +;; (unless one +;; (let ((overlays (overlays-at (point)))) +;; (while (and overlays +;; (not (or (overlay-get (car overlays) 'input) +;; (overlay-get (car overlays) 'output)))) +;; (setq overlays (cdr overlays))) +;; (setq one (car overlays)))) +;; (when one +;; (let ((other (or (overlay-get one 'input) +;; (overlay-get one 'output)))) +;; (delete-overlay one) +;; (delete-overlay other))) +;; ) + +;; (defun zencoding-handle-overlay-change (input del beg end &optional old) +;; "Update preview after overlay change." +;; (let* ((output (overlay-get input 'output)) +;; (start (overlay-start output)) +;; (string (buffer-substring-no-properties +;; (overlay-start input) +;; (overlay-end input))) +;; (ast (car (zencoding-expr string))) +;; (markup (when (not (eq ast 'error)) +;; (zencoding-transform ast)))) +;; (save-excursion +;; (delete-region start (overlay-end output)) +;; (goto-char start) +;; (if markup +;; (insert markup) +;; (insert (propertize "error" 'face 'font-lock-error-face))) +;; (move-overlay output start (point)))) +;; ) + +(provide 'zencoding-mode) + +;;; zencoding-mode.el ends here