[ELPA] New package: beacon

[ELPA] New package: beacon

[Artur Malabarba]

Whenever the window scrolls or the buffer changes a light will shine on
top of your cursor so you know where it is.

That’s it. See this gif for example:
https://github.com/Malabarba/beacon/raw/master/example-beacon.gif


----------


;;; beacon.el --- Highlight the cursor when the window scrolls  -*-
lexical-binding: t; -*-

;; Copyright (C) 2015 Free Software Foundation, Inc.

;; Author: Artur Malabarba <emacs@endlessparentheses.com>
;; URL: https://github.com/Malabarba/beacon
;; Keywords: convenience
;; Version: 0.1
;; Package-Requires: ((seq "1.9"))

;; 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 is a global minor-mode. Turn it on everywhere with:
;; ┌────
;; │ (beacon-mode 1)
;; └────
;;
;; Whenever the window scrolls or the buffer changes a light will shine on
;; top of your cursor so you know where it is.
;;
;; That’s it.
;;
;;
;; 1 Customizations
;; ════════════════
;;
;;   • To customize the appearance of the beacon, configure `beacon-size'
;;     and `beacon-color'.
;;
;;   • To customize how long it lasts, configure `beacon-blink-duration'
;;       and `beacon-blink-delay'.
;;
;;   • To customize /when/ it is used at all, configure
;;     `beacon-blink-when-window-scrolls',
;;     `beacon-blink-when-buffer-changes', and
;;     `beacon-blink-when-point-moves'.

;;; Code:

(require 'seq)

(defgroup beacon nil
  "Customization group for beacon."
  :group 'emacs
  :prefix "beacon-")

(defvar beacon--timer nil)

(defcustom beacon-push-mark nil
  "Should the mark be pushed before long movements?
If nil, `beacon' will not push the mark.
Otherwise this should be a number, and `beacon' will push the
mark whenever point moves more than that many lines."
  :type '(choice integer (const nil)))

(defcustom beacon-blink-when-point-moves nil
  "Should the beacon blink when moving a long distance?
If nil, don't blink due to plain movement.
If non-nil, this should be an integer, which is the minimum
movement distance (in lines) that triggers a beacon blink."
  :type '(choice integer (const nil)))

(defcustom beacon-blink-when-buffer-changes t
  "Should the beacon blink when changing buffer?"
  :type 'boolean)

(defcustom beacon-blink-when-window-scrolls t
  "Should the beacon blink when the window scrolls?"
  :type 'boolean)

(defcustom beacon-blink-duration 0.3
  "Time, in seconds, that the blink should last."
  :type 'number)

(defcustom beacon-blink-delay 0.3
  "Time, in seconds, before starting to fade the beacon."
  :type 'number)

(defcustom beacon-size 40
  "Size of the beacon in characters."
  :type 'number)

(defcustom beacon-color 0.5
  "Color of the beacon.
This can be a string or a number.

If it is a number, the color is taken to be white or
black (depending on the current theme's background) and this
number is a float between 0 and 1 specifing the brightness.

If it is a string, it is a color name or specification,
e.g. \"#666600\"."
  :type '(choice number color))


;;; Overlays
(defvar beacon--ovs nil)

(defun beacon--colored-overlay (color)
  "Put an overlay at point with background COLOR."
  (let ((ov (make-overlay (point) (1+ (point)))))
    (overlay-put ov 'face (list :background color))
    (overlay-put ov 'beacon t)
    (push ov beacon--ovs)))

(defun beacon--ov-put-after-string (overlay colors)
  "Add an after-string property to OVERLAY.
The property's value is a string of spaces with background
COLORS applied to each one."
  (if (not colors)
      (delete-overlay overlay)
    (overlay-put overlay 'beacon-colors colors)
    (overlay-put overlay 'after-string
                 (propertize
                  (mapconcat (lambda (c) (propertize " " 'face (list
:background c)))
                             colors
                             "")
                  'cursor 1000))))

(defun beacon--after-string-overlay (colors)
  "Put an overlay at point with an after-string property.
The property's value is a string of spaces with background
COLORS applied to each one."
  (let ((ov (make-overlay (point) (point)))
        ;; The after-string must not be longer than the remaining columns from
        ;; point to right window-end else it will be wrapped around (assuming
        ;; truncate-lines is nil) introducing an ugly wrap-around for a
        ;; fraction of a second.
        (colors (seq-take colors (- (window-width) (current-column)))))
    (beacon--ov-put-after-string ov colors)
    (overlay-put ov 'beacon t)
    (push ov beacon--ovs)))

(defun beacon--ov-at-point ()
  (car (or (seq-filter (lambda (o) (overlay-get o 'beacon))
                     (overlays-in (point) (point)))
           (seq-filter (lambda (o) (overlay-get o 'beacon))
                     (overlays-at (point))))))

(defun beacon--vanish ()
  "Turn off the beacon."
  (when (timerp beacon--timer)
    (cancel-timer beacon--timer))
  (mapc #'delete-overlay beacon--ovs)
  (setq beacon--ovs nil))


;;; Colors
(defun beacon--int-range (a b)
  "Return a list of integers between A inclusive and B exclusive.
Only returns `beacon-size' elements."
  (let ((d (/ (- b a) beacon-size))
        (out (list a)))
    (dotimes (_ (1- beacon-size))
      (push (+ (car out) d) out))
    (nreverse out)))

(defun beacon--color-range ()
  "Return a list of background colors for the beacon."
  (let* ((bg (color-values (face-attribute 'default :background)))
         (fg (cond
              ((stringp beacon-color) (color-values beacon-color))
              ((< (color-distance "black" bg)
                  (color-distance "white" bg))
               (make-list 3 (* beacon-color 65535)))
              (t (make-list 3 (* (- 1 beacon-color) 65535))))))
    (apply #'cl-mapcar (lambda (r g b) (format "#%04x%04x%04x" r g b))
           (mapcar (lambda (n) (butlast (beacon--int-range (elt fg n)
(elt bg n))))
                   [0 1 2]))))


;;; Blinking
(defun beacon--shine ()
  "Shine a beacon at point."
  (let ((colors (beacon--color-range)))
    (save-excursion
      (while colors
        (if (looking-at "$")
            (progn
              (beacon--after-string-overlay colors)
              (setq colors nil))
          (beacon--colored-overlay (pop colors))
          (forward-char 1))))))

(defun beacon--dec ()
  "Decrease the beacon brightness by one."
  (pcase (beacon--ov-at-point)
    (`nil (beacon--vanish))
    ((and o (let c (overlay-get o 'beacon-colors)) (guard c))
     (beacon--ov-put-after-string o (cdr c)))
    (o
     (delete-overlay o)
     (save-excursion
       (while (progn (forward-char 1)
                     (setq o (beacon--ov-at-point)))
         (let ((colors (overlay-get o 'beacon-colors)))
           (if (not colors)
               (move-overlay o (1- (point)) (point))
             (forward-char -1)
             (beacon--colored-overlay (pop colors))
             (beacon--ov-put-after-string o colors)
             (forward-char 1))))))))

(defun beacon-blink ()
  "Blink the beacon at the position of the cursor."
  (interactive)
  (beacon--vanish)
  (beacon--shine)
  (setq beacon--timer
        (run-at-time beacon-blink-delay
                     (/ beacon-blink-duration 1.0 beacon-size)
                     #'beacon--dec)))


;;; Movement detection
(defvar beacon--window-scrolled nil)
(defvar beacon--previous-place nil)
(defvar beacon--previous-mark-head nil)

(defun beacon--movement-> (delta)
  "Return non-nil if latest point movement is > DELTA.
If DELTA is nil, return nil."
  (and delta
       (markerp beacon--previous-place)
       (equal (marker-buffer beacon--previous-place)
              (current-buffer))
       (> (abs (- (point) beacon--previous-place))
          delta)
       (> (count-screen-lines (min (point) beacon--previous-place)
                              (max (point) beacon--previous-place))
          delta)))

(defun beacon--maybe-push-mark ()
  "Push mark if it seems to be safe."
  (when (and (not mark-active)
             (beacon--movement-> beacon-push-mark))
    (let ((head (car mark-ring)))
      (when (and (eq beacon--previous-mark-head head)
                 (not (equal head beacon--previous-place)))
        (push-mark beacon--previous-place)))))

(defun beacon--post-command ()
  "Blink if point moved very far."
  (cond
   ((not (markerp beacon--previous-place))
    (beacon--vanish))
   ;; Blink because we changed buffer.
   ((not (equal (marker-buffer beacon--previous-place)
                (current-buffer)))
    (when beacon-blink-when-buffer-changes
      (unless (window-minibuffer-p)
        (beacon-blink))))
   ;; Blink for scrolling.
   ((and beacon-blink-when-window-scrolls
         beacon--window-scrolled
         (equal beacon--window-scrolled (selected-window)))
    (beacon-blink)
    (setq beacon--window-scrolled nil))
   ;; Blink for movement
   ((beacon--movement-> beacon-blink-when-point-moves)
    (beacon-blink))
   ;; Even if we don't blink, vanish any previous beacon.
   (t (beacon--vanish)))
  (beacon--maybe-push-mark)
  (unless (window-minibuffer-p)
    (setq beacon--previous-mark-head (car mark-ring))
    (setq beacon--previous-place (point-marker))))

(defun beacon--window-scroll-function (win _start-pos)
  "Blink the beacon or record that window has been scrolled.
If invoked during the command loop, record the current window so
that it may be blinked on post-command.  This is because the
scrolled window might not be active, but we only know that at
`post-command-hook'.

If invoked outside the command loop, `post-command-hook' would be
unreliable, so just blink immediately."
  (if this-command
      (setq beacon--window-scrolled win)
    (beacon-blink)))


;;; Minor-mode
(defcustom beacon-lighter
  (cond
   ((char-displayable-p ?💡) " 💡")
   ((char-displayable-p ?Λ) " Λ")
   (t " *"))
  "Lighter string used on the mode-line."
  :type 'string)

;;;###autoload
(define-minor-mode beacon-mode
  nil nil beacon-lighter nil
  :global t
  (if beacon-mode
      (progn
        (add-hook 'window-scroll-functions #'beacon--window-scroll-function)
        (add-hook 'post-command-hook #'beacon--post-command))
    (remove-hook 'window-scroll-functions #'beacon--window-scroll-function)
    (remove-hook 'post-command-hook #'beacon--post-command)))

(provide 'beacon)
;;; beacon.el ends here

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 12035 bytes --]

I haven't read either of the source codes, but is it similar to
lisp/cedet/pulse.el?


--
Kaushal Modi

On Thu, Oct 15, 2015 at 1:02 PM, Artur Malabarba <bruce.connor.am@gmail.com>
wrote:

> Whenever the window scrolls or the buffer changes a light will shine on
> top of your cursor so you know where it is.
>
> That’s it. See this gif for example:
> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>
>
> ----------
>
>
> ;;; beacon.el --- Highlight the cursor when the window scrolls  -*-
> lexical-binding: t; -*-
>
> ;; Copyright (C) 2015 Free Software Foundation, Inc.
>
> ;; Author: Artur Malabarba <emacs@endlessparentheses.com>
> ;; URL: https://github.com/Malabarba/beacon
> ;; Keywords: convenience
> ;; Version: 0.1
> ;; Package-Requires: ((seq "1.9"))
>
> ;; 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 is a global minor-mode. Turn it on everywhere with:
> ;; ┌────
> ;; │ (beacon-mode 1)
> ;; └────
> ;;
> ;; Whenever the window scrolls or the buffer changes a light will shine on
> ;; top of your cursor so you know where it is.
> ;;
> ;; That’s it.
> ;;
> ;;
> ;; 1 Customizations
> ;; ════════════════
> ;;
> ;;   • To customize the appearance of the beacon, configure `beacon-size'
> ;;     and `beacon-color'.
> ;;
> ;;   • To customize how long it lasts, configure `beacon-blink-duration'
> ;;       and `beacon-blink-delay'.
> ;;
> ;;   • To customize /when/ it is used at all, configure
> ;;     `beacon-blink-when-window-scrolls',
> ;;     `beacon-blink-when-buffer-changes', and
> ;;     `beacon-blink-when-point-moves'.
>
> ;;; Code:
>
> (require 'seq)
>
> (defgroup beacon nil
>   "Customization group for beacon."
>   :group 'emacs
>   :prefix "beacon-")
>
> (defvar beacon--timer nil)
>
> (defcustom beacon-push-mark nil
>   "Should the mark be pushed before long movements?
> If nil, `beacon' will not push the mark.
> Otherwise this should be a number, and `beacon' will push the
> mark whenever point moves more than that many lines."
>   :type '(choice integer (const nil)))
>
> (defcustom beacon-blink-when-point-moves nil
>   "Should the beacon blink when moving a long distance?
> If nil, don't blink due to plain movement.
> If non-nil, this should be an integer, which is the minimum
> movement distance (in lines) that triggers a beacon blink."
>   :type '(choice integer (const nil)))
>
> (defcustom beacon-blink-when-buffer-changes t
>   "Should the beacon blink when changing buffer?"
>   :type 'boolean)
>
> (defcustom beacon-blink-when-window-scrolls t
>   "Should the beacon blink when the window scrolls?"
>   :type 'boolean)
>
> (defcustom beacon-blink-duration 0.3
>   "Time, in seconds, that the blink should last."
>   :type 'number)
>
> (defcustom beacon-blink-delay 0.3
>   "Time, in seconds, before starting to fade the beacon."
>   :type 'number)
>
> (defcustom beacon-size 40
>   "Size of the beacon in characters."
>   :type 'number)
>
> (defcustom beacon-color 0.5
>   "Color of the beacon.
> This can be a string or a number.
>
> If it is a number, the color is taken to be white or
> black (depending on the current theme's background) and this
> number is a float between 0 and 1 specifing the brightness.
>
> If it is a string, it is a color name or specification,
> e.g. \"#666600\"."
>   :type '(choice number color))
>
>
> ;;; Overlays
> (defvar beacon--ovs nil)
>
> (defun beacon--colored-overlay (color)
>   "Put an overlay at point with background COLOR."
>   (let ((ov (make-overlay (point) (1+ (point)))))
>     (overlay-put ov 'face (list :background color))
>     (overlay-put ov 'beacon t)
>     (push ov beacon--ovs)))
>
> (defun beacon--ov-put-after-string (overlay colors)
>   "Add an after-string property to OVERLAY.
> The property's value is a string of spaces with background
> COLORS applied to each one."
>   (if (not colors)
>       (delete-overlay overlay)
>     (overlay-put overlay 'beacon-colors colors)
>     (overlay-put overlay 'after-string
>                  (propertize
>                   (mapconcat (lambda (c) (propertize " " 'face (list
> :background c)))
>                              colors
>                              "")
>                   'cursor 1000))))
>
> (defun beacon--after-string-overlay (colors)
>   "Put an overlay at point with an after-string property.
> The property's value is a string of spaces with background
> COLORS applied to each one."
>   (let ((ov (make-overlay (point) (point)))
>         ;; The after-string must not be longer than the remaining columns
> from
>         ;; point to right window-end else it will be wrapped around
> (assuming
>         ;; truncate-lines is nil) introducing an ugly wrap-around for a
>         ;; fraction of a second.
>         (colors (seq-take colors (- (window-width) (current-column)))))
>     (beacon--ov-put-after-string ov colors)
>     (overlay-put ov 'beacon t)
>     (push ov beacon--ovs)))
>
> (defun beacon--ov-at-point ()
>   (car (or (seq-filter (lambda (o) (overlay-get o 'beacon))
>                      (overlays-in (point) (point)))
>            (seq-filter (lambda (o) (overlay-get o 'beacon))
>                      (overlays-at (point))))))
>
> (defun beacon--vanish ()
>   "Turn off the beacon."
>   (when (timerp beacon--timer)
>     (cancel-timer beacon--timer))
>   (mapc #'delete-overlay beacon--ovs)
>   (setq beacon--ovs nil))
>
>
> ;;; Colors
> (defun beacon--int-range (a b)
>   "Return a list of integers between A inclusive and B exclusive.
> Only returns `beacon-size' elements."
>   (let ((d (/ (- b a) beacon-size))
>         (out (list a)))
>     (dotimes (_ (1- beacon-size))
>       (push (+ (car out) d) out))
>     (nreverse out)))
>
> (defun beacon--color-range ()
>   "Return a list of background colors for the beacon."
>   (let* ((bg (color-values (face-attribute 'default :background)))
>          (fg (cond
>               ((stringp beacon-color) (color-values beacon-color))
>               ((< (color-distance "black" bg)
>                   (color-distance "white" bg))
>                (make-list 3 (* beacon-color 65535)))
>               (t (make-list 3 (* (- 1 beacon-color) 65535))))))
>     (apply #'cl-mapcar (lambda (r g b) (format "#%04x%04x%04x" r g b))
>            (mapcar (lambda (n) (butlast (beacon--int-range (elt fg n)
> (elt bg n))))
>                    [0 1 2]))))
>
>
> ;;; Blinking
> (defun beacon--shine ()
>   "Shine a beacon at point."
>   (let ((colors (beacon--color-range)))
>     (save-excursion
>       (while colors
>         (if (looking-at "$")
>             (progn
>               (beacon--after-string-overlay colors)
>               (setq colors nil))
>           (beacon--colored-overlay (pop colors))
>           (forward-char 1))))))
>
> (defun beacon--dec ()
>   "Decrease the beacon brightness by one."
>   (pcase (beacon--ov-at-point)
>     (`nil (beacon--vanish))
>     ((and o (let c (overlay-get o 'beacon-colors)) (guard c))
>      (beacon--ov-put-after-string o (cdr c)))
>     (o
>      (delete-overlay o)
>      (save-excursion
>        (while (progn (forward-char 1)
>                      (setq o (beacon--ov-at-point)))
>          (let ((colors (overlay-get o 'beacon-colors)))
>            (if (not colors)
>                (move-overlay o (1- (point)) (point))
>              (forward-char -1)
>              (beacon--colored-overlay (pop colors))
>              (beacon--ov-put-after-string o colors)
>              (forward-char 1))))))))
>
> (defun beacon-blink ()
>   "Blink the beacon at the position of the cursor."
>   (interactive)
>   (beacon--vanish)
>   (beacon--shine)
>   (setq beacon--timer
>         (run-at-time beacon-blink-delay
>                      (/ beacon-blink-duration 1.0 beacon-size)
>                      #'beacon--dec)))
>
>
> ;;; Movement detection
> (defvar beacon--window-scrolled nil)
> (defvar beacon--previous-place nil)
> (defvar beacon--previous-mark-head nil)
>
> (defun beacon--movement-> (delta)
>   "Return non-nil if latest point movement is > DELTA.
> If DELTA is nil, return nil."
>   (and delta
>        (markerp beacon--previous-place)
>        (equal (marker-buffer beacon--previous-place)
>               (current-buffer))
>        (> (abs (- (point) beacon--previous-place))
>           delta)
>        (> (count-screen-lines (min (point) beacon--previous-place)
>                               (max (point) beacon--previous-place))
>           delta)))
>
> (defun beacon--maybe-push-mark ()
>   "Push mark if it seems to be safe."
>   (when (and (not mark-active)
>              (beacon--movement-> beacon-push-mark))
>     (let ((head (car mark-ring)))
>       (when (and (eq beacon--previous-mark-head head)
>                  (not (equal head beacon--previous-place)))
>         (push-mark beacon--previous-place)))))
>
> (defun beacon--post-command ()
>   "Blink if point moved very far."
>   (cond
>    ((not (markerp beacon--previous-place))
>     (beacon--vanish))
>    ;; Blink because we changed buffer.
>    ((not (equal (marker-buffer beacon--previous-place)
>                 (current-buffer)))
>     (when beacon-blink-when-buffer-changes
>       (unless (window-minibuffer-p)
>         (beacon-blink))))
>    ;; Blink for scrolling.
>    ((and beacon-blink-when-window-scrolls
>          beacon--window-scrolled
>          (equal beacon--window-scrolled (selected-window)))
>     (beacon-blink)
>     (setq beacon--window-scrolled nil))
>    ;; Blink for movement
>    ((beacon--movement-> beacon-blink-when-point-moves)
>     (beacon-blink))
>    ;; Even if we don't blink, vanish any previous beacon.
>    (t (beacon--vanish)))
>   (beacon--maybe-push-mark)
>   (unless (window-minibuffer-p)
>     (setq beacon--previous-mark-head (car mark-ring))
>     (setq beacon--previous-place (point-marker))))
>
> (defun beacon--window-scroll-function (win _start-pos)
>   "Blink the beacon or record that window has been scrolled.
> If invoked during the command loop, record the current window so
> that it may be blinked on post-command.  This is because the
> scrolled window might not be active, but we only know that at
> `post-command-hook'.
>
> If invoked outside the command loop, `post-command-hook' would be
> unreliable, so just blink immediately."
>   (if this-command
>       (setq beacon--window-scrolled win)
>     (beacon-blink)))
>
>
> ;;; Minor-mode
> (defcustom beacon-lighter
>   (cond
>    ((char-displayable-p ?💡) " 💡")
>    ((char-displayable-p ?Λ) " Λ")
>    (t " *"))
>   "Lighter string used on the mode-line."
>   :type 'string)
>
> ;;;###autoload
> (define-minor-mode beacon-mode
>   nil nil beacon-lighter nil
>   :global t
>   (if beacon-mode
>       (progn
>         (add-hook 'window-scroll-functions
> #'beacon--window-scroll-function)
>         (add-hook 'post-command-hook #'beacon--post-command))
>     (remove-hook 'window-scroll-functions #'beacon--window-scroll-function)
>     (remove-hook 'post-command-hook #'beacon--post-command)))
>
> (provide 'beacon)
> ;;; beacon.el ends here
>
>

[-- Attachment #2: Type: text/html, Size: 14741 bytes --]

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 12705 bytes --]

Of course pulse.el is a library which other packages might find useful and
beacon.el is an end-user package. I was just curious if the technique used
to set overlay on the current position was similar.


--
Kaushal Modi

On Thu, Oct 15, 2015 at 1:24 PM, Kaushal Modi <kaushal.modi@gmail.com>
wrote:

> I haven't read either of the source codes, but is it similar to
> lisp/cedet/pulse.el?
>
>
> --
> Kaushal Modi
>
> On Thu, Oct 15, 2015 at 1:02 PM, Artur Malabarba <
> bruce.connor.am@gmail.com> wrote:
>
>> Whenever the window scrolls or the buffer changes a light will shine on
>> top of your cursor so you know where it is.
>>
>> That’s it. See this gif for example:
>> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>>
>>
>> ----------
>>
>>
>> ;;; beacon.el --- Highlight the cursor when the window scrolls  -*-
>> lexical-binding: t; -*-
>>
>> ;; Copyright (C) 2015 Free Software Foundation, Inc.
>>
>> ;; Author: Artur Malabarba <emacs@endlessparentheses.com>
>> ;; URL: https://github.com/Malabarba/beacon
>> ;; Keywords: convenience
>> ;; Version: 0.1
>> ;; Package-Requires: ((seq "1.9"))
>>
>> ;; 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 is a global minor-mode. Turn it on everywhere with:
>> ;; ┌────
>> ;; │ (beacon-mode 1)
>> ;; └────
>> ;;
>> ;; Whenever the window scrolls or the buffer changes a light will shine on
>> ;; top of your cursor so you know where it is.
>> ;;
>> ;; That’s it.
>> ;;
>> ;;
>> ;; 1 Customizations
>> ;; ════════════════
>> ;;
>> ;;   • To customize the appearance of the beacon, configure `beacon-size'
>> ;;     and `beacon-color'.
>> ;;
>> ;;   • To customize how long it lasts, configure `beacon-blink-duration'
>> ;;       and `beacon-blink-delay'.
>> ;;
>> ;;   • To customize /when/ it is used at all, configure
>> ;;     `beacon-blink-when-window-scrolls',
>> ;;     `beacon-blink-when-buffer-changes', and
>> ;;     `beacon-blink-when-point-moves'.
>>
>> ;;; Code:
>>
>> (require 'seq)
>>
>> (defgroup beacon nil
>>   "Customization group for beacon."
>>   :group 'emacs
>>   :prefix "beacon-")
>>
>> (defvar beacon--timer nil)
>>
>> (defcustom beacon-push-mark nil
>>   "Should the mark be pushed before long movements?
>> If nil, `beacon' will not push the mark.
>> Otherwise this should be a number, and `beacon' will push the
>> mark whenever point moves more than that many lines."
>>   :type '(choice integer (const nil)))
>>
>> (defcustom beacon-blink-when-point-moves nil
>>   "Should the beacon blink when moving a long distance?
>> If nil, don't blink due to plain movement.
>> If non-nil, this should be an integer, which is the minimum
>> movement distance (in lines) that triggers a beacon blink."
>>   :type '(choice integer (const nil)))
>>
>> (defcustom beacon-blink-when-buffer-changes t
>>   "Should the beacon blink when changing buffer?"
>>   :type 'boolean)
>>
>> (defcustom beacon-blink-when-window-scrolls t
>>   "Should the beacon blink when the window scrolls?"
>>   :type 'boolean)
>>
>> (defcustom beacon-blink-duration 0.3
>>   "Time, in seconds, that the blink should last."
>>   :type 'number)
>>
>> (defcustom beacon-blink-delay 0.3
>>   "Time, in seconds, before starting to fade the beacon."
>>   :type 'number)
>>
>> (defcustom beacon-size 40
>>   "Size of the beacon in characters."
>>   :type 'number)
>>
>> (defcustom beacon-color 0.5
>>   "Color of the beacon.
>> This can be a string or a number.
>>
>> If it is a number, the color is taken to be white or
>> black (depending on the current theme's background) and this
>> number is a float between 0 and 1 specifing the brightness.
>>
>> If it is a string, it is a color name or specification,
>> e.g. \"#666600\"."
>>   :type '(choice number color))
>>
>>
>> ;;; Overlays
>> (defvar beacon--ovs nil)
>>
>> (defun beacon--colored-overlay (color)
>>   "Put an overlay at point with background COLOR."
>>   (let ((ov (make-overlay (point) (1+ (point)))))
>>     (overlay-put ov 'face (list :background color))
>>     (overlay-put ov 'beacon t)
>>     (push ov beacon--ovs)))
>>
>> (defun beacon--ov-put-after-string (overlay colors)
>>   "Add an after-string property to OVERLAY.
>> The property's value is a string of spaces with background
>> COLORS applied to each one."
>>   (if (not colors)
>>       (delete-overlay overlay)
>>     (overlay-put overlay 'beacon-colors colors)
>>     (overlay-put overlay 'after-string
>>                  (propertize
>>                   (mapconcat (lambda (c) (propertize " " 'face (list
>> :background c)))
>>                              colors
>>                              "")
>>                   'cursor 1000))))
>>
>> (defun beacon--after-string-overlay (colors)
>>   "Put an overlay at point with an after-string property.
>> The property's value is a string of spaces with background
>> COLORS applied to each one."
>>   (let ((ov (make-overlay (point) (point)))
>>         ;; The after-string must not be longer than the remaining columns
>> from
>>         ;; point to right window-end else it will be wrapped around
>> (assuming
>>         ;; truncate-lines is nil) introducing an ugly wrap-around for a
>>         ;; fraction of a second.
>>         (colors (seq-take colors (- (window-width) (current-column)))))
>>     (beacon--ov-put-after-string ov colors)
>>     (overlay-put ov 'beacon t)
>>     (push ov beacon--ovs)))
>>
>> (defun beacon--ov-at-point ()
>>   (car (or (seq-filter (lambda (o) (overlay-get o 'beacon))
>>                      (overlays-in (point) (point)))
>>            (seq-filter (lambda (o) (overlay-get o 'beacon))
>>                      (overlays-at (point))))))
>>
>> (defun beacon--vanish ()
>>   "Turn off the beacon."
>>   (when (timerp beacon--timer)
>>     (cancel-timer beacon--timer))
>>   (mapc #'delete-overlay beacon--ovs)
>>   (setq beacon--ovs nil))
>>
>>
>> ;;; Colors
>> (defun beacon--int-range (a b)
>>   "Return a list of integers between A inclusive and B exclusive.
>> Only returns `beacon-size' elements."
>>   (let ((d (/ (- b a) beacon-size))
>>         (out (list a)))
>>     (dotimes (_ (1- beacon-size))
>>       (push (+ (car out) d) out))
>>     (nreverse out)))
>>
>> (defun beacon--color-range ()
>>   "Return a list of background colors for the beacon."
>>   (let* ((bg (color-values (face-attribute 'default :background)))
>>          (fg (cond
>>               ((stringp beacon-color) (color-values beacon-color))
>>               ((< (color-distance "black" bg)
>>                   (color-distance "white" bg))
>>                (make-list 3 (* beacon-color 65535)))
>>               (t (make-list 3 (* (- 1 beacon-color) 65535))))))
>>     (apply #'cl-mapcar (lambda (r g b) (format "#%04x%04x%04x" r g b))
>>            (mapcar (lambda (n) (butlast (beacon--int-range (elt fg n)
>> (elt bg n))))
>>                    [0 1 2]))))
>>
>>
>> ;;; Blinking
>> (defun beacon--shine ()
>>   "Shine a beacon at point."
>>   (let ((colors (beacon--color-range)))
>>     (save-excursion
>>       (while colors
>>         (if (looking-at "$")
>>             (progn
>>               (beacon--after-string-overlay colors)
>>               (setq colors nil))
>>           (beacon--colored-overlay (pop colors))
>>           (forward-char 1))))))
>>
>> (defun beacon--dec ()
>>   "Decrease the beacon brightness by one."
>>   (pcase (beacon--ov-at-point)
>>     (`nil (beacon--vanish))
>>     ((and o (let c (overlay-get o 'beacon-colors)) (guard c))
>>      (beacon--ov-put-after-string o (cdr c)))
>>     (o
>>      (delete-overlay o)
>>      (save-excursion
>>        (while (progn (forward-char 1)
>>                      (setq o (beacon--ov-at-point)))
>>          (let ((colors (overlay-get o 'beacon-colors)))
>>            (if (not colors)
>>                (move-overlay o (1- (point)) (point))
>>              (forward-char -1)
>>              (beacon--colored-overlay (pop colors))
>>              (beacon--ov-put-after-string o colors)
>>              (forward-char 1))))))))
>>
>> (defun beacon-blink ()
>>   "Blink the beacon at the position of the cursor."
>>   (interactive)
>>   (beacon--vanish)
>>   (beacon--shine)
>>   (setq beacon--timer
>>         (run-at-time beacon-blink-delay
>>                      (/ beacon-blink-duration 1.0 beacon-size)
>>                      #'beacon--dec)))
>>
>>
>> ;;; Movement detection
>> (defvar beacon--window-scrolled nil)
>> (defvar beacon--previous-place nil)
>> (defvar beacon--previous-mark-head nil)
>>
>> (defun beacon--movement-> (delta)
>>   "Return non-nil if latest point movement is > DELTA.
>> If DELTA is nil, return nil."
>>   (and delta
>>        (markerp beacon--previous-place)
>>        (equal (marker-buffer beacon--previous-place)
>>               (current-buffer))
>>        (> (abs (- (point) beacon--previous-place))
>>           delta)
>>        (> (count-screen-lines (min (point) beacon--previous-place)
>>                               (max (point) beacon--previous-place))
>>           delta)))
>>
>> (defun beacon--maybe-push-mark ()
>>   "Push mark if it seems to be safe."
>>   (when (and (not mark-active)
>>              (beacon--movement-> beacon-push-mark))
>>     (let ((head (car mark-ring)))
>>       (when (and (eq beacon--previous-mark-head head)
>>                  (not (equal head beacon--previous-place)))
>>         (push-mark beacon--previous-place)))))
>>
>> (defun beacon--post-command ()
>>   "Blink if point moved very far."
>>   (cond
>>    ((not (markerp beacon--previous-place))
>>     (beacon--vanish))
>>    ;; Blink because we changed buffer.
>>    ((not (equal (marker-buffer beacon--previous-place)
>>                 (current-buffer)))
>>     (when beacon-blink-when-buffer-changes
>>       (unless (window-minibuffer-p)
>>         (beacon-blink))))
>>    ;; Blink for scrolling.
>>    ((and beacon-blink-when-window-scrolls
>>          beacon--window-scrolled
>>          (equal beacon--window-scrolled (selected-window)))
>>     (beacon-blink)
>>     (setq beacon--window-scrolled nil))
>>    ;; Blink for movement
>>    ((beacon--movement-> beacon-blink-when-point-moves)
>>     (beacon-blink))
>>    ;; Even if we don't blink, vanish any previous beacon.
>>    (t (beacon--vanish)))
>>   (beacon--maybe-push-mark)
>>   (unless (window-minibuffer-p)
>>     (setq beacon--previous-mark-head (car mark-ring))
>>     (setq beacon--previous-place (point-marker))))
>>
>> (defun beacon--window-scroll-function (win _start-pos)
>>   "Blink the beacon or record that window has been scrolled.
>> If invoked during the command loop, record the current window so
>> that it may be blinked on post-command.  This is because the
>> scrolled window might not be active, but we only know that at
>> `post-command-hook'.
>>
>> If invoked outside the command loop, `post-command-hook' would be
>> unreliable, so just blink immediately."
>>   (if this-command
>>       (setq beacon--window-scrolled win)
>>     (beacon-blink)))
>>
>>
>> ;;; Minor-mode
>> (defcustom beacon-lighter
>>   (cond
>>    ((char-displayable-p ?💡) " 💡")
>>    ((char-displayable-p ?Λ) " Λ")
>>    (t " *"))
>>   "Lighter string used on the mode-line."
>>   :type 'string)
>>
>> ;;;###autoload
>> (define-minor-mode beacon-mode
>>   nil nil beacon-lighter nil
>>   :global t
>>   (if beacon-mode
>>       (progn
>>         (add-hook 'window-scroll-functions
>> #'beacon--window-scroll-function)
>>         (add-hook 'post-command-hook #'beacon--post-command))
>>     (remove-hook 'window-scroll-functions
>> #'beacon--window-scroll-function)
>>     (remove-hook 'post-command-hook #'beacon--post-command)))
>>
>> (provide 'beacon)
>> ;;; beacon.el ends here
>>
>>
>

[-- Attachment #2: Type: text/html, Size: 15579 bytes --]

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 14377 bytes --]

BTW, I just tried it out and it looks great! I like that meteor trail
effect :)

I now just need to figure out how to make it play nice with fci-mode.

If a beacon pre/post hook is available, I can disable/enable fci-mode in
there.

I have this to make fci-mode play nice with popup:

    ;; Turn off fci-mode when popups are activated
    ;;
https://github.com/alpaker/Fill-Column-Indicator/issues/21#issuecomment-6959718
    (with-eval-after-load 'popup
      (defvar sanityinc/fci-mode-suppressed nil)

      (defun sanityinc/suppress-fci-mode (&rest args)
        "Suspend fci-mode while popups are visible"
        (setq-local sanityinc/fci-mode-suppressed fci-mode)
        (when fci-mode
          (turn-off-fci-mode)))
      (advice-add 'popup-create :before #'sanityinc/suppress-fci-mode)

      (defun sanityinc/restore-fci-mode (&rest args)
        "Restore fci-mode when all popups have closed"
        (when (and sanityinc/fci-mode-suppressed
                   (null popup-instances))
          (setq-local sanityinc/fci-mode-suppressed nil)
          (turn-on-fci-mode)))
      (advice-add 'popup-delete :after #'sanityinc/restore-fci-mode))





--
Kaushal Modi

On Thu, Oct 15, 2015 at 1:26 PM, Kaushal Modi <kaushal.modi@gmail.com>
wrote:

> Of course pulse.el is a library which other packages might find useful and
> beacon.el is an end-user package. I was just curious if the technique used
> to set overlay on the current position was similar.
>
>
> --
> Kaushal Modi
>
> On Thu, Oct 15, 2015 at 1:24 PM, Kaushal Modi <kaushal.modi@gmail.com>
> wrote:
>
>> I haven't read either of the source codes, but is it similar to
>> lisp/cedet/pulse.el?
>>
>>
>> --
>> Kaushal Modi
>>
>> On Thu, Oct 15, 2015 at 1:02 PM, Artur Malabarba <
>> bruce.connor.am@gmail.com> wrote:
>>
>>> Whenever the window scrolls or the buffer changes a light will shine on
>>> top of your cursor so you know where it is.
>>>
>>> That’s it. See this gif for example:
>>> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>>>
>>>
>>> ----------
>>>
>>>
>>> ;;; beacon.el --- Highlight the cursor when the window scrolls  -*-
>>> lexical-binding: t; -*-
>>>
>>> ;; Copyright (C) 2015 Free Software Foundation, Inc.
>>>
>>> ;; Author: Artur Malabarba <emacs@endlessparentheses.com>
>>> ;; URL: https://github.com/Malabarba/beacon
>>> ;; Keywords: convenience
>>> ;; Version: 0.1
>>> ;; Package-Requires: ((seq "1.9"))
>>>
>>> ;; 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 is a global minor-mode. Turn it on everywhere with:
>>> ;; ┌────
>>> ;; │ (beacon-mode 1)
>>> ;; └────
>>> ;;
>>> ;; Whenever the window scrolls or the buffer changes a light will shine
>>> on
>>> ;; top of your cursor so you know where it is.
>>> ;;
>>> ;; That’s it.
>>> ;;
>>> ;;
>>> ;; 1 Customizations
>>> ;; ════════════════
>>> ;;
>>> ;;   • To customize the appearance of the beacon, configure `beacon-size'
>>> ;;     and `beacon-color'.
>>> ;;
>>> ;;   • To customize how long it lasts, configure `beacon-blink-duration'
>>> ;;       and `beacon-blink-delay'.
>>> ;;
>>> ;;   • To customize /when/ it is used at all, configure
>>> ;;     `beacon-blink-when-window-scrolls',
>>> ;;     `beacon-blink-when-buffer-changes', and
>>> ;;     `beacon-blink-when-point-moves'.
>>>
>>> ;;; Code:
>>>
>>> (require 'seq)
>>>
>>> (defgroup beacon nil
>>>   "Customization group for beacon."
>>>   :group 'emacs
>>>   :prefix "beacon-")
>>>
>>> (defvar beacon--timer nil)
>>>
>>> (defcustom beacon-push-mark nil
>>>   "Should the mark be pushed before long movements?
>>> If nil, `beacon' will not push the mark.
>>> Otherwise this should be a number, and `beacon' will push the
>>> mark whenever point moves more than that many lines."
>>>   :type '(choice integer (const nil)))
>>>
>>> (defcustom beacon-blink-when-point-moves nil
>>>   "Should the beacon blink when moving a long distance?
>>> If nil, don't blink due to plain movement.
>>> If non-nil, this should be an integer, which is the minimum
>>> movement distance (in lines) that triggers a beacon blink."
>>>   :type '(choice integer (const nil)))
>>>
>>> (defcustom beacon-blink-when-buffer-changes t
>>>   "Should the beacon blink when changing buffer?"
>>>   :type 'boolean)
>>>
>>> (defcustom beacon-blink-when-window-scrolls t
>>>   "Should the beacon blink when the window scrolls?"
>>>   :type 'boolean)
>>>
>>> (defcustom beacon-blink-duration 0.3
>>>   "Time, in seconds, that the blink should last."
>>>   :type 'number)
>>>
>>> (defcustom beacon-blink-delay 0.3
>>>   "Time, in seconds, before starting to fade the beacon."
>>>   :type 'number)
>>>
>>> (defcustom beacon-size 40
>>>   "Size of the beacon in characters."
>>>   :type 'number)
>>>
>>> (defcustom beacon-color 0.5
>>>   "Color of the beacon.
>>> This can be a string or a number.
>>>
>>> If it is a number, the color is taken to be white or
>>> black (depending on the current theme's background) and this
>>> number is a float between 0 and 1 specifing the brightness.
>>>
>>> If it is a string, it is a color name or specification,
>>> e.g. \"#666600\"."
>>>   :type '(choice number color))
>>>
>>>
>>> ;;; Overlays
>>> (defvar beacon--ovs nil)
>>>
>>> (defun beacon--colored-overlay (color)
>>>   "Put an overlay at point with background COLOR."
>>>   (let ((ov (make-overlay (point) (1+ (point)))))
>>>     (overlay-put ov 'face (list :background color))
>>>     (overlay-put ov 'beacon t)
>>>     (push ov beacon--ovs)))
>>>
>>> (defun beacon--ov-put-after-string (overlay colors)
>>>   "Add an after-string property to OVERLAY.
>>> The property's value is a string of spaces with background
>>> COLORS applied to each one."
>>>   (if (not colors)
>>>       (delete-overlay overlay)
>>>     (overlay-put overlay 'beacon-colors colors)
>>>     (overlay-put overlay 'after-string
>>>                  (propertize
>>>                   (mapconcat (lambda (c) (propertize " " 'face (list
>>> :background c)))
>>>                              colors
>>>                              "")
>>>                   'cursor 1000))))
>>>
>>> (defun beacon--after-string-overlay (colors)
>>>   "Put an overlay at point with an after-string property.
>>> The property's value is a string of spaces with background
>>> COLORS applied to each one."
>>>   (let ((ov (make-overlay (point) (point)))
>>>         ;; The after-string must not be longer than the remaining
>>> columns from
>>>         ;; point to right window-end else it will be wrapped around
>>> (assuming
>>>         ;; truncate-lines is nil) introducing an ugly wrap-around for a
>>>         ;; fraction of a second.
>>>         (colors (seq-take colors (- (window-width) (current-column)))))
>>>     (beacon--ov-put-after-string ov colors)
>>>     (overlay-put ov 'beacon t)
>>>     (push ov beacon--ovs)))
>>>
>>> (defun beacon--ov-at-point ()
>>>   (car (or (seq-filter (lambda (o) (overlay-get o 'beacon))
>>>                      (overlays-in (point) (point)))
>>>            (seq-filter (lambda (o) (overlay-get o 'beacon))
>>>                      (overlays-at (point))))))
>>>
>>> (defun beacon--vanish ()
>>>   "Turn off the beacon."
>>>   (when (timerp beacon--timer)
>>>     (cancel-timer beacon--timer))
>>>   (mapc #'delete-overlay beacon--ovs)
>>>   (setq beacon--ovs nil))
>>>
>>>
>>> ;;; Colors
>>> (defun beacon--int-range (a b)
>>>   "Return a list of integers between A inclusive and B exclusive.
>>> Only returns `beacon-size' elements."
>>>   (let ((d (/ (- b a) beacon-size))
>>>         (out (list a)))
>>>     (dotimes (_ (1- beacon-size))
>>>       (push (+ (car out) d) out))
>>>     (nreverse out)))
>>>
>>> (defun beacon--color-range ()
>>>   "Return a list of background colors for the beacon."
>>>   (let* ((bg (color-values (face-attribute 'default :background)))
>>>          (fg (cond
>>>               ((stringp beacon-color) (color-values beacon-color))
>>>               ((< (color-distance "black" bg)
>>>                   (color-distance "white" bg))
>>>                (make-list 3 (* beacon-color 65535)))
>>>               (t (make-list 3 (* (- 1 beacon-color) 65535))))))
>>>     (apply #'cl-mapcar (lambda (r g b) (format "#%04x%04x%04x" r g b))
>>>            (mapcar (lambda (n) (butlast (beacon--int-range (elt fg n)
>>> (elt bg n))))
>>>                    [0 1 2]))))
>>>
>>>
>>> ;;; Blinking
>>> (defun beacon--shine ()
>>>   "Shine a beacon at point."
>>>   (let ((colors (beacon--color-range)))
>>>     (save-excursion
>>>       (while colors
>>>         (if (looking-at "$")
>>>             (progn
>>>               (beacon--after-string-overlay colors)
>>>               (setq colors nil))
>>>           (beacon--colored-overlay (pop colors))
>>>           (forward-char 1))))))
>>>
>>> (defun beacon--dec ()
>>>   "Decrease the beacon brightness by one."
>>>   (pcase (beacon--ov-at-point)
>>>     (`nil (beacon--vanish))
>>>     ((and o (let c (overlay-get o 'beacon-colors)) (guard c))
>>>      (beacon--ov-put-after-string o (cdr c)))
>>>     (o
>>>      (delete-overlay o)
>>>      (save-excursion
>>>        (while (progn (forward-char 1)
>>>                      (setq o (beacon--ov-at-point)))
>>>          (let ((colors (overlay-get o 'beacon-colors)))
>>>            (if (not colors)
>>>                (move-overlay o (1- (point)) (point))
>>>              (forward-char -1)
>>>              (beacon--colored-overlay (pop colors))
>>>              (beacon--ov-put-after-string o colors)
>>>              (forward-char 1))))))))
>>>
>>> (defun beacon-blink ()
>>>   "Blink the beacon at the position of the cursor."
>>>   (interactive)
>>>   (beacon--vanish)
>>>   (beacon--shine)
>>>   (setq beacon--timer
>>>         (run-at-time beacon-blink-delay
>>>                      (/ beacon-blink-duration 1.0 beacon-size)
>>>                      #'beacon--dec)))
>>>
>>>
>>> ;;; Movement detection
>>> (defvar beacon--window-scrolled nil)
>>> (defvar beacon--previous-place nil)
>>> (defvar beacon--previous-mark-head nil)
>>>
>>> (defun beacon--movement-> (delta)
>>>   "Return non-nil if latest point movement is > DELTA.
>>> If DELTA is nil, return nil."
>>>   (and delta
>>>        (markerp beacon--previous-place)
>>>        (equal (marker-buffer beacon--previous-place)
>>>               (current-buffer))
>>>        (> (abs (- (point) beacon--previous-place))
>>>           delta)
>>>        (> (count-screen-lines (min (point) beacon--previous-place)
>>>                               (max (point) beacon--previous-place))
>>>           delta)))
>>>
>>> (defun beacon--maybe-push-mark ()
>>>   "Push mark if it seems to be safe."
>>>   (when (and (not mark-active)
>>>              (beacon--movement-> beacon-push-mark))
>>>     (let ((head (car mark-ring)))
>>>       (when (and (eq beacon--previous-mark-head head)
>>>                  (not (equal head beacon--previous-place)))
>>>         (push-mark beacon--previous-place)))))
>>>
>>> (defun beacon--post-command ()
>>>   "Blink if point moved very far."
>>>   (cond
>>>    ((not (markerp beacon--previous-place))
>>>     (beacon--vanish))
>>>    ;; Blink because we changed buffer.
>>>    ((not (equal (marker-buffer beacon--previous-place)
>>>                 (current-buffer)))
>>>     (when beacon-blink-when-buffer-changes
>>>       (unless (window-minibuffer-p)
>>>         (beacon-blink))))
>>>    ;; Blink for scrolling.
>>>    ((and beacon-blink-when-window-scrolls
>>>          beacon--window-scrolled
>>>          (equal beacon--window-scrolled (selected-window)))
>>>     (beacon-blink)
>>>     (setq beacon--window-scrolled nil))
>>>    ;; Blink for movement
>>>    ((beacon--movement-> beacon-blink-when-point-moves)
>>>     (beacon-blink))
>>>    ;; Even if we don't blink, vanish any previous beacon.
>>>    (t (beacon--vanish)))
>>>   (beacon--maybe-push-mark)
>>>   (unless (window-minibuffer-p)
>>>     (setq beacon--previous-mark-head (car mark-ring))
>>>     (setq beacon--previous-place (point-marker))))
>>>
>>> (defun beacon--window-scroll-function (win _start-pos)
>>>   "Blink the beacon or record that window has been scrolled.
>>> If invoked during the command loop, record the current window so
>>> that it may be blinked on post-command.  This is because the
>>> scrolled window might not be active, but we only know that at
>>> `post-command-hook'.
>>>
>>> If invoked outside the command loop, `post-command-hook' would be
>>> unreliable, so just blink immediately."
>>>   (if this-command
>>>       (setq beacon--window-scrolled win)
>>>     (beacon-blink)))
>>>
>>>
>>> ;;; Minor-mode
>>> (defcustom beacon-lighter
>>>   (cond
>>>    ((char-displayable-p ?💡) " 💡")
>>>    ((char-displayable-p ?Λ) " Λ")
>>>    (t " *"))
>>>   "Lighter string used on the mode-line."
>>>   :type 'string)
>>>
>>> ;;;###autoload
>>> (define-minor-mode beacon-mode
>>>   nil nil beacon-lighter nil
>>>   :global t
>>>   (if beacon-mode
>>>       (progn
>>>         (add-hook 'window-scroll-functions
>>> #'beacon--window-scroll-function)
>>>         (add-hook 'post-command-hook #'beacon--post-command))
>>>     (remove-hook 'window-scroll-functions
>>> #'beacon--window-scroll-function)
>>>     (remove-hook 'post-command-hook #'beacon--post-command)))
>>>
>>> (provide 'beacon)
>>> ;;; beacon.el ends here
>>>
>>>
>>
>

[-- Attachment #2: Type: text/html, Size: 20232 bytes --]

Re: [ELPA] New package: beacon

[Artur Malabarba]

[-- Attachment #1: Type: text/plain, Size: 457 bytes --]

2015-10-15 18:33 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:

> BTW, I just tried it out and it looks great! I like that meteor trail
> effect :)
>
> I now just need to figure out how to make it play nice with fci-mode.
>
> If a beacon pre/post hook is available, I can disable/enable fci-mode in
> there.
>

Before I push this tomorrow there'll be a way to conditionally avoid
blinking. Would that help? What's fci-mode like and why does it conflict?

[-- Attachment #2: Type: text/html, Size: 1207 bytes --]

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 1497 bytes --]

This gif shows the problem with fci-mode enabled:
http://i.imgur.com/G2ojtKc.gifv

That vertical line on the right is what the Fill Column Indicator package
is inserting. With that persistently enabled, you can see that it messes up
the beacon.. the cursor keeps on jumping to the set column.

I tried this to disable fci at the right time:

(defun beacon--shine ()
  "Shine a beacon at point."
  (setq-local sanityinc/fci-mode-suppressed fci-mode)
  (when fci-mode
    (turn-off-fci-mode))
  (let ((colors (beacon--color-range)))
    (save-excursion
      (while colors
        (if (looking-at "$")
            (progn
              (beacon--after-string-overlay colors)
              (setq colors nil))
          (beacon--colored-overlay (pop colors))
          (forward-char 1))))))


But I cannot figure out where to reenable it.. it didn't work if I tried to
renable at the end of beacon--shine or beacon-blink.


--
Kaushal Modi

On Thu, Oct 15, 2015 at 5:27 PM, Artur Malabarba <bruce.connor.am@gmail.com>
wrote:

>
> 2015-10-15 18:33 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>
>> BTW, I just tried it out and it looks great! I like that meteor trail
>> effect :)
>>
>> I now just need to figure out how to make it play nice with fci-mode.
>>
>> If a beacon pre/post hook is available, I can disable/enable fci-mode in
>> there.
>>
>
> Before I push this tomorrow there'll be a way to conditionally avoid
> blinking. Would that help? What's fci-mode like and why does it conflict?
>

[-- Attachment #2: Type: text/html, Size: 4024 bytes --]

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 1870 bytes --]

OK, I think I need to reenable fci-mode at the end of beacon--dec. It seems
to sort of work, just that the fci-mode gets re-enabled too soon, slightly
before the beacon trails finish vanishing.


--
Kaushal Modi

On Thu, Oct 15, 2015 at 5:37 PM, Kaushal Modi <kaushal.modi@gmail.com>
wrote:

> This gif shows the problem with fci-mode enabled:
> http://i.imgur.com/G2ojtKc.gifv
>
> That vertical line on the right is what the Fill Column Indicator package
> is inserting. With that persistently enabled, you can see that it messes up
> the beacon.. the cursor keeps on jumping to the set column.
>
> I tried this to disable fci at the right time:
>
> (defun beacon--shine ()
>   "Shine a beacon at point."
>   (setq-local sanityinc/fci-mode-suppressed fci-mode)
>   (when fci-mode
>     (turn-off-fci-mode))
>   (let ((colors (beacon--color-range)))
>     (save-excursion
>       (while colors
>         (if (looking-at "$")
>             (progn
>               (beacon--after-string-overlay colors)
>               (setq colors nil))
>           (beacon--colored-overlay (pop colors))
>           (forward-char 1))))))
>
>
> But I cannot figure out where to reenable it.. it didn't work if I tried
> to renable at the end of beacon--shine or beacon-blink.
>
>
> --
> Kaushal Modi
>
> On Thu, Oct 15, 2015 at 5:27 PM, Artur Malabarba <
> bruce.connor.am@gmail.com> wrote:
>
>>
>> 2015-10-15 18:33 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>>
>>> BTW, I just tried it out and it looks great! I like that meteor trail
>>> effect :)
>>>
>>> I now just need to figure out how to make it play nice with fci-mode.
>>>
>>> If a beacon pre/post hook is available, I can disable/enable fci-mode in
>>> there.
>>>
>>
>> Before I push this tomorrow there'll be a way to conditionally avoid
>> blinking. Would that help? What's fci-mode like and why does it conflict?
>>
>
>

[-- Attachment #2: Type: text/html, Size: 4902 bytes --]

Re: [ELPA] New package: beacon

[Artur Malabarba]

2015-10-15 22:44 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
> OK, I think I need to reenable fci-mode at the end of beacon--dec. It seems
> to sort of work, just that the fci-mode gets re-enabled too soon, slightly
> before the beacon trails finish vanishing.

You can try reenabling it at the end of beacon--vanish.
But here's another idea: try adding this line inside
beacon--ov-put-after-string, between the two calls to `overlay-put'
    (overlay-put overlay 'priority most-positive-fixnum)

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 1216 bytes --]

> You can try reenabling it at the end of beacon--vanish.
That worked!

> But here's another idea: try adding this line inside
beacon--ov-put-after-string, between the two calls to `overlay-put'
    (overlay-put overlay 'priority most-positive-fixnum)

​I commented out the fci-mode hacks, did the above and re-evalled.. this
works even better! Thanks!​

I didn't quite understand why setting the beacon overlay priority to the
max worked.. Was it that earlier the fci-mode overlays were fighting to get
displayed inbetween the beacon overlay displays?

--
Kaushal Modi

On Thu, Oct 15, 2015 at 6:13 PM, Artur Malabarba <bruce.connor.am@gmail.com>
wrote:

> 2015-10-15 22:44 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
> > OK, I think I need to reenable fci-mode at the end of beacon--dec. It
> seems
> > to sort of work, just that the fci-mode gets re-enabled too soon,
> slightly
> > before the beacon trails finish vanishing.
>
> You can try reenabling it at the end of beacon--vanish.
> But here's another idea: try adding this line inside
> beacon--ov-put-after-string, between the two calls to `overlay-put'
>     (overlay-put overlay 'priority most-positive-fixnum)
>

[-- Attachment #2: Type: text/html, Size: 2933 bytes --]

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 1676 bytes --]

​I have one more optimization request:

If the same buffer is shown in multiple windows, the beacon "leaks" in all
those windows.

It would be nice to have a customization option like hl-line-sticky-flag​
(from the hl-line package) such that the beacon is shown only in the active
window.


--
Kaushal Modi

On Thu, Oct 15, 2015 at 6:27 PM, Kaushal Modi <kaushal.modi@gmail.com>
wrote:

> > You can try reenabling it at the end of beacon--vanish.
> That worked!
>
> > But here's another idea: try adding this line inside
> beacon--ov-put-after-string, between the two calls to `overlay-put'
>     (overlay-put overlay 'priority most-positive-fixnum)
>
> ​I commented out the fci-mode hacks, did the above and re-evalled.. this
> works even better! Thanks!​
>
> I didn't quite understand why setting the beacon overlay priority to the
> max worked.. Was it that earlier the fci-mode overlays were fighting to get
> displayed inbetween the beacon overlay displays?
>
> --
> Kaushal Modi
>
> On Thu, Oct 15, 2015 at 6:13 PM, Artur Malabarba <
> bruce.connor.am@gmail.com> wrote:
>
>> 2015-10-15 22:44 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>> > OK, I think I need to reenable fci-mode at the end of beacon--dec. It
>> seems
>> > to sort of work, just that the fci-mode gets re-enabled too soon,
>> slightly
>> > before the beacon trails finish vanishing.
>>
>> You can try reenabling it at the end of beacon--vanish.
>> But here's another idea: try adding this line inside
>> beacon--ov-put-after-string, between the two calls to `overlay-put'
>>     (overlay-put overlay 'priority most-positive-fixnum)
>>
>
>

[-- Attachment #2: Type: text/html, Size: 4350 bytes --]

Re: [ELPA] New package: beacon

[Tassilo Horn]

Kaushal Modi <kaushal.modi@gmail.com> writes:

> If the same buffer is shown in multiple windows, the beacon "leaks" in all
> those windows.
>
> It would be nice to have a customization option like hl-line-sticky-flag​
> (from the hl-line package) such that the beacon is shown only in the active
> window.

I've independently addressed this (and other things) in my PR:

  https://github.com/Malabarba/beacon/pull/6

Bye,
Tassilo

Re: [ELPA] New package: beacon

[Artur Malabarba]

2015-10-15 23:27 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>> You can try reenabling it at the end of beacon--vanish.
> That worked!
>
>> But here's another idea: try adding this line inside
> beacon--ov-put-after-string, between the two calls to `overlay-put'
>     (overlay-put overlay 'priority most-positive-fixnum)
>
> I commented out the fci-mode hacks, did the above and re-evalled.. this
> works even better! Thanks!
>
> I didn't quite understand why setting the beacon overlay priority to the max
> worked.. Was it that earlier the fci-mode overlays were fighting to get
> displayed inbetween the beacon overlay displays?

fci-mode overlays were being displayed on top of beacon's overlays. By
upping the priority we ensure that beacon gets to be on top.
I'll add that code to the package now.

Re: [ELPA] New package: beacon

[Artur Malabarba]

2015-10-15 18:24 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>
> I haven't read either of the source codes, but is it similar to lisp/cedet/pulse.el?

Hm, I don't know. I'll look into what that does. Maybe it could have
saved me some implementation effort. :)

Re: [ELPA] New package: beacon

[Phillip Lord]

Artur Malabarba <bruce.connor.am@gmail.com> writes:

> 2015-10-15 18:24 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
>>
>> I haven't read either of the source codes, but is it similar to lisp/cedet/pulse.el?
>
> Hm, I don't know. I'll look into what that does. Maybe it could have
> saved me some implementation effort. :)


I used pulse.el when I wrote eval-pulse.el and it's quite nice for the
purpose.

But then I discovered eval-sexp-fu and realised that I've wasted my time
writing eval-pulse.

Having some commonality for these visual distratctions kind of mode
would be good -- it should allow configuration once.

Phil

Re: [ELPA] New package: beacon

[Artur Malabarba]

[-- Attachment #1: Type: text/plain, Size: 1256 bytes --]

On 16 Oct 2015 2:11 pm, "Phillip Lord" <phillip.lord@newcastle.ac.uk> wrote:
>
>
>
> Artur Malabarba <bruce.connor.am@gmail.com> writes:
>
> > 2015-10-15 18:24 GMT+01:00 Kaushal Modi <kaushal.modi@gmail.com>:
> >>
> >> I haven't read either of the source codes, but is it similar to
lisp/cedet/pulse.el?
> >
> > Hm, I don't know. I'll look into what that does. Maybe it could have
> > saved me some implementation effort. :)
>
>
> I used pulse.el when I wrote eval-pulse.el and it's quite nice for the
> purpose.
>
> But then I discovered eval-sexp-fu and realised that I've wasted my time
> writing eval-pulse.
>
> Having some commonality for these visual distratctions kind of mode
> would be good -- it should allow configuration once.

Yeah, I had a look at pulse and there's definitely some common ground.
Beacon is really a user package, while pulse is more of a dependency lib.

I want to merge some of beacon's internals into pulse, so that beacon could
just a small extension on top of pulse, but that's not trivial. Their
internal logic is quite different, both in structure and in final outcome
(pulse fades a single color overlay by changing a font's background, while
beacon shrinks a multi-colour highlight by moving/deleting many overlays).

[-- Attachment #2: Type: text/html, Size: 1713 bytes --]

Re: [ELPA] New package: beacon

[Rasmus]

Hi,

Arthur: great idea.

Kaushal Modi <kaushal.modi@gmail.com> writes:

> I haven't read either of the source codes, but is it similar to
> lisp/cedet/pulse.el?

pulse.el is cool!  Thanks for pointing it out.

Unfortunately, the following is a bit too aggressive as it also updated on
ispell events and input-methods:

    (add-to-list 'buffer-list-update-hook
                 (defun rasmus/pulse () (pulse-momentary-highlight-one-line (point))))

Is there a hook that would better serve as an easy way to detect real
buffer changes, or would one have to introduce a state variable,
e.g. current buffer name?

    (defvar rasmus/pulse-buffer nil)

    (add-to-list 'buffer-list-update-hook
                 (defun rasmus/pulse () 
                   (unless (equal rasmus/pulse-buffer (buffer-name))
                     (pulse-momentary-highlight-one-line (point))
                     (setq rasmus/pulse-buffer (buffer-name)))))

Thanks,
Rasmus

-- 
Lasciate ogni speranza o voi che entrate: siete nella mani di'machellaio

Re: [ELPA] New package: beacon

[Marcin Borkowski]

On 2015-10-15, at 19:02, Artur Malabarba <bruce.connor.am@gmail.com> wrote:

> Whenever the window scrolls or the buffer changes a light will shine on
> top of your cursor so you know where it is.
>
> That’s it. See this gif for example:
> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif

Cool.  I didn't understand one thing (and could not see it in the gif):
what do you mean by "buffer changes"?  Any self-insert-command key will
fire this flashy-thing?  That didn't work for me.  (Beacon on point
movement didn'twork here, either.)  I'm on GNU Emacs 25.0.50.1
(i686-pc-linux-gnu, GTK+ Version 3.10.8) of 2015-01-02.

Best,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: [ELPA] New package: beacon

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 1094 bytes --]

I think "buffer changes" refer to actions like switching to other window or
other buffer, because I get those beacons when I do that.


--
Kaushal Modi

On Thu, Oct 15, 2015 at 1:36 PM, Marcin Borkowski <mbork@mbork.pl> wrote:

>
> On 2015-10-15, at 19:02, Artur Malabarba <bruce.connor.am@gmail.com>
> wrote:
>
> > Whenever the window scrolls or the buffer changes a light will shine on
> > top of your cursor so you know where it is.
> >
> > That’s it. See this gif for example:
> > https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>
> Cool.  I didn't understand one thing (and could not see it in the gif):
> what do you mean by "buffer changes"?  Any self-insert-command key will
> fire this flashy-thing?  That didn't work for me.  (Beacon on point
> movement didn'twork here, either.)  I'm on GNU Emacs 25.0.50.1
> (i686-pc-linux-gnu, GTK+ Version 3.10.8) of 2015-01-02.
>
> Best,
>
> --
> Marcin Borkowski
> http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
> Faculty of Mathematics and Computer Science
> Adam Mickiewicz University
>
>

[-- Attachment #2: Type: text/html, Size: 1999 bytes --]

Re: [ELPA] New package: beacon

[Artur Malabarba]

[-- Attachment #1: Type: text/plain, Size: 861 bytes --]

On 15 Oct 2015 6:36 pm, "Marcin Borkowski" <mbork@mbork.pl> wrote:
>
>
> On 2015-10-15, at 19:02, Artur Malabarba <bruce.connor.am@gmail.com>
wrote:
>
> > Whenever the window scrolls or the buffer changes a light will shine on
> > top of your cursor so you know where it is.
> >
> > That’s it. See this gif for example:
> > https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>
> Cool.  I didn't understand one thing (and could not see it in the gif):
> what do you mean by "buffer changes"?  Any self-insert-command key will
> fire this flashy-thing?

No, I mean when you switch buffer. :-)

Simply editing the buffer will not blink the beacon.

Moving point will only blink the beacon if it causes the window to scroll.
But there's a variable to make it blink when point moves very far even if
the window didn't scroll.

[-- Attachment #2: Type: text/html, Size: 1243 bytes --]

Re: [ELPA] New package: beacon

[Howard Melman]

Artur Malabarba <bruce.connor.am@gmail.com> writes:

> Whenever the window scrolls or the buffer changes a light will shine on
> top of your cursor so you know where it is.
>
> That’s it. See this gif for example:
> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif

I like it. Though I reversed the list of colors that
beacon--color-range returned and prefer it. At least on my
light-colored background, the effect is that the "shine"
moves towards the cursor, leaving my eye at the cursor.

Howard

Re: [ELPA] New package: beacon

[Artur Malabarba]

2015-10-15 19:31 GMT+01:00 Howard Melman <hmelman@gmail.com>:
>
> Artur Malabarba <bruce.connor.am@gmail.com> writes:
>
>> Whenever the window scrolls or the buffer changes a light will shine on
>> top of your cursor so you know where it is.
>>
>> That’s it. See this gif for example:
>> https://github.com/Malabarba/beacon/raw/master/example-beacon.gif
>
> I like it. Though I reversed the list of colors that
> beacon--color-range returned and prefer it. At least on my
> light-colored background, the effect is that the "shine"
> moves towards the cursor, leaving my eye at the cursor.

Allowing other beacon types is definitely something I want. Besides
just reversing it, I could see using a cross-hair shape or a circle.

Re: [ELPA] New package: on-screen (was: [ELPA] New package: beacon)

[Michael Heerdegen]

Hi,

I want to offer something quite related here for uploading to Elpa:
"on-screen" - here a link to the Commentary section of the source:

https://github.com/michael-heerdegen/on-screen.el/blob/master/on-screen.el#L30

It implements a minor mode that highlights (in a customizable way) the
last visible buffer area after scrolling, for better orientation when
reading texts or code.


Regards,

Michael.

Re: [ELPA] New package: on-screen

[John Wiegley]

>>>>> Michael Heerdegen <michael_heerdegen@web.de> writes:

> It implements a minor mode that highlights (in a customizable way) the last
> visible buffer area after scrolling, for better orientation when reading
> texts or code.

Neat.  Just two comments:

  (let ((method `(,on-screen-highlight-method . ,on-screen-inverse-flag)))

Is the same as:

  (let ((method (const on-screen-highlight-method on-screen-inverse-flag)))


The other one is a matter of affecting the global environment. In
`on-screen-initialize', you should pass `t' as a 3rd argument to add-hook, so
the hooks are only affected in buffers where on-screen mode is active.

John

Re: [ELPA] New package: on-screen

[John Wiegley]

>>>>> John Wiegley <johnw@newartisans.com> writes:

> Is the same as:
>   (let ((method (const on-screen-highlight-method on-screen-inverse-flag)))

I meant, `cons'.

John

Re: [ELPA] New package: on-screen

[Michael Heerdegen]

"John Wiegley" <johnw@newartisans.com> writes:

> Just two comments:

That was quick!  Thanks for having a look.

>
>   (let ((method `(,on-screen-highlight-method . ,on-screen-inverse-flag)))
>
> Is the same as:
>
>   (let ((method (const on-screen-highlight-method
> on-screen-inverse-flag)))

I guess you mean `cons' ;-)  Then I agree.

> The other one is a matter of affecting the global environment. In
> `on-screen-initialize', you should pass `t' as a 3rd argument to
> add-hook, so the hooks are only affected in buffers where on-screen
> mode is active.

This is a actually an intended design choice.  What you suggest is not
sufficient if you scroll the "other" buffer via M-next/M-prior, or
scroll any buffer "with the mouse wheel" that is not current, but has
the mode on.  Then you still want to see the highlighting effect.

Another common use case is reading news with Gnus and scrolling the
article buffer with RET or Space: the summary buffer is current, but you
are reading, and scrolling the article buffer, which has the mode turned
on.

So, to avoid unnecessary complication, I decided to install my stuff in
the global hooks.  If you don't have any buffer with `on-screen-mode'
turned on visible, there is no performance loss this way, so I decided
that's acceptable.


Thanks,

Michael.

Re: [ELPA] New package: on-screen

[John Wiegley]

>>>>> Michael Heerdegen <michael_heerdegen@web.de> writes:

> So, to avoid unnecessary complication, I decided to install my stuff in the
> global hooks. If you don't have any buffer with `on-screen-mode' turned on
> visible, there is no performance loss this way, so I decided that's
> acceptable.

OK, the way you've described it makes sense. So this is intended as a "global
minor mode". Since you've also included a way to disable it, it looks good to
me.

John

Re: [ELPA] New package: on-screen

[David Kastrup]

"John Wiegley" <johnw@newartisans.com> writes:

>>>>>> Michael Heerdegen <michael_heerdegen@web.de> writes:
>
>> It implements a minor mode that highlights (in a customizable way) the last
>> visible buffer area after scrolling, for better orientation when reading
>> texts or code.
>
> Neat.  Just two comments:
>
>   (let ((method `(,on-screen-highlight-method . ,on-screen-inverse-flag)))
>
> Is the same as:
>
>   (let ((method (const on-screen-highlight-method on-screen-inverse-flag)))

Elisp seems to disagree.  Oh, you rather mean `cons' !

-- 
David Kastrup