bug#48724: Code collapsing and outline headings for elisp

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

Currently, outline-minor-mode has the capability to treat "defun" constructs
as heading, allowing one to choose to hide some code from view by collapsing
the region of code.  It would be beneficial for the actual major mode itself
(i.e. emacs-lisp-mode) to handle the code collapsing, leaving the code highlighting
intact.  Code collapsing could also be extended beyond not only collapsing
functions and variables ((defun, defvar), but also to additional constructs that could
be indented (e.g. lists '(...), let, let*, pcase) and other constructs users could
find useful (e.g. if, when, ).

And for outline-minor-mode, the mode could then be used to further enhance the structuring
of larger chunks of code (e.g. a collection of functions) using outline headings.  Outlining
would then be a separate capability different from code collapsing.

Regards
Christopher

bug#48724: Code collapsing and outline headings for elisp

[Juri Linkov]

> Currently, outline-minor-mode has the capability to treat "defun" constructs
> as heading, allowing one to choose to hide some code from view by collapsing
> the region of code.  It would be beneficial for the actual major mode itself
> (i.e. emacs-lisp-mode) to handle the code collapsing, leaving the code highlighting
> intact.  Code collapsing could also be extended beyond not only collapsing
> functions and variables ((defun, defvar), but also to additional constructs that could
> be indented (e.g. lists '(...), let, let*, pcase) and other constructs users could
> find useful (e.g. if, when, ).
>
> And for outline-minor-mode, the mode could then be used to further enhance the structuring
> of larger chunks of code (e.g. a collection of functions) using outline headings.  Outlining
> would then be a separate capability different from code collapsing.

Currently everything is customizable in outline-minor-mode by just
two variables: outline-regexp and outline-level.  So when necessary,
emacs-lisp-mode could provide an option that will set different values
of these variables, one of which could set outline-regexp to a regexp
that matches: lists, '(...), let, let*, pcase, if, when, etc…

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 9:57 AM
> From: "Juri Linkov" <juri@linkov.net>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: 48724@debbugs.gnu.org
> Subject: Re: bug#48724: Code collapsing and outline headings for elisp
>
> > Currently, outline-minor-mode has the capability to treat "defun" constructs
> > as heading, allowing one to choose to hide some code from view by collapsing
> > the region of code.  It would be beneficial for the actual major mode itself
> > (i.e. emacs-lisp-mode) to handle the code collapsing, leaving the code highlighting
> > intact.  Code collapsing could also be extended beyond not only collapsing
> > functions and variables ((defun, defvar), but also to additional constructs that could
> > be indented (e.g. lists '(...), let, let*, pcase) and other constructs users could
> > find useful (e.g. if, when, ).
> >
> > And for outline-minor-mode, the mode could then be used to further enhance the structuring
> > of larger chunks of code (e.g. a collection of functions) using outline headings.  Outlining
> > would then be a separate capability different from code collapsing.
> 
> Currently everything is customizable in outline-minor-mode by just
> two variables: outline-regexp and outline-level.  So when necessary,
> emacs-lisp-mode could provide an option that will set different values
> of these variables, one of which could set outline-regexp to a regexp
> that matches: lists, '(...), let, let*, pcase, if, when, etc…

The general impression is that outline-minor-mode is a general mode
for customisable headings that are then handled by the respective
major mode.

General settings could be better, because some variables are not customizable.

Serious problem is that the two important variables: `outline-regexp' and
`outline-heading-alist' are not customizable by using "M-x customize-group".

Additionally both of them should be customizable per mode.  Don't you think so?

There has been a discussion today about outline-minor-mode settings for fortran
(both fixed and free form).  Have had a go at using "!" and "!!", but "Hide Body"
did not hide the body.

There could be some default headings for fortran when outline-minor-mode is enabled.
One could follow the current setup for emacs-lisp-mode, for fortran.

!! for heading level 1
!!! for subheading level 2
!!!! for subsubheading level 3

Together with "Hide Body" for lines beginning with "subroutine" and "function".

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 11:55 AM
> From: "Christopher Dimech" <dimech@gmx.com>
> To: "Juri Linkov" <juri@linkov.net>
> Cc: 48724@debbugs.gnu.org
> Subject: bug#48724: Code collapsing and outline headings for elisp
>
> > Sent: Sunday, May 30, 2021 at 9:57 AM
> > From: "Juri Linkov" <juri@linkov.net>
> > To: "Christopher Dimech" <dimech@gmx.com>
> > Cc: 48724@debbugs.gnu.org
> > Subject: Re: bug#48724: Code collapsing and outline headings for elisp
> >
> > > Currently, outline-minor-mode has the capability to treat "defun" constructs
> > > as heading, allowing one to choose to hide some code from view by collapsing
> > > the region of code.  It would be beneficial for the actual major mode itself
> > > (i.e. emacs-lisp-mode) to handle the code collapsing, leaving the code highlighting
> > > intact.  Code collapsing could also be extended beyond not only collapsing
> > > functions and variables ((defun, defvar), but also to additional constructs that could
> > > be indented (e.g. lists '(...), let, let*, pcase) and other constructs users could
> > > find useful (e.g. if, when, ).
> > >
> > > And for outline-minor-mode, the mode could then be used to further enhance the structuring
> > > of larger chunks of code (e.g. a collection of functions) using outline headings.  Outlining
> > > would then be a separate capability different from code collapsing.
> > 
> > Currently everything is customizable in outline-minor-mode by just
> > two variables: outline-regexp and outline-level.  So when necessary,
> > emacs-lisp-mode could provide an option that will set different values
> > of these variables, one of which could set outline-regexp to a regexp
> > that matches: lists, '(...), let, let*, pcase, if, when, etc…
> 
> The general impression is that outline-minor-mode is a general mode
> for customisable headings that are then handled by the respective
> major mode.
> 
> General settings could be better, because some variables are not customizable.
> 
> Serious problem is that the two important variables: `outline-regexp' and
> `outline-heading-alist' are not customizable by using "M-x customize-group".
> 
> Additionally both of them should be customizable per mode.  Don't you think so?
> 
> There has been a discussion today about outline-minor-mode settings for fortran
> (both fixed and free form).  Have had a go at using "!" and "!!", but "Hide Body"
> did not hide the body.
> 
> There could be some default headings for fortran when outline-minor-mode is enabled.
> One could follow the current setup for emacs-lisp-mode, for fortran.
> 
> !! for heading level 1
> !!! for subheading level 2
> !!!! for subsubheading level 3
> 
> Together with "Hide Body" for lines beginning with "subroutine" and "function".
 
Looking at emacs-lisp again, the levels should be as follows

!!! for heading level 1 (starting as !!! as in emacs-lisp-mode)
!!!! for subheading level 2
!!!!! for subsubheading level 3  etc

I wonder if there exists the capabibily in outline-minor-mode to hide
code structures inside another code structure.

For instance for "do", "if" and "else" statements.

do in1 = 1, nr(1)
  do in2 = 1, nr(1)
    ind = in1 - in2
    if (ind < 0) then
      res(in1, in2) = conjg(fc(abs(ind)+1))
    else
      res(in1, in2) = fc(ind+1)
    endif
  enddo
enddo

hiding would then give the following

do in1 = 1, nr(1)
  do in2 = 1, nr(1)
    ind = in1 - in2
    if (ind < 0) then ...
    else ...
    end if
  end do
end do

do in1 = 1, nr(1)
  do in2 = 1, nr(1) ...
  end do
end do

do in1 = 1, nr(1) ...
end do

bug#48724: Code collapsing and outline headings for elisp

[Juri Linkov]

> Serious problem is that the two important variables: `outline-regexp' and
> `outline-heading-alist' are not customizable by using "M-x customize-group".
>
> Additionally both of them should be customizable per mode.  Don't you think so?

I think that modes should set `outline-regexp' and `outline-heading-alist'
according to the constructs of their programming language.  Then users
don't need to customize these variables.

> There has been a discussion today about outline-minor-mode settings for fortran
> (both fixed and free form).  Have had a go at using "!" and "!!", but "Hide Body"
> did not hide the body.
>
> There could be some default headings for fortran when outline-minor-mode is enabled.
> One could follow the current setup for emacs-lisp-mode, for fortran.
>
> !! for heading level 1
> !!! for subheading level 2
> !!!! for subsubheading level 3

I agree it would be nice to set an appropriate value of `outline-regexp'
and `outline-heading-alist' for fortran-mode in lisp/progmodes/fortran.el.

But the last time I used Fortran was when Fortran had the "C" character
for comments at the first fixed column on a punched card, and now
your example uses some new syntax "!" for comments, so sorry, can't help here.

This task would be a nice assignment for the group of students.

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

> Sent: Monday, May 31, 2021 at 10:15 AM
> From: "Juri Linkov" <juri@linkov.net>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: 48724@debbugs.gnu.org
> Subject: Re: bug#48724: Code collapsing and outline headings for elisp
>
> > Serious problem is that the two important variables: `outline-regexp' and
> > `outline-heading-alist' are not customizable by using "M-x customize-group".
> >
> > Additionally both of them should be customizable per mode.  Don't you think so?
>
> I think that modes should set `outline-regexp' and `outline-heading-alist'
> according to the constructs of their programming language.  Then users
> don't need to customize these variables.

Quite Right.

> > There has been a discussion today about outline-minor-mode settings for fortran
> > (both fixed and free form).  Have had a go at using "!" and "!!", but "Hide Body"
> > did not hide the body.
> >
> > There could be some default headings for fortran when outline-minor-mode is enabled.
> > One could follow the current setup for emacs-lisp-mode, for fortran.
> >
> > !! for heading level 1
> > !!! for subheading level 2
> > !!!! for subsubheading level 3
>
> I agree it would be nice to set an appropriate value of `outline-regexp'
> and `outline-heading-alist' for fortran-mode in lisp/progmodes/fortran.el.
>
> But the last time I used Fortran was when Fortran had the "C" character
> for comments at the first fixed column on a punched card, and now
> your example uses some new syntax "!" for comments, so sorry, can't help here.
>
> This task would be a nice assignment for the group of students.

There are currently two modes (1) the fixed format fortran (fortran-made) you
describe with "C" character for comments, and (2) the newer free format fortran
with "!" character for comments (f90-mode).

Could use for fortran-mode starting from three CCC as in elisp

CCC Heading
CCCC Subheading
CCCCC SubSubHeading etc

And for f90-mode use the following, starting from three !!! as in elisp

!!! for heading level 1
!!!! for subheading level 2
!!!!! for subsubheading level 3

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

> Sent: Monday, May 31, 2021 at 10:15 AM
> From: "Juri Linkov" <juri@linkov.net>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: 48724@debbugs.gnu.org
> Subject: Re: bug#48724: Code collapsing and outline headings for elisp
>
> > Serious problem is that the two important variables: `outline-regexp' and
> > `outline-heading-alist' are not customizable by using "M-x customize-group".
> >
> > Additionally both of them should be customizable per mode.  Don't you think so?
>
> I think that modes should set `outline-regexp' and `outline-heading-alist'
> according to the constructs of their programming language.  Then users
> don't need to customize these variables.
>
> > There has been a discussion today about outline-minor-mode settings for fortran
> > (both fixed and free form).  Have had a go at using "!" and "!!", but "Hide Body"
> > did not hide the body.
> >
> > There could be some default headings for fortran when outline-minor-mode is enabled.
> > One could follow the current setup for emacs-lisp-mode, for fortran.
> >
> > !! for heading level 1
> > !!! for subheading level 2
> > !!!! for subsubheading level 3
>
> I agree it would be nice to set an appropriate value of `outline-regexp'
> and `outline-heading-alist' for fortran-mode in lisp/progmodes/fortran.el.

I suggest that emacs-lisp-mode does code collapse (show/hide) by default.
Then outline-minor-mode does additional headings in the form

;;; Heading 1
;;;; SubHeading
;;;;; SubSubHeading

;;; Heading 2

outline-minor-mode would then be made to collapse sections of code between
headlines.

This means that a headline hide could hide a number of variable and function
definitions that belong together.

> But the last time I used Fortran was when Fortran had the "C" character
> for comments at the first fixed column on a punched card, and now
> your example uses some new syntax "!" for comments, so sorry, can't help here.
>
> This task would be a nice assignment for the group of students.

Which major modes could be done straight away?

bug#48724: Code collapsing and outline headings for elisp

[Juri Linkov]

> I suggest that emacs-lisp-mode does code collapse (show/hide) by default.
> Then outline-minor-mode does additional headings in the form
>
> ;;; Heading 1
> ;;;; SubHeading
> ;;;;; SubSubHeading
>
> ;;; Heading 2
>
> outline-minor-mode would then be made to collapse sections of code between
> headlines.
>
> This means that a headline hide could hide a number of variable and function
> definitions that belong together.

Recently we changed the outlines of emacs-lisp-mode in https://debbugs.gnu.org/46878
So this is already fixed.

bug#48724: Code collapsing and outline headings for elisp

[Christopher Dimech]

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

> Sent: Wednesday, June 02, 2021 at 8:44 AM
> From: "Juri Linkov" <juri@linkov.net>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: 48724@debbugs.gnu.org
> Subject: Re: bug#48724: Code collapsing and outline headings for elisp

> I suggest that emacs-lisp-mode does code collapse (show/hide) by default.
> Then outline-minor-mode does additional headings in the form
>
> ;;; Heading 1
> ;;;; SubHeading
> ;;;;; SubSubHeading
>
> ;;; Heading 2
>
> outline-minor-mode would then be made to collapse sections of code between
> headlines.
>
> This means that a headline hide could hide a number of variable and function
> definitions that belong together.

Recently we changed the outlines of emacs-lisp-mode in https://debbugs.gnu.org/46878
So this is already fixed.

Have been discussing all this together with Protesilaos Stavrou.  Could you have a read
to see if we actually got to something?

> Sent: Wednesday, June 02, 2021 at 1:46 AM
> From: "Protesilaos Stavrou" <info@protesilaos.com>
> To: "Christopher Dimech" <dimech@gmx.com>
> Subject: Re: modus-themes and headlines
>
> On 2021-06-01, 14:42 +0200, Christopher Dimech <dimech@gmx.com> wrote:
>
> > I send you a file to see how doing "Hide Body" looks like after enabling
> > outline-minor-mode.
> >
> > For headings, you seem to change the font.  Anyway, I have seen that the colours
> > for headings staring with comments (;;; ;;;; ;;;;; ...) are basically indistinguisable
> > from code headlines ("(defvar", "(defun"),  Almost same colour but not the same.
> >
> > Don't you play with contrast ratio between headings starting with ;;; and those starting
> > with code?
>
> Just rebuilt Emacs and checked with the file you sent.  Long story
> short: this is the same as we discussed the other day, namely, that the
> problem is with outline.el and how it chooses to fontify forms that are
> not explicitly defined as headings (defvar, defun...).
>
> To the defun, defvar etc. it applies the outline-8 face, whereas the
> real headings (starting with comments that have three delimiters: ;;;)
> are styled with outline-1 and then incremented for each extra comment
> delimiter.
>
> This happens regardless of theme.  It just is that the generic theme
> inherits from font-lock, so the problem is not obvious even though it is
> still there: try it with and without outline-minor-mode to see the
> difference.
>
> Here is what I did (screenshots attached):
>
> - emacs -Q and find-file gungadin.el (screenshot 1)
>
> - M-x outline-minor-mode (screenshot 2)
>
> - M-x load-theme RET modus-operandi RET (screenshot 3)
>
> - M-: (setq-default outline-minor-mode-highlight 'override) RET
>   and then M-x outline-minor-mode twice to re-enable the mode
>   (screenshot 4)
>
> - M-x disable-theme RET modus-operandi RET (screenshot 5)
>
> - M-x outline-minor-mode (screenshot 6)
>
> Just comparing the last two screenshots you can see that the problem is
> there.
>
> As for the style of the headings for the modus-themes (screenshot 4),
> you can use the variable 'modus-themes-headings' as we mentioned before.
>
> I suggest we bring this issue upstream.  Ask them whether the
> defvar,defun etc. can retain their styles and only for explicit headings
> to be fontified.
>
> --
> Protesilaos Stavrou
> https://protesilaos.com
>

[-- Attachment #2: gungadin.el --]
[-- Type: text/plain, Size: 24096 bytes --]

;;; gungadin.el - Loads Emacs Lisp files

;; Version 1.0
;; Copyright 2017 Matematiker Christopher Dimech
;; This file forms part of Behistun, a Gnu Package.

;; @rec
;; File: gungadin.el
;; Brief: Loads Emacs Lisp files for Emacs Customisation.
;; FileVers: 1.0
;; Copyright: 2017 Matematiker Christopher Dimech
;; License: Gnu Affero General Public License (Gnu AGPL)
;; LicVers: Version 3 or any later version.
;; Author: Christopher Dimech
;; Keywords: Elisp
;; @end rec

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

;;; Copying Conditions

;;   ___              ___             _
;;  / __|_ __ _  _   / __|___ _ _  __| |_ __
;; | (__| '_ \ || | | (__/ _ \ ' \/ _` \ \ /
;;  \___| .__/\_, |  \___\___/_||_\__,_/_\_\
;;      |_|   |__/

;; This file is part of Behistena Gnu Package.

;; Gnu Behistun is free software; you can redistribute it and/or modify
;; it under the terms of the Gnu Affero General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.

;; This file 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
;; Affero General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this file.  A copy of the license is included in the
;; file entitled "gnu--agpl.texi".  If not, see
;; <http://www.gnu.org/licenses/>.

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

;;; Commentary:

;; @rec
;; Subject: Byte Compilation
;; Brief: The Byte Compiler makes emacs run faster by translating
;; + lisp commands into Byte-Code Representation in a file with .elc
;; + extension.  The .elc file can then be read by the Byte-Code
;; + Interpreter.
;; Detail: Byte compilation will show helpful error and warning messages
;; Example:  M-x byte-compile-file <ret> gungadin.el <ret>
;; Example:  (byte-compile-file "gungadin.el")
;; Example: Byte compile newer .el files compared to .elc files.
;; +  (byte-recompile-directory ".")
;; Example: Byte compile .el file when .elc file does not exist.
;; +  (byte-recompile-directory "." 0)

;; Example: Lists information about block devices
;; +  lsblk

;; Example: Checking and repairing a filesystem
;; +   sudo fsck -y /dev/sdc1

;;; Code:

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; @rec
;; Define: multic, keytrigger-text-scale
;; Brief: [1] Enables multi-line comments; [2] Changes the height of
;; + the default text typeface.
;; @end rec

(defmacro multic (&rest _))


(defvar mydoc "foobar")

(defun aoe (x)
  (:documentation mydoc)
  (+ x 42))

;;(aoe 5)

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun defun-detail (fname detail)
   "Put DETAIL in function-documentation property of FNAME.
Usage:  (defun-detail 'fname 'detail)"

   (put fname 'function-documentation detail))

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
#+STARTUP: content
* Defvar: Buffer name, version, license
** gungadin-bufr-name")

(defvar gungadin-bufr-name "*Gungadin*")

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
** Defvar: gungadin-version-license")

(defvar gungadin-version-license
  "Gungadin 1.0 of 2017-05-02
Gungadin is part of Behistun, a Gnu Package.
Copyright (C) 2017 Christopher Dimech
Author: Christopher Dimech

Gungadin is Free Software, software that fully respects the computing
freedom of its users as defined by the Free Software Foundation.
See `(url-link https://www.gnu.org/philosophy/philosophy.html)'.

You can redistribute exact copies of Gungadin or modify it under the
terms of the Gnu Affero General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.")

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
** gungadin-guidance-message")

(defvar gungadin-guidance-message
  "M-x finder-commentary
  Displays elisp file commentary section.

C-h f flight\n")

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
* Make buffer and startup
** gungadin-bufr-insert")

(defun gungadin-bufr-insert (message)
   "Inserts formatted string into the Gungadin Dedicated Buffer."

   (with-current-buffer
       (get-buffer-create gungadin-bufr-name)
     (insert message)) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-inhibit-windows")

;;; * gungadin-inhibit-windows

(defvar startup-windows-kondor 0)

(defun gungadin-inhibit-windows ()
  "Inhibits emacs startup windows.
Startup windows provide information about copyleft and basic
emacs usage."
  (setq inhibit-startup-screen t)
  (add-hook 'emacs-startup-hook
               (lambda ()
                  (delete-other-windows)) t) )

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
** gungadin-debug-sweep")

;;; * gungadin-debug-sweep

;;                            _     _
;;  ___ _ __  __ _ __ ___  __| |___| |__ _  _ __ _ _ _
;; / -_) '  \/ _` / _(_-< / _` / -_) '_ \ || / _` | '_|
;; \___|_|_|_\__,_\__/__/ \__,_\___|_.__/\_,_\__, |_|
;;                                           |___/

;; @rec
;; Defvar: gungadin-debug-kondor
;; Brief: Instructs how the lisp debugger behaves when errors happen.
;; Defun: gungadin-debug-sweep, gungadin-launch-debug,
;; Defun: keytrigger-text-scale
;; Brief: [1] Provides ways to enter the debugger; [2] Easy way
;; + to launch the lisp debugger; [3] Changes text height.
;; @end rec

;; toggle-debug-on-error

(defvar gungadin-debug-sweep-kondor 0)

(defun gungadin-debug-sweep ()
  "Enables the Emacs Debugger."
  (interactive)

  (pcase gungadin-debug-sweep-kondor
      ;; ----------------------------------------------------------------
      (1                                ; enter debug mode on error
         (setq debug-on-error t)       ; some errors ignored
	 (message "(+) debug-on-error")
	 (setq gungadin-debug-sweep-kondor 2))
      ;; ----------------------------------------------------------------
      (2                                ; add dubug of ignored errors
         (setq debug-on-error t)
         (setq debug-ignored-errors t)
	 (message "[debug-on-error] (+) debug-ignored-errors")
	 (setq gungadin-debug-sweep-kondor 3))
      ;; ----------------------------------------------------------------
      (3                                ;  debugs all errors
         (setq debug-on-error t)
         (setq debug-ignored-errors t)
         (setq debug-on-message "unescaped character literals")
	 (message "[debug-on-error] (+) debug-ignored-errors")
	 (message "[debug-on-error] (+) debug-on-message")
	 (setq gungadin-debug-sweep-kondor 4)
	 )
      ;; ----------------------------------------------------------------
      (_                                ; normal operation - no debug
         (setq debug-on-error nil)
	 (message "(-) debug-on-error")
	 (setq gungadin-debug-sweep-kondor 1)) ))

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
** gungadin-debug-launch")

;;; * gungadin-debug-launch

(defun gungadin-debug-launch ()
  "Debugging gungadin
SEL  Selection"
  (gungadin-debug-sweep))

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* keytrigger-text-scale")

;;; * gungadin-text-scale-keytrigger

;;  _           _                 _
;; | |_ _____ _| |_   ___ __ __ _| |___
;; |  _/ -_) \ /  _| (_-</ _/ _` | / -_)
;;  \__\___/_\_\\__| /__/\__\__,_|_\___|

;; @rec
;; Defun: gungadin-text-scale-keytrigger
;; Brief: Changes the height of the default text typeface.
;; @end rec

(defun gungadin-text-scale-keytrigger ()
   "Changes the height of the default text typeface."

   ;; keybinding alternative to "C-x C--"
   (global-set-key (kbd "C-,") 'text-scale-decrease)

   ;; keybinding alternative to "C-x C-+" and "C-x C-="
   (global-set-key (kbd "C-.") 'text-scale-increase) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* Gungadin initial startup
** gungadin-initial-startup")

;;; * gungadin-initial-startup

;;     _            _                 _        _     _
;;  __| |_ __ _ _ _| |_ _  _ _ __   _| |_   __| |___| |__ _  _ __ _
;; (_-<  _/ _` | '_|  _| || | '_ \ |_   _| / _` / -_) '_ \ || / _` |
;; /__/\__\__,_|_|  \__|\_,_| .__/   |_|   \__,_\___|_.__/\_,_\__, |
;;                          |_|                               |___/

(defun gungadin-initial-startup ()
  "Sets initial startup"

  (gungadin-inhibit-windows)
  (gungadin-debug-launch)
  (gungadin-text-scale-keytrigger)
  (gungadin-bufr-insert gungadin-version-license) )

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  (multic "
** Execute gungadin-initial-startup")

(gungadin-initial-startup)

;; Helm and Icicles.

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* Colour theme
** gungadin-colour-theme")

;;; * gungadin-colour-theme

;;         _                _   _
;;  __ ___| |___ _  _ _ _  | |_| |_  ___ _ __  ___
;; / _/ _ \ / _ \ || | '_| |  _| ' \/ -_) '  \/ -_)
;; \__\___/_\___/\_,_|_|    \__|_||_\___|_|_|_\___|

;; @rec
;; Defun: gungadin-colour-theme
;; Brief: Launches the modus-operandi colour theme
;; @end rec

(defun gungadin-colour-theme ()
  "Loads atd launches modus-themes."

  (add-to-list 'load-path
     "~/Admir/bin/gungadin-1.0/emacs/modus-themes")

  (require 'modus-themes)          ; common code
  (require 'modus-operandi-theme)  ; light theme
  (require 'modus-vivendi-theme)   ; dark theme

  ;; Set customization options to values of your choice
  (setq modus-themes-slanted-constructs t
        modus-themes-bold-constructs nil
        modus-themes-fringes nil
        modus-themes-mode-line '3d
        modus-themes-syntax 'alt-syntax
        modus-themes-intense-hl-line nil
        modus-themes-paren-match 'intense-bold
        modus-themes-links 'neutral-underline
        modus-themes-no-mixed-fonts nil
        modus-themes-prompts 'intense
        modus-themes-completions 'opinionated
        modus-themes-region 'bg-only-no-extend
        modus-themes-diffs nil
	modus-themes-org-blocks 'rainbow
        modus-themes-org-habit 'traffic-light
        modus-themes-headings
	  '( (1 . rainbow-line)
             (2 . rainbow-line)
             (3 . rainbow-line)
             (t . rainbow-line))
        modus-themes-variable-pitch-headings t
        modus-themes-scale-headings t
        modus-themes-scale-1 1.1
        modus-themes-scale-2 1.15
        modus-themes-scale-3 1.21
        modus-themes-scale-4 1.27
        modus-themes-scale-5 1.33
        modus-themes-lang-checkers 'intense-foreground )

  (load-theme 'modus-operandi t)
  (load-theme 'modus-vivendi t) )

;;        '((1 . rainbow)
;;          (2 . rainbow)
;;          (3 . rainbow-line)
;;          (t . rainbow-line-no-bold))


;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-speedbar")

;;; * gungadin-speedbar

;;                      _ _
;;  ____ __  ___ ___ __| | |__  __ _ _ _
;; (_-< '_ \/ -_) -_) _` | '_ \/ _` | '_|
;; /__/ .__/\___\___\__,_|_.__/\__,_|_|
;;    |_|

;; @rec
;; Defun: gungadin-speedbar
;; Brief: Allows better navigation of source code using the speedbar.
;; @end rec

(defun gungadin-speedbar ()
  "Settings for the speedbar"

  (speedbar 1)  ; enables speedbar
  (make-face 'speedbar-face)
  (set-face-font 'speedbar-face "Monospace-16")

  (setq speedbar-mode-hook
     '(lambda ()
         (buffer-face-set 'speedbar-face)))

  ;; Shell, awk and sed commands
  (speedbar-add-supported-extension ".sh")
  (speedbar-add-supported-extension ".awk")

  ;; Fortran Language
  (speedbar-add-supported-extension ".f")
  (speedbar-add-supported-extension ".f90")
  (speedbar-add-supported-extension ".f95")
  (speedbar-add-supported-extension ".f03")
  (speedbar-add-supported-extension ".f08")

  ;; C Language
  (speedbar-add-supported-extension ".c")
  (speedbar-add-supported-extension ".h")

  ;; C++ Language
  (speedbar-add-supported-extension ".cpp")
  (speedbar-add-supported-extension ".hpp")
  (speedbar-add-supported-extension ".ipp")

  ;; Texinfo and Org-Mode
  (speedbar-add-supported-extension ".texi")
  (speedbar-add-supported-extension ".org")

  (speedbar-add-supported-extension ".rec")
  (speedbar-add-supported-extension ".vik")

  (speedbar-add-supported-extension ".htm")
  (speedbar-add-supported-extension ".html")

  (speedbar-add-supported-extension ".r")
  (speedbar-add-supported-extension ".oct") )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-automode, gungadin-mode-sweep")

;;; * gungadin-automode

;;              _                         _
;;  _ __  __ _ (_)___ _ _   _ __  ___  __| |___
;; | '  \/ _` || / _ \ '_| | '  \/ _ \/ _` / -_)
;; |_|_|_\__,_|/ \___/_|   |_|_|_\___/\__,_\___|
;;           |__/

;; @rec
;; Defun: gungadin-automode, gungadin-mode-sweep
;; Brief: [1] Associates emacs major modes to specific file types;
;; + [2] Cycles buffer through three major modes (text, org, normal).
;; @end rec

(defun gungadin-automode ()
  "Assigns major mode to specific files."

  ;; Bash and Elisp
  (add-to-list 'auto-mode-alist '("\\.sh\\'"   . sh-mode))
  (add-to-list 'auto-mode-alist '("\\.bash\\'" . sh-mode))
  (add-to-list 'auto-mode-alist '("\\.el\\'"   . emacs-lisp-mode))

  ;; Fortran
  (add-to-list 'auto-mode-alist '("\\.f\\'"    . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f90\\'"  . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f95\\'"  . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f03\\'"  . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f08\\'"  . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.fi\\'"   . f90-mode))

  ;; C Language
  (add-to-list 'auto-mode-alist '("\\.c\\'"    . c-mode))
  (add-to-list 'auto-mode-alist '("\\.h\\'"    . c-mode))

  ;; C++ Language
  (add-to-list 'auto-mode-alist '("\\.cpp\\'"  . c++-mode))
  (add-to-list 'auto-mode-alist '("\\.hpp\\'"  . c++-mode))
  (add-to-list 'auto-mode-alist '("\\.ipp\\'"  . c++-mode))

  ;; Org-Mode, Texinfo and Info
  (add-to-list 'auto-mode-alist '("\\.org\\'"  . org-mode))
  (add-to-list 'auto-mode-alist '("\\.texi\\'" . texinfo-mode))
  (add-to-list 'auto-mode-alist '("\\.info\\'" . Info-on-current-buffer))

  ;; Recutils
  (add-to-list 'auto-mode-alist '("\\.rec\\'"  . rec-mode))
  (add-to-list 'auto-mode-alist '("\\.vik\\'"  . rec-mode))

  ;; Html and Octave
  (add-to-list 'auto-mode-alist '("\\.htm\\'"  . html-mode))
  (add-to-list 'auto-mode-alist '("\\.html\\'" . html-mode))
  (add-to-list 'auto-mode-alist '("\\.oct\\'"  . octave-mode)) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-major-mode-sweep")

;;; * gungadin-major-mode-sweep

(defun gungadin-major-mode-sweep ()
  "Cycles buffer through three major modes (text, org, normal)."
  (interactive)

  (let* ( ($modes (list #'org-mode #'text-mode #'normal-mode))
          ($new-mode
              (or (cadr (member major-mode $modes)) (car $modes))) )
    (apply (list $new-mode)) ))

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* Elbaite Coloured Cursor")

;;; * Elbaite Coloured Cursor

;; @rec
;; Defvar: elbaite-kondor, elbaite-colours
;; Brief: Set colour state and list of cursor colours.
;; Define: blink-cursor-timer-function
;; Brief: Changes colour of cursor point at each blink.
;; Details: Overwrites blink-cursor-timer-function in frame.el file.
;; Defun: focus-paren-marks-din, focus-paren-region-din
;; Brief: Focuses attention to parenthetical sections.
;; @end rec

(defvar elbaite-kondor 0
  "Sets colour or cursor")

(defvar elbaite-colours
  (list "#FFA500" "#8A8AFF" "#FF6161" "#61FF61" "#FFFF00" "#E859E8"
	"#FFFFFF" "#FFC370" "#C370FF")
  "Sets elbaite colours for cursor.")

(defun blink-cursor-timer-function ()
  "Blinks the cursor"

  (when (not (internal-show-cursor-p))
    (when (>= elbaite-kondor (length elbaite-colours))
      (setq elbaite-kondor 0))
    (set-cursor-color (nth elbaite-kondor elbaite-colours))
    (setq eckondor (+ 1 elbaite-kondor)))
  (internal-show-cursor nil (not (internal-show-cursor-p))) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; * gungadin-startup

  (multic "
* gungadin-launch")

;; @rec
;; Function: gungadin-launch
;; Brief: Sets list of cursor colours and colour counter.
;; @end rec

(defun gungadin-startup ()
  "Sets the emacs startup."

  (setq initial-frame-alist '((width . 75) (height . 34)) )

  (setq text-scale-mode-step 1.1)
  (set-face-attribute 'default nil :height 210)  ; 21pt
  (set-face-attribute 'default nil :weight 'ultra-bold)

  (gungadin-colour-theme)          ; launches dark modus-vivendi
  (global-set-key (kbd "<f5>") #'modus-themes-toggle)
  (message "[modus-themes] (+) modus-vivendi")

  (gungadin-speedbar)              ; display speedbar
  (gungadin-automode)              ; associate emacs mode

  (blink-cursor-timer-function)    ; coloured blinking cursor
  (set-face-attribute 'region nil  ; colour selected region
     :background "#660066" :foreground "#ffffff")

  ;; remove window travel indicator
  (setq mode-line-percent-position nil)

  (redraw-display) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-break-line-sweep")

;;; ** gungadin-break-line-sweep

;; @rec
;; Function: gungadin-break-line-sweep
;; Brief: Expedites the breaking of long lines.
;; @end rec

(defvar glienicker-brucke 0)  ; default mark for case of user inaction
(setq-default auto-fill-function 'do-auto-fill)

(defun gungadin-break-line-sweep ()
  "Breaks long lines using auto-fill tool."
  (interactive)

  (pcase glienicker-brucke
    ((or 'nil 0)
       (setq-default auto-fill-function 'nil)
       (setq comment-auto-fill-only-comments nil)
       (auto-fill-mode -1)
       (turn-off-auto-fill)
       (message "%s %s"
	  "(-) Break line;  kondor:" glienicker-brucke)
       (setq glienicker-brucke (+ glienicker-brucke 1)) )
    (1
       (setq fill-column 72)
       (setq comment-auto-fill-only-comments t)
       (auto-fill-mode 1)
       (message "%s %s"
	  "(+) Break comments only;  kondor:" glienicker-brucke)
       (setq glienicker-brucke (+ glienicker-brucke 1)) )
    (_
       (setq comment-auto-fill-only-comments nil)
       (auto-fill-mode 1)
       (message "%s %s"
	  "(+) Break all long lines;  kondor:" glienicker-brucke)
       (setq glienicker-brucke 0)) ))

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-keytrigger")

;;; * gungadin-keytrigger

;; @rec
;; Function: gungadin-keytrigger
;; Brief: Sets hotkey shortcuts for rapid launching of commands.
;; @end rec

(defun gungadin-keytrigger ()
  "Bypasses the need to call commands by name"

  ;; Cycles buffer read-only
  ;; (global-set-key (kbd "H-f b") #'read-only-ddd)
  ;; (global-set-key (kbd "H-f r") #'read-only-ddd)

  ;; Rapid file saving for dvorak key layout
  (global-set-key (kbd "M-s") (kbd "C-x C-s"))

  ;; automatically break long lines
  (setq-default auto-fill-function 'nil)  ; auto-fill initially disabled
  (global-set-key (kbd "H-b") #'gungadin-break-line-sweep)

  ;; Complete group marks
  (setq skeleton-pair t)
  (global-set-key (kbd "`")  'skeleton-pair-insert-maybe)
  (global-set-key (kbd "'")  'skeleton-pair-insert-maybe)
  (global-set-key (kbd "\"") 'skeleton-pair-insert-maybe)
  (global-set-key (kbd "<")  'skeleton-pair-insert-maybe)
  (global-set-key (kbd "(")  'skeleton-pair-insert-maybe)
  (global-set-key (kbd "[")  'skeleton-pair-insert-maybe)
  (global-set-key (kbd "{")  'skeleton-pair-insert-maybe)

  ;; names and runs a terminal sub-shell to an emacs buffer
  (global-set-key (kbd "C-`") 'shell)           ; `M-x shell'
  (add-hook 'shell-mode-hook 'rename-uniquely)  ; `M-x rename-buffer'

  ;; change major mode of working buffer
  (global-set-key (kbd "H-1") #'gungadin-major-mode-sweep) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-save-context")

;;; * gungadin-save-context

;;                                _           _
;;  ___ __ ___ _____   __ ___ _ _| |_ _____ _| |_
;; (_-</ _` \ V / -_) / _/ _ \ ' \  _/ -_) \ /  _|
;; /__/\__,_|\_/\___| \__\___/_||_\__\___/_\_\\__|

;; @rec
;; Function: gungadin-save-context
;; Brief: Preserves positional information during emacs operation
;; @end rec

(defun gungadin-save-context ()
  "Sets the Emacs Face."

  ;; Disable auto-saving of every file-visiting buffer
  (setq auto-save-default nil)

  ;; Keep cursor point at window position during scroll
  (setq scroll-preserve-screen-position t)

  ;; Save cursor position before exiting files
  (save-place-mode 1)
  (setq save-place-forget-unreadable-files nil) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-locate-archives")

;;; * gungadin-locate-archives

;;       _                      _    _
;;  _ __| |____ _   __ _ _ _ __| |_ (_)_ _____ ___
;; | '_ \ / / _` | / _` | '_/ _| ' \| \ V / -_|_-<
;; | .__/_\_\__, | \__,_|_| \__|_||_|_|\_/\___/__/
;; |_|      |___/

;; @rec
;; Defun: recognise-package-archives
;; Brief: Establishes emacs package archives `Elpa' and `Melpa'.
;; @end rec

(defun gungadin-locate-archives ()
   "Installs package archives."

   (require 'package)
   (add-to-list
      'package-archives '("org"   . "https://orgmode.org/elpa/"))
   (add-to-list
      'package-archives '("melpa" . "https://melpa.org/packages/"))

   ;; (package-initialize)
   )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* gungadin-marshall")

(defun gungadin-marshall ()
   "Launches marshall tools."
   (add-to-list 'load-path "~/Admir/bin/gungadin-1.0/emacs/marshall")
   (require 'marshall)
   (launch-marshall) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* Launch the Gungadin Emacs Tools")

(defun gungadin-launch ()
  "Launches the gungadin emacs tools"

  ;; Elemental tools provided by gungadin
  (gungadin-startup)
  (gungadin-keytrigger)
  (gungadin-save-context)
  (gungadin-locate-archives)

  ;; Launches the marshall extensions
  (gungadin-marshall) )

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; (custom-set-variables)   ; Init file should contain only one instance

(provide 'gungadin)

;;; code ends here

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (multic "
* Marginalia")

;;                      _           _ _
;;  _ __  __ _ _ _ __ _(_)_ _  __ _| (_)__ _
;; | '  \/ _` | '_/ _` | | ' \/ _` | | / _` |
;; |_|_|_\__,_|_| \__, |_|_||_\__,_|_|_\__,_|
;;                |___/

  (multic "
** Installing  packages from Elpa and Melpa")

;; Emacs is designed to install packages from Elpa.

;; Installing packages using Elpa and Melpa
;;   1. Type `M-x list-packages'.
;;   2. Select package by moving cursor, then hit <ret> key.
;;   3. Go to package window, then hit install button, followed by the
;;      <ret> key.

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; gungadin.el ends here

[-- Attachment #3: screenshot-1.png --]
[-- Type: image/png, Size: 123181 bytes --]

[-- Attachment #4: screenshot-2.png --]
[-- Type: image/png, Size: 126604 bytes --]

[-- Attachment #5: screenshot-3.png --]
[-- Type: image/png, Size: 125833 bytes --]

[-- Attachment #6: screenshot-4.png --]
[-- Type: image/png, Size: 128967 bytes --]

[-- Attachment #7: screenshot-5.png --]
[-- Type: image/png, Size: 122426 bytes --]

[-- Attachment #8: screenshot-6.png --]
[-- Type: image/png, Size: 125769 bytes --]

bug#48724: Code collapsing and outline headings for elisp

[Juri Linkov]

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

> Have been discussing all this together with Protesilaos Stavrou.  Could you have a read
> to see if we actually got to something?

Thank you for sending this mail.

>> I suggest we bring this issue upstream.  Ask them whether the
>> defvar,defun etc. can retain their styles and only for explicit headings
>> to be fontified.

Like in bug#48777, the solution is to use

(setq outline-minor-mode-highlight 'append)

But what is important, to make outline headings readable
while retaining major-mode fontification is what I did
in the init file, and what I highly recommend to you is
to customize outline faces, and to turn their foreground
colors into background colors, so it looks nicely like this:


[-- Attachment #2: screenshot-7.png --]
[-- Type: image/png, Size: 50192 bytes --]