Release 1.2.3

@chrisdone

.gitignore

@@ -0,0 +1 @@
+elpa

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "util/ecukes"]
-	path = util/ecukes
-	url = git://github.com/rejeep/ecukes.git
-[submodule "util/espuds"]
-	path = util/espuds
-	url = git://github.com/rejeep/espuds.git

.travis.yml

@@ -12,9 +12,10 @@ before_install:
       sudo apt-get install -qq
           emacs24 emacs24-el emacs24-common-non-dfsg;
     fi
+  - curl -fsSkL https://raw.github.com/rejeep/cask.el/master/go | sh
+  - export PATH="/home/travis/.cask/bin:$PATH"
+  - cask
 env:
-  - EMACS=emacs
+  - EMACS=emacs24 TAGS=""
-  - EMACS=emacs24
-  - EMACS=emacs-snapshot
 script:
-  ./run-travis-ci.sh
+  ./run-travis-ci.sh

Cask

@@ -0,0 +1,8 @@
+(source melpa)
+
+(package-file "multiple-cursors.el")
+
+(development
+ (depends-on "ecukes")
+ (depends-on "espuds")
+ (depends-on "wrap-region"))

README.md

@@ -46,9 +46,22 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
  - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
  - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
+ - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
+ - `mc/pop-mark`: Set a cursor at the current point and move to the next (different) position on the mark stack.  This allows for fine grained control over the placement of cursors.
+
+### Juggle around with the current cursors
+
+ - `mc/unmark-next-like-this`: Remove the cursor furthest down in the buffer.
+ - `mc/unmark-previous-like-this`: Remove the cursor furthest up in the buffer.
+ - `mc/skip-to-next-like-this`: Remove the cursor furthest down, marking the next occurance down.
+ - `mc/skip-to-previous-like-this`: Remove the cursor furthest up, marking the next occurance up.
+ - `mc/mark-next-like-this-extended`: Temporarily bind the arrow keys to mark/unmark/skip cursors.
 
 ### Mark many occurrences
 
+ - `mc/edit-lines`: Adds one cursor to each line in the current region.
+ - `mc/edit-beginnings-of-lines`: Adds a cursor at the start of each line in the current region.
+ - `mc/edit-ends-of-lines`: Adds a cursor at the end of each line in the current region.
  - `mc/mark-all-like-this`: Marks all parts of the buffer that matches the current region.
  - `mc/mark-all-words-like-this`: Like `mc/mark-all-like-this` but only for whole words.
  - `mc/mark-all-symbols-like-this`: Like `mc/mark-all-like-this` but only for whole symbols.
@@ -62,6 +75,9 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
 
  - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
  - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
+ - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
+ - `mc/sort-regions`: Sort the marked regions alphabetically.
+ - `mc/reverse-regions`: Reverse the order of the marked regions.
 
 ## Tips and tricks
 
@@ -72,19 +88,38 @@ You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.co
 - Sometimes you end up with cursors outside of your view. You can
   scroll the screen to center on each cursor with `C-v` and `M-v`.
 
-- Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
+- Try pressing `mc/mark-next-like-this` with no region selected. It
-  on the next line.
+  will just add a cursor on the next line.
 
 - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
 
 - Notice that the number of cursors active can be seen in the modeline.
 
+- If you get out of multiple-cursors-mode and yank - it will yank only
+  from the kill-ring of main cursor. To yank from the kill-rings of
+  every cursor use yank-rectangle, normally found at C-x r y.
+
+- You can use `mc/reverse-regions` with nothing selected and just one cursor.
+  It will then flip the sexp at point and the one below it.
+
 - If you would like to keep the global bindings clean, and get custom keybindings
   when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).
 
 BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
 right next to the key for `er/expand-region`.
 
+### Binding mouse events
+
+To override a mouse event, you will likely have to also unbind the
+`down-mouse` part of the event. Like this:
+
+    (global-unset-key (kbd "M-<down-mouse-1>"))
+    (global-set-key (kbd "M-<mouse-1>") 'mc/add-cursor-on-click)
+
+Or you can do like me and find an unused, but less convenient, binding:
+
+    (global-set-key (kbd "C-S-<mouse-1>") 'mc/add-cursor-on-click)
+
 ## Unknown commands
 
 Multiple-cursors uses two lists of commands to know what to do: the run-once list
@@ -117,21 +152,24 @@ You'll find the repo at:
 
     https://github.com/magnars/multiple-cursors.el
 
-To fetch the test dependencies:
+To fetch the test dependencies, install
+[cask](https://github.com/rejeep/cask.el) if you haven't already,
+then:
 
     $ cd /path/to/multiple-cursors
-    $ git submodule update --init
+    $ cask
 
 Run the tests with:
 
-    $ ./util/ecukes/ecukes --graphical
+    $ ./run-tests.sh
 
 ## Contributors
 
-* [Takafumi Arakaki](https://github.com/tkf) made .mc-lists.el diff friendly
+* [Takafumi Arakaki](https://github.com/tkf) has contributed several small improvements
 * [Marco Baringer](https://github.com/segv) contributed looping to mc/cycle and adding cursors without region for mark-more.
 * [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line
 * [Fuco](https://github.com/Fuco1) added the first version of `mc/mark-all-like-this-dwim`
+* [Zach Kost-Smith](https://github.com/smithzvk) added `mc/mark-pop`
 
 Thanks!
 

features/edit-lines.feature

@@ -42,3 +42,16 @@ Feature: Switching from a multiline region to multiple cursors
     And I go to the front of the word "long"
     And I press "C-S-c C-S-c"
     Then I should have 2 cursors
+
+  Scenario: Edit without using transient mark mode
+    Given I turn off transient-mark-mode
+    And I insert:
+    """
+    hello
+    there
+    """
+    And I go to the front of the word "hello"
+    And I set the mark
+    And I go to the front of the word "there"
+    And I press "C-S-c C-S-c"
+    Then I should have 2 cursors

features/insert-numbers.feature

@@ -0,0 +1,13 @@
+Feature: Insert increasing numbers
+
+  Scenario: Three cursors, 0-1-2
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "H-0"
+    And I press "SPC"
+    Then I should see "This 0 text contains the word 1 text thrice (2 text)"
+
+  Scenario: Three cursors, 9-10-11
+    Given I have cursors at "text" in "This text contains the word text thrice (text)"
+    When I press "C-9 H-0"
+    And I press "SPC"
+    Then I should see "This 9 text contains the word 10 text thrice (11 text)"

features/mark-more.feature

@@ -132,3 +132,13 @@ Feature: Marking multiple parts of the buffer
     b_bb
     c_cc
     """
+
+  Scenario: Multiple cursor with shift selection
+    When I insert "This text contains the word text twice"
+    And I go to the front of the word "text"
+    And I press "M-S-f"
+    And I press "C->"
+    And I press "C-f"
+    And I press "<deletechar>"
+    Then I should see "This text ontains the word text wice"
+

features/mark-pop.feature

@@ -0,0 +1,88 @@
+Feature: Popping cursors off of the mark stack
+
+  Scenario: Single pop
+    Given I turn off transient-mark-mode
+    And I insert:
+    """
+    hello
+    there
+    """
+    And I go to the front of the word "hello"
+    And I set the mark
+    And I go to the front of the word "there"
+    And I press "M-x mc/mark-pop"
+    Then I should have 2 cursors
+
+  Scenario: Multiple pops
+    Given I turn off transient-mark-mode
+    And I insert:
+    """
+    hello
+    there, my friend
+    """
+    And I go to the front of the word "hello"
+    And I set the mark
+    And I go to the front of the word "my"
+    And I set the mark
+    And I go to the front of the word "friend"
+    And I press "M-x mc/mark-pop"
+    And I press "M-x mc/mark-pop"
+    Then I should have 3 cursors
+
+  Scenario: Discard identical mark and point
+    Given I turn off transient-mark-mode
+    And I insert:
+    """
+    hello
+    there, my friend
+    """
+    And I go to the front of the word "hello"
+    And I set the mark
+    And I go to the front of the word "my"
+    And I set the mark
+    And I go to the front of the word "friend"
+    And I set the mark
+    And I press "M-x mc/mark-pop"
+    And I press "M-x mc/mark-pop"
+    Then I should have 3 cursors
+
+  Scenario: Changing the text
+    Given I turn off transient-mark-mode
+    And I insert:
+    """
+    hello
+    there, my friend
+    """
+    And I go to the front of the word "hello"
+    And I set the mark
+    And I go to the front of the word "my"
+    And I set the mark
+    And I go to the front of the word "friend"
+    And I press "M-x mc/mark-pop"
+    And I press "M-x mc/mark-pop"
+    And I type "!"
+    Then I should see:
+    """
+    !hello
+    there, !my !friend
+    """
+
+  Scenario: With transient-mark-mode
+    And I insert:
+    """
+    hello
+    there, my friend
+    """
+    And I go to the front of the word "hello"
+    And I press "C-@ C-@"
+    And I go to the front of the word "my"
+    And I press "C-@ C-@"
+    And I go to the front of the word "friend"
+    And I press "M-x mc/mark-pop"
+    And I press "M-x mc/mark-pop"
+    And I type "!"
+    Then I should see:
+    """
+    !hello
+    there, !my !friend
+    """

features/mark-things.feature

@@ -0,0 +1,137 @@
+Feature: Mark things
+
+  Scenario: Mark all symbols like this with select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I select "ghi"
+    And I mark all symbols like this
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message some-other-ghi))
+    """
+
+  Scenario: Mark all words like this with select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I select "ghi"
+    And I mark all words like this
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message some-other-hmm))
+    """
+
+  Scenario: Mark all symbols like this in defun with select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I select "ghi"
+    And I mark all symbols like this in defun
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (ghi) (message some-other-ghi))
+    """
+
+  Scenario: Mark all words like this in defun with select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I select "ghi"
+    And I mark all words like this in defun
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (ghi) (message some-other-ghi))
+    """
+
+  Scenario: Mark all symbols like this with no select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I go to word "ghi"
+    And I mark all symbols like this
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message some-other-ghi))
+    """
+
+  Scenario: Mark all words like this with no select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I go to word "ghi"
+    And I mark all words like this
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (hmm) (message some-other-hmm))
+    """
+
+  Scenario: Mark all symbols like this in defun with no select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I go to word "ghi"
+    And I mark all symbols like this in defun
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (ghi) (message some-other-ghi))
+    """
+
+  Scenario: Mark all words like this in defun with no select
+    Given I turn on emacs-lisp-mode
+    And I turn on delete-selection-mode
+    And I insert:
+    """
+    (defun abc (ghi) (message ghi))
+    (defun def (ghi) (message some-other-ghi))
+    """
+    When I go to word "ghi"
+    And I mark all words like this in defun
+    And I type "hmm"
+    Then I should see:
+    """
+    (defun abc (hmm) (message hmm))
+    (defun def (ghi) (message some-other-ghi))
+    """

features/multiple-cursors-core.feature

@@ -115,7 +115,7 @@ Feature: Multiple cursors core
     And I go to the front of the word "text"
     And I press "C-SPC"
     And I press "M-f"
-    And I press "C->"
+    And I mark next like this
     And I type "!"
     Then I should see "This ! contains the word ! twice"
 
@@ -124,7 +124,7 @@ Feature: Multiple cursors core
     And I insert "This text contains the word text twice"
     And I go to the front of the word "text"
     And I press "C-M-SPC"
-    And I press "C->"
+    And I mark next like this
     And I press "C-g"
     And I type "("
     Then I should see "This (text contains the word (text twice"

features/sort-and-reverse.feature

@@ -0,0 +1,19 @@
+Feature: Sorting and reversing cursor regions
+
+  Scenario: Reversing regions
+    Given I have cursors at "text" in "This text contains the word text thrice (text here)"
+    When I press "M-f"
+    And I press "C-f"
+    And I press "C-SPC"
+    And I press "M-f"
+    And I press "H-1"
+    Then I should see "This text here the word text thrice (text contains)"
+
+  Scenario: Sorting regions
+    Given I have cursors at "text" in "This text contains the word text thrice (text here)"
+    When I press "M-f"
+    And I press "C-f"
+    And I press "C-SPC"
+    And I press "M-f"
+    And I press "H-2"
+    Then I should see "This text contains the word text here (text thrice)"

features/step-definitions/multiple-cursors-steps.el

@@ -1,7 +1,41 @@
+(When "^I mark next like this$"
+      (lambda () (call-interactively 'mc/mark-next-like-this)))
+
+(When "^I mark previous like this$"
+      (lambda () (call-interactively 'mc/mark-previous-like-this)))
+
+(When "^I mark all like this$"
+      (lambda () (call-interactively 'mc/mark-all-like-this)))
+
+(When "^I mark all like this dwim$"
+      (lambda () (call-interactively 'mc/mark-all-like-this-dwim)))
+
+(When "^I mark all in region$"
+      (lambda () (call-interactively 'mc/mark-all-in-region)))
+
+(When "^I insert numbers$"
+      (lambda () (call-interactively 'mc/insert-numbers)))
+
+(When "^I reverse regions$"
+      (lambda () (call-interactively 'mc/reverse-regions)))
+
+(When "^I sort regions$"
+      (lambda () (call-interactively 'mc/sort-regions)))
+
+(When "^I edit lines$"
+      (lambda () (call-interactively 'mc/edit-lines)))
+
+(When "^I set rectangular region anchor$"
+      (lambda () (call-interactively 'set-rectangular-region-anchor)))
+
 (And "^delete-selection-mode is active$"
      (lambda ()
        (delete-selection-mode 1)))
 
+(Given "^I turn off transient-mark-mode$"
+       (lambda ()
+         (transient-mark-mode -1)))
+
 (Then "^I should have \\([0-9]+\\) cursors$"
       (lambda (num)
         (let ((actual (mc/num-cursors)))
@@ -95,3 +129,11 @@
           (assert search nil "The text '%s' was not found in the current buffer." text))
         (set-mark (point))
         (re-search-forward text)))
+
+(When "^I mark all \\(.+\\)$"
+      (lambda (rest)
+        (let ((func (intern (mapconcat 'identity
+                                       (cons  "mc/mark-all"
+                                              (split-string rest))
+                                       "-"))))
+          (call-interactively func))))

features/support/env.el

@@ -25,6 +25,9 @@
  (global-set-key (kbd "M-!") 'mc/mark-all-like-this)
  (global-set-key (kbd "M-$") 'mc/mark-all-like-this-dwim)
  (global-set-key (kbd "M-#") 'mc/mark-all-in-region)
+ (global-set-key (kbd "H-0") 'mc/insert-numbers)
+ (global-set-key (kbd "H-1") 'mc/reverse-regions)
+ (global-set-key (kbd "H-2") 'mc/sort-regions)
  (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
  (global-set-key (kbd "H-SPC") 'set-rectangular-region-anchor)
  (switch-to-buffer

mc-cycle-cursors.el

@@ -113,4 +113,10 @@
 
 (provide 'mc-cycle-cursors)
 
+
+;; Local Variables:
+;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
+;; End:
+
 ;;; mc-cycle-cursors.el ends here

mc-edit-lines.el

@@ -35,7 +35,7 @@
 Starts from mark and moves in straight down or up towards the
 line point is on."
   (interactive)
-  (when (not (use-region-p))
+  (when (not (and mark-active (/= (point) (mark))))
     (error "Mark a set of lines first."))
   (mc/remove-fake-cursors)
   (let* ((col (current-column))
@@ -57,16 +57,14 @@ line point is on."
   "Add one cursor to the end of each line in the active region."
   (interactive)
   (mc/edit-lines)
-  (mc/execute-command-for-all-fake-cursors 'end-of-line)
+  (mc/execute-command-for-all-cursors 'end-of-line))
-  (end-of-line))
 
 ;;;###autoload
 (defun mc/edit-beginnings-of-lines ()
   "Add one cursor to the beginning of each line in the active region."
   (interactive)
   (mc/edit-lines)
-  (mc/execute-command-for-all-fake-cursors 'beginning-of-line)
+  (mc/execute-command-for-all-cursors 'beginning-of-line))
-  (beginning-of-line))
 
 (provide 'mc-edit-lines)
 

mc-mark-more.el

@@ -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"
@@ -225,15 +237,28 @@ With zero ARG, skip the last one and mark next."
       (multiple-cursors-mode 1)
     (multiple-cursors-mode 0)))
 
+(defun mc--select-thing-at-point (thing)
+  (let ((bound (bounds-of-thing-at-point thing)))
+    (when bound
+      (set-mark (car bound))
+      (goto-char (cdr bound))
+      bound)))
+
+(defun mc--select-thing-at-point-or-bark (thing)
+  (unless (or (region-active-p) (mc--select-thing-at-point thing))
+    (error "Mark a region or set cursor on a %s." thing)))
+
 ;;;###autoload
 (defun mc/mark-all-words-like-this ()
   (interactive)
+  (mc--select-thing-at-point-or-bark 'word)
   (let ((mc/enclose-search-term 'words))
     (mc/mark-all-like-this)))
 
 ;;;###autoload
 (defun mc/mark-all-symbols-like-this ()
   (interactive)
+  (mc--select-thing-at-point-or-bark 'symbol)
   (let ((mc/enclose-search-term 'symbols))
     (mc/mark-all-like-this)))
 
@@ -256,52 +281,109 @@ With zero ARG, skip the last one and mark next."
       (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
+The adjustments work like this:
-key-binding used to invoke the command, with all modifiers removed:
 
-   <up>    Mark previous like this
+   <up>    Mark previous like this and set direction to 'up
-   <down>  Mark next like this
+   <down>  Mark next like this and set direction to 'down
-   <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
+If direction is 'up:
-as long as the input event read (with all modifiers removed)
+
-is one of the above."
+   <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)
-  (let ((first t)
+  (mc/mmlte--down)
-        (ev last-command-event)
+  (set-temporary-overlay-map mc/mark-more-like-this-extended-keymap t))
-        (cmd 'mc/mark-next-like-this)
+
-        (arg 1)
+(defvar mc/mark-more-like-this-extended-direction nil
-        last echo-keystrokes)
+  "When using mc/mark-more-like-this-extended are we working on the next or previous cursors?")
-    (while cmd
+
-      (let ((base (event-basic-type ev)))
+(make-variable-buffer-local 'mc/mark-more-like-this-extended)
-        (cond ((eq base 'left)
+
-               (if (eq last 'mc/mark-previous-like-this)
+(defun mc/mmlte--message ()
-                   (setq cmd last arg 0)
+  (if (eq mc/mark-more-like-this-extended-direction 'up)
-                 (setq cmd 'mc/mark-next-like-this arg -1)))
+      (message "<up> to mark previous, <left> to skip, <right> to remove, <down> to mark next")
-              ((eq base 'up)
+    (message "<down> to mark next, <right> to skip, <left> to remove, <up> to mark previous")))
-               (setq cmd 'mc/mark-previous-like-this arg 1))
+
-              ((eq base 'right)
+(defun mc/mmlte--up ()
-               (if (eq last 'mc/mark-next-like-this)
+  (interactive)
-                   (setq cmd last arg 0)
+  (mc/mark-previous-like-this 1)
-                 (setq cmd 'mc/mark-previous-like-this arg -1)))
+  (setq mc/mark-more-like-this-extended-direction 'up)
-              ((eq base 'down)
+  (mc/mmlte--message))
-               (setq cmd 'mc/mark-next-like-this arg 1))
+
-              (first
+(defun mc/mmlte--down ()
-               (setq cmd 'mc/mark-next-like-this arg 1))
+  (interactive)
-              (t
+  (mc/mark-next-like-this 1)
-               (setq cmd nil))))
+  (setq mc/mark-more-like-this-extended-direction 'down)
-      (when cmd
+  (mc/mmlte--message))
-        (ignore-errors
+
-          (funcall cmd arg))
+(defun mc/mmlte--left ()
-        (setq first nil last cmd)
+  (interactive)
-        (setq ev (read-event "Use arrow keys for more marks: "))))
+  (if (eq mc/mark-more-like-this-extended-direction 'down)
-    (push ev unread-command-events)))
+      (mc/unmark-next-like-this)
+    (mc/skip-to-previous-like-this))
+  (mc/mmlte--message))
+
+(defun mc/mmlte--right ()
+  (interactive)
+  (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)
 
@@ -314,7 +396,8 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
   (interactive "P")
   (if arg
       (mc/mark-all-like-this)
-    (if (and (mc--no-region-and-in-sgmlish-mode)
+    (if (and (not (use-region-p))
+             (derived-mode-p 'sgml-mode)
              (mc--on-tag-name-p))
         (mc/mark-sgml-tag-pair)
       (let ((before (mc/num-cursors)))
@@ -333,10 +416,6 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
         (when (<= (mc/num-cursors) before)
           (mc/mark-all-like-this))))))
 
-(defun mc--no-region-and-in-sgmlish-mode ()
-  (and (not (use-region-p))
-       (derived-mode-p 'sgml-mode)))
-
 (defun mc--in-defun ()
   (bounds-of-thing-at-point 'defun))
 
@@ -355,6 +434,7 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
 (defun mc/mark-all-words-like-this-in-defun ()
   "Mark all words like this in defun."
   (interactive)
+  (mc--select-thing-at-point-or-bark 'word)
   (if (mc--in-defun)
       (save-restriction
         (widen)
@@ -366,6 +446,7 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
 (defun mc/mark-all-symbols-like-this-in-defun ()
   "Mark all symbols like this in defun."
   (interactive)
+  (mc--select-thing-at-point-or-bark 'symbol)
   (if (mc--in-defun)
       (save-restriction
         (widen)
@@ -398,6 +479,23 @@ With prefix, it behaves the same as original `mc/mark-all-like-this'"
          (>= (point) beg)
          (<= (point) end))))
 
+;;;###autoload
+(defun mc/add-cursor-on-click (event)
+  "Add a cursor where you click."
+  (interactive "e")
+  (mouse-minibuffer-check event)
+  ;; Use event-end in case called from mouse-drag-region.
+  ;; If EVENT is a click, event-end and event-start give same value.
+  (let ((position (event-end event)))
+    (if (not (windowp (posn-window position)))
+        (error "Position not in text area of window"))
+    (select-window (posn-window position))
+    (if (numberp (posn-point position))
+        (save-excursion
+          (goto-char (posn-point position))
+          (mc/create-fake-cursor-at-point)))
+    (mc/maybe-multiple-cursors-mode)))
+
 ;;;###autoload
 (defun mc/mark-sgml-tag-pair ()
   "Mark the tag we're in and its pair for renaming."

mc-mark-pop.el

@@ -0,0 +1,23 @@
+;;; mc-mark-pop.el --- Pop cursors off of the mark stack
+
+(require 'multiple-cursors-core)
+
+;;;###autoload
+(defun mc/mark-pop ()
+  "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."
+  (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

mc-separate-operations.el

@@ -0,0 +1,90 @@
+;;; mc-separate-operations.el - functions that work differently on each cursor
+
+;; Copyright (C) 2012 Magnar Sveen
+
+;; Author: Magnar Sveen <magnars@gmail.com>
+;; Keywords: editing cursors
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file contains functions that work differently on each cursor,
+;; instead of treating all of them the same.
+
+;; Please see multiple-cursors.el for more commentary.
+
+;;; Code:
+
+(require 'multiple-cursors-core)
+
+;;;###autoload
+(defun mc/insert-numbers (arg)
+  "Insert increasing numbers for each cursor, starting at 0 or ARG."
+  (interactive "P")
+  (setq mc--insert-numbers-number (or arg 0))
+  (mc/for-each-cursor-ordered
+   (mc/execute-command-for-fake-cursor 'mc--insert-number-and-increase cursor)))
+
+(defvar mc--insert-numbers-number 0)
+
+(defun mc--insert-number-and-increase ()
+  (interactive)
+  (insert (number-to-string mc--insert-numbers-number))
+  (setq mc--insert-numbers-number (1+ mc--insert-numbers-number)))
+
+(defun mc--ordered-region-strings ()
+  (let (strings)
+    (save-excursion
+      (mc/for-each-cursor-ordered
+       (setq strings (cons (buffer-substring-no-properties
+                            (mc/cursor-beg cursor)
+                            (mc/cursor-end cursor)) strings))))
+    (nreverse strings)))
+
+(defvar mc--strings-to-replace nil)
+
+(defun mc--replace-region-strings-1 ()
+  (interactive)
+  (delete-region (region-beginning) (region-end))
+  (save-excursion (insert (car mc--strings-to-replace)))
+  (setq mc--strings-to-replace (cdr mc--strings-to-replace)))
+
+(defun mc--replace-region-strings ()
+  (mc/for-each-cursor-ordered
+   (mc/execute-command-for-fake-cursor 'mc--replace-region-strings-1 cursor)))
+
+;;;###autoload
+(defun mc/reverse-regions ()
+  (interactive)
+  (if (not multiple-cursors-mode)
+      (progn
+        (mc/mark-next-lines 1)
+        (mc/reverse-regions)
+        (multiple-cursors-mode 0))
+    (unless (use-region-p)
+      (mc/execute-command-for-all-cursors 'mark-sexp))
+    (setq mc--strings-to-replace (nreverse (mc--ordered-region-strings)))
+    (mc--replace-region-strings)))
+
+;;;###autoload
+(defun mc/sort-regions ()
+  (interactive)
+  (unless (use-region-p)
+    (mc/execute-command-for-all-cursors 'mark-sexp))
+  (setq mc--strings-to-replace (sort (mc--ordered-region-strings) 'string<))
+  (mc--replace-region-strings))
+
+(provide 'mc-separate-operations)
+;;; mc-separate-operations.el ends here

multiple-cursors-core.el

@@ -41,13 +41,14 @@
 
 (defmacro mc/add-fake-cursor-to-undo-list (&rest forms)
   "Make sure point is in the right place when undoing"
-  `(let ((undo-cleaner (cons 'apply (cons 'deactivate-cursor-after-undo (list id)))))
+  (let ((uc (make-symbol "undo-cleaner")))
-     (setq buffer-undo-list (cons undo-cleaner buffer-undo-list))
+    `(let ((,uc (cons 'apply (cons 'deactivate-cursor-after-undo (list id)))))
-     ,@forms
+       (setq buffer-undo-list (cons ,uc buffer-undo-list))
-     (if (eq undo-cleaner (car buffer-undo-list)) ;; if nothing has been added to the undo-list
+       ,@forms
-         (setq buffer-undo-list (cdr buffer-undo-list)) ;; then pop the cleaner right off again
+       (if (eq ,uc (car buffer-undo-list)) ;; if nothing has been added to the undo-list
-       (setq buffer-undo-list ;; otherwise add a function to activate this cursor
+           (setq buffer-undo-list (cdr buffer-undo-list)) ;; then pop the cleaner right off again
-             (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list)))))
+         (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
@@ -61,35 +62,40 @@
 
 (defmacro mc/save-excursion (&rest forms)
   "Saves and restores all the state that multiple-cursors cares about."
-  `(let ((current-state (mc/store-current-state-in-overlay
+  (let ((cs (make-symbol "current-state")))
-                         (make-overlay (point) (point) nil nil t))))
+    `(let ((,cs (mc/store-current-state-in-overlay
-     (overlay-put current-state 'type 'original-cursor)
+                 (make-overlay (point) (point) nil nil t))))
-     (save-excursion ,@forms)
+       (overlay-put ,cs 'type 'original-cursor)
-     (mc/pop-state-from-overlay current-state)))
+       (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 ((real-cursor (mc/create-fake-cursor-at-point)))
+  (let ((rci (make-symbol "real-cursor-id")))
-     (mapc #'(lambda (cursor)
+    `(let ((,rci (overlay-get (mc/create-fake-cursor-at-point) 'mc-id)))
-               (when (mc/fake-cursor-p cursor)
+       (mapc #'(lambda (cursor)
-                 ,@forms))
+                 (when (mc/fake-cursor-p cursor)
-           (sort (overlays-in (point-min) (point-max)) 'mc--compare-by-overlay-start))
+                   ,@forms))
-     (mc/pop-state-from-overlay real-cursor)))
+             (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 (set-marker (make-marker) (point)))
+  (let ((p (make-symbol "p"))
-         (start (set-marker (make-marker) (window-start)))
+        (s (make-symbol "start"))
-         (hscroll (window-hscroll)))
+        (h (make-symbol "hscroll")))
-     ,@forms
+    `(let ((,p (set-marker (make-marker) (point)))
-     (goto-char p)
+           (,s (set-marker (make-marker) (window-start)))
-     (set-window-start nil start)
+           (,h (window-hscroll)))
-     (set-window-hscroll nil hscroll)
+       ,@forms
-     (set-marker p nil)
+       (goto-char ,p)
-     (set-marker start nil)))
+       (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."
@@ -118,41 +124,32 @@ 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
                                   er/history)
   "A list of vars that need to be tracked on a per-cursor basis.")
 
-(defun mc/store-cursor-specific-var (var)
-  (when (boundp var) (overlay-put o var (eval var))))
-
-(defun mc/restore-cursor-specific-var (var)
-  (when (boundp var) (set var (overlay-get o var))))
-
 (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)
+  (dolist (var mc/cursor-specific-vars)
-  (overlay-put o 'mark-active mark-active)
+    (when (boundp var) (overlay-put o var (symbol-value var))))
-  (overlay-put o 'yank-undo-function yank-undo-function)
-  (overlay-put o 'kill-ring-yank-pointer kill-ring-yank-pointer)
-  (mapc 'mc/store-cursor-specific-var mc/cursor-specific-vars)
   o)
 
 (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))
+  (dolist (var mc/cursor-specific-vars)
-  (setq mark-active (overlay-get o 'mark-active))
+    (when (boundp var) (set var (overlay-get o var)))))
-  (setq yank-undo-function (overlay-get o 'yank-undo-function))
-  (setq kill-ring-yank-pointer (overlay-get o 'kill-ring-yank-pointer))
-  (mapc 'mc/restore-cursor-specific-var mc/cursor-specific-vars))
 
 (defun mc/remove-fake-cursor (o)
   "Delete overlay with state, including dependent overlays and markers."
@@ -202,6 +199,17 @@ Saves the current state in the overlay to be restored later."
 
 (defvar mc--executing-command-for-fake-cursor nil)
 
+(defun mc/execute-command-for-fake-cursor (cmd cursor)
+  (let ((mc--executing-command-for-fake-cursor t)
+        (id (overlay-get cursor 'mc-id))
+        (annoying-arrows-mode nil)
+        (smooth-scroll-margin 0))
+    (mc/add-fake-cursor-to-undo-list
+     (mc/pop-state-from-overlay cursor)
+     (ignore-errors
+       (mc/execute-command cmd)
+       (mc/create-fake-cursor-at-point id)))))
+
 (defun mc/execute-command-for-all-fake-cursors (cmd)
   "Calls CMD interactively for each cursor.
 It works by moving point to the fake cursor, setting
@@ -212,17 +220,14 @@ cursor with updated info."
    (mc/save-window-scroll
     (mc/for-each-fake-cursor
      (save-excursion
-       (let ((mc--executing-command-for-fake-cursor t)
+       (mc/execute-command-for-fake-cursor cmd cursor)))))
-             (id (overlay-get cursor 'mc-id))
-             (annoying-arrows-mode nil)
-             (smooth-scroll-margin 0))
-         (mc/add-fake-cursor-to-undo-list
-          (mc/pop-state-from-overlay cursor)
-          (ignore-errors
-            (mc/execute-command cmd)
-            (mc/create-fake-cursor-at-point id))))))))
   (mc--reset-read-prompts))
 
+(defun mc/execute-command-for-all-cursors (cmd)
+  "Calls CMD interactively for the real cursor and all fakes."
+  (call-interactively cmd)
+  (mc/execute-command-for-all-fake-cursors cmd))
+
 ;; Intercept some reading commands so you won't have to
 ;; answer them for every single cursor
 
@@ -301,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)
+    (let ((cmd (or (command-remapping this-original-command)
-                               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."
@@ -332,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)
@@ -344,9 +350,16 @@ the original cursor, to inform about the lack of support."
 
             ;; if it's a lambda, we can't know if it's supported or not
             ;; - so go ahead and assume it's ok, because we're just optimistic like that
-            (if (not (symbolp original-command))
+            (if (or (not (symbolp original-command))
+                    ;; lambda registered by smartrep
+                    (string-prefix-p "(" (symbol-name original-command)))
                 (mc/execute-command-for-all-fake-cursors original-command)
 
+              ;; smartrep `intern's commands into own obarray to help
+              ;; `describe-bindings'.  So, let's re-`intern' here to
+              ;; make the command comparable by `eq'.
+              (setq original-command (intern (symbol-name original-command)))
+
               ;; otherwise it's a symbol, and we can be more thorough
               (if (get original-command 'mc--unsupported)
                   (message "%S is not supported with multiple cursors%s"
@@ -378,19 +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
+(unless mc/keymap
-    nil
   (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))
+  (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
+  (when (fboundp '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)
+(defun mc--all-equal (list)
-  "Are all these entries equal?"
+  "Are all the items in LIST equal?"
-  (let ((first (car entries))
+  (let ((first (car list))
         (all-equal t))
-    (while (and all-equal entries)
+    (while (and all-equal list)
-      (setq all-equal (equal first (car entries)))
+      (setq all-equal (equal first (car list)))
-      (setq entries (cdr entries)))
+      (setq list (cdr list)))
     all-equal))
 
 (defun mc--kill-ring-entries ()
@@ -408,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.")
 
@@ -509,7 +525,7 @@ for running commands with multiple cursors.")
 
 (defun mc/dump-list (list-symbol)
   "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
-  (let ((value (symbol-value list-symbol)))
+  (symbol-macrolet ((value (symbol-value list-symbol)))
     (insert "(setq " (symbol-name list-symbol) "\n"
             "      '(")
     (newline-and-indent)
@@ -558,8 +574,22 @@ for running commands with multiple cursors.")
                                      mc/mark-all-symbols-like-this-in-defun
                                      mc/mark-all-like-this-dwim
                                      mc/mark-sgml-tag-pair
+                                     mc/insert-numbers
+                                     mc/sort-regions
+                                     mc/reverse-regions
                                      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
@@ -645,6 +675,7 @@ for running commands with multiple cursors.")
                                         backward-delete-char-untabify
                                         delete-char delete-forward-char
                                         delete-backward-char
+                                        py-electric-backspace
                                         c-electric-backspace
                                         org-delete-backward-char
                                         paredit-backward-delete
@@ -684,4 +715,9 @@ for running commands with multiple cursors.")
 
 (provide 'multiple-cursors-core)
 
+;; Local Variables:
+;; coding: utf-8
+;; byte-compile-warnings: (not cl-functions)
+;; End:
+
 ;;; multiple-cursors-core.el ends here

multiple-cursors-pkg.el

@@ -1,2 +1,2 @@
-(define-package "multiple-cursors" "1.1.4"
+(define-package "multiple-cursors" "1.2.3"
                 "Multiple cursors for Emacs.")

multiple-cursors.el

@@ -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
@@ -66,6 +67,7 @@
 ;;  - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
 ;;  - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
 ;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurances.
+;;  - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
 
 ;; ### Mark many occurrences
 
@@ -82,29 +84,51 @@
 
 ;;  - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
 ;;  - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
+;;  - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
+;;  - `mc/sort-regions`: Sort the marked regions alphabetically.
+;;  - `mc/reverse-regions`: Reverse the order of the marked regions.
 
 ;; ## Tips and tricks
 
 ;; - To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
 ;;   first disable multiple regions before disabling multiple cursors. If you want to
 ;;   insert a newline in multiple-cursors-mode, use `C-j`.
-
+;;
 ;; - Sometimes you end up with cursors outside of your view. You can
 ;;   scroll the screen to center on each cursor with `C-v` and `M-v`.
-
+;;
 ;; - Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
 ;;   on the next line.
-
+;;
 ;; - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
-
+;;
 ;; - Notice that the number of cursors active can be seen in the modeline.
-
+;;
+;; - If you get out of multiple-cursors-mode and yank - it will yank only
+;;   from the kill-ring of main cursor. To yank from the kill-rings of
+;;   every cursor use yank-rectangle, normally found at C-x r y.
+;;
+;; - You can use `mc/reverse-regions` with nothing selected and just one cursor.
+;;   It will then flip the sexp at point and the one below it.
+;;
 ;; - If you would like to keep the global bindings clean, and get custom keybindings
 ;;   when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).
-
+;;
 ;; BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
 ;; right next to the key for `er/expand-region`.
 
+;; ### Binding mouse events
+
+;; To override a mouse event, you will likely have to also unbind the
+;; `down-mouse` part of the event. Like this:
+;;
+;;     (global-unset-key (kbd "M-<down-mouse-1>"))
+;;     (global-set-key (kbd "M-<mouse-1>") 'mc/add-cursor-on-click)
+;;
+;; Or you can do like me and find an unused, but less convenient, binding:
+;;
+;;     (global-set-key (kbd "C-S-<mouse-1>") 'mc/add-cursor-on-click)
+
 ;; ## Unknown commands
 
 ;; Multiple-cursors uses two lists of commands to know what to do: the run-once list
@@ -158,7 +182,9 @@
 (require 'mc-edit-lines)
 (require 'mc-cycle-cursors)
 (require 'mc-mark-more)
+(require 'mc-mark-pop)
 (require 'rectangular-region-mode)
+(require 'mc-separate-operations)
 
 (provide 'multiple-cursors)
 

rectangular-region-mode.el

@@ -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)
+  (if (not rectangular-region-mode)
-  (let* ((annoying-arrows-mode nil)
+      (remove-hook 'post-command-hook 'rrm/repaint t)
-         (point-column (current-column))
+    ;; else
-         (point-line (line-number-at-pos))
+    (rrm/remove-rectangular-region-overlays)
-         (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
+    (let* ((annoying-arrows-mode nil)
-         (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
+           (point-column (current-column))
-         (left-column (if (< point-column anchor-column) point-column anchor-column))
+           (point-line (line-number-at-pos))
-         (right-column (if (> point-column anchor-column) point-column anchor-column))
+           (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
-         (navigation-step (if (< point-line anchor-line) 1 -1)))
+           (anchor-line (save-excursion (goto-char rrm/anchor) (line-number-at-pos)))
-    (move-to-column anchor-column)
+           (left-column (if (< point-column anchor-column) point-column anchor-column))
-    (set-mark (point))
+           (right-column (if (> point-column anchor-column) point-column anchor-column))
-    (move-to-column point-column)
+           (navigation-step (if (< point-line anchor-line) 1 -1)))
-    (mc/save-excursion
+      (move-to-column anchor-column)
-     (while (not (= anchor-line (line-number-at-pos)))
+      (set-mark (point))
-       (forward-line navigation-step)
+      (move-to-column point-column)
-       (move-to-column anchor-column)
+      (mc/save-excursion
-       (when (= anchor-column (current-column))
+       (while (not (= anchor-line (line-number-at-pos)))
-         (set-mark (point))
+         (forward-line navigation-step)
-         (move-to-column point-column)
+         (move-to-column anchor-column)
-         (when (= point-column (current-column))
+         (when (= anchor-column (current-column))
-           (mc/create-fake-cursor-at-point)))))))
+           (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."

run-tests.sh

@@ -0,0 +1,2 @@
+#!/bin/sh -e
+cask exec ecukes "$@"

run-travis-ci.sh

@@ -1,20 +1,13 @@
-#!/bin/sh
+#!/bin/sh -e
 
 cd "$(dirname "$0")"
 
-set_default () {
+ECUKES_EMACS=${EMACS:-$(which emacs)}
-  eval "
+export ECUKES_EMACS
-if [ -z \$$1 ]; then
-  $1=$2
-fi
-"
-}
-
-set_default ECUKES_EMACS "$(which emacs)"
 
 echo "*** Emacs version ***"
-echo "ECUKES_EMACS =" $(which $ECUKES_EMACS)
+echo "ECUKES_EMACS = $ECUKES_EMACS"
-$ECUKES_EMACS --version
+"$ECUKES_EMACS" --version
 echo
 
-exec ./util/ecukes/ecukes --graphical
+exec ./run-tests.sh $TAGS

util/vendor/wrap-region.el

@@ -1,329 +0,0 @@
-;;; wrap-region.el --- Wrap text with punctation or tag
-
-;; Copyright (C) 2008-2012 Johan Andersson
-
-;; Author: Johan Andersson <johan.rejeep@gmail.com>
-;; Maintainer: Johan Andersson <johan.rejeep@gmail.com>
-;; Version: 0.6.0
-;; Keywords: speed, convenience
-;; URL: http://github.com/rejeep/wrap-region
-
-;; This file is NOT part of GNU Emacs.
-
-
-;;; License:
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with 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:
-
-;; wrap-region is a minor mode that wraps a region with
-;; punctuations. For tagged markup modes, such as HTML and XML, it
-;; wraps with tags.
-;;
-;; To use wrap-region, make sure that this file is in Emacs load-path:
-;;   (add-to-list 'load-path "/path/to/directory/or/file")
-;;
-;; Then require wrap-region:
-;;   (require 'wrap-region)
-
-;; To start wrap-region:
-;;   (wrap-region-mode t) or M-x wrap-region-mode
-;;
-;; If you only want wrap-region active in some mode, use hooks:
-;;   (add-hook 'ruby-mode-hook 'wrap-region-mode)
-;;
-;; Or if you want to activate it in all buffers, use the global mode:
-;;   (wrap-region-global-mode t)
-
-;; To wrap a region, select that region and hit one of the punctuation
-;; keys. In "tag-modes"" (see `wrap-region-tag-active-modes'), "<" is
-;; replaced and wraps the region with a tag. To activate this behavior
-;; in a mode that is not default:
-;;   (add-to-list 'wrap-region-tag-active-modes 'some-tag-mode)
-;;
-;; `wrap-region-table' contains the default punctuations
-;; that wraps. You can add and remove new wrappers by using the
-;; functions `wrap-region-add-wrapper' and
-;; `wrap-region-remove-wrapper' respectively.
-;;   (wrap-region-add-wrapper "`" "'")                  ; hit ` then region -> `region'
-;;   (wrap-region-add-wrapper "/*" "*/" "/")            ; hit / then region -> /*region*/
-;;   (wrap-region-add-wrapper "$" "$" nil 'latex-mode)  ; hit $ then region -> $region$ in latex-mode
-;;   (wrap-region-remove-wrapper "(")
-;;   (wrap-region-remove-wrapper "$" 'latex-mode)
-;;
-;; Some modes may have conflicting key bindings with wrap-region. To
-;; avoid conflicts, the list `wrap-region-except-modes' contains names
-;; of modes where wrap-region should not be activated (note, only in
-;; the global mode). You can add new modes like this:
-;;   (add-to-list 'wrap-region-except-modes 'conflicting-mode)
-
-
-;;; Code:
-
-(require 'edmacro)
-(eval-when-compile
-  (require 'cl))
-
-
-(defstruct wrap-region-wrapper key left right modes)
-
-(defvar wrap-region-mode-map (make-sparse-keymap)
-  "Keymap for `wrap-region-mode'.")
-
-(defvar wrap-region-table (make-hash-table :test 'equal)
-  "Table with wrapper pairs.")
-
-(defvar wrap-region-tag-active-modes '(html-mode sgml-mode rhtml-mode nxml-mode nxhtml-mode)
-  "List of modes that uses tags.")
-
-(defvar wrap-region-except-modes '(calc-mode dired-mode)
-  "A list of modes in which `wrap-region-mode' should not be activated.")
-
-(defvar wrap-region-hook nil
-  "Called when `wrap-region-mode' is turned on.")
-
-(defvar wrap-region-before-wrap-hook nil
-  "Called before wrapping.")
-
-(defvar wrap-region-after-wrap-hook nil
-  "Called after wrapping.")
-
-(defvar wrap-region-only-with-negative-prefix nil
-  "Only wrap if the trigger key is prefixed with a negative value.")
-
-(defvar wrap-region-keep-mark nil
-  "Keep the wrapped region active.")
-
-(defun wrap-region-trigger (arg key)
-  "Called when trigger key is pressed."
-  (let* ((wrapper (wrap-region-find key)))
-    (if (and wrapper
-             (region-active-p)
-             (if wrap-region-only-with-negative-prefix (< arg 0) t))
-        (if (wrap-region-insert-tag-p key)
-            (wrap-region-with-tag)
-          (wrap-region-with-punctuations
-           (wrap-region-wrapper-left wrapper)
-           (wrap-region-wrapper-right wrapper)))
-      (wrap-region-fallback key))))
-
-(defun wrap-region-find (key)
-  "Find first wrapper with trigger KEY that should be active in MAJOR-MODE."
-  (let ((wrappers (gethash key wrap-region-table)))
-    (or
-     (find-if
-      (lambda (wrapper)
-        (member major-mode (wrap-region-wrapper-modes wrapper)))
-      wrappers)
-     (find-if
-      (lambda (wrapper)
-        (not (wrap-region-wrapper-modes wrapper)))
-      wrappers))))
-
-(defun wrap-region-insert-tag-p (key)
-  "Check if tag should be inserted or not."
-  (and
-   (equal key "<")
-   (member major-mode wrap-region-tag-active-modes)))
-
-(defun wrap-region-with-tag ()
-  "Wraps region with tag."
-  (let* ((tag (read-string "Enter Tag (with optional attributes): "))
-         (split (split-string tag " "))
-         (tag-name (car split))
-         (left (concat "<" tag ">"))
-         (right (concat "</" tag-name ">")))
-    (wrap-region-with left right)))
-
-(defun wrap-region-with-punctuations (left right)
-  "Wraps region with LEFT and RIGHT punctuations."
-  (wrap-region-with left right))
-
-(defun wrap-region-with (left right)
-  "Wraps region with LEFT and RIGHT."
-  (run-hooks 'wrap-region-before-wrap-hook)
-  (let ((beg (region-beginning))
-        (end (region-end))
-        (pos (point))
-        (deactivate-mark nil))
-    (save-excursion
-      (goto-char beg)
-      (insert left)
-      (goto-char (+ end (length left)))
-      (insert right))
-    (if wrap-region-keep-mark
-        (let* ((beg-p (eq beg pos))
-               (beg* (+ beg (length left)))
-               (end* (+ end (length left)))
-               (pos* (if beg-p beg* end*)))
-          (push-mark (if beg-p end* beg*) nil t)
-          (goto-char (if beg-p beg* end*)))
-      (deactivate-mark)))
-  (run-hooks 'wrap-region-after-wrap-hook))
-
-(defun wrap-region-fallback (key)
-  "Execute function that KEY was bound to before `wrap-region-mode'."
-  (let ((wrap-region-mode nil))
-    (execute-kbd-macro
-     (edmacro-parse-keys key))))
-
-(defun wrap-region-add-wrappers (wrappers)
-  "Add WRAPPERS by calling `wrap-region-add-wrapper' for each one."
-  (mapc
-   (lambda (wrapper)
-     (apply 'wrap-region-add-wrapper wrapper))
-   wrappers))
-
-(defun wrap-region-add-wrapper (left right &optional key mode-or-modes)
-  "Add new LEFT and RIGHT wrapper.
-
-Optional KEY is the trigger key and MODE-OR-MODES is a single
-mode or multiple modes that the wrapper should trigger in."
-  (or key (setq key left))
-  (let ((wrappers (gethash key wrap-region-table))
-        (modes
-         (if mode-or-modes
-             (if (listp mode-or-modes)
-                 mode-or-modes
-               (list mode-or-modes)))))
-    (if wrappers
-        (let ((wrapper-exactly-same
-               (find-if
-                (lambda (wrapper)
-                  (and
-                   (equal (wrap-region-wrapper-key wrapper) key)
-                   (equal (wrap-region-wrapper-left wrapper) left)
-                   (equal (wrap-region-wrapper-right wrapper) right)))
-                wrappers)))
-          (if wrapper-exactly-same
-              (when (wrap-region-wrapper-modes wrapper-exactly-same)
-                (if modes
-                    (setf
-                     (wrap-region-wrapper-modes wrapper-exactly-same)
-                     (union modes (wrap-region-wrapper-modes wrapper-exactly-same)))
-                  (let ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right)))
-                    (puthash key (cons new-wrapper wrappers) wrap-region-table))))
-            (let* ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right :modes modes))
-                   (wrapper-same-trigger
-                    (find-if
-                     (lambda (wrapper)
-                       (equal (wrap-region-wrapper-key wrapper) key))
-                     wrappers))
-                   (wrapper-same-trigger-modes
-                    (wrap-region-wrapper-modes wrapper-same-trigger)))
-              (when (and wrapper-same-trigger wrapper-same-trigger-modes)
-                (let ((new-modes (nset-difference (wrap-region-wrapper-modes wrapper-same-trigger) modes)))
-                  (if new-modes
-                      (setf (wrap-region-wrapper-modes wrapper-same-trigger) new-modes)
-                    (setq wrappers (delete wrapper-same-trigger wrappers)))))
-              (puthash key (cons new-wrapper wrappers) wrap-region-table))))
-      (let ((new-wrapper (make-wrap-region-wrapper :key key :left left :right right :modes modes)))
-        (puthash key (list new-wrapper) wrap-region-table))))
-  (wrap-region-define-trigger key))
-
-(defun wrap-region-remove-wrapper (key &optional mode-or-modes)
-  "Remove wrapper with trigger KEY or exclude from MODE-OR-MODES.
-
-If MODE-OR-MODES is not present, all wrappers for KEY are removed."
-  (if mode-or-modes
-      (let ((wrappers (gethash key wrap-region-table))
-            (modes
-             (if mode-or-modes
-                 (if (listp mode-or-modes)
-                     mode-or-modes
-                   (list mode-or-modes)))))
-        (mapc
-         (lambda (mode)
-           (let ((wrapper-including-mode
-                  (find-if
-                   (lambda (wrapper)
-                     (member mode (wrap-region-wrapper-modes wrapper)))
-                   wrappers)))
-             (when wrapper-including-mode
-               (let ((new-modes (delete mode (wrap-region-wrapper-modes wrapper-including-mode))))
-                 (if new-modes
-                     (setf (wrap-region-wrapper-modes wrapper-including-mode) new-modes)
-                   (puthash key (delete wrapper-including-mode wrappers) wrap-region-table))))))
-         modes))
-    (wrap-region-destroy-wrapper key)))
-
-(defun wrap-region-destroy-wrapper (key)
-  "Remove the wrapper bound to KEY, no questions asked."
-  (remhash key wrap-region-table)
-  (wrap-region-unset-key key))
-
-(defun wrap-region-define-wrappers ()
-  "Defines defaults wrappers."
-  (mapc
-   (lambda (pair)
-     (apply 'wrap-region-add-wrapper pair))
-   '(("\"" "\"")
-     ("'"  "'")
-     ("("  ")")
-     ("{"  "}")
-     ("["  "]")
-     ("<"  ">"))))
-
-(defun wrap-region-define-trigger (key)
-  "Defines KEY as wrapper."
-  (wrap-region-define-key
-   key
-   `(lambda (arg)
-      (interactive "p")
-      (wrap-region-trigger arg ,key))))
-
-(defun wrap-region-unset-key (key)
-  "Remove KEY from `wrap-region-mode-map'."
-  (wrap-region-define-key key))
-
-(defun wrap-region-define-key (key &optional fn)
-  "Binds KEY to FN in `wrap-region-mode-map'."
-  (define-key wrap-region-mode-map (read-kbd-macro key) fn))
-
-
-;;;###autoload
-(define-minor-mode wrap-region-mode
-  "Wrap region with stuff."
-  :init-value nil
-  :lighter " wr"
-  :keymap wrap-region-mode-map
-  (when wrap-region-mode
-    (wrap-region-define-wrappers)
-    (run-hooks 'wrap-region-hook)))
-
-;;;###autoload
-(defun turn-on-wrap-region-mode ()
-  "Turn on `wrap-region-mode'"
-  (interactive)
-  (unless (member major-mode wrap-region-except-modes)
-    (wrap-region-mode +1)))
-
-;;;###autoload
-(defun turn-off-wrap-region-mode ()
-  "Turn off `wrap-region-mode'."
-  (interactive)
-  (wrap-region-mode -1))
-
-;;;###autoload
-(define-globalized-minor-mode wrap-region-global-mode
-  wrap-region-mode
-  turn-on-wrap-region-mode)
-
-(provide 'wrap-region)
-
-;;; wrap-region.el ends here

watch-tests.watchr

@@ -7,13 +7,13 @@ end
 
 def run_all_tests
   system('clear')
-  result = run "./util/ecukes/ecukes --graphical"
+  result = run "./run-tests.sh"
   puts result
 end
 
 def run_test(file)
   system('clear')
-  result = run "./util/ecukes/ecukes --graphical #{file}"
+  result = run "./run-tests.sh #{file} --verbose"
   puts result
 end