update mc
authorJoerg Jaspert <joerg@debian.org>
Wed, 1 Jan 2014 21:22:27 +0000 (22:22 +0100)
committerJoerg Jaspert <joerg@debian.org>
Wed, 1 Jan 2014 21:22:27 +0000 (22:22 +0100)
.emacs.d/config/emacs.org
.emacs.d/elisp/multiple-cursors/mc-mark-more.el
.emacs.d/elisp/multiple-cursors/mc-mark-pop.el [new file with mode: 0644]
.emacs.d/elisp/multiple-cursors/multiple-cursors-autoloads.el [new file with mode: 0644]
.emacs.d/elisp/multiple-cursors/multiple-cursors-core.el
.emacs.d/elisp/multiple-cursors/multiple-cursors-pkg.el
.emacs.d/elisp/multiple-cursors/multiple-cursors.el
.emacs.d/elisp/multiple-cursors/rectangular-region-mode.el

index 7ec2650..f7d65e6 100644 (file)
@@ -16,37 +16,27 @@ them first.
 safe-load does not break emacs initialization, should a file be
 unreadable while emacs boots up.
 #+BEGIN_SRC emacs-lisp tangle:yes
-  (defvar safe-load-error-list ""
-          "*List of files that reported errors when loaded via safe-load")
-  
-  (defun safe-load (file &optional noerror nomessage nosuffix)
-    "Load a file.  If error on load, report back, wait for
-     a key stroke then continue on"
-    (interactive "f")
-    (condition-case nil (load file noerror nomessage nosuffix)
-      (error
-        (progn
-         (setq safe-load-error-list  (concat safe-load-error-list  " " file))
-         (message "****** [Return to continue] Error loading %s" safe-load-error-list )
-          (sleep-for 1)
-         nil))))
-  
-  (defun safe-load-check ()
-   "Check for any previous safe-load loading errors.  (safe-load.el)"
-    (interactive)
-    (if (string-equal safe-load-error-list "") ()
-                 (message (concat "****** error loading: " safe-load-error-list))))
-#+END_SRC
-
-match-paren will either jump to the "other" paren or simply insert %
-#+BEGIN_SRC emacs-lisp tangle:yes
-(defun match-paren (arg)
-  "Go to the matching parenthesis if on parenthesis otherwise insert %."
-  (interactive "p")
-  (cond ((looking-at "\\s\(") (forward-list 1) (backward-char 1))
-        ((looking-at "\\s\)") (forward-char 1) (backward-list 1))
-        (t (self-insert-command (or arg 1)))))
-  #+END_SRC
+(defvar safe-load-error-list ""
+        "*List of files that reported errors when loaded via safe-load")
+
+(defun safe-load (file &optional noerror nomessage nosuffix)
+  "Load a file.  If error on load, report back, wait for
+   a key stroke then continue on"
+  (interactive "f")
+  (condition-case nil (load file noerror nomessage nosuffix)
+    (error
+      (progn
+       (setq safe-load-error-list  (concat safe-load-error-list  " " file))
+       (message "****** [Return to continue] Error loading %s" safe-load-error-list )
+        (sleep-for 1)
+       nil))))
+
+(defun safe-load-check ()
+ "Check for any previous safe-load loading errors.  (safe-load.el)"
+  (interactive)
+  (if (string-equal safe-load-error-list "") ()
+               (message (concat "****** error loading: " safe-load-error-list))))
+#+END_SRC
 
 I have some stuff put away in my local dir. I don't want to load it all
 at startup time, so it is using the autoload feature. For that to work
@@ -56,7 +46,6 @@ load the loaddefs, so autoload knows where to grab stuff
 (safe-load (concat jj-elisp-local-dir "/loaddefs.el"))
 #+END_SRC
 
-
 Always ensure to have a scratch buffer around.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (save-excursion
@@ -74,7 +63,6 @@ Handier way to add modes to auto-mode-alist
     (add-to-list 'auto-mode-alist (cons pattern mode))))
 #+END_SRC
 
-
 Helpers for the config
 #+BEGIN_SRC emacs-lisp tangle:yes
 (require 'use-package)
@@ -200,7 +188,7 @@ most for my shells, in Emacs Inconsolata clearly wins.
 I always use dark backgrounds, so tell Emacs about it. No need to
 guess around.
 #+BEGIN_SRC emacs-lisp tangle:yes
-(setq-default frame-background-mode 'dark)
+(setq-default frame-background-mode jj-color-style)
 #+END_SRC
 
 And I always liked dark backgrounds with colors setup for them. So I
@@ -891,40 +879,14 @@ For some file endings we need to tell emacs what mode we want for them.
 I only list modes here where I don't have any other special
 configuration.
 
-- Some extras for ruby, used with ruby on rails for example
-#+BEGIN_SRC emacs-lisp tangle:yes
-(add-to-list 'auto-mode-alist '("\\.rxml$" . ruby-mode))
-(add-to-list 'auto-mode-alist '("\\.rjs$" . ruby-mode))
-(add-to-list 'auto-mode-alist '("\\.rake$" . ruby-mode))
-(add-to-list 'auto-mode-alist '("Rakefile$" . ruby-mode))
-(add-to-list 'auto-mode-alist '("\\.gemspec$" . ruby-mode))
-#+END_SRC
-
 - Markdown syntax
 #+BEGIN_SRC emacs-lisp tangle:yes
-(add-to-list 'auto-mode-alist '("\\.mdwn$" . markdown-mode))
+(add-auto-mode 'markdown-mode "\\.mdwn$")
 #+END_SRC
 
 - diff
 #+BEGIN_SRC emacs-lisp tangle:yes
-(add-to-list 'auto-mode-alist '("COMMIT_EDITMSG$" . diff-mode))
-#+END_SRC
-
-- perl
-#+BEGIN_SRC emacs-lisp tangle:yes
-(add-to-list 'auto-mode-alist '("\\.\\([pP][Llm]\\|al\\)\\'" . cperl-mode))
-(add-to-list 'auto-mode-alist '("\\.pod$" . pod-mode))
-(add-to-list 'auto-mode-alist '("\\.tt$" . tt-mode))
-(add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
-(add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
-(add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))
-#+END_SRC
-
-- python
-#+BEGIN_SRC emacs-lisp tangle:yes
-(add-to-list 'auto-mode-alist '("\\.py\\'" . python-mode))
-(add-to-list 'auto-mode-alist '("\\.py$" . python-mode))
-(add-to-list 'interpreter-mode-alist '("python" . python-mode))
+(add-auto-mode 'diff-mode "COMMIT_EDITMSG$")
 #+END_SRC
 
 ** Region bindings mode
@@ -1089,56 +1051,62 @@ formats if one exists in the first 8 lines of the file.
 (add-hook 'write-file-hooks 'time-stamp)
 #+END_SRC
 
-** cperl
+** perl / cperl
 I like /cperl-mode/ a bit more than the default /perl-mode/, so set it
 up here to be used.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (autoload 'cperl-mode "cperl-mode" )
 (defalias 'perl-mode 'cperl-mode)
-(setq cperl-hairy t)
-(setq cperl-electric-keywords t)
-(setq cperl-electric-lbrace-space t)
-(setq cperl-electric-parens nil)
-(setq cperl-highlight-variables-indiscriminately t)
-(setq cperl-imenu-addback t)
-(setq cperl-invalid-face (quote underline))
-(setq cperl-lazy-help-time 5)
-(setq cperl-mode-hook (quote (turn-on-tinyperl-mode)))
-(setq cperl-scan-files-regexp "\\.\\([pP][Llm]\\|xs\\|cgi\\)$")
-(setq cperl-syntaxify-by-font-lock t)
-(setq cperl-use-syntax-table-text-property-for-tags t)
-#+END_SRC
-
-And have cperl mode give ElDoc a useful string
-#+BEGIN_SRC emacs-lisp tangle:yes
-(defun my-cperl-eldoc-documentation-function ()
-  "Return meaningful doc string for `eldoc-mode'."
-  (car
-   (let ((cperl-message-on-help-error nil))
-     (cperl-get-help))))
-(add-hook 'cperl-mode-hook
-          (lambda ()
-            (set (make-local-variable 'eldoc-documentation-function)
-                 'my-cperl-eldoc-documentation-function)
-            (eldoc-mode)))
+(add-auto-mode 'cperl-mode "\\.\\([pP][Llm]\\|al\\)\\'")
+(add-auto-mode 'pod-mode   "\\.pod$")
+(add-auto-mode 'tt-mode    "\\.tt$")
+(add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
+(add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
+(add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))
+
+(after 'cperl-mode
+  (setq cperl-hairy t)
+  (setq cperl-electric-keywords t)
+  (setq cperl-electric-lbrace-space t)
+  (setq cperl-electric-parens nil)
+  (setq cperl-highlight-variables-indiscriminately t)
+  (setq cperl-imenu-addback t)
+  (setq cperl-invalid-face (quote underline))
+  (setq cperl-lazy-help-time 5)
+  (setq cperl-mode-hook (quote (turn-on-tinyperl-mode)))
+  (setq cperl-scan-files-regexp "\\.\\([pP][Llm]\\|xs\\|cgi\\)$")
+  (setq cperl-syntaxify-by-font-lock t)
+  (setq cperl-use-syntax-table-text-property-for-tags t)
+
+  ;; And have cperl mode give ElDoc a useful string
+  (defun my-cperl-eldoc-documentation-function ()
+    "Return meaningful doc string for `eldoc-mode'."
+    (car
+     (let ((cperl-message-on-help-error nil))
+       (cperl-get-help))))
+
+  (add-hook 'cperl-mode-hook
+            (lambda ()
+              (set (make-local-variable 'eldoc-documentation-function)
+                   'my-cperl-eldoc-documentation-function)
+              (eldoc-mode))))
 #+END_SRC
 
 ** python
 #+BEGIN_SRC emacs-lisp tangle:yes
-  (autoload 'python-mode "python-mode" "Python Mode." t)
-  (add-to-list 'auto-mode-alist '("\\.py\\'" . python-mode))
-  (add-to-list 'interpreter-mode-alist '("python" . python-mode))
-  (setq interpreter-mode-alist
-        (cons '("python" . python-mode)
-              interpreter-mode-alist)
-        python-mode-hook
-        '(lambda () (progn
-                      (set-variable 'py-indent-offset 4)
-                      (set-variable 'py-smart-indentation nil)
-                      (set-variable 'indent-tabs-mode nil)
-                      (define-key python-mode-map "\C-m" 'newline-and-indent)
-                      (turn-on-eldoc-mode)
-                      )))
+(autoload 'python-mode "python-mode" "Python Mode." t)
+(add-auto-mode 'python-mode "\\.py\\'")
+(add-auto-mode 'python-mode "\\.py$")
+(add-auto-mode 'python-mode "SConstruct\\'")
+(add-auto-mode 'python-mode "SConscript\\'")
+(add-to-list 'interpreter-mode-alist '("python" . python-mode))
+
+(after 'python-mode
+  (set-variable 'py-indent-offset 4)
+  (set-variable 'py-smart-indentation nil)
+  (set-variable 'indent-tabs-mode nil)
+  (define-key python-mode-map "\C-m" 'newline-and-indent)
+  (turn-on-eldoc-mode)
   (defun python-auto-fill-comments-only ()
     (auto-fill-mode 1)
     (set (make-local-variable 'fill-nobreak-predicate)
@@ -1152,8 +1120,7 @@ And have cperl mode give ElDoc a useful string
   (autoload 'pymacs-call "pymacs")
   (autoload 'pymacs-eval "pymacs" nil t)
   (autoload 'pymacs-exec "pymacs" nil t)
-  (autoload 'pymacs-load "pymacs" nil t)
-  
+  (autoload 'pymacs-load "pymacs" nil t))
 #+END_SRC
 
 If an =ipython= executable is on the path, then assume that IPython is
@@ -1196,40 +1163,42 @@ Various modes should have line numbers in front of each line.
 But then there are some where it would just be deadly - like org-mode,
 gnus, so we have a list of modes where we don't want to see it.
 #+BEGIN_SRC emacs-lisp tangle:yes
-  (require 'linum)
-  (setq linum-format "%3d ")
-  (setq linum-mode-inhibit-modes-list '(org-mode
-                                        eshell-mode
-                                        shell-mode
-                                        gnus-group-mode
-                                        gnus-summary-mode
-                                        gnus-article-mode))
+(require 'linum)
+(setq linum-format "%3d ")
+(setq linum-mode-inhibit-modes-list '(org-mode
+                                      eshell-mode
+                                      shell-mode
+                                      gnus-group-mode
+                                      gnus-summary-mode
+                                      gnus-article-mode))
 
-  (defadvice linum-on (around linum-on-inhibit-for-modes)
-    "Stop the load of linum-mode for some major modes."
-      (unless (member major-mode linum-mode-inhibit-modes-list)
-        ad-do-it))
+(defadvice linum-on (around linum-on-inhibit-for-modes)
+  "Stop the load of linum-mode for some major modes."
+    (unless (member major-mode linum-mode-inhibit-modes-list)
+      ad-do-it))
 
-  (ad-activate 'linum-on)
-  (global-linum-mode 1)
+(ad-activate 'linum-on)
+(global-linum-mode 1)
 #+END_SRC
 
 ** css
 #+BEGIN_SRC emacs-lisp tangle:yes
 (autoload 'css-mode "css-mode")
 (add-auto-mode 'css-mode "\\.css")
-;;; CSS flymake
-(require 'flymake-css)
-(defun maybe-flymake-css-load ()
-  "Activate flymake-css as necessary, but not in derived modes."
-  (when (eq major-mode 'css-mode)
-    (flymake-css-load)))
-(add-hook 'css-mode-hook 'maybe-flymake-css-load)
-;;; Auto-complete CSS keywords
-(eval-after-load 'auto-complete
-  '(progn
-     (dolist (hook '(css-mode-hook sass-mode-hook scss-mode-hook))
-       (add-hook hook 'ac-css-mode-setup))))
+
+(after 'css-mode
+  ;;; CSS flymake
+  (require 'flymake-css)
+  (defun maybe-flymake-css-load ()
+    "Activate flymake-css as necessary, but not in derived modes."
+    (when (eq major-mode 'css-mode)
+      (flymake-css-load)))
+  (add-hook 'css-mode-hook 'maybe-flymake-css-load)
+  ;;; Auto-complete CSS keywords
+  (eval-after-load 'auto-complete
+    '(progn
+       (dolist (hook '(css-mode-hook sass-mode-hook scss-mode-hook))
+         (add-hook hook 'ac-css-mode-setup)))))
 #+END_SRC
 
 ** mmm-mode
@@ -1274,9 +1243,10 @@ coexist in one buffer.
 Instead of default /html-mode/ I use /html-helper-mode/.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (autoload 'html-helper-mode "html-helper-mode" "Yay HTML" t)
-(setq auto-mode-alist (cons '("\\.html$" . html-helper-mode) auto-mode-alist))
-(setq auto-mode-alist (cons '("\\.asp$" . html-helper-mode) auto-mode-alist))
-(setq auto-mode-alist (cons '("\\.phtml$" . html-helper-mode) auto-mode-alist))
+(add-auto-mode 'html-helper-mode "\\.html$")
+(add-auto-mode 'html-helper-mode "\\.asp$")
+(add-auto-mode 'html-helper-mode "\\.phtml$")
+(add-auto-mode 'html-helper-mode "\\.(jsp|tmpl)\\'")
 (defalias 'html-mode 'html-helper-mode)
 #+END_SRC
 
@@ -2382,13 +2352,14 @@ I want to access it from anywhere using =F6=.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (autoload 'mingus "mingus-stays-home" nil t)
 (global-set-key (kbd "<f6>") 'mingus)
-(setq mingus-dired-add-keys t)
-(setq mingus-mode-always-modeline nil)
-(setq mingus-mode-line-show-elapsed-percentage nil)
-(setq mingus-mode-line-show-volume nil)
-(setq mingus-mpd-config-file "/etc/mpd.conf")
-(setq mingus-mpd-playlist-dir "/var/lib/mpd/playlists")
-(setq mingus-mpd-root "/share/music/")
+(after 'mingus
+ (setq mingus-dired-add-keys t)
+ (setq mingus-mode-always-modeline nil)
+ (setq mingus-mode-line-show-elapsed-percentage nil)
+ (setq mingus-mode-line-show-volume nil)
+ (setq mingus-mpd-config-file "/etc/mpd.conf")
+ (setq mingus-mpd-playlist-dir "/var/lib/mpd/playlists")
+ (setq mingus-mpd-root "/share/music/"))
 #+END_SRC
 
 ** sessions
@@ -2474,17 +2445,19 @@ I took the following from [[http://www.emacswiki.org/emacs/EasyPG][EmacsWiki: Ea
 #+END_SRC
 ** message
 #+BEGIN_SRC emacs-lisp tangle:yes
-  (require 'message)
-  (setq message-kill-buffer-on-exit t)
+(require 'message)
+(setq message-kill-buffer-on-exit t)
 #+END_SRC
 ** gnus
 Most of my gnus config is in an own file, [[file:gnus.org][gnus.org]], here I only have
 what I want every emacs to know.
-
 #+BEGIN_SRC emacs-lisp tangle:yes
 ;;*** Keyboardmacros
 (global-unset-key "\M-n")
 (global-set-key "\M-n" 'gnus) ; Start gnus with M-n
+(after 'gnus
+  (jj-init-theme)
+)
 #+END_SRC
 
 ** url
@@ -2499,17 +2472,17 @@ operating system or location info.
 Crazy way of completion. It looks at the word before point and then
 tries to expand it in various ways.
 #+BEGIN_SRC emacs-lisp tangle:yes
-  (require 'hippie-exp)
-  (setq hippie-expand-try-functions-list '(try-expand-dabbrev
-                                           try-expand-dabbrev-all-buffers
-                                           try-expand-dabbrev-from-kill
-                                           try-complete-file-name-partially
-                                           try-complete-file-name
-                                           try-expand-all-abbrevs try-expand-list
-                                           try-expand-line
-                                           try-complete-lisp-symbol-partially
-                                           try-complete-lisp-symbol))
-  (global-set-key (kbd "M-/") 'hippie-expand)
+(require 'hippie-exp)
+(setq hippie-expand-try-functions-list '(try-expand-dabbrev
+                                         try-expand-dabbrev-all-buffers
+                                         try-expand-dabbrev-from-kill
+                                         try-complete-file-name-partially
+                                         try-complete-file-name
+                                         try-expand-all-abbrevs try-expand-list
+                                         try-expand-line
+                                         try-complete-lisp-symbol-partially
+                                         try-complete-lisp-symbol))
+(global-set-key (kbd "M-/") 'hippie-expand)
 #+END_SRC
 ** yasnippet
 [2013-04-27 Sa 23:16]
@@ -2592,7 +2565,7 @@ while I have one.
 #+END_SRC
 ** windmove
 [2013-04-21 So 20:27]
-Use shift + arrow keys to switch between visible buffers
+Use hyper + arrow keys to switch between visible buffers
 #+BEGIN_SRC emacs-lisp tangle:yes
 (require 'windmove)
 (windmove-default-keybindings 'hyper)
@@ -2622,9 +2595,6 @@ Saner regex syntax
 (require 're-builder)
 (setq reb-re-syntax 'string)
 #+END_SRC
-
-[2013-04-21 So 20:39]
-
 ** magit
 [2013-04-21 So 20:48]
 magit is a mode for interacting with git.
@@ -2646,7 +2616,7 @@ then I like it nice too...
 (setq lisp-coding-hook 'lisp-coding-defaults)
   (setq interactive-lisp-coding-hook 'interactive-lisp-coding-defaults)
 
-(eval-after-load "paredit"
+(after "paredit"
   '(diminish 'paredit-mode " π"))
 
 (setq prelude-emacs-lisp-mode-hook 'prelude-emacs-lisp-mode-defaults)
@@ -2655,11 +2625,11 @@ then I like it nice too...
 
 (define-key emacs-lisp-mode-map (kbd "M-.") 'find-function-at-point)
 
-(eval-after-load "elisp-slime-nav"
+(after "elisp-slime-nav"
   '(diminish 'elisp-slime-nav-mode))
-(eval-after-load "rainbow-mode"
+(after "rainbow-mode"
   '(diminish 'rainbow-mode))
-(eval-after-load "eldoc"
+(after "eldoc"
   '(diminish 'eldoc-mode))
 #+END_SRC
 
@@ -2749,7 +2719,8 @@ YAML is a nice format for data, which is both, human and machine
 readable/editable without getting a big headache.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (require 'yaml-mode)
-(add-to-list 'auto-mode-alist '("\\.yml$" . yaml-mode))
+(add-auto-mode 'yaml-mode "\\.yml$")
+(add-auto-mode 'yaml-mode "\\.yaml$")
 (add-hook 'yaml-mode-hook
  '(lambda ()
     (define-key yaml-mode-map "\C-m" 'newline-and-indent)))
@@ -2774,7 +2745,6 @@ understand for me.
 
 ** nxml
 [2013-05-22 Wed 22:02]
-
 nxml-mode is a major mode for editing XML.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (add-auto-mode
@@ -2788,7 +2758,6 @@ nxml-mode is a major mode for editing XML.
 (fset 'xml-mode 'nxml-mode)
 (setq nxml-slash-auto-complete-flag t)
 
-
 ;; See: http://sinewalker.wordpress.com/2008/06/26/pretty-printing-xml-with-emacs-nxml-mode/
 (defun pp-xml-region (begin end)
   "Pretty format XML markup in region. The function inserts
@@ -2812,65 +2781,42 @@ indentation rules."
      (add-hook 'nxml-mode-hook (lambda () (tidy-build-menu nxml-mode-map)))
      (add-hook 'html-mode-hook (lambda () (tidy-build-menu html-mode-map)))
      ))
-(add-auto-mode 'html-mode "\\.(jsp|tmpl)\\'")
 
 #+END_SRC
 ** ruby
 [2013-05-22 Wed 22:33]
 Programming in ruby...
 
+*** Auto-modes
 #+BEGIN_SRC emacs-lisp tangle:yes
 (add-auto-mode 'ruby-mode
                "Rakefile\\'" "\\.rake\\'" "\.rxml\\'"
                "\\.rjs\\'" ".irbrc\\'" "\.builder\\'" "\\.ru\\'"
                "\\.gemspec\\'" "Gemfile\\'" "Kirkfile\\'")
+#+END_SRC
 
-(setq ruby-use-encoding-map nil)
-
-(eval-after-load 'ruby-mode
-  '(progn
-     (define-key ruby-mode-map (kbd "RET") 'reindent-then-newline-and-indent)
-     (define-key ruby-mode-map (kbd "TAB") 'indent-for-tab-command)))
-
-;; Stupidly the non-bundled ruby-mode isn't a derived mode of
-;; prog-mode: we run the latter's hooks anyway in that case.
-(add-hook 'ruby-mode-hook
-          (lambda ()
-            (unless (derived-mode-p 'prog-mode)
-              (run-hooks 'prog-mode-hook))))
-
-;;; ERB
-(defun sanityinc/ensure-mmm-erb-loaded ()
-  (require 'mmm-erb))
-
-(require 'derived)
-
-(defun sanityinc/set-up-mode-for-erb (mode)
-  (add-hook (derived-mode-hook-name mode) 'sanityinc/ensure-mmm-erb-loaded)
-  (mmm-add-mode-ext-class mode "\\.erb\\'" 'erb))
-
-(let ((html-erb-modes '(html-mode html-erb-mode nxml-mode)))
-  (dolist (mode html-erb-modes)
-    (sanityinc/set-up-mode-for-erb mode)
-    (mmm-add-mode-ext-class mode "\\.r?html\\(\\.erb\\)?\\'" 'html-js)
-    (mmm-add-mode-ext-class mode "\\.r?html\\(\\.erb\\)?\\'" 'html-css)))
-
-(mapc 'sanityinc/set-up-mode-for-erb
-      '(coffee-mode js-mode js2-mode js3-mode markdown-mode textile-mode))
-
-(mmm-add-mode-ext-class 'html-erb-mode "\\.jst\\.ejs\\'" 'ejs)
-
-(add-auto-mode 'html-erb-mode "\\.rhtml\\'" "\\.html\\.erb\\'")
-(add-to-list 'auto-mode-alist '("\\.jst\\.ejs\\'"  . html-erb-mode))
-(mmm-add-mode-ext-class 'yaml-mode "\\.yaml\\'" 'erb)
+*** Config
+#+BEGIN_SRC emacs-lisp tangle:yes
+(after 'ruby-mode
+       (message "ruby has been loaded")
+       (define-key ruby-mode-map (kbd "RET") 'reindent-then-newline-and-indent)
+       (define-key ruby-mode-map (kbd "TAB") 'indent-for-tab-command)
 
-(dolist (mode (list 'js-mode 'js2-mode 'js3-mode))
-  (mmm-add-mode-ext-class mode "\\.js\\.erb\\'" 'erb))
+       (require 'ruby-hash-syntax)
+       (require 'inf-ruby)
+       (setq ruby-use-encoding-map nil)
+       ;; Stupidly the non-bundled ruby-mode isn't a derived mode of
+       ;; prog-mode: we run the latter's hooks anyway in that case.
+       (add-hook 'ruby-mode-hook
+                 (lambda ()
+                   (unless (derived-mode-p 'prog-mode)
+                     (run-hooks 'prog-mode-hook))))
 
+       )
 #+END_SRC
 ** emms
 EMMS is the Emacs Multimedia System.
-#+BEGIN_SRC emacs-lisp tangle:yes
+#+BEGIN_SRC emacs-lisp tangle:no
 (require 'emms-source-file)
 (require 'emms-source-playlist)
 (require 'emms-info)
@@ -3036,6 +2982,13 @@ file, so basically works in every halfway structured file.
 ;;(define-key global-map (kbd "C-c C-f") 'yafolding-toggle-all)
 (define-key global-map (kbd "C-c C-f") 'yafolding-toggle-all-by-current-level)
 #+END_SRC
+** icomplete
+Incremental mini-buffer completion preview: Type in the minibuffer,
+list of matching commands is echoed
+#+BEGIN_SRC emacs-lisp tangle:yes
+(icomplete-mode 99)
+#+END_SRC
+
 * Thats it
 And thats it for this file, control passes "back" to [[file:../initjj.org][initjj.org/el]]
 which then may load more files.
index ac669fc..c957ce8 100644 (file)
@@ -173,9 +173,9 @@ With zero ARG, skip the last one and mark next."
   (dotimes (i num-lines)
     (mc/create-fake-cursor-at-point)
     (ecase direction
-      (forwards (loop do (next-line 1 nil)
+      (forwards (loop do (next-logical-line 1 nil)
                       while (mc/all-fake-cursors (point) (1+ (point)))))
-      (backwards (loop do (previous-line 1 nil)
+      (backwards (loop do (previous-logical-line 1 nil)
                        while (mc/all-fake-cursors (point) (1+ (point))))))))
 
 ;;;###autoload
@@ -191,17 +191,29 @@ With zero ARG, skip the last one and mark next."
   (mc/maybe-multiple-cursors-mode))
 
 ;;;###autoload
-(defun mc/unmark-next-like-this (arg)
+(defun mc/unmark-next-like-this ()
   "Deselect next part of the buffer matching the currently active region."
   (interactive)
   (mc/mark-next-like-this -1))
 
 ;;;###autoload
-(defun mc/unmark-previous-like-this (arg)
+(defun mc/unmark-previous-like-this ()
   "Deselect prev part of the buffer matching the currently active region."
   (interactive)
   (mc/mark-previous-like-this -1))
 
+;;;###autoload
+(defun mc/skip-to-next-like-this ()
+  "Skip the current one and select the next part of the buffer matching the currently active region."
+  (interactive)
+  (mc/mark-next-like-this 0))
+
+;;;###autoload
+(defun mc/skip-to-previous-like-this ()
+  "Skip the current one and select the prev part of the buffer matching the currently active region."
+  (interactive)
+  (mc/mark-previous-like-this 0))
+
 ;;;###autoload
 (defun mc/mark-all-like-this ()
   "Find and mark all the parts of the buffer matching the currently active region"
@@ -256,65 +268,125 @@ With zero ARG, skip the last one and mark next."
   (interactive "r")
   (let ((search (read-from-minibuffer "Mark all in region: "))
         (case-fold-search nil))
-    (mc/remove-fake-cursors)
-    (goto-char beg)
-    (while (search-forward search end t)
-      (push-mark (match-beginning 0))
-      (mc/create-fake-cursor-at-point))
-    (let ((first (mc/furthest-cursor-before-point)))
-      (if (not first)
-          (error "Search failed for %S" search)
-        (mc/pop-state-from-overlay first))))
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
+    (if (string= search "")
+        (message "Mark aborted")
+      (progn
+        (mc/remove-fake-cursors)
+        (goto-char beg)
+        (while (search-forward search end t)
+          (push-mark (match-beginning 0))
+          (mc/create-fake-cursor-at-point))
+        (let ((first (mc/furthest-cursor-before-point)))
+          (if (not first)
+              (error "Search failed for %S" search)
+            (mc/pop-state-from-overlay first)))
+        (if (> (mc/num-cursors) 1)
+            (multiple-cursors-mode 1)
+          (multiple-cursors-mode 0))))))
+
+(when (not (fboundp 'set-temporary-overlay-map))
+  ;; Backport this function from newer emacs versions
+  (defun set-temporary-overlay-map (map &optional keep-pred)
+    "Set a new keymap that will only exist for a short period of time.
+The new keymap to use must be given in the MAP variable. When to
+remove the keymap depends on user input and KEEP-PRED:
+
+- if KEEP-PRED is nil (the default), the keymap disappears as
+  soon as any key is pressed, whether or not the key is in MAP;
+
+- if KEEP-PRED is t, the keymap disappears as soon as a key *not*
+  in MAP is pressed;
+
+- otherwise, KEEP-PRED must be a 0-arguments predicate that will
+  decide if the keymap should be removed (if predicate returns
+  nil) or kept (otherwise). The predicate will be called after
+  each key sequence."
+
+    (let* ((clearfunsym (make-symbol "clear-temporary-overlay-map"))
+           (overlaysym (make-symbol "t"))
+           (alist (list (cons overlaysym map)))
+           (clearfun
+            `(lambda ()
+               (unless ,(cond ((null keep-pred) nil)
+                              ((eq t keep-pred)
+                               `(eq this-command
+                                    (lookup-key ',map
+                                                (this-command-keys-vector))))
+                              (t `(funcall ',keep-pred)))
+                 (remove-hook 'pre-command-hook ',clearfunsym)
+                 (setq emulation-mode-map-alists
+                       (delq ',alist emulation-mode-map-alists))))))
+      (set overlaysym overlaysym)
+      (fset clearfunsym clearfun)
+      (add-hook 'pre-command-hook clearfunsym)
+
+      (push alist emulation-mode-map-alists))))
 
 ;;;###autoload
 (defun mc/mark-more-like-this-extended ()
   "Like mark-more-like-this, but then lets you adjust with arrows key.
-The actual adjustment made depends on the final component of the
-key-binding used to invoke the command, with all modifiers removed:
-
-   <up>    Mark previous like this
-   <down>  Mark next like this
-   <left>  If last was previous, skip it
-           If last was next, remove it
-   <right> If last was next, skip it
-           If last was previous, remove it
-
-Then, continue to read input events and further add or move marks
-as long as the input event read (with all modifiers removed)
-is one of the above."
+The adjustments work like this:
+
+   <up>    Mark previous like this and set direction to 'up
+   <down>  Mark next like this and set direction to 'down
+
+If direction is 'up:
+
+   <left>  Skip past the cursor furthest up
+   <right> Remove the cursor furthest up
+
+If direction is 'down:
+
+   <left>  Remove the cursor furthest down
+   <right> Skip past the cursor furthest down
+
+The bindings for these commands can be changed. See `mc/mark-more-like-this-extended-keymap'."
+  (interactive)
+  (mc/mmlte--down)
+  (set-temporary-overlay-map mc/mark-more-like-this-extended-keymap t))
+
+(defvar mc/mark-more-like-this-extended-direction nil
+  "When using mc/mark-more-like-this-extended are we working on the next or previous cursors?")
+
+(make-variable-buffer-local 'mc/mark-more-like-this-extended)
+
+(defun mc/mmlte--message ()
+  (if (eq mc/mark-more-like-this-extended-direction 'up)
+      (message "<up> to mark previous, <left> to skip, <right> to remove, <down> to mark next")
+    (message "<down> to mark next, <right> to skip, <left> to remove, <up> to mark previous")))
+
+(defun mc/mmlte--up ()
+  (interactive)
+  (mc/mark-previous-like-this 1)
+  (setq mc/mark-more-like-this-extended-direction 'up)
+  (mc/mmlte--message))
+
+(defun mc/mmlte--down ()
+  (interactive)
+  (mc/mark-next-like-this 1)
+  (setq mc/mark-more-like-this-extended-direction 'down)
+  (mc/mmlte--message))
+
+(defun mc/mmlte--left ()
+  (interactive)
+  (if (eq mc/mark-more-like-this-extended-direction 'down)
+      (mc/unmark-next-like-this)
+    (mc/skip-to-previous-like-this))
+  (mc/mmlte--message))
+
+(defun mc/mmlte--right ()
   (interactive)
-  (let ((first t)
-        (ev last-command-event)
-        (cmd 'mc/mark-next-like-this)
-        (arg 1)
-        last echo-keystrokes)
-    (while cmd
-      (let ((base (event-basic-type ev)))
-        (cond ((eq base 'left)
-               (if (eq last 'mc/mark-previous-like-this)
-                   (setq cmd last arg 0)
-                 (setq cmd 'mc/mark-next-like-this arg -1)))
-              ((eq base 'up)
-               (setq cmd 'mc/mark-previous-like-this arg 1))
-              ((eq base 'right)
-               (if (eq last 'mc/mark-next-like-this)
-                   (setq cmd last arg 0)
-                 (setq cmd 'mc/mark-previous-like-this arg -1)))
-              ((eq base 'down)
-               (setq cmd 'mc/mark-next-like-this arg 1))
-              (first
-               (setq cmd 'mc/mark-next-like-this arg 1))
-              (t
-               (setq cmd nil))))
-      (when cmd
-        (ignore-errors
-          (funcall cmd arg))
-        (setq first nil last cmd)
-        (setq ev (read-event "Use arrow keys for more marks: "))))
-    (push ev unread-command-events)))
+  (if (eq mc/mark-more-like-this-extended-direction 'up)
+      (mc/unmark-previous-like-this)
+    (mc/skip-to-next-like-this))
+  (mc/mmlte--message))
+
+(defvar mc/mark-more-like-this-extended-keymap (make-sparse-keymap))
+
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<up>") 'mc/mmlte--up)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<down>") 'mc/mmlte--down)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<left>") 'mc/mmlte--left)
+(define-key mc/mark-more-like-this-extended-keymap (kbd "<right>") 'mc/mmlte--right)
 
 (defvar mc--restrict-mark-all-to-symbols nil)
 
@@ -347,6 +419,28 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
         (when (<= (mc/num-cursors) before)
           (mc/mark-all-like-this))))))
 
+;;;###autoload
+(defun mc/mark-all-dwim (arg)
+  "Tries even harder to guess what you want to mark all of.
+
+If the region is active and spans multiple lines, it will behave
+as if `mc/mark-all-in-region'. With the prefix ARG, it will call
+`mc/edit-lines' instead.
+
+If the region is inactive or on a single line, it will behave like 
+`mc/mark-all-like-this-dwim'."
+  (interactive "P")
+  (if (and (use-region-p)
+           (not (> (mc/num-cursors) 1))
+           (not (= (line-number-at-pos (region-beginning))
+                   (line-number-at-pos (region-end)))))
+      (if arg
+          (call-interactively 'mc/edit-lines)
+       (call-interactively 'mc/mark-all-in-region))
+    (progn
+      (setq this-command 'mc/mark-all-like-this-dwim)
+      (mc/mark-all-like-this-dwim arg))))
+
 (defun mc--in-defun ()
   (bounds-of-thing-at-point 'defun))
 
diff --git a/.emacs.d/elisp/multiple-cursors/mc-mark-pop.el b/.emacs.d/elisp/multiple-cursors/mc-mark-pop.el
new file mode 100644 (file)
index 0000000..8a18381
--- /dev/null
@@ -0,0 +1,22 @@
+;;; mc-mark-pop.el --- Pop cursors off of the mark stack
+
+(require 'multiple-cursors-core)
+
+;;;###autoload
+(defun mc/mark-pop ()
+  "Add a cursor at the current point, pop off mark ring and jump
+to the popped mark."
+  (interactive)
+  ;; If the mark happens to be at the current point, just pop that one off.
+  (while (eql (mark) (point))
+    (pop-mark))
+  (mc/create-fake-cursor-at-point)
+  (exchange-point-and-mark)
+  (pop-mark)
+  (mc/maybe-multiple-cursors-mode))
+
+;; A good key binding for this feature is perhaps "C-S-p" ('p' for pop).
+
+(provide 'mc-mark-pop)
+
+;;; mc-mark-pop.el ends here
diff --git a/.emacs.d/elisp/multiple-cursors/multiple-cursors-autoloads.el b/.emacs.d/elisp/multiple-cursors/multiple-cursors-autoloads.el
new file mode 100644 (file)
index 0000000..9ba73c1
--- /dev/null
@@ -0,0 +1,243 @@
+;;; multiple-cursors-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (or (file-name-directory #$) (car load-path)))
+\f
+;;;### (autoloads nil "mc-edit-lines" "mc-edit-lines.el" (21045 37519
+;;;;;;  709674 618000))
+;;; Generated autoloads from mc-edit-lines.el
+
+(autoload 'mc/edit-lines "mc-edit-lines" "\
+Add one cursor to each line of the active region.
+Starts from mark and moves in straight down or up towards the
+line point is on.
+
+\(fn)" t nil)
+
+(autoload 'mc/edit-ends-of-lines "mc-edit-lines" "\
+Add one cursor to the end of each line in the active region.
+
+\(fn)" t nil)
+
+(autoload 'mc/edit-beginnings-of-lines "mc-edit-lines" "\
+Add one cursor to the beginning of each line in the active region.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "mc-mark-more" "mc-mark-more.el" (21045 37519
+;;;;;;  705674 598000))
+;;; Generated autoloads from mc-mark-more.el
+
+(autoload 'mc/mark-next-like-this "mc-mark-more" "\
+Find and mark the next part of the buffer matching the currently active region
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next.
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-next-word-like-this "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-next-symbol-like-this "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-previous-like-this "mc-mark-more" "\
+Find and mark the previous part of the buffer matching the currently active region
+With negative ARG, delete the last one instead.
+With zero ARG, skip the last one and mark next.
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-previous-word-like-this "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-previous-symbol-like-this "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-next-lines "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-previous-lines "mc-mark-more" "\
+
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/unmark-next-like-this "mc-mark-more" "\
+Deselect next part of the buffer matching the currently active region.
+
+\(fn)" t nil)
+
+(autoload 'mc/unmark-previous-like-this "mc-mark-more" "\
+Deselect prev part of the buffer matching the currently active region.
+
+\(fn)" t nil)
+
+(autoload 'mc/skip-to-next-like-this "mc-mark-more" "\
+Skip the current one and select the next part of the buffer matching the currently active region.
+
+\(fn)" t nil)
+
+(autoload 'mc/skip-to-previous-like-this "mc-mark-more" "\
+Skip the current one and select the prev part of the buffer matching the currently active region.
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-like-this "mc-mark-more" "\
+Find and mark all the parts of the buffer matching the currently active region
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-words-like-this "mc-mark-more" "\
+
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-symbols-like-this "mc-mark-more" "\
+
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-in-region "mc-mark-more" "\
+Find and mark all the parts in the region matching the given search
+
+\(fn BEG END)" t nil)
+
+(autoload 'mc/mark-more-like-this-extended "mc-mark-more" "\
+Like mark-more-like-this, but then lets you adjust with arrows key.
+The adjustments work like this:
+
+   <up>    Mark previous like this and set direction to 'up
+   <down>  Mark next like this and set direction to 'down
+
+If direction is 'up:
+
+   <left>  Skip past the cursor furthest up
+   <right> Remove the cursor furthest up
+
+If direction is 'down:
+
+   <left>  Remove the cursor furthest down
+   <right> Skip past the cursor furthest down
+
+The bindings for these commands can be changed. See `mc/mark-more-like-this-extended-keymap'.
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-like-this-dwim "mc-mark-more" "\
+Tries to guess what you want to mark all of.
+Can be pressed multiple times to increase selection.
+
+With prefix, it behaves the same as original `mc/mark-all-like-this'
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-all-dwim "mc-mark-more" "\
+Tries even harder to guess what you want to mark all of.
+
+If the region is active and spans multiple lines, it will behave
+as if `mc/mark-all-in-region'. With the prefix ARG, it will call
+`mc/edit-lines' instead.
+
+If the region is inactive or on a single line, it will behave like 
+`mc/mark-all-like-this-dwim'.
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/mark-all-like-this-in-defun "mc-mark-more" "\
+Mark all like this in defun.
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-words-like-this-in-defun "mc-mark-more" "\
+Mark all words like this in defun.
+
+\(fn)" t nil)
+
+(autoload 'mc/mark-all-symbols-like-this-in-defun "mc-mark-more" "\
+Mark all symbols like this in defun.
+
+\(fn)" t nil)
+
+(autoload 'mc/add-cursor-on-click "mc-mark-more" "\
+Add a cursor where you click.
+
+\(fn EVENT)" t nil)
+
+(autoload 'mc/mark-sgml-tag-pair "mc-mark-more" "\
+Mark the tag we're in and its pair for renaming.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "mc-mark-pop" "mc-mark-pop.el" (21045 37519
+;;;;;;  709674 618000))
+;;; Generated autoloads from mc-mark-pop.el
+
+(autoload 'mc/mark-pop "mc-mark-pop" "\
+Add a cursor at the current point, pop off mark ring and jump
+to the popped mark.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "mc-separate-operations" "mc-separate-operations.el"
+;;;;;;  (21045 37519 709674 618000))
+;;; Generated autoloads from mc-separate-operations.el
+
+(autoload 'mc/insert-numbers "mc-separate-operations" "\
+Insert increasing numbers for each cursor, starting at 0 or ARG.
+
+\(fn ARG)" t nil)
+
+(autoload 'mc/reverse-regions "mc-separate-operations" "\
+
+
+\(fn)" t nil)
+
+(autoload 'mc/sort-regions "mc-separate-operations" "\
+
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "rectangular-region-mode" "rectangular-region-mode.el"
+;;;;;;  (21045 37519 709674 618000))
+;;; Generated autoloads from rectangular-region-mode.el
+
+(autoload 'set-rectangular-region-anchor "rectangular-region-mode" "\
+Anchors the rectangular region at point.
+
+Think of this one as `set-mark' except you're marking a rectangular region. It is
+an exceedingly quick way of adding multiple cursors to multiple lines.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil nil ("mc-cycle-cursors.el" "multiple-cursors-core.el"
+;;;;;;  "multiple-cursors-pkg.el" "multiple-cursors.el") (21045 37519
+;;;;;;  715378 765000))
+
+;;;***
+\f
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; multiple-cursors-autoloads.el ends here
index 886d86d..4b30cf9 100644 (file)
 (defmacro mc/add-fake-cursor-to-undo-list (&rest forms)
   "Make sure point is in the right place when undoing"
   (let ((uc (make-symbol "undo-cleaner")))
-   `(let ((,uc (cons 'apply (cons 'deactivate-cursor-after-undo (list id)))))
-      (setq buffer-undo-list (cons ,uc buffer-undo-list))
-      ,@forms
-      (if (eq ,uc (car buffer-undo-list)) ;; if nothing has been added to the undo-list
-          (setq buffer-undo-list (cdr buffer-undo-list)) ;; then pop the cleaner right off again
-        (setq buffer-undo-list ;; otherwise add a function to activate this cursor
-              (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list))))))
+    `(let ((,uc (cons 'apply (cons 'deactivate-cursor-after-undo (list id)))))
+       (setq buffer-undo-list (cons ,uc buffer-undo-list))
+       ,@forms
+       (if (eq ,uc (car buffer-undo-list)) ;; if nothing has been added to the undo-list
+           (setq buffer-undo-list (cdr buffer-undo-list)) ;; then pop the cleaner right off again
+         (setq buffer-undo-list ;; otherwise add a function to activate this cursor
+               (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list))))))
 
 (defun mc/all-fake-cursors (&optional start end)
   (remove-if-not 'mc/fake-cursor-p
 (defmacro mc/save-excursion (&rest forms)
   "Saves and restores all the state that multiple-cursors cares about."
   (let ((cs (make-symbol "current-state")))
-   `(let ((,cs (mc/store-current-state-in-overlay
-                          (make-overlay (point) (point) nil nil t))))
-      (overlay-put ,cs 'type 'original-cursor)
-      (save-excursion ,@forms)
-      (mc/pop-state-from-overlay ,cs))))
+    `(let ((,cs (mc/store-current-state-in-overlay
+                 (make-overlay (point) (point) nil nil t))))
+       (overlay-put ,cs 'type 'original-cursor)
+       (save-excursion ,@forms)
+       (mc/pop-state-from-overlay ,cs))))
 
 (defun mc--compare-by-overlay-start (o1 o2)
   (< (overlay-start o1) (overlay-start o2)))
 (defmacro mc/for-each-cursor-ordered (&rest forms)
   "Runs the body for each cursor, fake and real, bound to the name cursor"
   (let ((rci (make-symbol "real-cursor-id")))
-   `(let ((,rci (overlay-get (mc/create-fake-cursor-at-point) 'mc-id)))
-      (mapc #'(lambda (cursor)
-                (when (mc/fake-cursor-p cursor)
-                  ,@forms))
-            (sort (overlays-in (point-min) (point-max)) 'mc--compare-by-overlay-start))
-      (mc/pop-state-from-overlay (mc/cursor-with-id ,rci)))))
+    `(let ((,rci (overlay-get (mc/create-fake-cursor-at-point) 'mc-id)))
+       (mapc #'(lambda (cursor)
+                 (when (mc/fake-cursor-p cursor)
+                   ,@forms))
+             (sort (overlays-in (point-min) (point-max)) 'mc--compare-by-overlay-start))
+       (mc/pop-state-from-overlay (mc/cursor-with-id ,rci)))))
 
 (defmacro mc/save-window-scroll (&rest forms)
   "Saves and restores the window scroll position"
   (let ((p (make-symbol "p"))
         (s (make-symbol "start"))
         (h (make-symbol "hscroll")))
-   `(let ((,p (set-marker (make-marker) (point)))
-          (,s (set-marker (make-marker) (window-start)))
-          (,h (window-hscroll)))
-      ,@forms
-      (goto-char ,p)
-      (set-window-start nil ,s t)
-      (set-window-hscroll nil ,h)
-      (set-marker ,p nil)
-      (set-marker ,s nil))))
+    `(let ((,p (set-marker (make-marker) (point)))
+           (,s (set-marker (make-marker) (window-start)))
+           (,h (window-hscroll)))
+       ,@forms
+       (goto-char ,p)
+       (set-window-start nil ,s t)
+       (set-window-hscroll nil ,h)
+       (set-marker ,p nil)
+       (set-marker ,s nil))))
 
 (defun mc/make-cursor-overlay-at-eol (pos)
   "Create overlay to look like cursor at end of line."
@@ -124,22 +124,22 @@ highlights the entire width of the window."
     (overlay-put overlay 'type 'additional-region)
     overlay))
 
-(defvar mc/cursor-specific-vars '(autopair-action
+(defvar mc/cursor-specific-vars '(transient-mark-mode
+                                  kill-ring
+                                  kill-ring-yank-pointer
+                                  mark-ring
+                                  mark-active
+                                  yank-undo-function
+                                  kill-ring-yank-pointer
+                                  autopair-action
                                   autopair-wrap-action
-                                  transient-mark-mode
                                   er/history)
   "A list of vars that need to be tracked on a per-cursor basis.")
 
 (defun mc/store-current-state-in-overlay (o)
   "Store relevant info about point and mark in the given overlay."
   (overlay-put o 'point (set-marker (make-marker) (point)))
-  (overlay-put o 'kill-ring kill-ring)
-  (overlay-put o 'kill-ring-yank-pointer kill-ring-yank-pointer)
   (overlay-put o 'mark (set-marker (make-marker) (mark)))
-  (overlay-put o 'mark-ring mark-ring)
-  (overlay-put o 'mark-active mark-active)
-  (overlay-put o 'yank-undo-function yank-undo-function)
-  (overlay-put o 'kill-ring-yank-pointer kill-ring-yank-pointer)
   (dolist (var mc/cursor-specific-vars)
     (when (boundp var) (overlay-put o var (symbol-value var))))
   o)
@@ -147,13 +147,7 @@ highlights the entire width of the window."
 (defun mc/restore-state-from-overlay (o)
   "Restore point and mark from stored info in the given overlay."
   (goto-char (overlay-get o 'point))
-  (setq kill-ring (overlay-get o 'kill-ring))
-  (setq kill-ring-yank-pointer (overlay-get o 'kill-ring-yank-pointer))
   (set-marker (mark-marker) (overlay-get o 'mark))
-  (setq mark-ring (overlay-get o 'mark-ring))
-  (setq mark-active (overlay-get o 'mark-active))
-  (setq yank-undo-function (overlay-get o 'yank-undo-function))
-  (setq kill-ring-yank-pointer (overlay-get o 'kill-ring-yank-pointer))
   (dolist (var mc/cursor-specific-vars)
     (when (boundp var) (set var (overlay-get o var)))))
 
@@ -312,8 +306,10 @@ been remapped. And certain modes (cua comes to mind) will change their
 remapping based on state. So a command that changes the state will afterwards
 not be recognized through the command-remapping lookup."
   (unless mc--executing-command-for-fake-cursor
-    (setq mc--this-command (or (command-remapping this-original-command)
-                               this-original-command))))
+    (let ((cmd (or (command-remapping this-original-command)
+                   this-original-command)))
+      (setq mc--this-command (and (not (eq cmd 'god-mode-self-insert))
+                                  cmd)))))
 
 (defun mc/execute-this-command-for-all-cursors ()
   "Wrap around `mc/execute-this-command-for-all-cursors-1' to protect hook."
@@ -343,7 +339,6 @@ the original cursor, to inform about the lack of support."
 
     (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
         (multiple-cursors-mode 0)
-
       (when this-original-command
         (let ((original-command (or mc--this-command
                                     (command-remapping this-original-command)
@@ -396,21 +391,22 @@ you should disable multiple-cursors-mode."
   "Keymap while multiple cursors are active.
 Main goal of the keymap is to rebind C-g and <return> to conclude
 multiple cursors editing.")
-(if mc/keymap
-    nil
+(unless mc/keymap
   (setq mc/keymap (make-sparse-keymap))
   (define-key mc/keymap (kbd "C-g") 'mc/keyboard-quit)
   (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
   (when (fboundp 'phi-search)
-    (define-key mc/keymap (kbd "C-s") 'phi-search)))
+    (define-key mc/keymap (kbd "C-s") 'phi-search))
+  (when (fboundp 'phi-search-backward)
+    (define-key mc/keymap (kbd "C-r") 'phi-search-backward)))
 
-(defun mc--all-equal (entries)
-  "Are all these entries equal?"
-  (let ((first (car entries))
+(defun mc--all-equal (list)
+  "Are all the items in LIST equal?"
+  (let ((first (car list))
         (all-equal t))
-    (while (and all-equal entries)
-      (setq all-equal (equal first (car entries)))
-      (setq entries (cdr entries)))
+    (while (and all-equal list)
+      (setq all-equal (equal first (car list)))
+      (setq list (cdr list)))
     all-equal))
 
 (defun mc--kill-ring-entries ()
@@ -428,7 +424,7 @@ So you can paste it in later with `yank-rectangle'."
     (unless (mc--all-equal entries)
       (setq killed-rectangle entries))))
 
-(defvar mc/unsupported-minor-modes '(auto-complete-mode)
+(defvar mc/unsupported-minor-modes '(auto-complete-mode flyspell-mode)
   "List of minor-modes that does not play well with multiple-cursors.
 They are temporarily disabled when multiple-cursors are active.")
 
@@ -577,6 +573,7 @@ for running commands with multiple cursors.")
                                      mc/mark-all-words-like-this-in-defun
                                      mc/mark-all-symbols-like-this-in-defun
                                      mc/mark-all-like-this-dwim
+                                     mc/mark-all-dwim
                                      mc/mark-sgml-tag-pair
                                      mc/insert-numbers
                                      mc/sort-regions
@@ -584,6 +581,16 @@ for running commands with multiple cursors.")
                                      mc/cycle-forward
                                      mc/cycle-backward
                                      mc/add-cursor-on-click
+                                     mc/mark-pop
+                                     mc/add-cursors-to-all-matches
+                                     mc/mmlte--left
+                                     mc/mmlte--right
+                                     mc/mmlte--up
+                                     mc/mmlte--down
+                                     mc/unmark-next-like-this
+                                     mc/unmark-previous-like-this
+                                     mc/skip-to-next-like-this
+                                     mc/skip-to-previous-like-this
                                      rrm/switch-to-multiple-cursors
                                      save-buffer
                                      ido-exit-minibuffer
index acfd408..9ab49fc 100644 (file)
@@ -1,2 +1,2 @@
-(define-package "multiple-cursors" "1.2.1"
-                "Multiple cursors for Emacs.")
+(define-package "multiple-cursors" "20130913.1148" "Multiple cursors for Emacs. [github]" 'nil)
+
index 518855c..9c847ee 100644 (file)
@@ -1,8 +1,9 @@
-;;; multiple-cursors.el --- An experiment in multiple cursors for emacs.
+;;; multiple-cursors.el --- Multiple cursors for emacs.
 
-;; Copyright (C) 2012 Magnar Sveen
+;; Copyright (C) 2012-2013 Magnar Sveen
 
 ;; Author: Magnar Sveen <magnars@gmail.com>
+;; Version: 1.2.2
 ;; Keywords: editing cursors
 
 ;; This program is free software; you can redistribute it and/or modify
 (require 'mc-edit-lines)
 (require 'mc-cycle-cursors)
 (require 'mc-mark-more)
+(require 'mc-mark-pop)
 (require 'rectangular-region-mode)
 (require 'mc-separate-operations)
 
index d6c9b73..f01a39f 100644 (file)
@@ -67,27 +67,30 @@ an exceedingly quick way of adding multiple cursors to multiple lines."
 
 (defun rrm/repaint ()
   "Start from the anchor and draw a rectangle between it and point."
-  (rrm/remove-rectangular-region-overlays)
-  (let* ((annoying-arrows-mode nil)
-         (point-column (current-column))
-         (point-line (line-number-at-pos))
-         (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
-         (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
-         (left-column (if (< point-column anchor-column) point-column anchor-column))
-         (right-column (if (> point-column anchor-column) point-column anchor-column))
-         (navigation-step (if (< point-line anchor-line) 1 -1)))
-    (move-to-column anchor-column)
-    (set-mark (point))
-    (move-to-column point-column)
-    (mc/save-excursion
-     (while (not (= anchor-line (line-number-at-pos)))
-       (forward-line navigation-step)
-       (move-to-column anchor-column)
-       (when (= anchor-column (current-column))
-         (set-mark (point))
-         (move-to-column point-column)
-         (when (= point-column (current-column))
-           (mc/create-fake-cursor-at-point)))))))
+  (if (not rectangular-region-mode)
+      (remove-hook 'post-command-hook 'rrm/repaint t)
+    ;; else
+    (rrm/remove-rectangular-region-overlays)
+    (let* ((annoying-arrows-mode nil)
+           (point-column (current-column))
+           (point-line (line-number-at-pos))
+           (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
+           (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
+           (left-column (if (< point-column anchor-column) point-column anchor-column))
+           (right-column (if (> point-column anchor-column) point-column anchor-column))
+           (navigation-step (if (< point-line anchor-line) 1 -1)))
+      (move-to-column anchor-column)
+      (set-mark (point))
+      (move-to-column point-column)
+      (mc/save-excursion
+       (while (not (= anchor-line (line-number-at-pos)))
+         (forward-line navigation-step)
+         (move-to-column anchor-column)
+         (when (= anchor-column (current-column))
+           (set-mark (point))
+           (move-to-column point-column)
+           (when (= point-column (current-column))
+             (mc/create-fake-cursor-at-point))))))))
 
 (defun rrm/switch-to-multiple-cursors (&rest forms)
   "Switch from rectangular-region-mode to multiple-cursors-mode."