Feedback, Hyperbole 7.0.8 Test Release

[gravitypost]

Good afternoon,

As recommended, I'm submitting my feedback on the 7.0.8 Test Release 
here -- hopefully I'm doing this correctly.

---------------------------------------------

OS: Windows 10 Home, Version 1909, Build 18363.592

GNU Emacs 26.3 (build 1, x86_64-w64-mingw32) of 2019-08-29

Hyperbole Built following the instructions on this Reddit post:

https://www.reddit.com/r/emacs/comments/euzxmx/gnu_hyperbole_708_test_release_with_patches/

Hyperbole Config:

 >   ;; hyperbole
 >   (require 'hyperbole)
 >   (load "hyperbole-autoloads")
 >   (load "hyperbole")


---------------------------------------------

Feedback #1: Implicit Buttons are Much Improved! Action buttons are 
great!
======================================================

I wanna say, first, that the implicit buttons are much improved in this 
release -- both in their ability to find the buttons, and in the options 
for labeling and linking. Likewise, the new Action Button syntax is 
cool! I'm super excited for the final build.

Feedback #2: Possible Bug Causing Implicit Buttons Require Additional 
User Input to Activate
===================================================================

Consider line 33 of the Hyperbole Demo document. It reads:

> Hyperbole displays that file when you press {C-h h d a}.  Hyperbole 
> assumes

If I want to invoke the key-sequence implicit button, I move the cursor 
there, and hit M-RET or click with the mouse action button.

The expected behavior is, obviously, that the button flashes, then 
activates. For me, though, activating the button causes the button to 
highlight persistently -- and no action occurs until I make another 
keypress. Any keypress that doesn't insert text works: ESC, Right-Arrow, 
etc.

Most of the time when I press the extra key, the button then just 
activates as normal, and works as expected. Sometimes when I press a 
key, I get an error like:

> apply: Wrong type argument: commandp, (keymap (keymap (9 . 
> backward-button)) ESC-prefix)

The debugger output:

>   Debugger entered--Lisp error: (wrong-type-argument commandp (keymap 
> (keymap (9 . backward-button)) ESC-prefix))
>     #<subr call-interactively>((keymap (keymap (9 . backward-button)) 
> ESC-prefix))
>     apply(#<subr call-interactively> (keymap (keymap (9 . 
> backward-button)) ESC-prefix) nil)
>     call-interactively@ido-cr+-record-current-command(#<subr 
> call-interactively> (keymap (keymap (9 . backward-button)) ESC-prefix))
>     apply(call-interactively@ido-cr+-record-current-command #<subr 
> call-interactively> (keymap (keymap (9 . backward-button)) ESC-prefix))
>     call-interactively((keymap (keymap (9 . backward-button)) 
> ESC-prefix))
>     (cond ((null binding) (if (kbd-key:special-sequence-p key-series) 
> (progn (setq unread-command-events (nconc unread-command-events (mapcar 
> (quote identity) key-series))) t))) ((memq binding (quote (action-key 
> action-mouse-key hkey-either))) (beep) (message "(kbd-key:act): This 
> key does what the Action Key does.") t) (t (call-interactively binding) 
> t))
>     (let ((binding (key-binding key-series))) (cond ((null binding) (if 
> (kbd-key:special-sequence-p key-series) (progn (setq 
> unread-command-events (nconc unread-command-events (mapcar ... 
> key-series))) t))) ((memq binding (quote (action-key action-mouse-key 
> hkey-either))) (beep) (message "(kbd-key:act): This key does what the 
> Action Key does.") t) (t (call-interactively binding) t)))
>     kbd-key:act("\033")
>     actypes::kbd-key("\033")
>     apply(actypes::kbd-key "\033")
>     eval((apply action args))
>     (if (or (symbolp action) (listp action) (hypb:emacs-byte-code-p 
> action) (and (stringp action) (not (integerp action)) (setq action 
> (key-binding action)))) (eval act) (eval action))
>     (or (if (or (symbolp action) (listp action) (hypb:emacs-byte-code-p 
> action) (and (stringp action) (not (integerp action)) (setq action 
> (key-binding action)))) (eval act) (eval action)) t)
>     (prog1 (or (if (or (symbolp action) (listp action) 
> (hypb:emacs-byte-code-p action) (and (stringp action) (not (integerp 
> action)) (setq action (key-binding action)))) (eval act) (eval action)) 
> t) (hhist:add hist-elt))
>     (let ((hist-elt (hhist:element))) (run-hooks (quote 
> action-act-hook)) (prog1 (or (if (or (symbolp action) (listp action) 
> (hypb:emacs-byte-code-p action) (and (stringp action) (not (integerp 
> action)) (setq action (key-binding action)))) (eval act) (eval action)) 
> t) (hhist:add hist-elt)))
>     (if (null action) (error "(actype:act): Null action for: `%s'" 
> actype) (and (symbolp action) (symtable:actype-p action) (setq args 
> (action:path-args-abs args))) (let ((hist-elt (hhist:element))) 
> (run-hooks (quote action-act-hook)) (prog1 (or (if (or (symbolp action) 
> (listp action) (hypb:emacs-byte-code-p action) (and (stringp action) 
> (not ...) (setq action ...))) (eval act) (eval action)) t) (hhist:add 
> hist-elt))))
>     (let ((prefix-arg current-prefix-arg) (action (actype:action 
> actype)) (act (quote (apply action args)))) (if (null action) (error 
> "(actype:act): Null action for: `%s'" actype) (and (symbolp action) 
> (symtable:actype-p action) (setq args (action:path-args-abs args))) 
> (let ((hist-elt (hhist:element))) (run-hooks (quote action-act-hook)) 
> (prog1 (or (if (or (symbolp action) (listp action) 
> (hypb:emacs-byte-code-p action) (and ... ... ...)) (eval act) (eval 
> action)) t) (hhist:add hist-elt)))))
>     actype:act(actypes::kbd-key "\033\015")
>     apply(actype:act actypes::kbd-key "\033\015")
>     (if hbut (apply hrule:action (hattr:get hbut (quote actype)) 
> (hattr:get hbut (quote args))))
>     hbut:act(hbut:current)
>     funcall(hbut:act hbut:current)
>     (cond ((and (called-interactively-p (quote interactive)) (null 
> but)) (hypb:error "(hbut-operate): No current button to operate upon")) 
> ((not (hbut:is-p but)) (hypb:error "(hbut-operate): Button is invalid; 
> it has no attributes")) (t (or but (setq but (quote hbut:current))) 
> (hui:but-flash) (funcall operation but)))
>     hui:hbut-operate(hbut:act "execute" hbut:current)
>     hui:hbut-act(hbut:current)
>     eval((hui:hbut-act (quote hbut:current)))
>     (progn (if hkey-debug (hkey-debug)) (eval hkey-action))
>     (if (setq hkey-action (if assist-flag (cdr (cdr hkey-form)) (car 
> (cdr hkey-form))) pred (car hkey-form) pred-value (eval pred)) (progn 
> (if hkey-debug (hkey-debug)) (eval hkey-action)) (setq hkey-forms (cdr 
> hkey-forms)))
>     (while (and (null pred-value) (setq hkey-form (car hkey-forms))) 
> (if (setq hkey-action (if assist-flag (cdr (cdr hkey-form)) (car (cdr 
> hkey-form))) pred (car hkey-form) pred-value (eval pred)) (progn (if 
> hkey-debug (hkey-debug)) (eval hkey-action)) (setq hkey-forms (cdr 
> hkey-forms))))
>     (let ((hkey-forms hkey-alist) (pred-value) (hkey-action) hkey-form 
> pred) (while (and (null pred-value) (setq hkey-form (car hkey-forms))) 
> (if (setq hkey-action (if assist-flag (cdr (cdr hkey-form)) (car (cdr 
> hkey-form))) pred (car hkey-form) pred-value (eval pred)) (progn (if 
> hkey-debug (hkey-debug)) (eval hkey-action)) (setq hkey-forms (cdr 
> hkey-forms)))) pred-value)
>     hkey-execute(nil)
>     (or (hkey-execute nil) (if (fboundp action-key-default-function) 
> (progn (funcall action-key-default-function) t)))
>     action-key-internal()
>     (prog1 (action-key-internal) (run-hooks (quote 
> action-key-depress-hook) (quote action-key-release-hook)))
>     action-key()
>     (if arg (assist-key) (action-key))
>     hkey-either(nil)
>     funcall-interactively(hkey-either nil)
>     #<subr call-interactively>(hkey-either nil nil)
>     apply(#<subr call-interactively> hkey-either (nil nil))
>     call-interactively@ido-cr+-record-current-command(#<subr 
> call-interactively> hkey-either nil nil)
>     apply(call-interactively@ido-cr+-record-current-command #<subr 
> call-interactively> (hkey-either nil nil))
>     call-interactively(hkey-either nil nil)
>     command-execute(hkey-either)

I get this behavior in elisp files as well. Consider the following:

>   ;; Info-mode
>   (when (eq system-type 'windows-nt)
>     (setq Info-additional-directory-list
>           (quote
>            ("~/Apps/msys2/usr/share/info" "~/Apps/msys2 
> /mingw64/share/info"))))

If I move to one of the paths listed, and hit the action button, 
Hyperbole correctly recognizes the path as an implicit button, 
highlights it, but then doesn't act upon it until I make some additional 
keypress. This case does not throw an error, so I can't provide debug 
information.

Feedback #3: Explicit Buttons Should Be Colored
===================================

If I have an explicit button in a file -- <(fake button)> -- it does not 
display in red as intended. Examining the way this stuff is set up, it 
looks like the button color is tied to the `Hbut` face, and that the 
`Hbut` face defaults to

> foreground: SystemWindowText
> background: SystemWindow

This basically means black text on a white background, just like all the 
other normal text in a file.

Modifying these faces doesn't seem to stick, either. If I go into 
Hyperbole's customization {C-h h c a} then the Hyperbole Buttons group, 
then the `Face Hbut` property and set it to `red` or `#ff0000` -- 
Hitting `Apply and Save` creates an entry in my custom.el:

> '(hbut ((t (:background "SystemWindow" :foreground "red"))) t)

 and changes the button color correctly... but upon restarting Emacs, it 
reverts back to `SystemWindowText`/`SystemWindow`. This is true even 
when `custom.el` is loads correctly. I have also tried this without 
having an external customization file -- in that case, customizing the 
face adds the line above to the bottom of my init, but there's no 
difference in behavior.

I was able to force the buttons to always be red by creating this hook 
-- but that shouldn't be necessary, right?

>    (add-hook 'hyperbole-init-hook (lambda ()
>                                     (hproperty:cycle-but-color "red")))




Thank you for all your hard work on this package. I use Hyperbole 
basically every day, and I'm always excited for a new release!