![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun-fns.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp|
Return to sun-fns.el CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp |
1.1 root 1: ;; Subroutines of Mouse handling for Sun windows
2: ;; Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: ;; This file is part of GNU Emacs.
5:
6: ;; GNU Emacs is distributed in the hope that it will be useful,
7: ;; but WITHOUT ANY WARRANTY. No author or distributor
8: ;; accepts responsibility to anyone for the consequences of using it
9: ;; or for whether it serves any particular purpose or works at all,
10: ;; unless he says so in writing. Refer to the GNU Emacs General Public
11: ;; License for full details.
12:
13: ;; Everyone is granted permission to copy, modify and redistribute
14: ;; GNU Emacs, but only under the conditions described in the
15: ;; GNU Emacs General Public License. A copy of this license is
16: ;; supposed to have been given to you along with GNU Emacs so you
17: ;; can know your rights and responsibilities. It should be in a
18: ;; file named COPYING. Among other things, the copyright notice
19: ;; and this notice must be preserved on all copies.
20:
21: ;;; Submitted Mar. 1987, Jeff Peck
22: ;;; Sun Microsystems Inc. <[email protected]>
23: ;;; Conceived Nov. 1986, Stan Jefferson,
24: ;;; Computer Science Lab, SRI International.
25: ;;; GoodIdeas Feb. 1987, Steve Greenbaum
26: ;;; & UpClicks Reasoning Systems, Inc.
27: ;;;
28: (provide 'sun-fns)
29: (require 'sun-mouse)
30: ;;;
31: ;;; Functions for manipulating via the mouse and mouse-map definitions
32: ;;; for accessing them. Also definitons of mouse menus.
33: ;;; This file you should freely modify to reflect you personal tastes.
34: ;;;
35: ;;; First half of file defines functions to implement mouse commands,
36: ;;; Don't delete any of those, just add what ever else you need.
37: ;;; Second half of file defines mouse bindings, do whatever you want there.
38:
39: ;;;
40: ;;; Mouse Functions.
41: ;;;
42: ;;; These functions follow the sun-mouse-handler convention of being called
43: ;;; with three arguements: (window x-pos y-pos)
44: ;;; This makes it easy for a mouse executed command to know where the mouse is.
45: ;;; Use the macro "eval-in-window" to execute a function
46: ;;; in a temporarily selected window.
47: ;;;
48: ;;; If you have a function that must be called with other arguments
49: ;;; bind the mouse button to an s-exp that contains the necessary parameters.
50: ;;; See "minibuffer" bindings for examples.
51: ;;;
52: (defconst cursor-pause-milliseconds 300
53: "*Number of milliseconds to display alternate cursor (usually the mark)")
54:
55: (defun indicate-region (&optional pause)
56: "Bounce cursor to mark for cursor-pause-milliseconds and back again"
57: (or pause (setq pause cursor-pause-milliseconds))
58: (let ((point (point)))
59: (goto-char (mark))
60: (sit-for-millisecs pause)
61: ;(update-display)
62: ;(sleep-for-millisecs pause)
63: (goto-char point)))
64:
65:
66: ;;;
67: ;;; Text buffer operations
68: ;;;
69: (defun mouse-move-point (window x y)
70: "Move point to mouse cursor."
71: (select-window window)
72: (move-to-loc x y)
73: (if (memq last-command ; support the mouse-copy/delete/yank
74: '(mouse-copy mouse-delete mouse-yank-move))
75: (setq this-command 'mouse-yank-move))
76: )
77:
78: (defun mouse-set-mark (window x y)
79: "Set mark at mouse cursor."
80: (eval-in-window window ;; use this to get the unwind protect
81: (let ((point (point)))
82: (move-to-loc x y)
83: (set-mark (point))
84: (goto-char point)
85: (indicate-region)))
86: )
87:
88: (defun mouse-set-mark-and-select (window x y)
89: "Set mark at mouse cursor, and select that window."
90: (select-window window)
91: (mouse-set-mark window x y)
92: )
93:
94: (defun mouse-set-mark-and-stuff (w x y)
95: "Set mark at mouse cursor, and put region in stuff buffer."
96: (mouse-set-mark-and-select w x y)
97: (sun-select-region (region-beginning) (region-end)))
98:
99: ;;;
100: ;;; Simple mouse dragging stuff: marking with button up
101: ;;;
102:
103: (defvar *mouse-drag-window* nil)
104: (defvar *mouse-drag-x* -1)
105: (defvar *mouse-drag-y* -1)
106:
107: (defun mouse-drag-move-point (window x y)
108: "Move point to mouse cursor, and allow dragging."
109: (mouse-move-point window x y)
110: (setq *mouse-drag-window* window
111: *mouse-drag-x* x
112: *mouse-drag-y* y))
113:
114: (defun mouse-drag-set-mark-stuff (window x y)
115: "The up click handler that goes with mouse-drag-move-point.
116: If mouse is in same WINDOW but at different X or Y than when
117: mouse-drag-move-point was last executed, set the mark at mouse
118: and put the region in the stuff buffer."
119: (if (and (eq *mouse-drag-window* window)
120: (not (and (equal *mouse-drag-x* x)
121: (equal *mouse-drag-y* y))))
122: (mouse-set-mark-and-stuff window x y)
123: (setq this-command last-command)) ; this was just an upclick no-op.
124: )
125:
126: (defun mouse-select-or-drag-move-point (window x y)
127: "Select window if not selected, otherwise do mouse-drag-move-point."
128: (if (eq (selected-window) window)
129: (mouse-drag-move-point window x y)
130: (mouse-select-window window x y)))
131:
132: ;;;
133: ;;; esoteria:
134: ;;;
135: (defun mouse-exch-pt-and-mark (window x y)
136: "Exchange point and mark."
137: (select-window window)
138: (exchange-point-and-mark)
139: )
140:
141: (defun mouse-call-kbd-macro (window x y)
142: "Invokes last keyboard macro at mouse cursor."
143: (mouse-move-point window x y)
144: (call-last-kbd-macro)
145: )
146:
147: (defun mouse-mark-thing (window x y)
148: "Set point and mark to text object using syntax table.
149: The resulting region is put in the sun-window stuff buffer.
150: Left or right Paren syntax marks an s-expression.
151: Clicking at the end of a line marks the line including a trailing newline.
152: If it doesn't recognize one of these it marks the character at point."
153: (mouse-move-point window x y)
154: (if (eobp) (open-line 1))
155: (let* ((char (char-after (point)))
156: (syntax (char-syntax char)))
157: (cond
158: ((eq syntax ?w) ; word.
159: (forward-word 1)
160: (set-mark (point))
161: (forward-word -1))
162: ;; try to include a single following whitespace (is this a good idea?)
163: ;; No, not a good idea since inconsistent.
164: ;;(if (eq (char-syntax (char-after (mark))) ?\ )
165: ;; (set-mark (1+ (mark))))
166: ((eq syntax ?\( ) ; open paren.
167: (mark-sexp 1))
168: ((eq syntax ?\) ) ; close paren.
169: (forward-char 1)
170: (mark-sexp -1)
171: (exchange-point-and-mark))
172: ((eolp) ; mark line if at end.
173: (set-mark (1+ (point)))
174: (beginning-of-line 1))
175: (t ; mark character
176: (set-mark (1+ (point)))))
177: (indicate-region)) ; display region boundary.
178: (sun-select-region (region-beginning) (region-end))
179: )
180:
181: (defun mouse-kill-thing (window x y)
182: "Kill thing at mouse, and put point there."
183: (mouse-mark-thing window x y)
184: (kill-region-and-unmark (region-beginning) (region-end))
185: )
186:
187: (defun mouse-kill-thing-there (window x y)
188: "Kill thing at mouse, leave point where it was.
189: See mouse-mark-thing for a description of the objects recognized."
190: (eval-in-window window
191: (save-excursion
192: (mouse-mark-thing window x y)
193: (kill-region (region-beginning) (region-end))))
194: )
195:
196: (defun mouse-save-thing (window x y &optional quiet)
197: "Put thing at mouse in kill ring.
198: See mouse-mark-thing for a description of the objects recognized."
199: (mouse-mark-thing window x y)
200: (copy-region-as-kill (region-beginning) (region-end))
201: (if (not quiet) (message "Thing saved"))
202: )
203:
204: (defun mouse-save-thing-there (window x y &optional quiet)
205: "Put thing at mouse in kill ring, leave point as is.
206: See mouse-mark-thing for a description of the objects recognized."
207: (eval-in-window window
208: (save-excursion
209: (mouse-save-thing window x y quiet))))
210:
211: ;;;
212: ;;; Mouse yanking...
213: ;;;
214: (defun mouse-copy-thing (window x y)
215: "Put thing at mouse in kill ring, yank to point.
216: See mouse-mark-thing for a description of the objects recognized."
217: (setq last-command 'not-kill) ;Avoids appending to previous kills.
218: (mouse-save-thing-there window x y t)
219: (yank)
220: (setq this-command 'yank))
221:
222: (defun mouse-move-thing (window x y)
223: "Kill thing at mouse, yank it to point.
224: See mouse-mark-thing for a description of the objects recognized."
225: (setq last-command 'not-kill) ;Avoids appending to previous kills.
226: (mouse-kill-thing-there window x y)
227: (yank)
228: (setq this-command 'yank))
229:
230: (defun mouse-yank-at-point (&optional window x y)
231: "Yank from kill-ring at point; then cycle thru kill ring."
232: (if (eq last-command 'yank)
233: (let ((before (< (point) (mark))))
234: (delete-region (point) (mark))
235: (rotate-yank-pointer 1)
236: (insert (car kill-ring-yank-pointer))
237: (if before (exchange-point-and-mark)))
238: (yank))
239: (setq this-command 'yank))
240:
241: (defun mouse-yank-at-mouse (window x y)
242: "Yank from kill-ring at mouse; then cycle thru kill ring."
243: (mouse-move-point window x y)
244: (mouse-yank-at-point window x y))
245:
246: (defun mouse-save/delete/yank (&optional window x y)
247: "Context sensitive save/delete/yank.
248: Consecutive clicks perform as follows:
249: * first click saves region to kill ring,
250: * second click kills region,
251: * third click yanks from kill ring,
252: * subsequent clicks cycle thru kill ring.
253: If mouse-move-point is performed after the first or second click,
254: the next click will do a yank, etc. Except for a possible mouse-move-point,
255: this command is insensitive to mouse location."
256: (cond
257: ((memq last-command '(mouse-delete yank mouse-yank-move)) ; third+ click
258: (mouse-yank-at-point))
259: ((eq last-command 'mouse-copy) ; second click
260: (kill-region (region-beginning) (region-end))
261: (setq this-command 'mouse-delete))
262: (t ; first click
263: (copy-region-as-kill (region-beginning) (region-end))
264: (message "Region saved")
265: (setq this-command 'mouse-copy))
266: ))
267:
268:
269: (defun mouse-split-horizontally (window x y)
270: "Splits the window horizontally at mouse cursor."
271: (eval-in-window window (split-window-horizontally (1+ x))))
272:
273: (defun mouse-split-vertically (window x y)
274: "Split the window vertically at the mouse cursor."
275: (eval-in-window window (split-window-vertically (1+ y))))
276:
277: (defun mouse-select-window (window x y)
278: "Selects the window, restoring point."
279: (select-window window))
280:
281: (defun mouse-delete-other-windows (window x y)
282: "Deletes all windows except the one mouse is in."
283: (delete-other-windows window))
284:
285: (defun mouse-delete-window (window x y)
286: "Deletes the window mouse is in."
287: (delete-window window))
288:
289: (defun mouse-undo (window x y)
290: "Invokes undo in the window mouse is in."
291: (eval-in-window window (undo)))
292:
293: ;;;
294: ;;; Scroll operations
295: ;;;
296:
297: ;;; The move-to-window-line is used below because otherwise
298: ;;; scrolling a non-selected process window with the mouse, after
299: ;;; the process has written text past the bottom of the window,
300: ;;; gives an "End of buffer" error, and then scrolls. The
301: ;;; move-to-window-line seems to force recomputing where things are.
302: (defun mouse-scroll-up (window x y)
303: "Scrolls the window upward."
304: (eval-in-window window (move-to-window-line 1) (scroll-up nil)))
305:
306: (defun mouse-scroll-down (window x y)
307: "Scrolls the window downward."
308: (eval-in-window window (scroll-down nil)))
309:
310: (defun mouse-scroll-proportional (window x y)
311: "Scrolls the window proportionally corresponding to window
312: relative X divided by window width."
313: (eval-in-window window
314: (if (>= x (1- (window-width)))
315: ;; When x is maximun (equal to or 1 less than window width),
316: ;; goto end of buffer. We check for this special case
317: ;; becuase the calculated goto-char often goes short of the
318: ;; end due to roundoff error, and we often really want to go
319: ;; to the end.
320: (goto-char (point-max))
321: (progn
322: (goto-char (+ (point-min) ; For narrowed regions.
323: (* x (/ (- (point-max) (point-min))
324: (1- (window-width))))))
325: (beginning-of-line))
326: )
327: (what-cursor-position) ; Report position.
328: ))
329:
330: (defun mouse-line-to-top (window x y)
331: "Scrolls the line at the mouse cursor up to the top."
332: (eval-in-window window (scroll-up y)))
333:
334: (defun mouse-top-to-line (window x y)
335: "Scrolls the top line down to the mouse cursor."
336: (eval-in-window window (scroll-down y)))
337:
338: (defun mouse-line-to-bottom (window x y)
339: "Scrolls the line at the mouse cursor to the bottom."
340: (eval-in-window window (scroll-up (+ y (- 2 (window-height))))))
341:
342: (defun mouse-bottom-to-line (window x y)
343: "Scrolls the bottom line up to the mouse cursor."
344: (eval-in-window window (scroll-down (+ y (- 2 (window-height))))))
345:
346: (defun mouse-line-to-middle (window x y)
347: "Scrolls the line at the mouse cursor to the middle."
348: (eval-in-window window (scroll-up (- y -1 (/ (window-height) 2)))))
349:
350: (defun mouse-middle-to-line (window x y)
351: "Scrolls the line at the middle to the mouse cursor."
352: (eval-in-window window (scroll-up (- (/ (window-height) 2) y 1))))
353:
354:
355: ;;;
356: ;;; main emacs menu.
357: ;;;
358: (defmenu expand-menu
359: ("Vertically" mouse-expand-vertically *menu-window*)
360: ("Horizontally" mouse-expand-horizontally *menu-window*))
361:
362: (defmenu delete-window-menu
363: ("This One" delete-window *menu-window*)
364: ("All Others" delete-other-windows *menu-window*))
365:
366: (defmenu mouse-help-menu
367: ("Text Region"
368: mouse-help-region *menu-window* *menu-x* *menu-y* 'text)
369: ("Scrollbar"
370: mouse-help-region *menu-window* *menu-x* *menu-y* 'scrollbar)
371: ("Modeline"
372: mouse-help-region *menu-window* *menu-x* *menu-y* 'modeline)
373: ("Minibuffer"
374: mouse-help-region *menu-window* *menu-x* *menu-y* 'minibuffer)
375: )
376:
377: (defmenu emacs-quit-menu
378: ("Suspend" suspend-emacstool)
379: ("Quit" save-buffers-kill-emacs))
380:
381: (defmenu emacs-menu
382: ("Emacs Menu")
383: ("Stuff Selection" sun-yank-selection)
384: ("Expand" . expand-menu)
385: ("Delete Window" . delete-window-menu)
386: ("Previous Buffer" mouse-select-previous-buffer *menu-window*)
387: ("Save Buffers" save-some-buffers)
388: ("List Directory" list-directory nil)
389: ("Dired" dired nil)
390: ("Mouse Help" . mouse-help-menu)
391: ("Quit" . emacs-quit-menu))
392:
393: (defun emacs-menu-eval (window x y)
394: "Pop-up menu of editor commands."
395: (sun-menu-evaluate window (1+ x) (1- y) 'emacs-menu))
396:
397: (defun mouse-expand-horizontally (window)
398: (eval-in-window window
399: (enlarge-window 4 t)
400: (update-display) ; Try to redisplay, since can get confused.
401: ))
402:
403: (defun mouse-expand-vertically (window)
404: (eval-in-window window (enlarge-window 4)))
405:
406: (defun mouse-select-previous-buffer (window)
407: "Switch buffer in mouse window to most recently selected buffer."
408: (eval-in-window window (switch-to-buffer (other-buffer))))
409:
410: ;;;
411: ;;; minibuffer menu
412: ;;;
413: (defmenu minibuffer-menu
414: ("Minibuffer" message "Just some miscellanous minibuffer commands")
415: ("Stuff" sun-yank-selection)
416: ("Do-It" exit-minibuffer)
417: ("Abort" abort-recursive-edit)
418: ("Suspend" suspend-emacs))
419:
420: (defun minibuffer-menu-eval (window x y)
421: "Pop-up menu of commands."
422: (sun-menu-evaluate window x (1- y) 'minibuffer-menu))
423:
424: (defun mini-move-point (window x y)
425: ;; -6 is good for most common cases
426: (mouse-move-point window (- x 6) 0))
427:
428: (defun mini-set-mark-and-stuff (window x y)
429: ;; -6 is good for most common cases
430: (mouse-set-mark-and-stuff window (- x 6) 0))
431:
432:
433: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
434: ;;; Buffer-mode Mouse commands
435: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
436:
437: (defun Buffer-at-mouse (w x y)
438: "Calls Buffer-menu-buffer from mouse click."
439: (save-window-excursion
440: (mouse-move-point w x y)
441: (beginning-of-line)
442: (Buffer-menu-buffer t)))
443:
444: (defun mouse-buffer-bury (w x y)
445: "Bury the indicated buffer."
446: (bury-buffer (Buffer-at-mouse w x y))
447: )
448:
449: (defun mouse-buffer-select (w x y)
450: "Put the indicated buffer in selected window."
451: (switch-to-buffer (Buffer-at-mouse w x y))
452: (list-buffers)
453: )
454:
455: (defun mouse-buffer-delete (w x y)
456: "mark indicated buffer for delete"
457: (save-window-excursion
458: (mouse-move-point w x y)
459: (Buffer-menu-delete)
460: ))
461:
462: (defun mouse-buffer-execute (w x y)
463: "execute buffer-menu selections"
464: (save-window-excursion
465: (mouse-move-point w x y)
466: (Buffer-menu-execute)
467: ))
468:
469: (defun enable-mouse-in-buffer-list ()
470: "Call this to enable mouse selections in *Buffer List*
471: LEFT puts the indicated buffer in the selected window.
472: MIDDLE buries the indicated buffer.
473: RIGHT marks the indicated buffer for deletion.
474: MIDDLE-RIGHT deletes the marked buffers.
475: To unmark a buffer marked for deletion, select it with LEFT."
476: (save-window-excursion
477: (list-buffers) ; Initialize *Buffer List*
478: (set-buffer "*Buffer List*")
479: (local-set-mouse '(text middle) 'mouse-buffer-bury)
480: (local-set-mouse '(text left) 'mouse-buffer-select)
481: (local-set-mouse '(text right) 'mouse-buffer-delete)
482: (local-set-mouse '(text middle right) 'mouse-buffer-execute)
483: )
484: )
485:
486:
487: ;;;*******************************************************************
488: ;;;
489: ;;; Global Mouse Bindings.
490: ;;;
491: ;;; There is some sense to this mouse binding madness:
492: ;;; LEFT and RIGHT scrolls are inverses.
493: ;;; SHIFT makes an opposite meaning in the scroll bar.
494: ;;; SHIFT is an alternative to DOUBLE (but double chords do not exist).
495: ;;; META makes the scrollbar functions work in the text region.
496: ;;; MIDDLE operates the mark
497: ;;; LEFT operates at point
498:
499: ;;; META commands are generally non-destructive,
500: ;;; SHIFT is a little more dangerous.
501: ;;; CONTROL is for the really complicated ones.
502:
503: ;;; CONTROL-META-SHIFT-RIGHT gives help on that region.
504:
505: ;;;
506: ;;; Text Region mousemap
507: ;;;
508: ;; The basics: Point, Mark, Menu, Sun-Select:
509: (global-set-mouse '(text left) 'mouse-drag-move-point)
510: (global-set-mouse '(text up left) 'mouse-drag-set-mark-stuff)
511: (global-set-mouse '(text shift left) 'mouse-exch-pt-and-mark)
512: (global-set-mouse '(text double left) 'mouse-exch-pt-and-mark)
513:
514: (global-set-mouse '(text middle) 'mouse-set-mark-and-stuff)
515:
516: (global-set-mouse '(text right) 'emacs-menu-eval)
517: (global-set-mouse '(text shift right) '(sun-yank-selection))
518: (global-set-mouse '(text double right) '(sun-yank-selection))
519:
520: ;; The Slymoblics multi-command for Save, Kill, Copy, Move:
521: (global-set-mouse '(text shift middle) 'mouse-save/delete/yank)
522: (global-set-mouse '(text double middle) 'mouse-save/delete/yank)
523:
524: ;; Save, Kill, Copy, Move Things:
525: ;; control-left composes with control middle/right to produce copy/move
526: (global-set-mouse '(text control middle ) 'mouse-save-thing-there)
527: (global-set-mouse '(text control right ) 'mouse-kill-thing-there)
528: (global-set-mouse '(text control left) 'mouse-yank-at-point)
529: (global-set-mouse '(text control middle left) 'mouse-copy-thing)
530: (global-set-mouse '(text control right left) 'mouse-move-thing)
531: (global-set-mouse '(text control right middle) 'mouse-mark-thing)
532:
533: ;; The Universal mouse help command (press all buttons):
534: (global-set-mouse '(text shift control meta right) 'mouse-help-region)
535: (global-set-mouse '(text double control meta right) 'mouse-help-region)
536:
537: ;;; Meta in Text Region is like meta version in scrollbar:
538: (global-set-mouse '(text meta left) 'mouse-line-to-top)
539: (global-set-mouse '(text meta shift left) 'mouse-line-to-bottom)
540: (global-set-mouse '(text meta double left) 'mouse-line-to-bottom)
541: (global-set-mouse '(text meta middle) 'mouse-line-to-middle)
542: (global-set-mouse '(text meta shift middle) 'mouse-middle-to-line)
543: (global-set-mouse '(text meta double middle) 'mouse-middle-to-line)
544: (global-set-mouse '(text meta control middle) 'mouse-split-vertically)
545: (global-set-mouse '(text meta right) 'mouse-top-to-line)
546: (global-set-mouse '(text meta shift right) 'mouse-bottom-to-line)
547: (global-set-mouse '(text meta double right) 'mouse-bottom-to-line)
548:
549: ;; Miscellaneous:
550: (global-set-mouse '(text meta control left) 'mouse-call-kbd-macro)
551: (global-set-mouse '(text meta control right) 'mouse-undo)
552:
553: ;;;
554: ;;; Scrollbar mousemap.
555: ;;; Are available in the Scrollbar Region, or with Meta Text (or Meta Scrollbar)
556: ;;;
557: (global-set-mouse '(scrollbar left) 'mouse-line-to-top)
558: (global-set-mouse '(scrollbar shift left) 'mouse-line-to-bottom)
559: (global-set-mouse '(scrollbar double left) 'mouse-line-to-bottom)
560:
561: (global-set-mouse '(scrollbar middle) 'mouse-line-to-middle)
562: (global-set-mouse '(scrollbar shift middle) 'mouse-middle-to-line)
563: (global-set-mouse '(scrollbar double middle) 'mouse-middle-to-line)
564: (global-set-mouse '(scrollbar control middle) 'mouse-split-vertically)
565:
566: (global-set-mouse '(scrollbar right) 'mouse-top-to-line)
567: (global-set-mouse '(scrollbar shift right) 'mouse-bottom-to-line)
568: (global-set-mouse '(scrollbar double right) 'mouse-bottom-to-line)
569:
570: (global-set-mouse '(scrollbar meta left) 'mouse-line-to-top)
571: (global-set-mouse '(scrollbar meta shift left) 'mouse-line-to-bottom)
572: (global-set-mouse '(scrollbar meta double left) 'mouse-line-to-bottom)
573: (global-set-mouse '(scrollbar meta middle) 'mouse-line-to-middle)
574: (global-set-mouse '(scrollbar meta shift middle) 'mouse-middle-to-line)
575: (global-set-mouse '(scrollbar meta double middle) 'mouse-middle-to-line)
576: (global-set-mouse '(scrollbar meta control middle) 'mouse-split-vertically)
577: (global-set-mouse '(scrollbar meta right) 'mouse-top-to-line)
578: (global-set-mouse '(scrollbar meta shift right) 'mouse-bottom-to-line)
579: (global-set-mouse '(scrollbar meta double right) 'mouse-bottom-to-line)
580:
581: ;; And the help menu:
582: (global-set-mouse '(scrollbar shift control meta right) 'mouse-help-region)
583: (global-set-mouse '(scrollbar double control meta right) 'mouse-help-region)
584:
585: ;;;
586: ;;; Modeline mousemap.
587: ;;;
588: ;;; Note: meta of any single button selects window.
589:
590: (global-set-mouse '(modeline left) 'mouse-scroll-up)
591: (global-set-mouse '(modeline meta left) 'mouse-select-window)
592:
593: (global-set-mouse '(modeline middle) 'mouse-scroll-proportional)
594: (global-set-mouse '(modeline meta middle) 'mouse-select-window)
595: (global-set-mouse '(modeline control middle) 'mouse-split-horizontally)
596:
597: (global-set-mouse '(modeline right) 'mouse-scroll-down)
598: (global-set-mouse '(modeline meta right) 'mouse-select-window)
599:
600: ;;; control-left selects this window, control-right deletes it.
601: (global-set-mouse '(modeline control left) 'mouse-delete-other-windows)
602: (global-set-mouse '(modeline control right) 'mouse-delete-window)
603:
604: ;; in case of confusion, just select it:
605: (global-set-mouse '(modeline control left right)'mouse-select-window)
606:
607: ;; even without confusion (and without the keyboard) select it:
608: (global-set-mouse '(modeline left right) 'mouse-select-window)
609:
610: ;; And the help menu:
611: (global-set-mouse '(modeline shift control meta right) 'mouse-help-region)
612: (global-set-mouse '(modeline double control meta right) 'mouse-help-region)
613:
614: ;;;
615: ;;; Minibuffer Mousemap
616: ;;; Demonstrating some variety:
617: ;;;
618: (global-set-mouse '(minibuffer left) 'mini-move-point)
619:
620: (global-set-mouse '(minibuffer middle) 'mini-set-mark-and-stuff)
621:
622: (global-set-mouse '(minibuffer shift middle) '(prev-complex-command))
623: (global-set-mouse '(minibuffer double middle) '(prev-complex-command))
624: (global-set-mouse '(minibuffer control middle) '(next-complex-command 1))
625: (global-set-mouse '(minibuffer meta middle) '(previous-complex-command 1))
626:
627: (global-set-mouse '(minibuffer right) 'minibuffer-menu-eval)
628:
629: (global-set-mouse '(minibuffer shift control meta right) 'mouse-help-region)
630: (global-set-mouse '(minibuffer double control meta right) 'mouse-help-region)
631:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.