Re: Functions which are mode dependent

[Heime]

On Friday, August 23rd, 2024 at 6:58 AM, Yuri Khan <yuri.v.khan@gmail.com> 
wrote:

> On Mon, 19 Aug 2024 at 04:15, Heime heimeborgia@protonmail.com wrote:
>
> > I need some help understanding how to automatically enable some 
> > functionality
> > when loading a file with some major mode.
>
>
> The major mode you’re customizing has a hook. As an end user, you add
> your own function to that hook, and enable the functionality there.
>
> (As a package developer, you’d make your functionality use some
> buffer-local variables. Your users would add their own functions to
> mode hooks where they would set their own variable values and then
> call your function or enable your minor mode.)

How does one use the buffer local variable ?  Is it to save the 
regexp which I sot immediately to imenu-generic-expression ?

How would one do it ?

> > For instance I have a function that sets
> >
> > (defun expr-elisp ()
> >
> > (setq imenu-generic-expression
> > `( ("defun" ,(concat "^\\s-*"
> > "(\\(defun\\|define-minor-mode\\)\\s-+"
> > "\\(\\(\\sw\\|\\s_\\)+\\)") 2) )) )
> >
> > (defun expr-selector ()
> >
> > (cond
> > ((eq major-mode 'emacs-lisp-mode) (expr-elisp))
> > (t (expr-generic)) ))
>
>
> Having to compare ‘major-mode’ against a symbol is a sign you’re doing
> something wrong, for several reasons.

This is the first time doing such a thing, and came up with it.  I had
a hunch it was not the proper way, so I asked for some feedback to make
it good, with this help list.

> * A major mode can inherit from another major mode. In that case, the
> right thing is for your customization to work automatically for the
> derived mode as well as the base mode. However, comparing for equality
> only handles the base mode.

What is one to use to handle an elisp derived mode for my case ?
Still with a mode hook ?

> * To extend your customization to modes not originally in your list,
> you’d have to modify your ‘expr-selector’ function.
>
> > I have put the code above in a minor mode.
> >
> > ;;;###autoload
> > (define-minor-mode tema-minor-mode
> >
> > (if tema-minor-mode
> > (expr-selector)
> > (message "Tema Deactivated")))
> >
> > with hooks to load the minor mode automatically for specific major modes.
>
> As told by Stefan, your minor mode is pointless because it does
> nothing when turned off.

For now I only want to make the functionality work, and concentrate
upon that first.  

> > (add-hook emacs-lisp-mode-hook #'tema-minor-mode)

> If all you want is to set ‘imenu-generic-expression’ to that list for
> buffers using ‘emacs-lisp-mode’ or any major mode derived from that,
> and to another list for buffers in ‘sh-mode’ or any major modes
> derived from that, all you need to do is:
>
> (defun expr-elisp ()
> (setq imenu-generic-expression
> `( ("defun" ,(concat "^\\\\s-*" 
> "(\\\\(defun\\\\|define-minor-mode\\\\)\\\\s-+" 
> "\\\\(\\\\(\\\\sw\\\\|\\\\s_\\\\)+\\\\)") 2) )) ) (add-hook 
> emacs-lisp-mode-hook #'expr-elisp) (defun expr-sh () (setq 
> imenu-generic-expression` ( …something else… )))
>
> (add-hook sh-mode-hook #'expr-sh)
>
> You do not need a minor mode for that.

I know about using hook with a function such as (add-hook sh-mode-hook 
#'expr-sh)

But I want to work on making a minor-mode.  Firstly because I have some
other functionality to add to it. Secondly to see how to do a minor-mode
that in also major mode dependent.

> (Also, your private functions should be named starting with a short
> string reasonably unique to you, so that it does not collide with any
> public packages you could install.)

I have no problem with doing so.