* mu4e: use <insert> as binding for deferred ('something') marking, just like

midnight commander

mu4e/mu4e-headers.el

@@ -402,7 +402,7 @@ after the end of the search results."
 ;; since `mu4e~headers-defun-mark-func' is a macro, the argument must be a
 ;; literal value.
 (mu4e~headers-defun-mark-for refile)
-(mu4e~headers-defun-mark-for deferred)
+(mu4e~headers-defun-mark-for something)
 (mu4e~headers-defun-mark-for delete)
 (mu4e~headers-defun-mark-for flag)
 (mu4e~headers-defun-mark-for move)
@@ -484,8 +484,13 @@ after the end of the search results."
       (define-key map (kbd "-")            'mu4e-headers-mark-for-unflag)
       (define-key map (kbd "&")            'mu4e-headers-mark-for-custom)
 
-      (define-key map (kbd "*")              'mu4e-headers-mark-for-deferred)
-      (define-key map (kbd "<kp-multiply>")  'mu4e-headers-mark-for-deferred)
+      ;; (define-key map (kbd "*")              'mu4e-headers-mark-for-something)
+      ;; (define-key map (kbd "<kp-multiply>")  'mu4e-headers-mark-for-something)
+
+      (define-key map (kbd "<insertchar>")   'mu4e-headers-mark-for-something)
+      (define-key map (kbd "<insert>")       'mu4e-headers-mark-for-something)
+
+      
       (define-key map (kbd "#")   'mu4e-mark-resolve-deferred-marks)
 
       (define-key map "U" 'mu4e-mark-unmark-all)

mu4e/mu4e-mark.el

@@ -93,16 +93,16 @@ The following marks are available, and the corresponding props:
 
    MARK       TARGET    description
    ----------------------------------------------------------
-   `refile'  y		mark this message for archiving
-   `deferred' n         mark this message for *something* (decided later)
-   `delete'   n         remove the message
-   `flag'     n         mark this message for flagging
-   `move'     y         move the message to some folder
-   `read'     n         mark the message as read
-   `trash'    y         thrash the message to some folder
-   `unflag'   n         mark this message for unflagging
-   `unmark'   n         unmark this message
-   `unread'   n         mark the message as unread"
+   `refile'    y	mark this message for archiving
+   `something' n	mark this message for *something* (decided later)
+   `delete'    n	remove the message
+   `flag'      n	mark this message for flagging
+   `move'      y	move the message to some folder
+   `read'      n	mark the message as read
+   `trash'     y	thrash the message to some folder
+   `unflag'    n	mark this message for unflagging
+   `unmark'    n	unmark this message
+   `unread'    n	mark the message as unread"
   (interactive)
   (let* ((msg (mu4e-message-at-point))
 	  (docid (mu4e-message-field msg :docid))
@@ -112,7 +112,7 @@ The following marks are available, and the corresponding props:
 	  (markcell
 	    (case mark
 	      (refile    `("r" . ,target))
-	      (deferred  '("*" . "deferred"))
+	      (something '("*" . ""))
 	      (delete    '("D" . "delete"))
 	      (flag      '("+" . "flag"))
 	      (move      `("m" . ,target))
@@ -197,9 +197,9 @@ headers in the region. Optionally, provide TARGET (for moves)."
 	(when (mu4e~headers-goto-docid docid)
 	  (mu4e-mark-at-point (car markcell) (cdr markcell)))))))
 
-(defun mu4e~mark-get-markpair (prompt &optional allow-deferred)
-  "Ask user for a mark; return (MARK . TARGET). If ALLOW-DEFERRED
-is non-nil, allow the 'deferred' pseudo mark as well."
+(defun mu4e~mark-get-markpair (prompt &optional allow-something)
+  "Ask user for a mark; return (MARK . TARGET). If ALLOW-SOMETHING
+is non-nil, allow the 'something' pseudo mark as well."
   (let* ((marks '( ("refile"   . refile)
 		   ("move"	. move)
 		   ("dtrash"	. trash)
@@ -210,8 +210,8 @@ is non-nil, allow the 'deferred' pseudo mark as well."
 		   ("-unflag"	. unflag)
 		   ("unmark"	. unmark)))
 	  (marks
-	    (if allow-deferred
-	      (append marks (list '("*deferred" . deferred)))
+	    (if allow-something
+	      (append marks (list '("something" . something)))
 	      marks))
 	  (mark (mu4e-read-option prompt marks))
 	  (target
@@ -221,14 +221,14 @@ is non-nil, allow the 'deferred' pseudo mark as well."
 
 
 (defun mu4e-mark-resolve-deferred-marks ()
-  "Check if there are any deferred marks. If there are such marks,
+  "Check if there are any deferred ('something') marks. If there are such marks,
 replace them with a _real_ mark (ask the user which one)."
   (interactive)
   (let ((markpair))
     (maphash
       (lambda (docid val)
 	(let ((mark (car val)) (target (cdr val)))
-	  (when (eql mark 'deferred)
+	  (when (eql mark 'something)
 	    (unless markpair
 	      (setq markpair
 		(mu4e~mark-get-markpair "Set deferred mark to: " nil)))

mu4e/mu4e-view.el

@@ -549,8 +549,12 @@ at POINT, or if nil, at (point)."
       (define-key map (kbd "+") 'mu4e-view-mark-for-flag)
       (define-key map (kbd "-") 'mu4e-view-mark-for-unflag)
 
-      (define-key map (kbd "*")             'mu4e-view-mark-for-deferred)
-      (define-key map (kbd "<kp-multiply>") 'mu4e-view-mark-for-deferred)
+      ;; (define-key map (kbd "*")             'mu4e-view-mark-for-something)
+      ;; (define-key map (kbd "<kp-multiply>") 'mu4e-view-mark-for-something)
+
+      (define-key map (kbd "<insert>")     'mu4e-view-mark-for-something)
+      (define-key map (kbd "<insertchar>") 'mu4e-view-mark-for-something)
+      
       (define-key map (kbd "#") 'mu4e-mark-resolve-deferred-marks)
 
       ;; misc

mu4e/mu4e.texi

@@ -693,8 +693,8 @@ U            unmark *all* messages
 %            mark based on a regular expression
 T,t          mark whole thread, subthread
 
-*            deferred mark (decide what to mark for later)
-#            resolve deferred marks
+<insert>     mark for 'something' (decide later)
+#            resolve deferred 'something' marks
 
 x            execute actions for the marked messages
 
@@ -929,8 +929,8 @@ U            unmark *all* messages
 %            mark based on a regular expression
 T,t          mark whole thread, subthread
 
-SPC          deferred mark (decide what to mark for later)
-*            resolve deferred marks
+<insert>     mark for 'something' (decide later)
+#            resolve deferred 'something' marks
 
 x            execute actions for the marked messages
 
@@ -1644,7 +1644,7 @@ apply to messages:
 @verbatim
 | mark for/as  | keybinding  | description              |
 |--------------+-------------+--------------------------|
-| deferred     | *           | mark now, decide later   |
+| 'something'  | <insert>    | mark now, decide later   |
 | delete       | D, <delete> | delete                   |
 | flag         | +           | mark as 'flagged'        |
 | move         | m           | move to some maildir     |
@@ -1665,11 +1665,14 @@ may slow down things significantly@footnote{this uses an emacs feature called
 @emph{overlays}, which are slow when used a lot in a buffer}. For this reason,
 you can disable this by setting @code{mu4e-headers-show-target} to @code{nil}.
 
-@t{deferred} is a special kind of mark; you can use it to mark some messages,
-and then decide later what mark to use for them. At any time, you can set the
-actual mark with @code{mu4e-mark-resolve-deferred-marks} (@key{#}), or
-@t{mu4e} asks you for it when you execute the marks (@key{x}).
-
+@t{something} is a special kind of mark; you can use it to mark messages for
+'something', and then decide later what the 'something' should
+be@footnote{This kind of 'deferred marking' is similar to the facility in
+@t{midnight commander} (@url{http://www.midnight-commander.org/}) and the
+like, and uses the same key binding (@key{insert}).}  , using @t{M-x
+mu4e-mark-resolve-deferred-marks} (@key{#}). Alternatively, @t{mu4e} will ask
+you when you execute the marks (@key{x}).
+ 
 @node Executing the marks
 @section Executing the marks