#+setupfile:    ~/.MyCfg/emacs/templates/default/ToPrint.setup

#+title:        \laquo\alpha & \omega\raquo della configurazione di emacs Vrs 1.0\copy\reg
#+description:  File in formato org con la configurazione di emacs
#+author:       Mrk
#+email:        mirko.aletto@csico.it
#+language:     IT
#+options:      ':t toc:nil num:t author:t email:t
#+macro:        latest-export-date (eval (format-time-string "%F %T %z"))
#+macro:        word-count (eval (count-words (point-min) (point-max)))
#+property:     header-args :results none
#+startup:      content indent

#+TAGS: @Disable @Obsolete @ToReview @Usato @Done @Missing

[ Ultima revisione ed esportazione il *{{{latest-export-date}}}* con un
conteggio di parole *{{{word-count}}}*. ]


#+BEGIN_COMMENT
- coding: utf-8
- Utilizzato un fill-colum a 80 caratteri
#+END_COMMENT

#+TOC: headlines 3
#+html: <div style="page-break-before: always;"></div>
#+odt: <text:p text:style-name="PageBreak"/>
#+latex: \newpage
#+latex: \clearpage


* \to Esigenze:                                                   :@ToReview:
:PROPERTIES:
:ID:       a27e1c98-29d0-4f72-b0b6-2a5b6548ce79
:END:

Funzionalità che voglio ottenere in emacs. Per ora la lista è verbosa, ma voglio
rivederla e sfoltirla in base all'esperienza d'uso con la prima versione.

Punti da analizzare:
- org: vedere come gestire le immagini, soprattutto che siano visibili
  sull'esportazione.
- Emacs: gestione delle immagini o altri file di riferimento tramite la cartella
  =~/Pub/.Res/=
- Emacs: navigazione fra i buffer
- Emacs: come fare trova/sostituisci (almeno al livello di notepad++)
- Emacs: come gestire macro (almeno al livello di notepad++)
- Emacs: come gestire l'editazione multi cursore. (almeno al livello di notepad++)
- Emacs: come avere il correttore ortografico
- org: gestire aggenda settimanale
- org: gestire la cattura di eventi (note, link dal web, appunti estemporanei, ecc..)
- org: gestire creazione degli ID univoci delle intestazioni, sia
  quelli standard (=ID=), sia quelli testuali (=CUSTOM_ID=). Nel farlo
  rivedere il comando =M-x org-id-get-create= che l'[[https://writequit.org/articles/emacs-org-mode-generate-ids.html][articolo]].
- org: gestire la pubblicazione dei miei file, sia come knoweldge base, sia come
  esportazione di un singolo file da inviare ad un collega (per esempio una
  stima per un'offerta).
  - https://opensource.com/article/20/3/blog-emacs articolo di un blog che parla
    della pbblicazione
- 
- mettere comandi semplici per esportare tutto su html
- mettere a punto esportazione su pdf
- mettere a punto espansione dei testi abbreviati soprattutto per:
  - i blocchi codice
  - form di introduzione di dati ripetitivi tipo un resum di un lavoro.
- mettere comandi veloci per:
  - evidenziare un capitolo nascondendo gli altri e viceversa.
  - far partire timer e fermarli
  - registrare ed eseguire delle macro
    Per le macro vi sono questi reference:
    - [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Keyboard-Macros.html#Keyboard-Macros][Manual]]
    - [[https://www.emacswiki.org/emacs/KeyboardMacros][Wiki]]
    - Using emacs series [[https://cestlaz.github.io/posts/using-emacs-15-macros/][video 15]]
- sfruttare nuova struttura:
  - file unico (Inbox) con i lavori attuali e indici a file di riferimento per
    ciascun cliente.
  - file di reference dei vari clienti magari vedendo se può essere uno solo e
    sfruttare aggenda per estrarre i dati tramite tag o altro
  - file con le nozioni e i CFG dell'ufficio e della casa
  - file con i riferimenti money report per capire come investo e quanto ho nei
    vari investimenti
- sistemare con le nuove caratteristiche i capture in modo che fuzionino bene per:
  - link utili da rivedere o per bibbliografia
  - telefonate
  - ToDo
  - Note
  - appuntamenti
  - Idee future
- sistemare i tag per:
  - classificare i vari reference per il TGD
  - classificare le cose per future ricerche
- Pensare come legarsi con keep per sincronizarsi con cellulare
- Esempi di emacs:
  - come configurare emacs: https://github.com/abrochard/emacs-config (dal video
    https://meet.jit.si/FAR_HJ9Bzjs0tmF0DlA9qHIE)
  - Tutorial molto bello in vari video: https://cestlaz.github.io/stories/emacs/
- Indagare sui bookmark di emacs per capire come sfruttarli (vedi [[https://www.youtube.com/watch?v=ajiEBK2swKo][Lukewh video
  12]]) [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Bookmarks.html][emacs manual]]
- Informarsi su 'Company mode' package che crea una specie di intellisense per
  suggerire come completare le parole in base a quanto editato prima (come in
  notepad++). Per riferimenti: [[https://www.youtube.com/watch?v=q-9Z2eR7cTE][Lukewh video 16]] o [[http://company-mode.github.io/][Company mode on GitHub]]
- vedere per la correzione ortografica (Flycheck, flymake o altro)
  - [[https://www.flycheck.org/en/latest/][flycheck]] anche da [[https://www.youtube.com/watch?v=EGR9CwM1ksQ][Lukewh video 17]]
- ORG PUBBLISH: Sul sito [[https://opensource.com/article/20/3/blog-emacs][blog-emacs]] c'è un tutorial sulla pubblicazione tramite
  org che è molto bello, inoltre mostra anche come cambiare il file autogenerato
  mapindex in un generico index.html con css e tutto per renderlo più bello.
- Impostare l'utilizzo di org anche dal cellulare. Per farlo vedere come
  utilizzare orgmobile o [[https://f-droid.org/en/packages/com.orgzly/][orgzly]] o l'interfaccia web ecc.... Un esempio molto
  interessante che utilizza anche GIT per mettere sul clud i file è quello in
  dal portale opensource.com: [[https://opensource.com/article/19/4/calendar-git][Manage your daily schedule with Git]]
- rivedere il gestore di calendari in modo testuale [[https://lostpackets.de/khal/index.html][khal]] perchè sempbra molto
  carino.

  
* \checkmark Intro
:PROPERTIES:
:ID:       13b2138b-213d-4ec7-ad57-b55e023688ac
:END:

Questo è il mio file di configurazione di Emacs in forma letterale. È una
combinazione di prosa e codice.

Quello che stai leggendo ora è il file =prot-emacs.org=. Che è il documento che
genera (e quindi controlla) tutti gli altri file che sono alla base della mia
configurazione di Emacs. Questo file Org non viene caricato direttamente. Il suo
unico scopo è quello di produrre i file =*.el= che sono la configurazione
effettiva di emacs.

Questo non è una configurazione standard di Emacs. Nella maggior parte dei casi,
si ha un file generico =.emacs= o un =init.el= con una chiamata alla funzione
~org-babel-load-file~ che riceve come valore il documento Org che descrive la
configurazione (questo =my-emacs-config.org=).

Questo documento Org, invece, funge da

Questo metodo funziona, ma è molto lento, perché dobbiamo caricare Org prima di
avviare Emacs (e Org carica anche un sacco di altre cose di cui non abbiamo
bisogno in una fase così iniziale).
- punto di accesso unico alla mia configurazione di Emacs
- origine dei file =*.el= delle mie configurazioni

Anche se definisco tutto in un singolo file Org, in realtà non avvio Emacs
leggendo questo file. Piuttosto, sto istruendo Org a inserire i blocchi di
codice qui definiti in file separati, organizzati per ambito. Il risultato
finale è qualcosa per cui non si può capire se è stato eseguito un programma
letterale o meno.

Questa è la bellezza di tutto ciò. Posso continuare a modificare un singolo file
come "fonte di verità", pur potendo gestire ogni file singolarmente (ad esempio,
se qualcuno vuole vedere come eseguo una determinata operazione, condivido solo
quel file come allegato e-mail, senza bisogno di inviare l'intero documento).

Quando voglio modificare la mia configurazione di Emacs, modifico questo file e
poi valuto il blocco con il comando =M-x org-babel-tangle= (=C-c C-v C-t=), che
rigenera tutti i file di configurazione.

I punti/funzionalità non ancora chiariti o che voglio rivedere, cerco di
riassumerli all'inizio del file, in modo che appena ho tempo da dedicarci, posso
prendere un argomenti di essi ed esplicitarlo.

Definiamo questi file =*.el= di configurazione:
- =early-init.el= :: Il file caricato prima di lanciare emacs, include
  ottimizzazioni per l'avvio di Emacs e imposta alcune funzionalità di base,
  come ad esempio evitare il lampeggio della luce all'avvio di Emacs in un
  ambiente scuro.
- =init.el= :: Il file standard di configurazione, caricato dopo il lancio di
  emacs; contiene i blocchi fondamentali del mio sistema, ovvero le macro Lisp
  che definisco, e carica i singoli moduli di configurazione.
- =init_fnc.el= :: Il file in cui riporto le mie funzioni elisp personali che
  poi posso utilizzare ovunque in emacs.
- =init_{modulo}.el= :: Eventuali file che esplicitano la configurazione di un
  particolare modulo. In questo modo posso fare una configurazione modulare, in
  cui specifico i dettagli di un argomento su moduli dedicati. Questi file
  saranno richiamati dal =init.el= in modo opportuno.

** Elenco dei tag e delle parole chiave:
:PROPERTIES:
:ID:       90b6e478-424c-4663-aedf-3d4fdc93473c
:END:

Nel testo, utilizzerò le =label= (tag o semplici etichette) seguenti:
- @Disable :: per impostazioni che attualmente sono disattivate o commentate
- @Obsolete :: per impostazioni eliminate perchè sostituite da altre
- @ToReview :: per impostazioni che devo rivedere, aggiornare, correggere o
  ampliare.
- @Usato :: per indicare una risorsa utilizzata per la configurazione.
- @Done :: per indicare un punto chiuso e che non prevedo più di rivedere (a
  meno di bug o malfunzionamenti nelle nuove versioni di emacs).
- @Missing :: per indicare una parte solo accennata, ma ancora da fare (il prima
  possibile).

Inoltre sfruttando i [[https://orgmode.org/worg/org-symbols.html][simboli]] grafici gestiti da org, utilizzo questi caratteri
all'inizio delle headline per enfatizarle. Questo è comodo perchè poi si
ritroveranno anche sulla TOC.
- \checkmark :: per indicare le headline che sono a posto e non prevedo di ritoccare fino alla prossima versione
- \Xi :: per indicare le headline che devo ancora rivedere o terminare
- \to :: per le headline che necessitano di revisione urgente
  
** Applicativo emacs:
:PROPERTIES:
:ID:       f6fd8942-dfff-41bb-94eb-041e74a78cfb
:END:

Come emacs, utilizzo direttamente quello scaricabile dal progetto [[https://www.gnu.org/software/emacs/][GNU Emacs]]
(Emacs 30.2 al [2026-05-25 lun]) disarchiviando lo zip, sulla cartella:
: C:/MyTools/emacs
e lo eseguo lanciando il file
: C:/MyTools/emacs/bin/runemacs.exe

** Path Home:
:PROPERTIES:
:ID:       743a6355-921b-4abe-8392-65ce90de1d9d
:END:

Per inserire =C:\_Home\= come path predefinito, non serve definirlo sulla
variabile di sistema PATH, ma basta definire una variabile utente =home=:
- in windows aprire il form delle variabili utente: 'Edit enviroment variables
  for account'
- inserire una nuova variabile con i seguenti valori:
  - Variable name:  home
  - Variable value: C:\_Home

In emacs, il PATH viene gestito dalla variabile interna =exec-path= e quindi
basterebbe inserire il path =C:\_Home\= in questa variabile, però è più comodo
definire la variabile di sistema (per esempio è utilizzata anche da git ed in
genere da tutti i tool unix-like).

In ogni momento, per visualizzare il contenuto della variabile =exec-path=,
basta andare nel buffer =scratch=, scrivere il nome della variabile su una nuova
riga e dare il comando =C-c j= per valutare il codice della riga.

** Eseguibile find.exe
:PROPERTIES:
:ID:       38abb527-08e3-43d2-83fa-e2165d98b0fc
:END:

Il pacchetto =consult= ed in genere altri pacchetti, utilizzano il programma
find.exe di unix per ricercare file o altro sul sitema; in windows però questo
programma è diverso e siccome non voglio installare il pacchetto di utiliti per
evitare problemi con altri programmi, indico a emacs quale find utilizzare.

Per verifica, se utilizzo il comando

#+begin_src emacs-lisp :tangle no :results none
  (executable-find "find")
#+end_src

ritorna il valore

#+begin_src emacs-lisp :tangle no :results none
  "c:/WINDOWS/system32/find.exe"
#+end_src

confermando che emacs sta utilizzando il find.exe di windows.

Come find di unix, voglio utilizzare quello dato già assieme a git. Serve quindi
impostare il path corretto, da internet ho trovato il comando

#+begin_src emacs-lisp :tangle no :results none
  (setq find-program "C:/Program Files/Git/usr/bin/find.exe")
#+end_src

ma sembra non funzionare, emacs continua a puntare al find di windows. Procedo
quindi a inserire il path del find di unix sul PATH complessivo che utilizza
emacs. In questo modo non altero il PATH di windows e quindi sono più sicuro.

#+begin_src emacs-lisp :tangle no :results none
  ;; imposto la directory del find unix:
  (setq find-program-path "C:/Program Files/Git/usr/bin")
  ;; la inserisco nel PATH di emacs:
  (push find-program-path exec-path)
  ;; impostiamo la cartella di default:
  (setq default-directory "~/Doc/Org/")
#+end_src


* \checkmark Reference:                                                      :@ToReview:
:PROPERTIES:
:ID:       c0fb602d-e4ef-4892-97c3-c60f32a93638
:END:

- [[https://www.gnu.org/software/emacs/][Editor emacs]] :: Sito web da cui scaricare emacs
- [[https://orgmode.org/][org-mode web site]] :: Sito originale del pacchetto org-mode, con i manuali
  ufficiali ([[https://orgmode.org/orgguide.pdf][orgguide.pdf]] e [[https://orgmode.org/org.pdf][org.pdf]]) e la sezione =worg= per tutorial e molte
  info utili.
- [[https://doc.norang.ca/org-mode.html][Org Mode - Organize Your Life In Plain Text!]] :: Sito che ha dato il via a
  tutto. Datato ma sempre ottimo.
- [[https://github.com/james-stoup/emacs-org-mode-tutorial][emacs org-mode tutorial]] :: bel tutorial/introduzione alla configurazione di
  org-mode. Buoni spunti su come strutturare i TODO, l'aggenda e
  l'esportazione. Da rivedere assolutamente durant elo sviluppo della
  configurazione specifica di org-mode.
- [[https://github.com/howardabrams/dot-files/blob/master/emacs.org#Journaling][Journal dot-files]] configurazione molto particolareggiata sia di org, sia di
  come usarlo nel journal, sia di altri pacchetti (PlantUML and Graphviz). Vi
  sono arrivato dall'articolo [[https://www.howardism.org/Technical/Emacs/journaling-org.html][journaling-org.html]].
- [[https://bzg.fr/en/notes/the-zen-of-task-management-with-org/][The Zen of Task Management with Org]] :: configurazione minimale di org per la
  funzionalità di task manager di progetti. Anche questa da rivedere in ottica
  della configurazione specifica di org-mode.
- [[https://adamkovic.org/emacs.html][Rudolf Adamkovič Blog]] :: Blog dell'autore di [[https://bzg.fr/en/notes/the-zen-of-task-management-with-org/][The Zen of Task Management with
  Org]] che ha molti articoli interessanti.
- [[https://protesilaos.com/codelog/][protesilaos.com]] :: Blog di uno sviluppatore di pacchetti emacs, che risulta
  molto utile. Ha dato lo slancio per la revisione attuale della
  configurazione. La sua configurazione completa è disponibile in: [[https://github.com/protesilaos/dotfiles][GitHub Repo]] o
  [[https://gitlab.com/protesilaos/dotfiles][GitLab Repo]]. Alcuni articoli del blog che ritengo particolarmente
  interessanti:
  - [[https://protesilaos.com/codelog/2024-11-28-basic-emacs-configuration/][Emacs: a basic and capable configuration]] per una confugurazione base,ma già
    molto utile per migliorare la UI.  =@Usato=
  - [[https://protesilaos.com/emacs/dotemacs][Emacs: GNU Emacs configuration]] per la sua configurazione completa
    disponibile nei repository indicati sopra. Vi è anche il relativo [[https://www.youtube.com/watch?v=ycyxytk1NAQ][video]].
    =@Usato=
  - [[https://protesilaos.com/codelog/2026-04-30-emacs-decent-default-sacha-chua/][Emacs: decent defaults I shared with Sacha Chua]] configurazione minima
    definita in live nel [[https://www.youtube.com/watch?v=z7pcLdwuyxE][video]].  =@Usato=
  - [[https://protesilaos.com/codelog/2025-01-26-emacs-organise-init/][Emacs: organise your init file]] in cui descrive il metodo attualmente usato
    per fare questo file org. Vi è anche il relativo [[https://www.youtube.com/watch?v=Dkoy3NrLN9g][Video]].  =@Usato=
  - [[https://protesilaos.com/codelog/2024-02-17-emacs-modern-minibuffer-packages/][Emacs: modern minibuffer packages (Vertico, Consult, etc.)]] in cui descrive
    come migliorare la UI del minibuffer. Vi è anche il relativo [[https://www.youtube.com/watch?v=d3aaxOqwHhI][video]].
    =@Usato=
  - [[https://protesilaos.com/codelog/2024-02-08-emacs-window-rules-display-buffer-alist/][Emacs: control where buffers are displayed (the 'display-buffer-alist')]] in
    cui descrive come gestire la visualizzazione dei buffer e la relativa
    navigazione. Vi è anche il relativo [[https://www.youtube.com/watch?v=1-UIzYPn38s][video]]. =@ToReview=
  - [[https://protesilaos.com/codelog/2024-07-23-emacs-use-package-essentials/][Emacs: use-package essentials]] in cui descrive come utilizzare i package di
    emacs per nuove funzionalità, soprattutto dal punto di vista della
    configuraione. Vi è anche il relativo [[https://www.youtube.com/watch?v=RaqtzemHFDU][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2023-06-10-emacs-search-replace-basics/][Emacs: basics of search and replace]] in cui descrive le basi del
    trova/sostituisci con emacs. Vi è anche il relativo [[https://www.youtube.com/watch?v=f2mQXNnChwc][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2023-11-17-emacs-ediff-basics/][Emacs: ediff basics]] in cui descrive come fare un diff (stile winmerge) di
    due file su emacs. Vi è anche il relativo [[https://www.youtube.com/watch?v=pSvsAutseO0][video]]. =@ToReview=
  - [[https://protesilaos.com/codelog/2025-01-16-emacs-org-todo-agenda-basics/][Emacs: Org todo and agenda basics]] in cui descrive le basi dell'aggenda e
    come filtrare gli eventi. Vi è anche il relativo [[https://www.youtube.com/watch?v=L0EJeN1fCYw][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2024-12-15-emacs-org-coaching-clock/][Emacs: custom Org clock report for my coaching]] in cui descrive come utilizza
    i timer e i relativi report per misurare il tempo di lavoro. Vi è anche il
    relativo [[https://www.youtube.com/watch?v=FMutOCOoFSQ][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2024-09-19-emacs-command-popup-frame-emacsclient/][Emacs: commands in popup frames with 'emacsclient']] in cui descrive come
    visualizzare dei comandi iterattivi in finestre popup. Vi è anche il
    relativo [[https://www.youtube.com/watch?v=vbWxT8tht9A][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2024-02-03-emacs-abbrev-mode/][Emacs: abbreviations with abbrev-mode (quick text expansion)]] in cui descrive
    come sfruttare le abbreviazioni per inserire velocemente testo. Vi è anche
    il relativo [[https://www.youtube.com/watch?v=ruPpRlh2re4][video]]. =@ToReview=
  - [[https://protesilaos.com/codelog/2019-07-22-emacs-dired-basics/][Emacs: Basics of the powerful Emacs file manager (Dired) 1]] in cui descrive
    il pacchetto dired e come usarlo. Vi è anche il relativo [[https://www.youtube.com/watch?v=5dlydii7tAU][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2019-07-23-emacs-dired-pt2/][Emacs: Basics of the powerful Emacs file manager (Dired) 2]] in cui descrive
    il pacchetto dired e come usarlo. Vi è anche il relativo [[https://www.youtube.com/watch?v=2lF3z7H8oaI][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2019-07-29-emacs-kbd-macros/][Emacs: Introduction to keyboard macros in Emacs]] in cui descrive le macro in
    emacs. Vi è anche il relativo [[https://www.youtube.com/watch?v=-5yH_8nl9LU][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2019-08-01-emacs-macros-golf/][Emacs: Practical macros in Emacs]] in cui descrive l'uso pratico delle macro
    in emacs. Vi è anche il relativo [[https://www.youtube.com/watch?v=oLY-X5BMjc8][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2019-08-15-emacs-isearch-tweaks/][Emacs: ISEARCH features and tweaks]] in cui descrive come trova/sostituisci
    usando isearch. Vi è anche il relativo [[https://www.youtube.com/watch?v=y6_bmcd3nis][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2023-05-23-emacs-org-basics/][Emacs: basics of Org mode]] in cui descrive le basi di org-mode e relativa
    aggenda. Vi è anche il relativo [[https://www.youtube.com/watch?v=e9Ucb1JHUfQ][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2023-06-26-emacs-file-dired-basics/][Emacs: file and Dired basics]] in cui descrive il pacchetto =dired=. Vi è
    anche il relativo [[https://www.youtube.com/watch?v=L_4pLN0gXGI][video]].  =@ToReview=
  - [[https://protesilaos.com/codelog/2023-06-28-emacs-mark-register-basics/][Emacs: mark and register basics]] in cui descrive come sfruttare la tastiera
    per editare (selezionare testi, navigare ecc...). Vi è anche il relativo
    [[https://www.youtube.com/watch?v=TJrAkCyH6Dk][video]].  =@ToReview=
- [[https://codeberg.org/ashton314/emacs-bedrock][Emacs Bedrock]] configurazione minima ma bella, creata dal blog da rivedere per
  prendere spunti.  =@ToReview=
- [[https://github.com/SystemCrafters/crafted-emacs][SystemCrafters/crafted-emacs]] configurazione creata nella video serie di system
  crafter.  =@ToReview=
- [[https://sachachua.com/blog/][sachachua blog]] blog pieno di informazioni e di configurazioni.  =@ToReview=
  - [[https://sachachua.com/dotemacs/index.html][Sacha Chua's Emacs configuration]] disponibile sui repository [[https://codeberg.org/sachac/.emacs][codeberg]] o
    [[https://github.com/sachac/.emacs.d/][GitHub]]
  - [[https://www.youtube.com/watch?v=kvBS8wz8ZRw][Yay Emacs 10: Talking to Prot about Emacs workflows]] con relativi [[https://www.youtube.com/watch?v=kvBS8wz8ZRw][video]] e
    [[https://sachachua.com/blog/2026/04/yayemacs-10-emacs-coaching-with-prot-packaging-emacs-lisp/][articolo]]
- Come personalizzare l'esportazione:  =@ToReview=
  - https://www.reddit.com/r/emacs/comments/3pvbag/is_there_a_collection_of_css_styles_for_org/
  - https://www.reddit.com/r/emacs/comments/eozyyv/exporting_orgmode_to_beautiful_websites/
  - https://github.com/jessekelly881/Rethink
  - https://github.com/jessekelly881/Imagine
  - https://github.com/grc/jujutsu-website/tree/master
  - https://github.com/alphapapa/org-html-theme-darksun
  - https://github.com/Zilong-Li/org-tufte
  - https://juanjose.garciaripoll.com/blog/css-style-org-mode/
   
** Old References from previous version to review:
:PROPERTIES:
:ID:       abef4fbb-80ee-4a68-8b82-baebcff068a7
:END:

La configurazione partirà da quanto fatto finora (Configurazione Vrs. 3.3 del
04/10/2018) ripartendo da zero con le considerazioni ricavate dalle varie sorgenti
analizzate:
- [[http://doc.norang.ca/org-mode.html][Org Mode - Organize Your Life In Plain Text!]] :: Bel esempio di come utilizzare in
     particolar modo org-mode nella produttività.
- [[https://cestlaz.github.io/stories/emacs/][Using Emacs Series]] :: serie di video su emacs di Mike Zamansky che hanno anche il
     relativo [[https://github.com/zamansky/using-emacs][GitHub repo]]
- [[https://www.youtube.com/watch?v=9pkuBijrMD4&list=PLNJWazvift25KnHDwYlhwrrgr60wtpQOB][Lukewh]] :: Playlist di video su emacs. Ne parla anche su [[https://lbry.tv/@lukewh:3][LBRY]]
- [[http://pages.sachachua.com/.emacs.d/Sacha.html][http://pages.sachachua.com/.emacs.d/Sacha.html]]
- [[https://sachachua.com/blog/][Sacha Blog]]
- [[http://ergoemacs.org/emacs/emacs_encoding_decoding_faq.html][Emacs File Encoding FAQ]]
- [[https://egli.dev/posts/using-org-mode-for-meeting-minutes/][Using org-mode for meeting minutes]]
- [[https://www.youtube.com/watch?v=2-0OwGTt0dI][Emacs: introduction to MAGIT]]
- Blog molto carino: [[https://irreal.org/blog/][irreal]]
- [[https://katherine.cox-buday.com/blog/2015/03/14/writing-specs-with-org-mode/][Writing Specs with Org-mode]] esempio di come produrre documentazione tecnica
  con org-mode, LaTeX, PlantUML per ottenere pdf. Mostra anche il relativo
  file di configurazione.
- Created a new HTML export back-end that uses Tailwind.css classes
  - Link [[https://www.reddit.com/r/emacs/comments/fw6onf/created_a_new_html_export_backend_that_uses/][articolo]]
  - Link [[https://github.com/vascoferreira25/ox-tailwind][GitHub]]
- Socially isolating my Emacs with Docker! 
 - Link [[https://www.youtube.com/watch?v=D2E1Eh9Hxdg&feature=youtu.be][video]]
- riconfigurare l'esportazione in html:
 - tenere conto delle info dal sito [[https://opensource.com/article/20/3/blog-emacs][blog-emacs]] per personalizzare il file mapindex
 - rivedere l'esportazione partendo tutto in ~/Pub e in esso mantenere anche i reference
   e styli.
   

* \checkmark File di preconfigurazione: *early-init.el*
:PROPERTIES:
:ID:       97dd741c-97aa-4d2f-bd95-707815b781e7
:END:

Questo è il primo file che Emacs legge all'avvio. E' precaricato prima di
eseguire emacs e quindi deve contenere codice che non dipenda da alcun pacchetto
o dalle proporzioni del frame di Emacs. In generale, questo file di
inizializzazione iniziale ha lo scopo di impostare alcune cose di base prima che
Emacs produca il frame iniziale, delegando a =init.el= il resto della
configurazione.

** Le impostazioni di base del frame
:PROPERTIES:
:ID:       4cfcc493-965f-4b4a-88d3-19088e4d7e97
:END:

Queste sono alcune impostazioni generali per i frame e le basi del toolkit. In
breve, voglio mantenere le cose al minimo. Notate ~frame-resize-pixelwise~ e
~frame-inhibit-implied-resize~: per impostazione predefinita Emacs ridimensiona
il frame se si modifica la dimensione del carattere, cosa che non voglio mai
fare.

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
(setq frame-resize-pixelwise t
      frame-inhibit-implied-resize 'force
      frame-title-format '("%b")
      ring-bell-function 'ignore
      use-dialog-box t ; only for mouse events, which I seldom use
      use-file-dialog nil
      use-short-answers t
      inhibit-splash-screen t
      inhibit-startup-screen t
      inhibit-x-resources t
      inhibit-startup-echo-area-message user-login-name ; read the docstring
      inhibit-startup-buffer-menu t)
#+end_src

** Impostiamo i parametri del frame per desktop 
:PROPERTIES:
:ID:       25163662-be4f-4ee1-96df-9fe7473c25e7
:END:

Qui imposto i parametri per le dimensioni della finestra di Emacs: la prima e
tutte quelle successive. In un window manager a riquadri, i parametri di
larghezza e altezza non sono importanti, poiché tutte le finestre vengono
forzatamente adattate a rettangoli (riquadri). Gli altri parametri, invece, sono
rilevanti. In un window manager a sovrapposizione, tutte le impostazioni sono
importanti.

Il parametro ~initial-frame-alist~ si riferisce alla prima finestra che viene
generata all'avvio di Emacs. Per questo motivo deve essere definito nel file
=early-init.el=: il codice qui presente viene eseguito prima che venga disegnata
la prima finestra.

Il parametro ~default-frame-alist~ si riferisce a tutte le finestre
successive. In linea di principio, potremmo definirlo al di fuori del file
=early-init.el=, ma è più logico averlo qui.

Qui si imposta se utilizzare la barra dei menu, la barra delle icone e le
scrollbar:

Ho scelto di provare ad usare Emacs senza barra degli strumenti e barre di
scorrimento. Occupano spazio prezioso sullo schermo e, inoltre, mi distraggono.

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  ;; Imposto barre e menu:
  ;; - menu bar (1=enable, -1=disable)
  (menu-bar-mode 1)
  ;; - tool bar (1=enable, -1=disable)
  (tool-bar-mode -1)
  ;; - scroll bar (1=enable, -1=disable)
  (scroll-bar-mode -1)
  ;; - Don't show startup message
  (setq inhibit-startup-message t)
  ;; - Stop al blinking del cursore
  (blink-cursor-mode -1)     ;; (setq blink-cursor-delay 2  blink-cursor-interval 0.5)
  ;; - Higlight line (1=enable, -1=disable)
  (global-hl-line-mode 1)

  ;; se non ho la riga seguente, perdo la barra di trasinamento della finestra dell'editor e non posso più muoverla in windows.
  (add-hook 'window-size-change-functions #'frame-hide-title-bar-when-maximized) 

  ;; Inizializzazione del frame
  (setq initial-frame-alist `((horizontal-scroll-bars . nil)
                              (menu-bar-lines . 1)
                              (tool-bar-lines . 0)
                              (vertical-scroll-bars . nil)
                              (scroll-bar-width . 12)
                              (width . (text-pixels . 800))
                              (height . (text-pixels . 900))
  			    (undecorated . nil)
  			   ))
  ;; Ripeti l'operazione dopo l'inizializzazione in modo che eventuali
  ;; modifiche intermedie non vengano mantenute. Nota che non possiamo fare
  ;; affidamento sull'impostazione di questo valore su
  ;; `initial-frame-alist' poiché potrebbe cambiare nel
  ;; frattempo. Impostiamo esplicitamente il valore per essere certi del
  ;; risultato. Ciò non impedisce ad altri programmi di modificare
  ;; l'elenco, anche se lo considererei indesiderabile se modificassero
  ;; queste impostazioni specifiche.
  (add-hook 'after-init-hook (lambda ()
                               (setq default-frame-alist `((horizontal-scroll-bars . nil)
                                                           (menu-bar-lines . 1)
                                                           (tool-bar-lines . 0)
                                                           (vertical-scroll-bars . nil)
                                                           (scroll-bar-width . 12)
                                                           (width . (text-pixels . 800))
                                                           (height . (text-pixels . 900))
  							 (undecorated . nil)
  							  ))))    														
  ;; Funzione generale per disattivare la barra di scorrimento di una finestra
  (defun mrk-emacs-no-minibuffer-scroll-bar (frame)
    "Remove the minibuffer scroll bars from FRAME."
    (when scroll-bar-mode
      (set-window-scroll-bars (minibuffer-window frame) nil nil nil nil :persistent)))
  ;; Disattivo la barra di scorrimento sul minibuffer usando la funzione precedente:
  (add-hook 'after-make-frame-functions #'mrk-emacs-no-minibuffer-scroll-bar)
#+end_src

** Dimensioni font
:PROPERTIES:
:ID:       da153ad9-fb4c-4e26-a1c6-04ab3de8153b
:END:

Per ridimensionare il testo, c'è il comando:
: C-x C-0 
Dopo il quale si hanno i seguenti comandi:
: +  incrementa il size
: -  decrementa il size
: 0  ritorna al default
I comandi si possono ripetere a piacere fino a quando si è raggiunta
la dimensione desiderata e poi chiude con
: ESC

Imposto la dimensione di default del testo per facilitare la lettura:
#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
 ;; Imposto la dimensione del testo: (punti*10)
 (set-face-attribute 'default nil :height 110)
#+end_src

** Impostazioni del garbage-collection per velocizzare avvio:
:PROPERTIES:
:ID:       db056b6b-1592-467b-91b9-091979e204df
:END:

Non ho una conoscenza approfondita del =garbage collection=, ma ho imparato per
tentativi ed errori che posso massimizzare la soglia all'avvio per velocizzare
un po' l'avvio di Emacs. Quello che sto facendo è impostare i valori rilevanti
su valori molto alti all'avvio e poi riportarli a valori più gestibili una volta
che Emacs ha terminato il caricamento.

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  ;; Temporarily increase the garbage collection threshold.  These
  ;; changes help shave off about half a second of startup time.  The
  ;; `most-positive-fixnum' is DANGEROUS AS A PERMANENT VALUE.  See the
  ;; `emacs-startup-hook' a few lines below for what I actually use.
  (setq gc-cons-threshold most-positive-fixnum
        gc-cons-percentage 0.5)

  ;; Same idea as above for the `file-name-handler-alist' and the
  ;; `vc-handled-backends' with regard to startup speed optimisation.
  ;; Here I am storing the default value with the intent of restoring it
  ;; via the `emacs-startup-hook'.
  (defvar mrk-emacs--file-name-handler-alist file-name-handler-alist)
  (defvar mrk-emacs--vc-handled-backends vc-handled-backends)

  (setq file-name-handler-alist nil
        vc-handled-backends nil)

  (add-hook 'emacs-startup-hook
            (lambda ()
              (setq gc-cons-threshold (* 100 100 8)
                    gc-cons-percentage 0.1
                    file-name-handler-alist mrk-emacs--file-name-handler-alist
                    vc-handled-backends mrk-emacs--vc-handled-backends)))
#+end_src

** Impostazioni della cache dei pacchetti
:PROPERTIES:
:ID:       1ee6dbe6-4d0b-4e1d-8e09-7af33dc5a5b8
:END:

Utilizzo lo standard =package.el= per gestire i miei pacchetti Emacs.

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  ;; Initialise installed packages at this early stage, by using the
  ;; available cache.  I had tried a setup with this set to nil in the
  ;; early-init.el, but (i) it ended up being slower and (ii) various
  ;; package commands, like `describe-package', did not have an index of
  ;; packages to work with, requiring a `package-refresh-contents'.
  (setq package-enable-at-startup t)
#+end_src

** Imposto la directory per il codice lisp custom:
:PROPERTIES:
:ID:       3143f3f7-1263-420a-adf4-6c5c3407a2d5
:END:

Gli eventuali codici lisp custom, che voglio utilizzare, li metterò manualmente
nella cartella =~/.emacs.d/MyAddOn/= e devo fare in modo che emacs li carichi
automaticamente ad ogni avvio.

Questa =user-lisp-directory= è un'opzione utente introdotta in
Emacs 31. Permette a Emacs di compilare in bytecode i file Emacs Lisp al suo
interno e di analizzarli alla ricerca di autoload.

Per ora sono ancora in emacs 30 però la tengo per il futuro.

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  (setq user-lisp-directory (locate-user-emacs-file "~/.emacs.d/MyAddOn/"))
#+end_src

per ora i file custom li carico qui: [[id:89b37a37-0f9b-42f6-9afa-bbe3648a04df][lisp custom on init.el]]

** Assegna un nome al frame predefinito
:PROPERTIES:
:ID:       3ff325ed-547a-4396-bafe-9b951a489a7a
:END:

Infine, mi piace chiamare il mio frame predefinito =home=. Questo perché
utilizzo il mio pacchetto per raggruppare l'elenco dei buffer per ogni singolo
frame. La disposizione =multi-frame= è la cosa migliore che abbia mai fatto per
aumentare la mia produttività: punti bonus se utilizzata in combinazione con un
window manager a finestre affiancate.

Assegnare un nome alle finestre consente di selezionarle tramite il
completamento automatico. Emacs può farlo (=M-x select-frame-by-name=), anche se
non è sempre affidabile in quanto dipende dal window manager (funziona bene su
GNOME, per quanto ne so).

#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  ;; rinomino il buffer in Home:
  (add-hook 'after-init-hook (lambda () (set-frame-name "home")))
#+end_src


* File di configurazione principale: *init.el*
:PROPERTIES:
:ID:       b463ab54-8b41-4c04-b070-d811b162a1bb
:END:

Qui definisco le macro Lisp utilizzate nella mia configurazione e carico tutti i
singoli moduli.

Questa parte, descrive cosa inserire nel file iniziale che viene automaticamente
letto all'avvio di emacs (=~/.emacs.d/init.el=). In esso voglio impostare le
funzioni base che sono "obbligatorie", mentre tutto il resto viene delegato ai
vari moduli.

** Impostazioni per rendere silenziosa la compilazione nativa
:PROPERTIES:
:ID:       5ab3ec8a-1718-42f5-8a78-a338291d3383
:END:

L'opzione di compilazione =--with-native-compilation=yes= di Emacs è molto
utile: abilita la "compilazione nativa" di Emacs Lisp, traducendolo in codice
macchina. Tuttavia, l'impostazione predefinita per la segnalazione degli errori
è impostata su un valore verboso che, nella mia esperienza di coaching, confonde
gli utenti: produce avvisi per problemi di compilazione che solo lo sviluppatore
del pacchetto in questione deve gestire. Questi includono fatti innocui come le
docstring che superano un certo numero di caratteri. A peggiorare ulteriormente
le cose, il buffer che mostra questi avvisi utilizza il carattere di stop,
risultando in un lungo elenco di righe con punti rossi ovunque, come se avessimo
completamente rotto Emacs.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Make native compilation silent.
  (when (native-comp-available-p)
    (setq native-comp-async-report-warnings-errors 'silent))  
#+end_src

** Salvare in automatico tutti i buffer ogni ora:
:PROPERTIES:
:ID:       20260531T144156.765250
:END:

Siccome ho lo script che fa il commit ogni ora dei documenti, il minuto
precedente, lancio il comando di salvataggio di tutti i buffer in emacs, così
posso committarli e mantenere il backup di tutto usando gitea.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Dalle 00:00 e ripetuto ogni ora:
  (run-at-time "00:00" 3600 'org-save-all-org-buffers)
#+end_src

** Impostazione per mandare ~custom-file~ nell'oblio:
:PROPERTIES:
:ID:       8f4ba6e8-b50c-49c3-aa88-5451986e0fdc
:END:

Per impostazione predefinita, Emacs scrive le personalizzazioni persistenti alla
fine del file di inizializzazione dell'utente. Questi elementi sono incapsulati
in un blocco "personalizzato". Emacs li scrive ogni volta che l'utente esegue
un'azione con =M-x customize= o comandi simili.

Personalmente, preferisco scrivere direttamente il codice Elisp piuttosto che
utilizzare l'interfaccia di =M-x customize=. Voglio anche che il mio file di
inizializzazione contenga solo ciò che ho scritto io e che non esegua mai, in
nessun caso, codice che non ho chiamato personalmente.

Pertanto, voglio impostare la variabile ~custom-file~ per indicare a Emacs di
scrivere le sue variabili persistenti in quel file anziché nel mio =init.el=.
Tuttavia, poiché non ho intenzione di utilizzare questo file, ho scelto di
renderlo temporaneo posizionandolo nella directory =/tmp= (questo è ciò che fa
la funzione ~make-temp-file~). Quindi, quando chiudo il computer, il file
scompare. Infine, non richiamo la funzione ~load~ perché non farò mai
affidamento sul ~custom-file~. Preferirei avere un'opzione per evitare
completamente l'infrastruttura Custom, ma non è possibile. Quindi eccoci qui...

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; -  ;; Disable the damn thing by making it disposable.
  ;; -  (setq custom-file (make-temp-file "emacs-custom-"))
  ;; Rendo il file persistente:
  (setq custom-file (locate-user-emacs-file "custom.el"))
  (load custom-file :no-error-if-file-is-missing)
#+end_src

** Impostazione per rendere =C-g= un po' più utile
:PROPERTIES:
:ID:       fe0a404d-fa48-4522-b5d2-f8c18802b65c
:END:

Avendo notato che i principianti hanno difficoltà con =C-g= perché non chiude il
minibuffer aperto, so che il seguente miglioramento semplifica l'esperienza
utente:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  (defun mrk/keyboard-quit-dwim ()
    "Do-What-I-Mean behaviour for a general `keyboard-quit'.

  The generic `keyboard-quit' does not do the expected thing when
  the minibuffer is open.  Whereas we want it to close the
  minibuffer, even without explicitly focusing it.

  The DWIM behaviour of this command is as follows:

  - When the region is active, disable it.
  - When a minibuffer is open, but not focused, close the minibuffer.
  - When the Completions buffer is selected, close it.
  - In every other case use the regular `keyboard-quit'."
    (interactive)
    (cond
     ((region-active-p)
      (keyboard-quit))
     ((derived-mode-p 'completion-list-mode)
      (delete-completion-window))
     ((> (minibuffer-depth) 0)
      (abort-recursive-edit))
     (t
      (keyboard-quit))))

  (define-key global-map (kbd "C-g") #'mrk/keyboard-quit-dwim)
#+end_src
** Impostazione per eseguire Emacs come server
:PROPERTIES:
:ID:       8f620d66-1a75-4b52-aa3b-5a86edcbab7c
:END:

Il "server" è funzionalmente simile al demone, tranne per il fatto che viene
eseguito dal primo frame di Emacs che avviamo. Con un server in esecuzione,
possiamo connetterci ad esso tramite una nuova chiamata =emacsclient=. Questo è
utile se vogliamo avviare nuovi frame che condividono risorse con il processo in
esecuzione. Tuttavia, =emacsclient= può essere utilizzato anche semplicemente
per eseguire codice al di fuori di un frame di Emacs (ad esempio per caricare un
nuovo tema, come faccio io con il mio delight.shscript di shell all'interno dei
miei dotfiles).

Quando chiudiamo l'ultimo frame, il server viene terminato. Il demone, invece,
rimane attivo anche se tutti i frame di Emacs vengono chiusi. Per me, il server
è più facile da usare, perché so con certezza quando inizia e finisce il suo
ciclo di vita. Detto questo, ho provato seriamente anche il demone. Emacs si
bloccava ogni volta che incontravo un errore in qualche valutazione Lisp. Il
server, invece, funziona perfettamente.

Nota che ciò avviene solo =server-start= se non è in esecuzione alcun
server. Uno è sufficiente.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Emacs server (allow emacsclient to connect to running session)
  (setq server-client-instructions nil)
  (require 'server)
  (unless (or (server-running-p) (daemonp))
    (server-start))
#+end_src

In questo modo si avrà una singola istanza di emacs e se faccio doppio click su
un file =*.org= questo verrà automaticamente aperto sull'istanza già in
esecuzione di emacs. Se però non vi è un'istanza attiva, si avrà errore, perchè
il server emacs rimane attivo solo fino a che non chiudo tutte le istanze di
emacs (non sto utilizzando il demone, cioè servizio in windows).

Quindi si avvia emacs semplicemente eseguendo l'eseguibile
=C:\MyTools\emacs\bin\runemacs.exe=. Questo fa partir eil server emacs. Con il
doppio click su un file =*.org= faccio partire l'evento che è registrato (al
primo click lo si salva) al comando:
: C:\MyTools\emacs\bin\emacsclientw.exe -c -n "C:\Path\To\Your\File.org"

** Impostazione per formato di default dei file: UTF-8
:PROPERTIES:
:ID:       d61b5760-4393-403d-a169-0d9da94db50a
:END:

Imposto come formato di default dei file: UTF8

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Imposto come formato di default l'UTF8
  (set-language-environment "UTF-8")
  (set-default-coding-systems 'utf-8-unix)
  (set-terminal-coding-system 'utf-8)
  (prefer-coding-system 'utf-8)
  (set-charset-priority 'unicode)
#+end_src

** Impostazione per directory con il codice lisp custom:
:PROPERTIES:
:ID:       89b37a37-0f9b-42f6-9afa-bbe3648a04df
:END:
:BACKLINKS:
[2026-05-31 dom 16:28] <- [[id:20260531T154957.127764][Imposto il pacchetto:  org-super-links]]
:END:

Gli eventuali codici lisp custom, che voglio utilizzare, li metterò manualmente
nella cartella =~/.emacs.d/MyAddOn/= e devo fare in modo che emacs li carichi
automaticamente ad ogni avvio.

Non potendo usare l'opzione specifica impostata nel file [[id:3143f3f7-1263-420a-adf4-6c5c3407a2d5][early-init.el]], lo comando
in modo esplicito:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
 ;; Carico il path dei file lisp che aggiungo:
 (add-to-list 'load-path (expand-file-name "~/.emacs.d/MyAddOn/"))
#+end_src

** Impostazioni grafiche base:                                   :@Obsolete:
:PROPERTIES:
:ID:       dd2b1aa7-07a3-4b36-9134-02ac02b23315
:END:

Le impostazioni grafiche base delle finestre, sono ora gestite direttamente nel
file [[id:4cfcc493-965f-4b4a-88d3-19088e4d7e97][early-init.el]] e quindi i seguenti comandi non sono più utilizzati.

#+begin_src emacs-lisp :tangle no :results none
  ;; Don't show startup message
  (setq inhibit-startup-message t)
  ;; Stop al blinking del cursore
  (blink-cursor-mode -1)     ;; (setq blink-cursor-delay 2  blink-cursor-interval 0.5)
  ;; menu bar (1=enable, -1=disable)
  (menu-bar-mode 1)
  ;; scroll bar (1=enable, -1=disable)         
  (toggle-scroll-bar 1)
  ;; tool bar (1=enable, -1=disable)
  (tool-bar-mode -1)
  ;; Higlight line (1=enable, -1=disable)
  (global-hl-line-mode 1)
#+end_src

** Impostazioni per disabilitare backup e file di blocco
:PROPERTIES:
:ID:       7423109a-35e6-4da0-be45-67f87a59f57a
:END:

Gestione dei file di salvataggio automatico (quelli con # all'inizio e alla
fine). Il file di salvataggio automatico di un determinato buffer viene
cancellato quando si salva esplicitamente il file. Per impedire ciò è necessario
impostare a nil la variabile =delete-auto-save-files=.

Se si modifica il nome del file aperto tramite =C-x C-w= o
=set-visited-file-name=, il nome del file di salvataggio automatico viene
modificato di conseguenza.

Alla modifica di un file, emacs fa un backup automatico del file (stesso nome
con la tilde finale). Per abilitare o no il backup automatico, si deve agire
sull'apposita variabile.

Per impostazione predefinita, Emacs tenta di bloccare i file in modo che non
vengano modificati da altri programmi.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Disabilita il backup automatico dei file
  (setq make-backup-files nil)
  (setq backup-inhibited nil) ; Not sure if needed, given `make-backup-files'
  ;; Disabilita il lock dei file
  (setq create-lockfiles nil)
  ;; Elimina i file di backup
  (setq delete-auto-save-files t)
#+end_src

** Impostazione per eliminare il testo selezionato all'inserimento :@ToReview:
:PROPERTIES:
:ID:       de4aa706-e761-4d50-8983-70a1524080a2
:END:

Praticamente tutti i programmi eliminano il testo selezionato/evidenziato non
appena l'utente digita qualcosa. Emacs non lo fa di default, pur avendo la
funzionalità disponibile. Abilitiamola:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; delete selection when edited  (1=enable, -1=disable)
  (delete-selection-mode 1)
  ;; -  ;; Nuovo metodo visto nella configurazione di prot, per ora non in uso, da rivedere
  ;; -  (use-package delsel
  ;; -      :ensure nil ; no need to install it as it is built-in
  ;; -      :hook (after-init . delete-selection-mode))
#+end_src

** Impostazione per il calendario in Italiano           :@ToReview:@Disable:
:PROPERTIES:
:ID:       13af1037-e191-443c-a7c0-ed933603dcb1
:END:

Personalizzazione del calendario per visualizzarlo in Italiano ed inserire le
festività italiane:

[opzione da rivedere perchè l'ultima versione di emacs mi sembra mi dia direttamente i nomi in italiano]

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; -  ;; Calendario in italiano
  ;; -  (setq calendar-christian-all-holidays-flag t)
  ;; -  (setq calendar-date-style (quote iso))
  ;; -  (setq calendar-day-name-array ["Domenica" "Lunedi'" "Martedi'" "Mercoledi'" "Giovedi'" "Venerdi'" "Sabato"])
  ;; -  (setq calendar-latitude [45 40 north])
  ;; -  (setq calendar-longitude [12 22 east])
  ;; -  (setq calendar-mark-holidays-flag t)
  ;; -  (setq calendar-month-name-array ["Gennaio" "Febbraio" "Marzo" "Aprile" "Maggio" "Giugno" "Luglio" "Agosto" "Settembre" "Ottobre" "Novembre" "Dicembre"])
  ;; -  (setq calendar-time-display-form (quote (24-hours ":" minutes (if time-zone " (") time-zone (if time-zone ")"))))
  ;; -  (setq calendar-view-holidays-initially-flag t)
  ;; -  (setq calendar-week-start-day 1)
  ;; -  (setq column-number-mode t)
  ;; -  (setq display-time-mode t)
  ;; -  (setq show-paren-mode t)
#+end_src

** Impostazione per la data e l'ora nella modeline
:PROPERTIES:
:ID:       96ab804d-06e0-4531-a9ec-88dbce62df68
:END:

Mi piace visualizzare la data e l'ora correnti sulla barra di
navigazione. Ecco cosa =display-time-mode= fa. Nota che la mia barra
di navigazione personalizzata mostra l'ora solo nella finestra
attiva/selezionata. Altrimenti, l'impostazione predefinita è quella di
mostrare l'ora su tutte le barre di navigazione, il che è fastidioso.

La =time.el= libreria che fornisce =display-time-mode= definisce anche
funzioni per ottenere il carico medio e controllare una directory per
nuove email. Non ho bisogno di questo e quindi lo disattivo.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  (setq display-time-format " %a %e %b, %H:%M ")
  ;;;; Covered by `display-time-format'
  ;; (setq display-time-24hr-format t)
  ;; (setq display-time-day-and-date t)
  (setq display-time-interval 60)
  (setq display-time-default-load-average nil)
  ;; NOTE 2022-09-21: For all those, I have implemented my own solution
  ;; that also shows the number of new items, although it depends on
  ;; notmuch: the `notmuch-indicator' package.
  (setq display-time-mail-directory nil)
  (setq display-time-mail-function nil)
  (setq display-time-use-mail-icon nil)
  (setq display-time-mail-string nil)
  (setq display-time-mail-face nil)

  ;; I don't need the load average and the mail indicator, so let this
  ;; be simple:
  (setq display-time-string-forms
        '((propertize
           (format-time-string display-time-format now)
           'face 'display-time-date-and-time
           'help-echo (format-time-string "%a %b %e, %Y" now))
          " "))

  ;; Enable function
  (display-time-mode 1)
  ;; Visualizzo nel formato 24 ore.
  (setq display-time-24hr-format t) ;; ricavato dalla configurazione precedente
#+end_src

** Impostazione per i fusi orari (world-clock)          :@ToReview:@Disable:
:PROPERTIES:
:ID:       6529bc2f-431a-4dfc-ab52-cfbb35dd4f15
:END:

Comunico con persone di tutto il mondo. Conoscere il loro orario locale è di
fondamentale importanza. Con =M-x world-clock= otteniamo un buffer con tutte le
città e i relativi fusi orari specificati in zone =world-clock-list=. Il
contenuto viene visualizzato in base a =world-clock-time-format=. Nota che
si può controllare il posizionamento di questo e molti altri buffer configurando
=display-buffer-alist=.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; -  (setq world-clock-list
  ;; -  	'(("America/Los_Angeles" "🇺🇸 Los Angeles")
  ;; -  		("America/Vancouver" "🇨🇦 Vancouver")
  ;; -  		("America/Denver" "🇺🇸 Denver")
  ;; -  		("America/Chicago" "🇺🇸 Chicago")
  ;; -  		("America/New_York" "🇺🇸 New York")
  ;; -  		("America/Toronto" "🇨🇦 Toronto")
  ;; -  		("America/Montreal" "🇨🇦 Montreal")
  ;; -  		("UTC" "🌐 UTC")
  ;; -  		("Europe/Lisbon" "🇵🇹 Lisbon")
  ;; -  		("Europe/London" "🇬🇧 London")
  ;; -  		("Europe/Paris" "🇫🇷 Paris")
  ;; -  		("Europe/Brussels" "🇧🇪 Brussels")
  ;; -  		("Europe/Berlin" "🇩🇪 Berlin")
  ;; -  		("Europe/Athens" "🇬🇷 Athens")
  ;; -  		("Asia/Nicosia" "🇨🇾 Lefkosia")
  ;; -  		("Asia/Istanbul" "🇹🇷 Istanbul")
  ;; -  		("Asia/Baghdad" "🇸🇾 Baghdad")
  ;; -  		("Asia/Riyadh" "🇸🇦 Riyadh")
  ;; -  		("Asia/Tehran" "🇮🇷 Tehran")
  ;; -  		("Asia/Tbilisi" "🇬🇪 Tbilisi")
  ;; -  		("Asia/Tashkent" "🇺🇿 Tashkent")
  ;; -  		("Asia/Karachi" "🇵🇰 Karachi")
  ;; -  		("Asia/Kolkata" "🇮🇳 Kolkata")
  ;; -  		("Asia/Dhaka" "🇧🇩 Dhaka")
  ;; -  		("Asia/Ho_Chi_Minh" "🇻🇳 Ho Chi Minh")
  ;; -  		("Asia/Singapore" "🇸🇬 Singapore")
  ;; -  		("Asia/Shanghai" "🇨🇳 Shanghai")
  ;; -  		("Asia/Seoul" "🇰🇷 Seoul")
  ;; -  		("Asia/Tokyo" "🇯🇵 Tokyo")
  ;; -  		("Australia/Brisbane" "🇦🇺 Brisbane")
  ;; -  		("Australia/Sydney" "🇦🇺 Sydney")
  ;; -  		("Pacific/Auckland" "🇳🇿 Auckland")
  ;; -  	 ))
  ;; -  ;; Formattazione dell'orario mostrato
  ;; -  (setq world-clock-time-format "%a %d %b %R %Z")
#+end_src

** Impostazioni per impostare il numero di caratteri
:PROPERTIES:
:ID:       97a52819-b008-48f5-b9a2-16d81f6559b4
:END:

Per impostare la larghezza massima in caratteri (default 70) in modo iterattivo,
si può utilizzare il comando =C-x f= (=fill-colum=). Altrimenti per impostare
permanentemente la larghezza massima a 80 caratteri all'avvio di Emacs, aggiungi
questa riga al tuo file di configurazione:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; fill-colum 80 caratteri:
  (setq-default fill-column 80)
#+end_src

** Impostazione per mostrare il numero delle righe durante la programmazione
:PROPERTIES:
:ID:       eb029077-2d97-4164-be14-95df45f6f5ff
:END:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Show line numbers on programming mode
  (add-hook 'prog-mode-hook 'display-line-numbers-mode)
#+end_src

** Impostazione per mostrare il numero delle colonne
:PROPERTIES:
:ID:       a63531b5-339b-4857-ae79-c67d22e4ed7c
:END:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Show the column number
  (column-number-mode 1)
#+end_src

** Impostazione per abbreviare le risposte Yes or No
:PROPERTIES:
:ID:       b0b149e0-845e-40b1-9fd2-50508b50ea06
:END:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Make all "yes or no" prompts be "y or n" instead
  (fset 'yes-or-no-p 'y-or-n-p)
#+end_src

** Impostazione per il matching delle parentesi
:PROPERTIES:
:ID:       f46e9b26-3ccd-41fe-96fe-2f6c0ad00b82
:END:

Abilito l'evidenziazione delle coppie di parentesi e riduco al minimo il tempo
di attesa

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Show the matching parenthesis and do it immediately, we are in a hurry
  (show-paren-mode t)
  (setq show-paren-delay 0)
#+end_src

** Impostazione per la directory iniziale o cartella di default
:PROPERTIES:
:ID:       913b56e4-9966-4678-904d-01f0f084ba30
:END:

Imposto la directory iniziale che è quella da cui partire per ricercare o
inserire file

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Directory iniziale o cartella di default
  (setq default-directory "~/Doc/Org/")
#+end_src

** Impostazione per il completamento dinamico sul minibuffer:    :@Disable:
:PROPERTIES:
:ID:       3b21f653-8a0f-4c20-9d9a-a2367913febc
:END:

[Per ora lo disabilito per l'uso di vertigo]

Facilita l'inserimento sul minibuffer. Un esempio è quando introduco un tag su
un file org, con questo abilitato, emcas mi sugerisce tutti i tag già inseriti.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; -  ;; Activate the dynamic completion in the mini-buffer
  ;; -  (icomplete-mode 1)
  ;; -  ;; This should actually turn on auto-fill-mode by default in all major
  ;; -  ;; modes. The other way to do this is to turn on the fill for specific modes
  ;; -  ;; via hooks.
  ;; -  (setq auto-fill-mode 1)
#+end_src

** Impostazione per il Kill buffer automatico                     :@Disable:
:PROPERTIES:
:ID:       00d85e5f-c9b7-4637-98d4-f6629afabb90
:END:

Per default il comando di chiusura di un buffer (=C-x k=) chiede il nome del
buffer da chiudere suggerendo inizialmente quello in cui si è. Tramite il
comando kill-this-buffer si può chiudere direttamente il buffer in cui si è
senza avere la richiesta di conferma. Se si vuole accelerare, si può quindi
bindare il comando generale a quello veloce:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; -  (global-set-key (kbd "C-x k") 'kill-this-buffer)
#+end_src

** Impostazione per la dimensione della finestra                 :@Obsolete:
:PROPERTIES:
:ID:       8ae8d0a4-bd54-4cec-8aa4-7d25c7769626
:END:

[ Questo è integrato in [[id:25163662-be4f-4ee1-96df-9fe7473c25e7][parametri frame in early-init.el]] ]

Ridimensiono la finestra di emacs in base a quanto visto nella pagina della
[[https://www.emacswiki.org/emacs/FrameSize][wiki]].

#+begin_src emacs-lisp :tangle no :results none
  ;; Imposto dimensioni finestra
  ;; (when window-system (set-frame-size (selected-frame) 92 46))
  (add-to-list 'default-frame-alist '(width . 100))
  (add-to-list 'default-frame-alist '(height . 48))
#+end_src

** Impostazione per fare il Buzzer visibile
:PROPERTIES:
:ID:       0f819bf1-cc9a-434e-b0da-5a0d586e203c
:END:

Dal sito [[https://pragmaticemacs.wordpress.com/2017/10/15/using-a-visible-bell-in-emacs/][Pragmatic emacs]] ho trovato come visualizzare un lampeggio in emacs al
posto del beep (per errori o allarmi) di emacs.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Buzzer visibile
  (setq visible-bell t)
#+end_src

** Impostazione per gestire i package:

Emacs ha un gestore di pacchetti basilare, ma comunque sufficientemente
efficiente. Lo utilizziamo per estendere Emacs con funzionalità fornite dalla
community. Emacs include molte funzioni utili, ma senza i pacchetti esterni
saremmo in una situazione peggiore. Inoltre, tenete presente che il fatto che un
pacchetto sia integrato in Emacs non lo rende necessariamente migliore delle
alternative di terze parti.

Vi sono diversi reposity, ma i principali, non chè ufficiali, sono:
- [[https://elpa.gnu.org/packages/][gnu-elpa]] Repository ufficiale con le versioni stabili
- [[https://elpa.gnu.org/devel/][gnu-elpa-devel]] Repository ufficiale con le versioni in sviluppo
- [[https://elpa.nongnu.org/nongnu/][nongnu]] Repository NonGNU
- [[https://melpa.org/packages/][melpa]] Repository ufficiale non GNU

Li inserisco tutti nella mia configurazione, però li ordino in modo che si
utilizzi il primo pacchetto trovato guardando i repository con l'ordine che
voglio.

*** Note sull'utilizzo e sui comandi:
:PROPERTIES:
:ID:       788b4534-ad1b-4919-88aa-873e0da4344d
:END:

Per vedere la lista dei package:
: M-x list-packages
Per aggiornare la lista dei package si usa:
: M-x package-refresh-contents
Per installare l'ultimo package di org:
: M-x package-install RET org RET
Per avere informazioni su un package si può usare il comando 
: M-x describe-package
che visualizza una finestra con le informazioni del pacchetto.

Per aggiornare l'installazione di un package, occorre che non sia in uso, poi si
richiama l'elenco dei packages con
: M-x list-packages
Ora si seleziona i pacchetti da aggiornare con
: U 
(mark Upgradable packages) e si avvia l'aggiornamento con
: x
(eXecute the installs and deletions). Alla fine dell'aggiornamento chiede
eventualmente se si vuole cancellare i pacchetti obsoleti e basta rispondere con
Yes.

If you run into a problem installing or upgrading, you may need to go into your
=~/.emacs.d/elpa/= directory and delete packages that are installed multiple
times. This can happen when the install times out.

*** Impostazione generale dei package repository
:PROPERTIES:
:ID:       fbac4656-a2b3-436a-abb4-b4c2acc255e6
:END:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Set the packet manager:
  (setq package-archives
        '(("gnu-elpa" . "https://elpa.gnu.org/packages/")
          ("gnu-elpa-devel" . "https://elpa.gnu.org/devel/")
          ("nongnu" . "https://elpa.nongnu.org/nongnu/")
          ("melpa" . "https://melpa.org/packages/")))
  ;; Set the repository priority:
  ;; Highest number gets priority (what is not mentioned has priority 0)
  (setq package-archive-priorities
        '(("gnu-elpa" . 3)
          ("melpa" . 2)
          ("nongnu" . 1)))
#+end_src

*** Impostazioni per l'aggiornamento dei pacchetti     :@ToReview:@Disable:
:PROPERTIES:
:ID:       e89bfa83-c993-45fe-98fd-bbacf51c68a6
:END:

Queste configurazioni vengono dalla vecchia versione, per ora le disabilito, ma
dovrò capire come usarle nella nuova configuraione.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Codice dalla vecchia versione, per ora disattivato:
  ;; -  ;;  Codice già resente in init.el:
  ;; -  ;;      (require 'package)
  ;; -  ;;      (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
  ;; -  ;;      ;;(add-to-list 'package-archives '("melpa-stable" . "https://stable.melpa.org/packages/") t)
  ;; -  ;;      (package-initialize)
  ;; -  ;;
  ;; -  ;; Codice per rinfrescare i package solo quando serve prima di utilizzarli:
  ;; -  (unless package-archive-contents (package-refresh-contents))    ;; Refresh the packages descriptions
  ;; -  (setq package-load-list '(all))     			     ;; List of packages to load
  ;; -  ;;
  ;; -  ;; Carico Org se non già caricato:
  ;; -  (unless (package-installed-p 'org) (package-install 'org))      ;; Make sure the Org package is installed, install it if not
  ;; -  ;;
  ;; -  ;; Codice per rinfrescare i package solo quando serve prima di utilizzarli:
  ;; -  (unless (package-installed-p 'use-package)
  ;; -    (package-refresh-contents)
  ;; -    (package-install 'use-package))
#+end_src

*** Impostazione per non visualizzare i warning durante il load dei pacchetti:
:PROPERTIES:
:ID:       23b9362f-a8cb-4c3b-9c38-0762ef26f79a
:END:

Quando si installa un nuovo pacchetto, Emacs mostra un buffer contenente tutti
gli avvisi generati dal compilatore bytecode (Configura il gestore di
pacchetti). Sebbene queste informazioni siano utili per gli sviluppatori,
risultano molto confuse per gli utenti. Molte volte ho ricevuto messaggi del
tipo "Emacs si è bloccato", quando in realtà gli avvisi riguardano problemi che
non interessano l'utente.

Il seguente frammento di codice impedisce la visualizzazione di questi buffer
(Configurazione completa). Rimangono comunque disponibili nell'elenco dei
buffer, qualora fossero necessari.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  (add-to-list 'display-buffer-alist
               '("\\`\\*\\(Warnings\\|Compile-Log\\)\\*\\'"
                 (display-buffer-no-window)
                 (allow-no-window . t)))  
#+end_src

** Impostazione per l'uso del Package:  Try
:PROPERTIES:
:ID:       bb851ab2-d68a-425d-a9fe-0314dd6de287
:END:

Permette di provare i vari pacchetti senza installarli. Quindi riavviando emacs
si ritorna alla situazione iniziale.

Quando installato, si può provare un pacchetto direttamente installandolo
temporaneamente con try. Per esempio e voglio installare il pacchetto del gioco
2048:
: M-x try RET 2048-game 
e quindi lanciare il gioco temporaneamente installato:
: M-X 2048-game RET

Si può utilizzare anche per provare un file dal web. Per esempio per caricare il
file, file.el, in modo temporaneo:
: M-x try RET https://url.com/to/some/file.el

Dai siti di rifererimento [[https://melpa.org/#/tryhttps://melpa.org/#/try][Melpa]], [[https://github.com/larstvei/Try][GitHub]]
#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
 (use-package try
   :ensure t)
#+end_src

** Impostazione per l'uso del Package:  Which-key                :@Obsolete:
:PROPERTIES:
:ID:       631ba5a0-99aa-44bc-8577-78a6494f3abd
:END:

[ Pacchetto reso obsoleto da =vertigo= che preferisco. ]

Visualizza sul minibuffer tutti i comandi possibili per completare quello
iniziato.  Quindi permette di iniziare un comando, per esempio =C-x=, attendere
qualche secondo, e mostra sul minibuffer tutti i possibili suggerimenti
   
E' simile ad IDO, ma è riferito esclusivamente ai comandi.

Sui siti di riferimento [[https://melpa.org/#/which-key][Melpa]], [[https://github.com/justbur/emacs-which-key][GitHub]], ci sono molte opzioni (visualizzare i
suggerimenti sotto, a destra, tempo di attesa prima di visualizzarli, ecc..) ma
per ora utilizzo la configurazione base e poi sperimentando vedo se variarla.
   
#+begin_src emacs-lisp :tangle no :results none
  (use-package which-key
    :ensure t
    :config
  	 (which-key-mode))
#+end_src
   
** Impostazione per l'uso del Package:  auto-complete   :@ToReview:@Disable:
:PROPERTIES:
:ID:       e4a7b079-6a5f-4dd4-95ea-1a2955c08679
:END:

[ PEr ora disabilitata perchè preferisco approfondire quello che usavo prima del
cambio versione con i template ]

Simile alla funzione di autocompletamento nativa di emacs (vedi [[id:d66bda07-4362-43fb-bfb0-45279cb3dab4][dynamic
abbreviations]] =M-/=) questa visualizza i suggerimenti tipo intellisense e quindi
è carina da vedere.

I siti di riferimento sono: [[https://melpa.org/#/auto-complete][Melpa]], [[https://github.com/auto-complete/auto-complete][GitHub]]

#+begin_src emacs-lisp :tangle no :results none
 (use-package auto-complete
   :ensure t
   :init
   (progn
 (ac-config-default)
 (global-auto-complete-mode t)
   ))
#+end_src
   
** Impostazione per l'uso del Package:  htmlize
:PROPERTIES:
:ID:       139aad2b-8b71-4969-860f-85fc0dbe8b92
:END:

Per convertire il testo ed i blocchi in testo html con associati i vari colori.

Siti di riferimento: [[https://melpa.org/#/htmlize][Melpa]], [[https://github.com/hniksic/emacs-htmlize][GitHub]] da cui si vede che è possibile personalizzare
lo stile dell'esportazione in tre modi in base ai valori assegnato alla
variabile:
: htmlize-output-type
:    css
:    inline-css
:    font

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  (use-package htmlize
    :ensure t)
#+end_src

** Impostazione per i caratteri non presenti sulla tastiera:
:PROPERTIES:
:ID:       d41b2219-3c26-4c6d-b377-26a718a32a88
:END:

Vi sono alcuni caratteri usati spesso che non sono presenti nella tastiera:
| Key   | New Binding |
|-------+-------------|
| ~     | C-ù         |
| C-SPC | C-ò         |

Cioè il carattere Tilde usato come Home e il set del mark, cioè il set del punto
di inizio di una selezione, utile per fare le selezioni con solo la tastiera.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Tilde
  (global-set-key (kbd "C-ù") (kbd "~"))
  ;;
  ;; Riassegnamento del set mark al posto di C-SPC
  (global-set-key (kbd "C-ò") 'set-mark-command)
#+end_src

** Carico file di configurazione della UI
:PROPERTIES:
:ID:       045e2874-6ab7-4bee-a557-a271fd805fbb
:END:

Carico il file con la configurazione della UI, che descrivo [[id:3a1e2165-6733-460d-95bc-652380277b31][qui]].

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Load Custon UI Preference File:
  (load "~/.emacs.d/UI-init.el")
#+end_src

** Carico file di configurazione del minibuffer
:PROPERTIES:
:ID:       459eecd9-bed2-4b6c-9556-11666d4a0c5b
:END:

Carico il file con la configurazione del minibuffer, che descrivo [[id:e7cc0e5c-9cf2-4665-8c76-517efd69f38a][qui]].

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Load Custon UI Preference File:
  (load "~/.emacs.d/mnbfr-init.el")
#+end_src

** Carico file di configurazione di org-mode
:PROPERTIES:
:ID:       0ab89109-24cb-445a-a913-e575bfb42a16
:END:

Carico il file con la configurazione della UI che descrivo [[id:3a5bad5e-b492-4459-b863-ee15421eb5d8][qui]].

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  ;; Load Custon UI Preference File:
  (load "~/.emacs.d/org-init.el")
#+end_src

** Uso dei pacchetti zip e find di unix:

Per prima cosa ho scaricato gli eseguibili dal progetto [[https://gnuwin32.sourceforge.net/packages.html][GnuWin32]] e li homessi
nella cartella =C:\MyTools\GnuWin32=. Quindi ho configurato emacs per caricare
quella cartella in modo che ritrovi i relativi eseguibili.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  	;; 1. Aggiunge la cartella con zip.exe e unzip.exe ai percorsi di Emacs
  	(add-to-list 'exec-path "C:/MyTools/GnuWin32")

  	;; 2. Disattiva il vecchio standard PKZIP (obbligatorio su Windows moderno)
  	(setq archive-zip-use-pkzip nil)

  	;; 3. Definisce i comandi esatti per la gestione degli archivi zip
  	(setq archive-zip-program "zip")
  	(setq archive-zip-extract '("unzip" "-qq" "-c"))

  	;; Verifica che sta prendendo gli eseguibili voluti:
  	;; (executable-find "zip") C-j   --> "c:/MyTools/GnuWin32/zip.exe"
  	;; (executable-find "unzip") C-j --> "c:/MyTools/GnuWin32/unzip.exe"
  	;; (executable-find "find") C-j  --> "c:/MyTools/GnuWin32/find.exe"
#+end_src

** Uso del Latex

Per usare latex, utilizzo il pacchetto portable MikTex, che ho configurato sul
disco virtuale X tramite il file batch =C:\MyTools\miktex\miktex -
Avvia.bat=. In questo modo posso esportare in latex avendo l'accortezza di
lanciare miktex prima di avviare l'esportazione.

Per fare in modo che emacs riconosca miktex, ho configurato:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/init.el"
  	;; X:/texmfs/install/miktex/bin/x64/pdflatex.exe
  	;; 1. Aggiunge la cartella con MikTex ai percorsi di Emacs
  	(add-to-list 'exec-path "X:/texmfs/install/miktex/bin/x64")
  	;;	;; 1. Dice a Emacs dove trovare pdflatex su Windows
  	;;	(setenv "PATH" (concat "C:\\Users\\" (user-login-name) "\\AppData\\Local\\Programs\\MiKTeX\\miktex\\bin\\x64;" (getenv "PATH")))
  	;;	;; 2. Sincronizza il percorso interno di Emacs
  	;;	;;	(setq exec-path (append '("C:/Users/" (user-login-name) "/AppData/Local/Programs/MiKTeX/miktex/bin/x64") exec-path))
  	;;	;; 3. Dice a Org-mode di usare pdflatex
  	;;	(setq org-latex-pdf-process '("pdflatex -interaction nonstopmode -output-directory %o %F"))
  	;;	;; questultima dà ancora errore pdflatex non trovato, quindi lo indico direttamente:
  	;; Risolviamo aggirando completamente il problema del PATH: inseriamo il percorso assoluto dell'eseguibile direttamente nel comando di compilazione, così Windows non dovrà "cercarlo".
  	(setq org-latex-pdf-process '("X:/texmfs/install/miktex/bin/x64/pdflatex.exe -interaction nonstopmode -output-directory %o %F"))
  	;; dopo questo ho:
  	;; (executable-find "pdflatex") --> "x:/texmfs/install/miktex/bin/x64/pdflatex.exe"
  	;; (executable-find "dvipng")  --> "x:/texmfs/install/miktex/bin/x64/dvipng.exe"
#+end_src

Alcune volte dà problemi, per esempio se vi sono formule matematiche in latex,
perchè non riesce a caricare correttamente dvipng. Per risolvere bisogna
utilizzare i riferimenti assoluti =%F= dei file e non relativi =%f= e quindi
occorre sistemare la variabile =org-preview-latex-process-alist= in modo che tutti i riferimenti siano
assoluti:

#+begin_src emacs-lisp :tangle no
  ;; Configurazione presa da internet
  (with-eval-after-load 'org
    (add-to-list 'org-preview-latex-process-alist
                 '(dvisvgm :programs ("latex" "dvisvgm")
                           :description "dvi > svg"
                           :message "you need to install the programs: latex and dvisvgm."
                           :use-xcolor t
                           :image-input-type "dvi"
                           :image-output-type "svg"
                           :image-size-adjust (1.7 . 1.5)
                           :latex-compiler ("latex -interaction nonstopmode -output-directory %o %f")
                           :image-converter ("dvisvgm %f -n -b min -c %S --currentcolor -o %O")))
    
    ;; Imposta il programma predefinito per il rendering
    (setq org-preview-latex-default-process 'dvisvgm))
#+end_src

#+begin_src emacs-lisp :tangle no
  ;; Configurazione creata da me con M-x customize-variable RET org-preview-latex-process-alist RET
  (custom-set-variables
   ;; custom-set-variables was added by Custom.
   ;; If you edit it by hand, you could mess it up, so be careful.
   ;; Your init file should contain only one such instance.
   ;; If there is more than one, they won't work right.
   '(org-preview-latex-process-alist
     '((dvipng :programs ("latex" "dvipng") :description "dvi > png"
  	     :message
  	     "you need to install the programs: latex and dvipng."
  	     :image-input-type "dvi" :image-output-type "png"
  	     :image-size-adjust (1.0 . 1.0) :latex-compiler
  	     ("latex -interaction nonstopmode -output-directory %o %F")
  	     :image-converter ("dvipng -D %D -T tight -o %O %F")
  	     :transparent-image-converter
  	     ("dvipng -D %D -T tight -bg Transparent -o %O %F"))
       (dvisvgm :programs ("latex" "dvisvgm") :description "dvi > svg"
  	      :message
  	      "you need to install the programs: latex and dvisvgm."
  	      :image-input-type "dvi" :image-output-type "svg"
  	      :image-size-adjust (1.7 . 1.5) :latex-compiler
  	      ("latex -interaction nonstopmode -output-directory %o %F")
  	      :image-converter
  	      ("dvisvgm %F --no-fonts --exact-bbox --scale=%S --output=%O"))
       (imagemagick :programs ("latex" "convert") :description
  		  "pdf > png" :message
  		  "you need to install the programs: latex and imagemagick."
  		  :image-input-type "pdf" :image-output-type "png"
  		  :image-size-adjust (1.0 . 1.0) :latex-compiler
  		  ("pdflatex -interaction nonstopmode -output-directory %o %F")
  		  :image-converter
  		  ("convert -density %D -trim -antialias %F -quality 100 %O")))))
#+end_src

* \checkmark File di configurazione della grafica *UI-init.el*
:PROPERTIES:
:ID:       3a1e2165-6733-460d-95bc-652380277b31
:END:

Questo è un file di configurazione ausiliario, che gestisce in particolare
l'aspetto grafico di emacs, cioè i temi e font.

Essendo un file di configurazione ausiliario, va caricato nel file =init.el=
come fatto [[id:045e2874-6ab7-4bee-a557-a271fd805fbb][qui]].

In questo file imposterò in particolare:
- font utili (nerd icons)
- thema utilizzato

** Impostazione per i nerd icon
:PROPERTIES:
:ID:       a0c69af1-f2d3-489e-9079-6fbd3cabab88
:END:

Il seguente frammento di codice mostrerà icone complementari nel minibuffer e in
Dired.

La configurazione, richiede che sul sistema siano installati i relativi font, e
quindi per far funzionare questa configurazione serve farlo. Per installarli,
l'utente deve digitare =M-x= e quindi richiamare il comando
=nerd-icons-install-fonts=. Questo salverà i file dei font delle icone in una
directory locale e poi vanno installati sul sistema windows. Per assicurarsi che
tutto funzioni correttamente, riavviare Emacs e ciò garantirà che i nuovi file
dei font vengano letti.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Install nerd-icons package for all mode that we use
  (use-package nerd-icons
    :ensure t)
  (use-package nerd-icons-completion
    :ensure t
    :after marginalia
    :config
    (add-hook 'marginalia-mode-hook #'nerd-icons-completion-marginalia-setup))
  (use-package nerd-icons-corfu
    :ensure t
    :after corfu
    :config
    (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
  (use-package nerd-icons-dired
    :ensure t
    :hook
    (dired-mode . nerd-icons-dired-mode))
#+end_src

** Impostazione per l'uso del Package:  Org-bullet               :@Obsolete:
:PROPERTIES:
:ID:       818a7692-c614-4060-94a5-23b56f56ce6f
:END:

Questo pacchetto permette di sostituire gli asterichi nelle header con dei
bullet più carini.  Dai siti di riferimento [[https://melpa.org/#/org-bullets][Melpa]], [[https://github.com/sabof/org-bullets][GitHub]] si indica che non sarà
più aggiornato e che viene sostituito da org-superstart, quindi anchio lo
disattivo ed utilizzo superstar. Il codice di configurazione era:

#+begin_src emacs-lisp :tangle no :results none
  (use-package org-bullets
       :ensure t
       :config
  	(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))
#+end_src

** Impostazione per l'uso del Package:  Org-superstar            :@Obsolete:
:PROPERTIES:
:ID:       6fa0a818-0b1e-4cf9-8ace-a6a92d6de0f3
:END:

[ Il thema è stato soppravanzato da org-modern, disattivo questo e provo l'altro ]

Questo pacchetto permette di sostituire gli asterichi nelle header con dei
bullet più carini. Dai siti di riferimento [[https://melpa.org/#/org-superstar][Melpa]] [[https://github.com/integral-dw/org-superstar-mode][GitHub]] viene indicato come il
successore di org-bullet.

Alcuni themi non li visualizzano correttamente, quindi nel caso devo
disattivarlo (:tangle no :results none) o
riattivarlo (:tangle  "~/.emacs.d/UI-init.el").

#+begin_src emacs-lisp :tangle no :results none
  ;; Carico il package
  (use-package org-superstar
    :ensure t
    :config
  ;; lo utilizzo in org
  (add-hook 'org-mode-hook (lambda () (org-superstar-mode 1))))
  ;; Per velocizzare la gestione del font 
  (setq inhibit-compacting-font-caches t)
  ;; Customize bullets
  ;; -  ;; Resize bullets
  ;; -  (with-eval-after-load 'org-superstar
  ;; -    (set-face-attribute 'org-superstar-item nil :height 1.2)
  ;; -    (set-face-attribute 'org-superstar-header-bullet nil :height 1.2)
  ;; -    (set-face-attribute 'org-superstar-leading nil :height 1.3))
  ;; Set different bullets, with one getting a terminal fallback.
  ;; -  (setq org-superstar-headline-bullets-list
  ;; -        '("◉" ("🞛" ?◈) "○" "▷"))
  ;; Stop cycling bullets to emphasize hierarchy of headlines.
  (setq org-superstar-cycle-headline-bullets nil)
  ;; Hide away leading stars on terminal.
  (setq org-superstar-leading-fallback ?\s)
#+end_src
** Impostazione per l'uso del Package:  Org-modern      :@ToReview:@Disable:
:PROPERTIES:
:ID:       c4062e8f-6f1e-4460-93d9-a1d4c5b12105
:END:

Dai siti di riferimento [[https://elpa.gnu.org/packages/doc/org-modern.html][ELPA]] e [[https://github.com/minad/org-modern][GitHub]] viene indicato come il successore di
org-bullet e org-superstar.

Questo pacchetto implementa uno stile moderno per i buffer Org utilizzando il
blocco dei caratteri e le proprietà del testo. Il pacchetto applica uno stile a
titoli, parole chiave, tabelle e blocchi di codice sorgente. Lo stile è
configurabile: è possibile disabilitare o modificare lo stile di ciascun
elemento di sintassi singolarmente tramite la customizzazione del gruppo
org-modern.

Poiché questo pacchetto regola lo stile del testo, dipende dalle impostazioni
del carattere. È necessario assicurarsi che le propietà del font
=variable-pitch= e =fixed-pitch= si combinino armoniosamente e abbiano
approssimativamente la stessa altezza. Come carattere predefinito, consiglio
varianti del carattere [[https://github.com/be5invis/Iosevka][Iosevka]] , ad esempio =Iosevka Term Curly=.
=org-modern-mode= cerca di regolare la visualizzazione dell'etichetta
del tag in base all'altezza del carattere.

#+begin_src emacs-lisp :tangle no :results none
  ;; Option 1: Per buffer
  (add-hook 'org-mode-hook #'org-modern-mode)
  (add-hook 'org-agenda-finalize-hook #'org-modern-agenda)

  ;; Option 2: Globally
  (with-eval-after-load 'org (global-org-modern-mode))
#+end_src

Ecco una configurazione più estesa:

#+begin_src emacs-lisp :tangle no :results none
  ;; abilito delle visualizzazioni più avanzate:
  (setq
   ;; Edit settings
   org-auto-align-tags nil
   org-tags-column 0
   org-catch-invisible-edits 'show-and-error
   org-special-ctrl-a/e t
   org-insert-heading-respect-content t
   ;; Org styling, hide markup etc.
   org-hide-emphasis-markers t
   org-pretty-entities t
   org-agenda-tags-column 0
   org-ellipsis "…")
  ;;; Abilito sempre org-modern
  (global-org-modern-mode)
#+end_src

Il font in uso ora è =Courier New=. Si può pensare di cambiarlo in questo modo:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Choose some fonts: "Iosevka" or "DejaVu"
  ;; 
  ;; - Main typeface
  ;;(set-face-attribute 'default nil :family "Iosevka" :height 140)
  ;;(set-face-attribute 'default nil :family "DejaVu Sans Mono" :height 110)
  ;; 
  ;; - Proportionately spaced typeface
  ;;(set-face-attribute 'variable-pitch nil :family "Iosevka Aile")
  ;;(set-face-attribute 'variable-pitch nil :family "DejaVu Serif" :height 1.0)
  ;; 
  ;; - Monospaced typeface
  ;;(set-face-attribute 'org-modern-symbol nil :family "Iosevka")
  ;;(set-face-attribute 'fixed-pitch nil :family "DejaVu Sans Mono" :height 1.5)
#+end_src

Nella mia review, ho installato il pacchetto manualmente:
- Per prima cosa aggiornato la lista dei pacchetti con il comando
  : package-refresh-contents
- Poi installato il pacchetto con il comando
  : package-install
  e inserendo alla richiesta il nome: org-modern

Ora il pacchetto è installato, ma non ancora richiamato dagli hook e
quindi per verificarlo va richiamato a mano con =M-x org-modern=.

Dai primi utilizzi, la grafica è molto bella, ma mi distrae
l'editazione, quindi per ora voglio tenere solo il simbolo all'inizio
della headline che è carino soprattutto per distinguere quelle aperte
da quelle compresse. Per farlo attivo quindi sempre org-manage ma ne
disabilito alcune funzionalità.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Per cambiare cosa viene Prettify e cosa no, cambiare le opzioni
  ;; usare t per abilitare l'opzionerelativa
  ;; usare nil per disabilitare l'opzione
  (use-package org-modern
    :after org
    :ensure t
    :hook ((org-mode . org-modern-mode))
    :custom
    (org-modern-timestamp t) ; Prettify time stamps
    (org-modern-table nil) ; Prettify tables
    (org-modern-priority t) ; Prettify priorities
    (org-modern-todo t) ; Prettify todo keywords, see org-todo-keywords
    (org-modern-tag t) ; Prettify tags in headlines
    (org-modern-block-name nil) ; Prettify blocks names
    (org-modern-block-fringe 2) ; Add a border to the blocks in the fringe (nil - 16)
    (org-modern-keyword t) ; Prettify keywords like #+title
    (org-modern-progress 10) ; Width in characters to draw progress bars. Set to nil to disable bars.
    )
#+end_src

Infine per evitare l'errore di visalizzazione del terzo livello
(perchè il font non ha il relativo carattere), utilizzo la soluzione
ricavata da [[https://www.reddit.com/r/emacs/comments/1qx48wl/does_anyone_here_use_org_modern_or_other_packages/?tl=it][redit]] o [[https://github.com/minad/org-modern/commit/5393edbb5a078348d0eea5723868c35be3e73494][GitHub]]:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Sostituisco i caratteri standard con la mia preferenza:
  (setq org-modern-fold-stars
        '(
  	("▶" . "▼")
  	("▷" . "▽")
  	("▸" . "▾")
  	("▹" . "▿")
  	)
        )
#+end_src

** Impostazione per selezionare il tema utilizzato:
:PROPERTIES:
:ID:       7568ad10-8549-4282-b83d-fc3b7118c244
:END:

La scelta del tema è soggettiva, quindi vi prego di non considerare quanto segue
come un'opinione definitiva. Ho semplicemente scelto il tema che mi piace di
più. Usatelo come modello per configurare eventualmente un altro tema.

Come reference per i theme ci sono i seguenti siti:
- [[https://pawelbx.github.io/emacs-theme-gallery/][emacs theme gallery]]
- [[https://emacsthemes.com/][emacs Themes]]
     
#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Esempio per utilizzare un pacchetto thema esterno
  ;; -  (use-package modus-themes
  ;; -    :ensure t
  ;; -    :config
  ;; -    (load-theme 'modus-vivendi-tinted :no-confirm-loading))
  ;; Esempio di utilizzo di un thema interno
  ;; -  (load-theme 'dichromacy :no-confirm-loading)  
#+end_src

** Impostazione del tema interno:  modus-operandi-deuteranopia    :@Disable:
:PROPERTIES:
:ID:       9eb8612c-9200-410c-9eae-e1c4c456aef8
:END:

Dal [[https://protesilaos.com/codelog/2022-08-03-modus-themes-2-5-0/][sito]] del thema, impostiamo l'utilizzo del tema =modus-operandi-deuteranopia=
impostando anche l'evidenziazione dei titoli ingrandendo il font.

#+begin_src emacs-lisp :tangle :tangle no :results none
  ;; Ridimensioni i titoli in base al livello:
  (setq modus-themes-headings
        '((0 . (variable-pitch 1.3))   ; Titolo principale/Documento
          (1 . (variable-pitch 1.1))   ; Livello 1
          (2 . (variable-pitch 1.1))   ; Livello 2
          (3 . (variable-pitch 1.0))   ; Livello 3 (non lo ridimensiono perchè con il colore, sembra già grande)
          (t . (rainbow bold 1.0))))   ; Tutti gli altri livelli (default)
  ;; Abilito il tema
  (load-theme 'modus-operandi-deuteranopia :no-confirm-loading)
#+end_src

** Impostazione per l'uso del Package:  Theme Zenburn             :@Disable:
:PROPERTIES:
:ID:       e640d15f-3f32-4d3f-a1a7-289890574aa4
:END:

[ Il tema non mi piace più, quindi lo disabilito ]

Permette di gestire comodamente il thema ZenBurn

I siti di riferimento sono: [[https://melpa.org/#/zenburn-theme][Melpa]], [[https://github.com/bbatsov/zenburn-emacs][GitHub]] da cui ricavo anche che il thema
gestisce dimensioni diverse per le headline.

Si possono ridefinire i colori andando a ridefinire la variabile
zenburn-override-colors-alist come in questo esempio.

#+begin_src emacs-lisp :tangle :tangle no :results none
  ;;    ;; Sample redefine colors:
  ;;    (setq zenburn-override-colors-alist
  ;;          '(("zenburn-bg+05" . "#282828")
  ;;            ("zenburn-bg+1"  . "#2F2F2F")
  ;;            ("zenburn-bg+2"  . "#3F3F3F")
  ;;            ("zenburn-bg+3"  . "#4F4F4F")))
  ;;    (load-theme 'zenburn t)
  ;;
  ;; use variable-pitch fonts for some headings and titles
  (setq zenburn-use-variable-pitch t)
  ;;
  ;; scale headings in org-mode
  (setq zenburn-scale-org-headlines t)
  ;;
  ;; scale headings in outline-mode
  (setq zenburn-scale-outline-headlines t)
  ;;
  ;; Load theme
  (use-package zenburn-theme
    :ensure t
    :config
    (load-theme 'zenburn t))
#+end_src

** Impostazione per l'uso del Package:  Theme Spacemacs           :@Disable:
:PROPERTIES:
:ID:       5e2ed87e-7835-43ed-833a-79335dcfb301
:END:

Permette di gestire comodamente il thema Spacemacs.  Spacemacs è una
configurazione particolare di emacs completa di configuratore e altro. Per
informazioni il sito di riferimento è: [[https://www.spacemacs.org/][Spacemacs]] o [[https://www.youtube.com/watch?v=hCNOB5jjtmc][Video]]

I siti di riferimento sono: [[https://melpa.org/#/spacemacs-theme][Melpa]], [[https://github.com/nashamri/spacemacs-theme][GitHub]] da cui ricavo anche che il thema
gestisce dimensioni diverse per le headline e anche il grassetto.

#+begin_src emacs-lisp :tangle no :results none
  ;; Load theme
  (use-package spacemacs-theme
    :ensure t
    :config (load-theme 'spacemacs-light t))
#+end_src

** Impostazione del tema interno:  dichromacy

Utilizzo il tema interno dichromacy, però trovo i colori troppo vivaci.

Tramite il comando =M-x customize-face= ricavo il colore di sfondo di ogni
singolo livello header. Per esempio si vede che =org-level-1= eredita il face da
=outline-1= che a sua volta eredita da =font-lock-function-name-face= che ha il
=Foreground: #d55e00=.

Colori originali di dichromacy:
org-level-1 -->  #d55e00 	vermilion
org-level-2 -->  #e69f00   	orange
org-level-3 -->  #56b4e9  	skyblue
org-level-4 -->  #009e73    bluegreen
org-level-5 -->  #0072b2    blue
org-level-6 -->  #d55e00    vermilion
org-level-7 -->  #0072b2    blue
org-level-8 -->  #848ea9    bluegray

In un primo tentativo hgo provato a shiftare i colori ma ancora non era il top,
quindi ho scelto una palette da 5 colori sul verde e quindi dopo aver caricato
il thema, devo personalizzarlo:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/UI-init.el"
  ;; Carico il theme: dichromacy
  (load-theme 'dichromacy :no-confirm-loading) 
  ;;
  ;; Personalizzo il colore e le dimensioni utilizzando la paletta:
  ;; 'Velluto della foresta': #1b1f23 #0b3d2e #145a3a #2f7d5b #cbbfa6
  (custom-set-faces
      '(org-level-1 ((t (:foreground "#56b4e9" :bold t :height 1.3))))
      '(org-level-2 ((t (:foreground "#2f7d5b" :bold t :height 1.1))))
      '(org-level-3 ((t (:foreground "#145a3a" :bold t :height 1.1))))
      '(org-level-4 ((t (:foreground "#0b3d2e" :bold t :height 1.1))))
      '(org-level-5 ((t (:foreground "#1b1f23" :bold t))))
  )
#+end_src


* File di configurazione del minibuffer: *mnbfr-init.el*
:PROPERTIES:
:ID:       e7cc0e5c-9cf2-4665-8c76-517efd69f38a
:END:

[Guarda anche il video sui pacchetti minibuffer moderni, alcuni dei quali non ho
incluso qui perché sono un po' più avanzati:
https://protesilaos.com/codelog/2024-02-17-emacs-modern-minibuffer-packages/.]

Il minibuffer è una componente fondamentale dell'esperienza Emacs. È il punto in
cui l'utente interagisce con Emacs per rispondere ai prompt, passare a un altro
buffer, aprire un nuovo file, eseguire un comando per nome completo e così
via. Il minibuffer predefinito è minimale, il che potrebbe essere utile per gli
utenti esperti, ma non facilita la scoperta delle opzioni.

Essendo un file di configurazione ausiliario, va caricato nel file =init.el=
come fatto [[id:459eecd9-bed2-4b6c-9556-11666d4a0c5b][qui]].

** Impostazione per l'uso del Package:  vertigo
:PROPERTIES:
:ID:       f7643b57-04fa-4e66-b3b6-0b84be9c149a
:END:

Utilizziamo il pacchetto =vertico= per creare un layout verticale nel
minibuffer. Ciò semplifica la visualizzazione delle opzioni disponibili.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; Load vertigo package
  (use-package vertico
    :ensure t
    :config
    (setq vertico-cycle t)
    (setq vertico-resize nil)
    (vertico-mode 1))
  ;; Configure directory extension.
  (use-package vertico-directory
    :after vertico
    :ensure nil
    ;; More convenient directory navigation commands
    :bind (:map vertico-map
                ("RET" . vertico-directory-enter)
                ("DEL" . vertico-directory-delete-char)
                ("M-DEL" . vertico-directory-delete-word))
    ;; Tidy shadowed file names
    :hook (rfn-eshadow-update-overlay . vertico-directory-tidy))
#+end_src

** Impostazione per l'uso del Package:  marginalia
:PROPERTIES:
:ID:       95c8f5d2-c947-4c96-95c1-f6a743348a37
:END:

Il pacchetto =Marginalia= è un ottimo complemento al layout verticale, poiché
utilizza lo spazio libero per mostrare informazioni utili sulle opzioni
visualizzate. Ad esempio, quando l'utente digita =M-x= per visualizzare un
elenco di nomi di comandi, Marginalia aggiungerà una breve descrizione di
ciascun comando. A seconda delle specifiche dell'interazione con il minibuffer
(apertura di un file, selezione di un buffer, ecc.), verranno visualizzate le
informazioni pertinenti.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; Load marginalia package
  (use-package marginalia
    :ensure t
    :config
    (marginalia-mode 1))
#+end_src

** Impostazione per l'uso del Package:  orderless
:PROPERTIES:
:ID:       870c854a-489c-4868-9b2a-796dc4dce2c6
:END:

Il pacchetto =Orderless= è una soluzione ideale per tutti quei casi in cui non
ricordiamo l'ordine esatto delle parole. Ad esempio, per attivare/disattivare la
visualizzazione dei numeri di riga nel buffer corrente, utilizziamo il comando
=M-x display-line-numbers-mode=. Con Orderless configurato, possiamo digitare
qualcosa come =li num dis= al prompt =M-x= e ottenere comunque il risultato
desiderato. Questo perché Orderless interpreta i caratteri separati da spazi in
qualsiasi ordine. Emacs include altri stili di corrispondenza di pattern, ma
"orderless" è un buon punto di partenza. Pertanto, ci assicuriamo che le altre
variabili rilevanti siano impostate su un valore nullo, in modo da ottenere
"orderless" ovunque.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; Load ordeless package
  (use-package orderless
    :ensure t
    :config
    (setq completion-styles '(orderless basic))
    (setq completion-category-defaults nil)
    (setq completion-category-overrides nil))
#+end_src

** Impostazione per l'uso del Package:  consult         :@Disable:@ToReview:
:PROPERTIES:
:ID:       5549b354-5d83-4a31-ad77-03d17d174ae5
:END:

[ Per ora il problema con il find.exe non sembra risolvibile e quindi disattivo il pacchetto ]

Il pacchetto =consult= fornisce numerosi comandi che sono varianti avanzate
delle funzionalità di base integrate. Una delle caratteristiche principali di
consult è la funzione di anteprima, che mostra in un'altra finestra di Emacs il
contesto di ciò che è attualmente corrispondente nel minibuffer.

Qui definisco le scorciatoie da tastiera per alcuni comandi che potrebbero
esservi utili. Il prefisso mnemonico è "alternative search" (in contrapposizione
alle scorciatoie da tastiera di base =C-s= o =C-r=).

#+begin_src emacs-lisp :tangle no :results none
  ;; Load consult package
  (use-package consult
    :ensure t
    :bind (;; Search for files names recursively
           ("M-s M-f" . consult-find)
           ;; Search through the outline (headings) of the file
           ("M-s M-o" . consult-outline)
           ;; Search the current buffer
           ("M-s M-l" . consult-line)
           ;; Switch to another buffer, or bookmarked file, or recently opened file.
           ("M-s M-b" . consult-buffer)
  	 ;; Search through history
  	 ("M-s M-h" . consult-history)
  	 ;; Search through mark
           ("M-s M-m" . consult-mark)
  	 ;; Search through yank
     	 ("M-s M-y" . consult-yank-pop)
  	 ))
#+end_src

Il comando =consult-find= non funziona su windows, infatti utilizza il programma
=find.exe= che però non è quello unix. In particolare con il comando

#+begin_src emacs-lisp :tangle no :results none
  (executable-find "find")
#+end_src

ritorna il valore

#+begin_src emacs-lisp :tangle no :results none
  "c:/WINDOWS/system32/find.exe"
#+end_src

indicando che utilizza il find.exe di windows. Come find di unix, voglio
utilizzare quello dato già assieme a git. Serve quindi impostare il path
corretto, da internet ho trovato il comando

#+begin_src emacs-lisp :tangle no :results none
  (setq find-program "C:/Program Files/Git/usr/bin/find.exe")
#+end_src

ma non funziona, emacs continua a puntare al find di windows. Procedo quindi a
inserire il path del find di unix sul PATH complessivo che utilizza emacs. In
questo modo non altero il PATH di windows e quindi sono più sicuro.

#+begin_src emacs-lisp :tangle no :results none
  ;; imposto la directory del find unix:
  (setq find-program-path "C:/Program Files/Git/usr/bin")
  ;; la inserisco nel PATH di emacs:
  (push find-program-path exec-path)
#+end_src

** Impostazione per l'uso del Package:  corfu           :@ToReview:@Disable:
:PROPERTIES:
:ID:       36e5e474-8ddd-4e4b-b909-3ad94b270327
:END:

[ Devo approfondire, per ora lo disattivo ]

Il pacchetto =corfu= fornisce un'interfaccia popup per il completamento
automatico all'interno del buffer. Concettualmente, è simile a quanto
avviene con il minibuffer, sebbene sia pensato per l'espansione del
testo all'interno di un file normale. Viene tipicamente utilizzato
nella programmazione. Ci sono ulteriori funzionalità che potrebbero
renderlo utile per le modalità di programmazione (in particolare, la
configurazione del Language Server Protocol), ma poiché queste
dipendono molto dalle esigenze specifiche di ciascun utente, qui
fornisco solo le funzionalità principali.

#+begin_src emacs-lisp :tangle no :results none
  (use-package corfu
    :ensure t
    :hook (after-init . global-corfu-mode)
    :bind (:map corfu-map ("<tab>" . corfu-complete))
    :config
    (setq tab-always-indent 'complete)
    (setq corfu-preview-current nil)
    (setq corfu-min-width 20)

    (setq corfu-popupinfo-delay '(1.25 . 0.5))
    (corfu-popupinfo-mode 1) ; shows documentation after `corfu-popupinfo-delay'

    ;; Sort by input history (no need to modify `corfu-sort-function').
    (with-eval-after-load 'savehist
      (corfu-history-mode 1)
      (add-to-list 'savehist-additional-variables 'corfu-history)))
#+end_src

** Impostazione per l'uso del Package:  dired
:PROPERTIES:
:ID:       030ddd93-aa42-4009-af1e-dc6e287de675
:END:

Emacs include un potente file manager integrato. Se ne parla a lungo in questo
video: [[https://protesilaos.com/codelog/2023-06-26-emacs-file-dired-basics/][Emacs: file and Dired basics]].

Le seguenti impostazioni definiscono alcune modifiche di base al comportamento
delle operazioni comuni di copia, ridenominazione ed eliminazione dei file.

La visualizzazione predefinita di =Dired= contiene molti dettagli (la
configurazione completa). Utilizziamo =dired-hide-details-mode= per
nasconderli. È possibile attivarli/disattivarli in qualsiasi momento con =M-x
dired-hide-details-mode=, che è associato al tasto =(= nei buffer di Dired.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; Load dired package
  (use-package dired
    :ensure nil
    :commands (dired)
    :hook
    ((dired-mode . dired-hide-details-mode)
     (dired-mode . hl-line-mode))
    :config
    (setq dired-recursive-copies 'always)
    (setq dired-recursive-deletes 'always)
    (setq delete-by-moving-to-trash t)
    (setq dired-dwim-target t))
#+end_src

Il pacchetto =dired-subtree= fornisce comandi per visualizzare rapidamente il
contenuto di una cartella utilizzando il tasto =TAB=.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  (use-package dired-subtree
    :ensure t
    :after dired
    :bind
    ( :map dired-mode-map
      ("<tab>" . dired-subtree-toggle)
      ("TAB" . dired-subtree-toggle)
      ("<backtab>" . dired-subtree-remove)
      ("S-TAB" . dired-subtree-remove))
    :config
    (setq dired-subtree-use-backgrounds nil))
#+end_src

** Impostazione per l'uso del Package:  trashed
:PROPERTIES:
:ID:       985ba7a1-8185-4b9a-b5c6-b98ee3b5f70a
:END:

In precedenza abbiamo configurato Dired per spostare i file eliminati nel
cestino di sistema. Il pacchetto =trashed= è quindi utile per fornire
un'interfaccia simile a Dired per quella cartella (funziona allo stesso modo di
Dired.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  (use-package trashed
    :ensure t
    :commands (trashed)
    :config
    (setq trashed-action-confirmer 'y-or-n-p)
    (setq trashed-use-header-line t)
    (setq trashed-sort-key '("Date deleted" . t))
    (setq trashed-date-format "%Y-%m-%d %H:%M:%S"))
#+end_src
** Impostazione per l'uso del Package:  savehist
:PROPERTIES:
:ID:       0f7172ff-ef2d-40b8-84b7-f0e66457720b
:END:

Il pacchetto integrato savehist tiene traccia degli input dell'utente e li
memorizza tra una sessione e l'altra. In questo modo, l'utente vedrà sempre le
sue ultime scelte in cima all'elenco (come con =M-x=).

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; Load savelist package
  (use-package savehist
    :ensure nil ; it is built-in
    :hook (after-init . savehist-mode))
#+end_src

I prompt del minibuffer possono avere una propria cronologia. In caso contrario,
condividono una cronologia comune degli input dell'utente. Emacs tiene traccia
di questa cronologia nella sessione corrente, ma la perde non appena la
chiudiamo. Con =savehist-mode= abilitata, tutte le cronologie del minibuffer
vengono scritte in un file e ripristinate al successivo avvio di Emacs.

Le storie sono utili in due modi:
- Le scelte più recenti compaiono in cima alla lista, così possiamo trovarle più
  facilmente.
- I comandi =M-p= (=previous-history-element=) e =M-n= (=next-history-element=)
  nel minibuffer saranno utili subito dopo il ripristino di Emacs (tutti i miei
  pacchetti sfruttano al meglio le cronologie del minibuffer per ogni prompt,
  quindi =M-p= e =M-n= mostrano solo i valori rilevanti).

Poiché stiamo già registrando la cronologia del minibuffer, possiamo istruirlo
=savehist-mode= a tenere traccia anche di variabili aggiuntive e a ripristinarle la
prossima volta che utilizziamo Emacs. Quindi =savehist-additional-variables=.

Si noti che l'opzione utente =history-length= si applica a ciascuna variabile della
cronologia singolarmente: non riguarda tutte le cronologie nel loro complesso.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;;;; `savehist' (minibuffer and related histories)
  (setq savehist-file (locate-user-emacs-file "savehist"))
  (setq history-length 100)
  (setq history-delete-duplicates t)
  (setq savehist-save-minibuffer-history t)
  (with-eval-after-load 'savehist
      (add-to-list 'savehist-additional-variables 'kill-ring))
  (savehist-mode 1)
#+end_src

** Impostazioni per l'uso delle  dynamic abbreviations  M-/      :@ToReview:
:PROPERTIES:
:ID:       d66bda07-4362-43fb-bfb0-45279cb3dab4
:END:

Il pacchetto integrato =dabbrev= fornisce un metodo di completamento del testo
che legge il contenuto di un buffer ed espande il testo davanti al cursore per
trovare possibili candidati. Questo viene fatto con =M-/= (=dabbrev-expand=) che
è ciò che uso più spesso per eseguire i completamenti in buffer.

Mi piace =dabbrev= perché è minimalista. Non genera popup né influisce sul
layout della finestra, permettendomi di concentrarmi su ciò che sto
facendo. Vorrei che avesse una funzione che consentisse di avviarlo e, in
qualsiasi momento, richiedere una presentazione completa in minibuffer di ciò
che sta cercando di trovare, invece di scorrere i candidati ripetutamente
=M-/=. Certo, di solito non scorro in questo modo, dato che in genere digito
abbastanza da trovare una corrispondenza esatta o essere a un =M-/= passo da
essa.

Oltre al =dabbrev-expand= comando, abbiamo =dabbrev-completion=. Non lo uso
perché non mi sembra naturale, mentre scrivo, fermarmi, controllare il
minibuffer per vedere se c'è del testo, selezionarlo e tornare a scrivere. Forse
questo dipende dal fatto che ho uno stile di scrittura senza interruzioni e
senza tornare immediatamente indietro a modificare ciò che ho scritto (a meno
che non stia facendo una dimostrazione, in cui lo spettatore deve seguire).

Il termine =dabbrev= sta per “dynamic abbreviations”. Emacs ha anche
[[id:3d430319-6637-4724-ab6b-d2960f279ce8][abbreviazioni statiche]] definite dall’utente.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;;;; `dabbrev' (dynamic word completion (dynamic abbreviations))
  (setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
  (setq dabbrev-abbrev-skip-leading-regexp "[$*/=~']")
  (setq dabbrev-backward-only nil)
  (setq dabbrev-case-distinction 'case-replace)
  (setq dabbrev-case-fold-search nil)
  (setq dabbrev-case-replace 'case-replace)
  (setq dabbrev-check-other-buffers t)
  (setq dabbrev-eliminate-newlines t)
  (setq dabbrev-upcase-means-case-search t)
  (setq dabbrev-ignored-buffer-modes '(archive-mode image-mode docview-mode pdf-view-mode))
#+end_src

** Impostazioni per l'uso delle  static abbreviations            :@ToReview:
:PROPERTIES:
:ID:       3d430319-6637-4724-ab6b-d2960f279ce8
:END:

[Vedi articolo/video relativo: [[https://protesilaos.com/codelog/2024-02-03-emacs-abbrev-mode/][Emacs: abbreviations with abbrev-mode]]]

A differenza delle [[id:d66bda07-4362-43fb-bfb0-45279cb3dab4][abbreviazioni dinamiche]] che dipendono dal testo già
disponibile in un buffer, possiamo definire abbreviazioni che si espandono
sempre in base a quanto specificato.

Le abbreviazioni, o il =abbrev= meccanismo, sono stringhe di caratteri che, una
volta digitate, vengono sostituite da un'altra stringa. Ad esempio, se voglio
digitare l'URL del mio sito web, inserisco mewebe continuo a digitare. Emacs
espanderà quella parola in https://protesilaos.com.

A meno che tu non stia documentando la funzione della tua abbreviazione o che tu
abbia abbreviazioni facili da digitare in modo errato, non avrai mai bisogno di
dire a Emacs di non espandere l'input fornito. Tieni presente che il comando
=unexpand-abbrev= è disponibile se ne hai bisogno. Ho dovuto usarlo nel paragrafo
precedente per digitare prima l'abbreviazione che ho usato come esempio.

Allo stesso modo, possiamo espandere un'abbreviazione ovunque con il comando
=expand-abbrev=, anche se normalmente non è necessario farlo perché avviene
automaticamente mentre digitiamo.

Emacs gestisce in modo intelligente la definizione e l'utilizzo delle
abbreviazioni. Ogni modalità principale ha la sua tabella di abbreviazioni, alla
quale aggiungiamo le nostre definizioni. Quando ci troviamo in un buffer che
utilizza quella modalità principale, otteniamo l'accesso alle abbreviazioni
corrispondenti. In =global-abbrev-table= è disponibile anche un'opzione per le
abbreviazioni. In caso di conflitto tra una tabella specifica per la modalità
principale e quella globale, la prima ha la precedenza. Inoltre, le tabelle di
abbreviazioni seguono lo stesso principio di ereditarietà delle modalità
principali in generale, il che significa che una modalità come Org erediterà
l'opzione =text-mode-abbrev-table= perché =org-mode= deriva da =text-mode=. Le
tabelle di abbreviazioni sono quindi coerenti con il funzionamento di hook e
mappature di tasti in termini di precedenza ed ereditarietà.

Come noterai più avanti, utilizzo la =prot-emacs-abbrev= macro per semplificare la
definizione di queste abbreviazioni. La maggior parte delle mie abbreviazioni
sono semplici modifiche alla maiuscola/minuscola. Tieni presente, tuttavia, che
il meccanismo sottostante è potente e può valutare codice Elisp arbitrario (ci
ho giocato un po', anche se non uso template e quindi non ne ho un reale
bisogno, ma funziona).

#+begin_src emacs-lisp :tangle  "~/.emacs.d/mnbfr-init.el"
  ;; -  ;;;; `abbrev' (Abbreviations, else Abbrevs)
  ;; -  ;; message-mode derives from text-mode, so we don't need a separate
  ;; -  ;; hook for it.
  ;; -  (prot-emacs-hook
  ;; -    (text-mode-hook prog-mode-hook git-commit-mode-hook)
  ;; -    abbrev-mode)
  ;; -  
  ;; -  (setq only-global-abbrevs nil)
  ;; -  
  ;; -  (prot-emacs-abbrev global-abbrev-table
  ;; -    "csico"   "CSiCo"
  ;; -    ";home"   "~"
  ;; -    ";tilde" "~")
  ;; -  
  ;; -  (prot-emacs-abbrev text-mode-abbrev-table
  ;; -    "asciidoc"       "AsciiDoc"
  ;; -    "auctex"         "AUCTeX"
  ;; -    "cafe"           "café"
  ;; -    "cliche"         "cliché"
  ;; -    "clojurescript"  "ClojureScript"
  ;; -    "emacsconf"      "EmacsConf"
  ;; -    "github"         "GitHub"
  ;; -    "gitlab"         "GitLab"
  ;; -    "javascript"     "JavaScript"
  ;; -    "latex"          "LaTeX"
  ;; -    "libreplanet"    "LibrePlanet"
  ;; -    "linkedin"       "LinkedIn"
  ;; -    "paypal"         "PayPal"
  ;; -    "sourcehut"      "SourceHut"
  ;; -    "texmacs"        "TeXmacs"
  ;; -    "typescript"     "TypeScript"
  ;; -    "visavis"        "vis-à-vis"
  ;; -    "deja"           "déjà"
  ;; -    "voila"          "voilà"
  ;; -    "youtube"        "YouTube"
  ;; -    ";up"            "🙃"
  ;; -    ";uni"           "🦄"
  ;; -    ";laugh"         "🤣"
  ;; -    ";smile"         "😀"
  ;; -    ";sun"           "☀️")
  ;; -  
  ;; -  ;; Allow abbrevs with a prefix colon, semicolon, or underscore.  I demonstrated
  ;; -  ;; this here: <https://protesilaos.com/codelog/2024-02-03-emacs-abbrev-mode/>.
  ;; -  (abbrev-table-put global-abbrev-table :regexp "\\(?:^\\|[\t\s]+\\)\\(?1:[:;_].*\\|.*\\)")
  ;; -  
  ;; -  (with-eval-after-load 'text-mode
  ;; -    (abbrev-table-put text-mode-abbrev-table :regexp "\\(?:^\\|[\t\s]+\\)\\(?1:[:;_].*\\|.*\\)"))
  ;; -  
  ;; -  (with-eval-after-load 'org
  ;; -    (prot-emacs-abbrev org-mode-abbrev-table
  ;; -  	";dev" "}"
  ;; -  	";key" #'prot-abbrev-org-macro-key
  ;; -  	";cmd" #'prot-abbrev-org-macro-key-command)
  ;; -    (abbrev-table-put org-mode-abbrev-table :regexp "\\(?:^\\|[\t\s]+\\)\\(?1:[:;_].*\\|.*\\)"))
  ;; -  
  ;; -  ;; Because the *scratch* buffer is produced before we load this, we
  ;; -  ;; have to explicitly activate the mode there.
  ;; -  (when-let* ((scratch (get-buffer "*scratch*")))
  ;; -    (with-current-buffer scratch
  ;; -  	(abbrev-mode 1)))
  ;; -  
  ;; -  ;; By default, abbrev asks for confirmation on whether to use
  ;; -  ;; `abbrev-file-name' to save abbrevations.  I do not need that, nor
  ;; -  ;; do I want it.
  ;; -  (remove-hook 'save-some-buffers-functions #'abbrev--possibly-save)
#+end_src


* \to File di configurazione di org-mode: *org-init.el*           :@ToReview:
:PROPERTIES:
:ID:       3a5bad5e-b492-4459-b863-ee15421eb5d8
:END:

Essendo un file di configurazione ausiliario, va caricato nel file =init.el=
come fatto [[id:0ab89109-24cb-445a-a913-e575bfb42a16][qui]].

Nella [[https://orgmode.org/org.html#Installation][guida di installazione]] di org è indicato che aggiornarlo durante l'uso
potrebbe comprometterlo. Per evitarlo l'aggiornamento lo tengo manuale secondo
questa procedura:
- chiudere emacs
- avviare emacs (magari in debug)
- nel buffer (non aprire nessun altro buffer) scratch inserie il seguente codice
  e valutarlo con il comando =C-j= o dal menu:
  #+begin_src emacs-lisp :tangle no :results none
    ;; aggiorno org:
    ;; - prima aggiorna le definizioni dei pacchetti
    ;; - infine aggiorna l'installazione di org
    (progn (package-refresh-contents) (package-upgrade 'org))
  #+end_src
- riavviare emacs e verificare la versione di org

** Attivazione di org
:PROPERTIES:
:ID:       71af7f69-5c51-4f36-85f9-d50d5b6bd2ad
:END:

Dal sito di riferimento di org: [[https://orgmode.org/][orgmode.org]] ricavo l'abilitazione del pacchetto:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Installazione
  (use-package org
      :ensure t)
  ;;
  ;; Imposto OrgMode come default per i file '*.org' e '*.org_archive'
  (add-to-list 'auto-mode-alist '("\\.\\(org\\|org_archive\\)$" . org-mode))
  ;; 
  ;; Attivazione pacchetto
  (require 'org)
#+end_src

** Impostazione per formato di default dei file: UTF-8
:PROPERTIES:
:ID:       dc2254e1-3881-4e5d-a153-9b1a6738599a
:END:

Oltre a quanto fatto [[id:d61b5760-4393-403d-a169-0d9da94db50a][prima]] imposto nello specifico il formato UTF8 per i file
org:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; default coding system  UTF-8
  (setq org-export-coding-system 'utf-8)
  (setq default-process-coding-system '(utf-8-unix . utf-8-unix))
#+end_src

** Imposto il pacchetto:  org-id
:PROPERTIES:
:ID:       20260531T154540.446558
:END:

Per poter usare gli id univoci, abilito l'uso del pacchetto org-id:

Org-id è una funzionalità integrata di Org Mode che assegna identificatori
univoci e permanenti a titoli o file specifici. Consente di creare collegamenti
ipertestuali permanenti e resilienti che continuano a funzionare anche se si
sposta, rinomina o archivia il file di destinazione.

Come si vede dal sito [[https://medium.com/@James86768479/org-id-org-attach-better-folder-names-3905f3841044][Org ID, Org Attach & Better Folder Names]] ricavo come
personalizzare =org-id= e =org-attach= per id più significativi:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Load org-id
  (require 'org-id)
  ;; 
  ;; Customize how IDs are generated (optional)
  ;; 'ts generates a timestamped ID,
  ;; 'uuid generates a random UUID (default)
  (setq org-id-method 'ts)
  ;;
  ;; Ordino anche le funzioni pe ril path:
  ;; La funzione UUID prende i primi due caratteri dell'UUID e crea una cartella
  ;; padre a partire da essi, mentre la funzione ts prende i primi sei cioè
  ;; l'anno e il mese.
  (setq org-attach-id-to-path-function-list
        '(org-attach-id-ts-folder-format org-attach-id-uuid-folder-format)
        )
  ;;
  ;; Dalla configurazione di org-super-links:
  (setq org-id-link-to-org-use-id 'create-if-interactive-and-no-custom-id)
#+end_src

Comandi essenziali

Una volta caricati, è possibile gestire gli ID utilizzando i seguenti comandi
interattivi:
- =M-x org-id-get-create= :: Assegna una proprietà :ID: univoca al titolo nel
  punto specificato (annidata all'interno di un riquadro :PROPERTIES:). Se
  esiste già un ID, lo lascia invariato.
- =M-x org-store-link= (=C-c l=) :: Mentre ci si trova su un titolo con un ID,
  questo comando memorizza un collegamento che punta specificamente a quell'ID.
- =M-x org-insert-link= (=C-c C-l=) :: Inserisce il collegamento ID
  precedentemente memorizzato nel documento, consentendo di assegnare un nome
  alla descrizione del collegamento.

** Imposto il pacchetto:  org-super-links
:PROPERTIES:
:ID:       20260531T154957.127764
:END:
:RELATED:
[2026-05-31 dom 16:28] -> [[id:89b37a37-0f9b-42f6-9afa-bbe3648a04df][Impostazione per directory con il codice lisp custom:]]
:END:

Dai reference [[https://github.com/toshism/org-super-links][GitHub]], [[https://karl-voit.at/2020/07/22/org-super-links/][Karl Voit article]], [[https://writequit.org/articles/emacs-org-mode-generate-ids.html][Lee Hinman article]]

L'idea generale è quella di creare link con backlink automatici. In poche
parole, questo pacchetto automatizza la creazione di ID org, il loro
collegamento a un'intestazione org e la creazione di un backlink da tale
intestazione a quella che si collega da essa.

Mi basta cercare l'intestazione a cui voglio collegarmi e tutto viene creato
automaticamente: un ID per l'intestazione in cui mi trovo, un ID per
l'intestazione a cui mi sto collegando, un link che punta a quell'ID nel mio
marcatore e un backlink nell'intestazione a cui mi sto collegando che punta
all'intestazione in cui mi trovo.

Nel post, Hinman spiega che se si utilizzano gli ID nel file org, si otterrà un
vantaggio anche durante l'esportazione in un file HTML: i link di intestazione
utilizzati punteranno alla posizione desiderata, anche dopo aver spostato le
intestazioni.

Per ora non vi è un pacchetto ELPA, quindi bisogna scaricare i file
=org-super-links.el=, =org-super-links-org-ql.el=,
=org-super-links-org-rifle.el= e metterli nella cartella di [[id:89b37a37-0f9b-42f6-9afa-bbe3648a04df][custom lisp]] in modo
che siano caricati all'avvio di emacs.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  (use-package org-super-links
    :bind (
  	 ("C-c s s" . org-super-links-link)
  	 ("C-c s l" . org-super-links-store-link)
  	 ("C-c s C-l" . org-super-links-insert-link)
  	 ("C-c s d" . org-super-links-quick-insert-drawer-link)
           ("C-c s i" . org-super-links-quick-insert-inline-link)
           ("C-c s C-d" . org-super-links-delete-link)
  	 )
    :config (
  	   setq org-super-links-related-into-drawer t
  		org-super-links-link-prefix 'org-super-links-link-prefix-timestamp)
  )
#+end_src

*** Utilizzo:
:PROPERTIES:
:ID:       20260531T161241.670404
:END:

Si può semplicemente usarlo in sostituzione del collegamento Org:

Usalo esattamente come useresti i normali link org. Invece di chiamare
=org-store-link= chiama =org-super-links-store-link= (=C-c s l=). Quindi per
inserire il link invece di =org-insert-link= chiama
=org-super-links-insert-link= (=C-c s C-l=). Questo inserirà un link normalmente
aggiungendo anche un backlink alla destinazione del link. Questo dovrebbe
funzionare allo stesso modo dei normali link org, con il vantaggio di aggiungere
il backlink.

** Imposto la visibilità iniziale di default: 
:PROPERTIES:
:ID:       e51a0604-d2d1-486e-ad56-20103e765ebd
:END:

Imposto la visibilità iniziale a tutto ragruppato per velocizzare la vista
dall'alto.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Visibilità iniziale: tutto ragruppato
  (setq org-startup-folded t)
#+end_src

Questo comportamento generale, si può modificare per ciascun file e per ciascun
header come esplicitato nei seguenti paramgrafi:

*** Opzione STARTUP
:PROPERTIES:
:ID:       a7ee76d6-6600-48f2-80a4-b641d9b711ce
:END:

Per cambiare il raggruppamento iniziale, di un intero file, utilizzare
sull'opzione *STARTUP* uno dei seguenti valori:
- overview :: Mostra solo i titoli di primo livello (tutto il resto è
  raggruppato).
- content :: Mostra tutti i titoli di tutti i livelli, ma nasconde il testo.
- nofold o showall :: Mostra tutto il file completamente espanso (testo
  incluso).
- show2levels fino a show5levels :: Espande i titoli fino al livello numerato
  indicato.
- showeverything :: Mostra assolutamente tutto, inclusi i cassetti nascosti
  (drawers).

Mentre per la visibilità dei singoli headline, si utilizza il parametro
*VISIBILITY*

*** Parametro VISIBILITY
:PROPERTIES:
:ID:       df2a6f58-5a41-4a47-a0cf-70ff934db8d4
:END:

Per cambiare la visibilità iniziale di un headline si utilizza la propietà
*VISIBILITY*:
- folded :: Mantiene il titolo completamente raggruppato (utile se il resto del
  file è impostato per aprirsi espanso).
- children :: Mostra solo i sotto-titoli diretti di quel livello, ma nasconde il
  loro testo interno e i sotto-titoli ancora più profondi.
- content :: Mostra tutti i sotto-titoli di qualsiasi livello appartenenti a
  quel ramo, ma nasconde tutto il testo.
- all :: Espande completamente l'intero ramo (mostra tutti i sotto-titoli e
  tutto il testo).

Questa va a sovrascrivere l'eventuale impostazione fatta a livello di file con
l'opzione *STARTUP* o quella generale.

** KeyBinding                                           :@Missing:@ToReview:
:PROPERTIES:
:ID:       25b3bfad-98e3-4f30-9ecb-89323e8e263b
:END:

*** Funzioni generali:
:PROPERTIES:
:ID:       0c1d8fea-d006-41da-a185-5c4505298c54
:END:

Impostiamo alcuni dei key binding di default:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;;(global-set-key (kbd "C-c l") 'org-store-link)
  (global-set-key (kbd "C-c a") 'org-agenda)
  (global-set-key (kbd "C-c c") 'org-capture)
#+end_src

*** Tasti funzione:                                             :@ToReview:
:PROPERTIES:
:ID:       505d9c55-8ba2-45b0-964b-edc3f9e2e9e0
:END:

Analisi dei tasti funzioni disponibili:

| Key       | Binding originale            | My Bingind                            |
|-----------+------------------------------+---------------------------------------|
| <F2>      | Divide schermo verticalmente |                                       |
| S-<F2>    | Divide schermo verticalmente |                                       |
| C-<F2>    | Non Definito                 |                                       |
| M-<F2>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F1>      | Show Help                    |                                       |
| S-<F1>    | Show Help                    |                                       |
| C-<F1>    | Non Definito                 |                                       |
| M-<F1>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F3>      | Defining kbd macro...        |                                       |
| S-<F3>    | Defining kbd macro...        |                                       |
| C-<F3>    | Non Definito                 |                                       |
| M-<F3>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F4>      | Excute macro                 |                                       |
| S-<F4>    | ???                          |                                       |
| C-<F4>    | Non Definito                 |                                       |
| M-<F4>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F5>      | Non Definito                 |                                       |
| S-<F5>    | Non Definito                 |                                       |
| C-<F5>    | Non Definito                 |                                       |
| M-<F5>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F6>      | Non Definito                 |                                       |
| S-<F6>    | Non Definito                 |                                       |
| C-<F6>    | Non Definito                 |                                       |
| M-<F6>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F7>      | Non Definito                 |                                       |
| S-<F7>    | Non Definito                 |                                       |
| C-<F7>    | Non Definito                 |                                       |
| M-<F7>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F8>      | Non Definito                 |                                       |
| S-<F8>    | Non Definito                 |                                       |
| C-<F8>    | Non Definito                 |                                       |
| M-<F8>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F9>      | Non Definito                 | Visualizza tutto                      |
| S-<F9>    | Non Definito                 | Visualizza solo ramo attuale          |
| C-<F9>    | Non Definito                 | Nascondi ramo attuale                 |
| M-<F9>    | Non Definito                 |                                       |
|-----------+------------------------------+---------------------------------------|
| <F10>     | Passa il focus al menu       |                                       |
| S-<F10>   | Passa il focus al menu       |                                       |
| C-<F10>   | Passa il focus al sottomenu  |                                       |
| M-<F10>   | Vista Intero/Finestra        |                                       |
|-----------+------------------------------+---------------------------------------|
| <F11>     | Vista Intero/Finestra        | Vis. dove c'è il clock attivo         |
| S-<F11>   | Vista Intero/Finestra        | Fa partire il clock di timing         |
| C-<F11>   | Non Definito                 | Termina il clock di timing            |
| M-<F11>   | Non Definito                 | ex Org manage per navigare fra i file |
|-----------+------------------------------+---------------------------------------|
| <F12>     | Non Definito                 | Apre agenda (C-c a)                  |
| S-<F12>   | Non Definito                 | Aprire subito Trash.org               |
| C-<F12>   | Non Definito                 | Aprire subito InBox.org               |
| M-<F12>   | Non Definito                 | Aprire subito Mrk.org                 |
| C-S-<F12> | Non Definito                 | Pubblicazione file org                |
|-----------+------------------------------+---------------------------------------|

Cioè voglio queste funzionalità:
- *F9* - /Visibilità/ -  per la visibilità sul file
- *F11* - /Loggin Work/ - per la gestione del log dei tempi
- *F12* - /Navigazione/ - per la navigazione fra i file (e la pubblicazione per compatibilità)
    
Questi binding vengono quindi così configurati:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Key F9 dedicato alle viste
  (global-set-key (kbd   "<f9>") 'widen)
  (global-set-key (kbd "C-<f9>") 'MRK/hide-other)
  (global-set-key (kbd "S-<f9>") 'narrow-to-region)
  ;; Key F11 dedicato ai timer
  (global-set-key (kbd   "<f11>") 'org-clock-goto)
  (global-set-key (kbd "C-<f11>") 'org-clock-in)
  (global-set-key (kbd "S-<f11>") 'org-clock-out)
  ;; (global-set-key (kbd "M-<f11>") 'org-manage )
  ;; Key F12 dedicato ai file
  (global-set-key (kbd     "<f12>") 'org-agenda)
  (global-set-key (kbd   "S-<f12>") (lambda() (interactive)(find-file "~/Doc/Trash/Trash.org")))
  (global-set-key (kbd   "C-<f12>") (lambda() (interactive)(find-file "~/Doc/Org/InBox.org")))
  (global-set-key (kbd   "M-<f12>") (lambda() (interactive)(find-file "~/Doc/Org/Private/MRK.org")))
  (global-set-key (kbd "C-S-<f12>") 'MRK/save-then-publish)
#+end_src

**** To Review:
:PROPERTIES:
:ID:       c228fc57-6d02-4e38-9fff-42b8102958cb
:END:

  Verificare come posso sfruttare i segnalibri per navigare fra i file:
  : C-x r m     bookmark-set       Imposta un segnalibro. Utile nelle ricerche
  : C-x r b     bookmark-jump      Salta ad un segnalibro.

  Come riepilogato nella [[https://www.emacswiki.org/emacs/BasicNarrowing][wiki]] i comandi base per narrowing/widen (narrow=stringere
  widen=allargare) in emacs sono:
  - C-x n n /narrow-to-region/ :: Visualizza solo il testo selezionato, e nasconde
	   tutto il resto.
  - C-x n w /widen/ :: Visualizza tutto il testo del buffer
  - C-x n p /narrow-to-page/ :: Visualizza solo il testo dal cursore a fine pagina.
  - C-x n d /narrow-to-defun/ :: Visualizza solo il testo tramite le [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Defuns.html#Defuns][Defun]].
  Naturalmente il testo nascosto non è più accessibile per le modifiche dal buffer
  fino a che non si rivisualizza (widen) però rimane gestito, quindi salvando il file
  lo mantiene ecc...
  
  Org-mode ha i seguenti modi per cambiare la visibilità del testo nel buffer:
  - C-c / /org-sparse-tree/ :: This prompts for an extra key to select a sparse-tree
	   creating command.

           

  Impostiamo il tasto F11 per iteragire con i timer ed il log delle ore e quindi
  devo pensare a come fare le seguenti cose:
  - avviare il log del task: Clock in
  - fermare un log del task: Clock out
  - fare il report dei log: ?
  - stimare il tempo di un task
  - modificare la stima di un task
  - mostrare stima e log di un task in forma colonne
  - navigare fra i task loggati (la ring relativa)




    Mentre imposto anche questi miei key binding custom:
    #+begin_src emacs-lisp :tangle no
      ;; Vecchio binding solo per reference:
      ;;(global-set-key (kbd "<f12>") 'org-agenda)
      ;;(global-set-key (kbd "<f5>") 'bh/org-todo)
      ;;(global-set-key (kbd "<S-f5>") 'bh/widen)
      ;;(global-set-key (kbd "<f7>") 'bh/set-truncate-lines)
      ;;(global-set-key (kbd "<f8>") 'org-cycle-agenda-files)
      ;;(global-set-key (kbd "<f9> <f9>") 'bh/show-org-agenda)
      ;;(global-set-key (kbd "<f9> b") 'bbdb)
      ;;(global-set-key (kbd "<f9> c") 'calendar)
      ;;(global-set-key (kbd "<f9> f") 'boxquote-insert-file)
      ;;(global-set-key (kbd "<f9> g") 'gnus)
      ;;(global-set-key (kbd "<f9> h") 'bh/hide-other)
      ;;(global-set-key (kbd "<f9> n") 'bh/toggle-next-task-display)
      ;;(global-set-key (kbd "<f9> I") 'bh/punch-in)
      ;;(global-set-key (kbd "<f9> O") 'bh/punch-out)
      ;;(global-set-key (kbd "<f9> o") 'bh/make-org-scratch)
      ;;(global-set-key (kbd "<f9> r") 'boxquote-region)
      ;;(global-set-key (kbd "<f9> s") 'bh/switch-to-scratch)
      ;;(global-set-key (kbd "<f9> t") 'bh/insert-inactive-timestamp)
      ;;(global-set-key (kbd "<f9> T") 'bh/toggle-insert-inactive-timestamp)
      ;;(global-set-key (kbd "<f9> v") 'visible-mode)
      ;;(global-set-key (kbd "<f9> l") 'org-toggle-link-display)
      ;;(global-set-key (kbd "<f9> SPC") 'bh/clock-in-last-task)
      ;;(global-set-key (kbd "C-<f9>") 'previous-buffer)
      ;;(global-set-key (kbd "M-<f9>") 'org-toggle-inline-images)
      ;;(global-set-key (kbd "C-x n r") 'narrow-to-region)
      ;;(global-set-key (kbd "C-<f10>") 'next-buffer)
      ;;(global-set-key (kbd "<f11>") 'org-clock-goto)
      ;;(global-set-key (kbd "C-<f11>") 'org-clock-in)
      ;;(global-set-key (kbd "C-<f12>") 'MRK/save-then-publish)
    #+end_src

** Tasks and States                                     :@Missing:@ToReview:
:PROPERTIES:
:ID:       9d0866dc-6d43-416b-829e-3959e3f0eef7
:END:

Imposto come parole chiavi per i ToDo i seguenti codici:
| key     | Descr                    |
|---------+--------------------------|
| TODO    | Task da fare             |
| NEXT    | Task in esecuzione       |
| DONE    | Task terminato           |
| WAITING | Task in attesa           |
| HOLD    | Task Bloccato            |
| ABORT   | Task Abortito(Cancellato |
| PHONE   | Telefonata               |
| MEETING | Meeting                  |

e corrisponde al seguente schema:

#+begin_src plantuml :file ~/Pub/.Tmp/Img/org-init.el_task_states.png :cache yes :tangle no
  title Task States
  [*] -> TODO
  TODO -> NEXT
  TODO -> DONE
  NEXT -> DONE
  DONE -> [*]
  TODO --> WAITING
  WAITING --> TODO
  NEXT --> WAITING
  WAITING --> NEXT
  HOLD --> CANCELLED
  WAITING --> CANCELLED
  CANCELLED --> [*]
  TODO --> HOLD
  HOLD --> TODO
  TODO --> CANCELLED
  TODO: t
  NEXT: n
  DONE: d
  WAITING:w
  note right of WAITING: Note records\nwhat it is waiting for
  HOLD:h
  note right of CANCELLED: Note records\nwhy it was cancelled
  CANCELLED:c
  WAITING --> DONE
#+end_src

per le chiamate:

#+begin_src plantuml :file ~/Pub/.Tmp/Img/org-init.el_phone_states.png :cache yes :tangle no
  title Phone Call Task State
  [*] -> PHONE
  PHONE -> [*]
#+end_src

per i meeting:

#+begin_src plantuml :file ~/Pub/.Tmp/Img/org-init.el_meeting_states.png :cache yes :tangle no
  title Meeting Task State
  [*] -> MEETING
  MEETING -> [*]
#+end_src

Per ciacuno di essi, definisco anche la lettera di abbreviazione per
l'inserimento veloce

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Task keywords definitions:
  (setq org-todo-keywords
    (quote (
      (sequence "TODO(t)" "NEXT(n)" "|" "DONE(d)")
      (sequence "WAITING(w@/!)" "HOLD(h@/!)" "|" "ABORT(a@/!)" "PHONE" "MEETING")
      )
    )
  )
#+end_src

Per ciascuna keyword posso personalizzare il faceplate, ma per ora non lo
faccio.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; -  ;; Task keywords colour settings:
  ;; -  (setq org-todo-keyword-faces (quote (
  ;; -  	("TODO"      :foreground "red"          :weight bold)
  ;; -  	("NEXT"      :foreground "blue"         :weight bold)
  ;; -  	("DONE"      :foreground "forest green" :weight bold)
  ;; -  	("WAITING"   :foreground "orange"       :weight bold)
  ;; -  	("HOLD"      :foreground "magenta"      :weight bold)
  ;; -  	("ABORT"     :foreground "forest green" :weight bold)
  ;; -  	("MEETING"   :foreground "forest green" :weight bold)
  ;; -  	("PHONE"     :foreground "forest green" :weight bold)
  ;; -  )))
#+end_src

Ai tipi di ToDo, associo anche in modo automatico dei tag per facilitare filtri
o ricerche:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Triggers that automatically assign tags to tasks based on state changes:
  (setq org-todo-state-tags-triggers (quote (
	  ("ABORT" ("ABORT" . t))
	  ("WAITING" ("WAITING" . t))
	  ("HOLD" ("WAITING") ("HOLD" . t))
	  (done ("WAITING") ("HOLD"))
	  ("TODO" ("WAITING") ("ABORT") ("HOLD"))
	  ("NEXT" ("WAITING") ("ABORT") ("HOLD"))
	  ("DONE" ("WAITING") ("ABORT") ("HOLD"))
  )))			
#+end_src

Abilito la selezione veloce delle keyword tramite il comando
: C-c C-t Keyword

Inoltre abilito lo switch fra le keyword tramite i comandi
: S-left
: S-right

senza però che si attivino le annotazioni automatiche.

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Fast todo selection allows changing from any task todo state to any other state directly by selecting the appropriate key from the fast todo selection key menu.
  ;; The relative command is:  C-c C-t KEY   where KEY is the appropriate fast todo state selection key as defined in org-todo-keywords.
  (setq org-use-fast-todo-selection t)
  ;;
  ;; Cycles through the todo states with S-left and S-right, but skips setting timestamps and entering notes
  (setq org-treat-S-cursor-todo-selection-as-state-change nil)
#+end_src

** Tags                                                           :@Missing:
:PROPERTIES:
:ID:       85effced-97fd-4e2f-ac89-3e16a4931461
:END:

Imposto i tag generali in uso

** Setup org-capture                                             :@Missing:
:PROPERTIES:
:ID:       ad8d08bc-66b4-4f16-b8c2-d5478a77ac4b
:END:

Imposto i form di cattura veloce

Per ora uso quelli di default. Da approfondire anche la modalità a promt in cui
chiede via via le info da riportare sul template.

Per ora ho approfondito questi template:
- Journal :: per fare una nuova entry sul ramo =Journal= del file InBox.org.

  In particolare:
  - Come struttura del ramo, utilizzo la divisione mensile
  - Abilito il clocking in modo da tenere traccia di quanto ci metto
    inserirla. =@ToReview= devo integrare la funzione che elimina i logbook con
    tempi sotto al minuto per evitare dispersione.
  - Nell'ultima riga inserisco fra parentesi quadre il timestamp di quando è
    creata l'entry. Non mostro più i link da dove è stata fatta perchè no so se
    li userò mai, e attualmente mi danno problemi nell'esportazione. Cioè
    utilizzo =[ Entered on %U ]= invece che la completa =[ Entered on %U from
    %i\n%a ]]=.

La configurazione complessiva è quindi:
#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  (setq org-capture-templates
        '(
  	("n" "Note"
  	  entry (file+headline "~/Doc/Org/InBox.org" "Notes")
  	  "* %?\n[ Entered on %U ]"
  	  :clock-in 
  	  :clock-keep 
  	  :empty-lines-before 1
  	  :empty-lines-after 0	  
  	  )

  	("t" "Todo"
  	  entry (file+headline "~/Doc/Org/InBox.org" "Tasks")
  	  "* TODO %?\n[ Entered on %U ]"
  	  :clock-in 
  	  :clock-keep 
  	  :empty-lines-before 1
  	  :empty-lines-after 0	  
  	  )
  	
  	("j" "Journal" 
  	  entry (file+datetree "~/Doc/Org/InBox.org" "Journal") 
  	  "* %?\n[ Entered on %U ]" 
  	  :clock-in 
  	  :clock-keep 
  	  :tree-type month  ; day week month list
  	  :empty-lines 0
  	  )
  	
  	)
        )
#+end_src

** Refil                                                           :@Missing:
:PROPERTIES:
:ID:       2ddc606d-7a12-488c-9237-462c76e115c7
:END:

Imposto il refill per ricollocare al volo gli header.

;;    ** Correzione Refil:
;;       Il refil non funziona più, non mi permette di cambiare file, per ovviare, ho visto il
;;       sito [[https://blog.aaronbieber.com/2017/03/19/organizing-notes-with-refile.html][Organizing Notes With Refile]] che mi dà questa ocnfigurazione:
;;       #+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
;;         ;; I want to be able to move a node to any of my agenda files,
;;         ;; and I also want to consider nodes up to three levels deep.
;;         (setq org-refile-targets '((org-agenda-files :maxlevel . 3)))
;;         ;; Refile to the Top Level
;;         (setq org-refile-use-outline-path 'file)
;;         ;; But, if you use Helm, which you really should, you will notice that as soon 
;;         ;; as you set this option, your target list contains only one filename. Typing 
;;         ;; to complete may allow you to find another filename within your agenda files, 
;;         ;; but you will only ever see a filename; no other headings ever appear! 
;;         ;; Why is that?!
;;         ;; It took a bit of searching to find this solution. This is because the 
;;         ;; default behavior for Refile is to allow you to do a step-by-step completion 
;;         ;; of this path, but if you’re using Helm, Helm is overriding the completing 
;;         ;; read to make it into a narrowing list (that we have all come to love).
;;         ;; So what you need to do is tell Org that you don’t want to complete in steps;
;;         ;; you want Org to generate all of the possible completions and present them at 
;;         ;; once. Helm then lets you narrow to the one you want.
;;         (setq org-outline-path-complete-in-steps nil)
;;         ;; Creating New Parents
;;         (setq org-refile-allow-creating-parent-nodes 'confirm)
;;       #+end_src
;;       Altro sito interessante, che ho trovato dopo: [[https://yiming.dev/blog/2018/03/02/my-org-refile-workflow/][My org-refile workflow]]

** org-protocol                                                    :@Missing:
:PROPERTIES:
:ID:       ce081403-fafc-4288-bcd5-0bdbb12b389b
:END:

Imposto org protocol per interagire con altri programmi

** Agenda                                                          :@Missing:
:PROPERTIES:
:ID:       7d3d32f2-8708-4d1e-bbe1-0b12223eec3b
:END:

[ In realtà voglio cambiar emetodo ed usare Inbox per tutto fino a quando posso
archiviare un lavoro su apposito file clienti o personale. L'agenda avrà solo
file InBox ed eventualmente un file tipo diario o simile, mentre tutti i file
dedicati a lavori e personali non vanno in agenda, perchè hanno solo info
statiche. ]

Per l'aggenda in primo acchitto utilizzo i file in cui lavoro, quindi utilizzerò
i file:
- Inbox.org:  Per tutti i task su cui sto lavorando e che quindi avranno sicuramente
  ToDo o lavori schedulati.
- Diary.org:  Per tutti i task ripetitivi o prevedibili tipo compleanni o altro o
  scadenze future (assicurazione, dividendi degli investimenti ecc...)
- KnowHow: Per tutti i file con le mie note, sopratutto per le ricerche in base ai tag
- Private: Per i miei lavori privati, in particolare prevedo vi saranno soprattutto
  task ripetitivi, perchè gestendo i lavori correnti con il Inbox.org, sulla cartella
  resteranno pochi task Todo o schedulati.
- Work: Per i miei lavori, in particolare prevedo vi saranno soprattutto task
  ripetitivi, perchè gestendo i lavori correnti con il Inbox.org, sulla cartella
  resteranno pochi task Todo o schedulati.
#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; File gestiti dall'agenda:
  (if (boundp 'org-user-agenda-files)
    (setq org-agenda-files org-user-agenda-files)
    (setq org-agenda-files ( quote (
  				   "~/Doc/Org/Diary.org"
  				   "~/Doc/Org/InBox.org"
  				   "~/Doc/Org/KnowHow"
  				   "~/Doc/Org/Private"
  				   "~/Doc/Org/Work"
  				 )
  			 )
    )
  )
#+end_src

** Time Clocking, Reporting, Tracking, Estimate                    :@Missing:
:PROPERTIES:
:ID:       0131267e-b953-4d6d-98a3-e537aae257d8
:END:

Dal manuale, si ricavano i seguenti comandi per la retentività dei clock:
#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  (setq org-clock-persist 'history)
  (org-clock-persistence-insinuate)
#+end_src

Voglio che il pulsante F9 sia dedicato al clock e quindi le varie comandi:
- org-clock-goto va al clock in corso (F9)
    
** GTD stuff (Project & Archiving)                                 :@Missing:
:PROPERTIES:
:ID:       28bc92a7-f8c7-4f63-86a9-784fb55c303a
:END:

Imposto i set per usare GTD ed eventualmente projetile e treemacs

** Reminders                                                      :@Missing:
:PROPERTIES:
:ID:       93a4b11c-616e-4bfd-bf48-963e33b1a4ae
:END:

Imposto i remainder e come utilizzarli.

** Publishing and Exporting                                      :@ToReview:
:PROPERTIES:
:ID:       97c3d76c-138f-48e8-b698-fa3bbe74565c
:END:

Impostazioni generali utili per l'esportazione (anche del singolo file):

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Alphabetical listing options need to be set before the exporters are loaded for filling to work correctly
  (setq org-alphabetical-lists t)
  ;;
  ;; Explicitly load required exporters
  (require 'ox-html)
  (require 'ox-latex)
  (require 'ox-ascii)
  (require 'ox-md)
  (require 'ox-texinfo)
  ;; 
  ;; Imposto dove trovare Ditaa (Corretto il setup di Ditaa in base alla discussione del forum: http://thread.gmane.org/gmane.emacs.orgmode/27859/focus=27864)
  (setq org-ditaa-jar-path "~/.MyCfg/emacs/AddOn/app/ditaa0_9.jar")
  ;; 
  ;; Imposto dove trovare PlantUML (http://plantuml.sourceforge.net/faq.html)
  (setq org-plantuml-jar-path "~/.MyCfg/emacs/AddOn/app/plantuml-1.2023.1.jar")
#+end_src

Imposto Babel:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Org-babel Setup:
  ;; 
  ;; Imposto di mostrare l'immagine:
  (add-hook 'org-babel-after-execute-hook 'org-display-inline-images)
  ;(add-hook 'org-babel-after-execute-hook 'bh/display-inline-images 'append)
  ;;
  ;; Make babel results blocks lowercase
  (setq org-babel-results-keyword "results")
  ;; 
  ;; Imposto quali linguaggi caricare:                    Per Problema a Ditaa sto studianto: http://thread.gmane.org/gmane.emacs.orgmode/27859/focus=27864
  (org-babel-do-load-languages
     (quote org-babel-load-languages)
     (quote (
	; (asymptote . t)
	; (awk . t)
	; (C . t)
	; (calc . t)
	; (clojure . t)
	; (comint . t)
	; (core . t)
	; (csharp . t)
	; (css . t)
	(ditaa . t)
	(dot . t)
	(emacs-lisp . t)
	; (eval . t)
	; (exp . t)
	; (fortran . t)
	; (gnuplot . t)
	; (haskell . t)
	; (io . t)
	; (java . t)
	; (js . t)
	; (keys . t)
	; (latex . t)
	; (ledger . t)
	; (lilypond . t)
	; (lisp . t)
	; (lob . t)
	; (makefile . t)
	; (matlab . t)
	; (maxima . t)
	; (mscgen . t)
	; (ocaml . t)
	; (octave . t)
	(org . t)
	; (perl . t)
	; (picolisp . t)
	(plantuml . t)
	; (python . t)
	; (R . t)
	; (ref . t)
	; (ruby . t)
	; (sass . t)
	; (scala . t)
	; (scheme . t)
	; (screen . t)
	; (sh . t)
	; (shell . t)
	; (shen . t)
	; (sql . t)
	; (sqlite . t)
	; (table . t)
	; (tangle . t)
  )))
  ;;
  ;; Do not prompt to confirm evaluation
  ;; This may be dangerous - make sure you understand the consequences
  ;; of setting this -- see the docstring for details
  (setq org-confirm-babel-evaluate nil)
  ;;
  ;; Use fundamental mode when editing plantuml blocks with C-c '
  (add-to-list 'org-src-lang-modes (quote ("plantuml" . fundamental)))
  ;; 
#+end_src

Altro sull'esportazione:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Inline images in HTML instead of producting links to the image
  (setq org-export-html-inline-images t)
  ;;; Disabilita la visualizzazione delle immagini per evitare errori nelle sessioni ssh
  ;(setq org-startup-with-inline-images nil)
  ;;
  ;; Inline images in HTML instead of producting links to the image
  (setq org-html-inline-images t)
  ;;
  ;; Do not use sub or superscripts - I currently don't need this functionality in my documents
  ;(setq org-export-with-sub-superscripts nil)
  ;;
  ;		;; Usa foglio di stile locale:  Preferisco caricarlo dal file template
  ;		(setq org-html-head-extra "<link rel=\"stylesheet\" href=\"file://C:/_Home/Pub/.Styles/norang/doc.norang.ca_org.css\" type=\"text/css\" />")
  ;		(setq org-html-head-include-default-style nil)
  ;		;;
  ;		;; Do not generate internal css formatting for HTML exports
  ;		(setq org-export-htmlize-output-type (quote css))
  ;;
  ;; Disabilita lo stile di default:
  (setq org-export-html-style-include-default nil)
  ;;
  ;; Export with LaTeX fragments
  (setq org-export-with-LaTeX-fragments t)
  ;;
  ;; For export to latex I use the following setting to get fontified listings from source blocks: 
  (setq org-export-latex-listings t)
  ;; 
  ;; Fontify Latex listings for source blocks
  (setq org-latex-listings t)
  ;; 
  ;; Rimuovo l'header XML per problemi di compatibilità con open office
  (setq org-html-xml-declaration (quote (
      ("html" . "")
      ("was-html" . "<?xml version=\"1.0\" encoding=\"%s\"?>")
  ("php" . "<?php echo \"<?xml version=\\\"1.0\\\" encoding=\\\"%s\\\" ?>\"; ?>")
  )))
  ;; 
  ;; Permetto in automatico l'override delle variabili di personalizzazione dell'esportazione
  (setq org-export-allow-BIND t)
  ;;
  ;;
#+end_src

Infine definisco il progetto di esportazione:

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  ;; Progetti per l'esportazione automatica:
  ;;   OrgData	- Esportazione di tutti i file in OrgData
  (setq org-publish-project-alist (quote (
      ;; Progetti nell'esportazione dei file Org:
      ;;  - orgFile are the org-files that generate the content
      ;;  - imgFile are images and css files that need to be included
      ;;  - OrgData is the top-level project that gets published
      ("orgFile"
	:base-directory "~/Doc/Org"
	:publishing-directory "~/Pub"
	:recursive t
	:section_numbers nil
	:table-of-contents nil
	:base-extension "org"
	:publishing-function org-html-publish-to-html
	:auto-index t
	:index-filename "Index.org"
	:index-title "Indice del materiale Org-Mode"
	:index-function org-publish-org-index
	:author-info t
	:creator-info t
	:auto-sitemap t
	:sitemap-filename "MySiteMap.org"
	:html-head-extra "<!-- Start Favicon e style per il sitemap -->\n<link rel=\"stylesheet\" type=\"text/css\" href=\"file://C:/_Home/Pub/.Styles/solarized-css/solarized-dark.css\"/>\n<link rel=\"icon\" type=\"image/x-icon\" href=\"file://C:/_Home/Pub/.Res/Img/CSiCo_favicon.ico\">\n<!-- End Favicon e style per il sitemap -->"
	:sitemap-title "Indice del materiale esportato in html")
      ("imgFile"
	:base-directory "~/Doc/Org"
	:publishing-directory "~/Pub"
	:base-extension "css\\|pdf\\|png\\|jpg\\|gif\\|txt"
	:publishing-function org-publish-attachment
	:recursive t
	:author nil)
      ("OrgData"
	:components ("orgFile" "imgFile"))
  )))
#+end_src

*** Template per le esportazioni                                :@ToReview:
:PROPERTIES:
:ID:       06b5f61b-2c88-4a72-ad1b-124d1ba4db3c
:END:

Oltre atutti gli altri template di esportazione, i più belli finora trovati sono:
- ToPrintStyle.css :: per esportare in html e poi stamparlo
- ox-twbs :: per esportare in un PDF elegante, sobrio e con il TOC laterale.

;;    ** Inserito ox-twbs: exporting to HTML with a Twitter Bootstrap theme
;;       Da [[https://github.com/marsmining/ox-twbs][GITHub]] ricavato l'esporter per esportare i file org, come documenti HTML compatibili
;;       con il [[http://getbootstrap.com/][Twitter Bootstrap]].
;;       #+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
;;         (use-package ox-twbs
;;           :ensure t)
;;       #+end_src



;; Export org-mode theme
;;    * Export org-mode theme
;;      In ~/.MyCfg/emacs/templates inserisco le definizioni dei themi da utilizzare con
;;      l'esportazione da org; mentre in ~/Pub/.Styles inserisco le relative risorse (css, js,
;;      ecc...) che sono necessarie per caricare localmente il tema. Quando possibile mantengo
;;      nelle definizioni sia il setup per i riferimenti locali (per mio utilizzo locale), sia
;;      il setup con i riferimenti remoti in modo che il file sia visibile da tutti (per
;;      utilizzo di altri).
;;    
;;      In particolare al 2020/04 ho impostato due themi principali, mentre al 2020/06 ho
;;      introdotto altri themi, per arrivare ai seguenti che riassumo brevemente nella forma
;;      locale:
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/norang/norang_local.org
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-bigblow-local.setup
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-readtheorg-local.setup
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/gongzhitaao.org/gongzhitaao_local.org
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-dark_local.org
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-light_local.org
;;      : #+SETUPFILE:    ~/.MyCfg/emacs/templates/thi.ng/thi.ng_local.org
;;    
;;    ** Norang
;;       Tema che ho ricavato dal sito [[http://doc.norang.ca/org-mode.html][Org Mode - Organize Your Life In Plain Text!]]
;;    
;;       I file di configurazione sono in ~/.MyCfg/emacs/templates/norang, mentre le relative
;;       risorse le ho messe in ~/Pub/.Styles/norang.
;;    
;;       Per applicarlo utilizzare il seguente metadata sul file org:
;;       - Versione con risorse locali:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/norang/norang_local.org
;;       - Versione con risorse remote:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/norang/norang.org
;;    
;;    ** Org-HTML (Bigblow, ReadTheOrg)
;;    
;;    ** gongzhitaao.org
;;       Stile semplice preso dal sito: https://gongzhitaao.org/orgcss/ tramite il link diretto:
;;       [[https://gongzhitaao.org/orgcss/org.css][org.css]] e che dispone del repository: [[https://github.com/gongzhitaao/orgcss][GitHub]]
;;    
;;       I file di configurazione sono in ~/.MyCfg/emacs/templates/gongzhitaao.org, mentre le relative
;;       risorse le ho messe in ~/Pub/.Styles/gongzhitaao.org.
;;    
;;       Per applicarlo utilizzare il seguente metadata sul file org:
;;       - Versione con risorse locali:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/gongzhitaao.org/gongzhitaao_local.org
;;       - Versione con risorse remote:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/gongzhitaao.org/gongzhitaao.org
;;    
;;    ** solarized-css
;;       Dal sito [[http://thomasf.github.io/solarized-css/][solarized-css]] ([[https://github.com/thomasf/solarized-css][GitHub]]) ricavo un thema chiaro ed uno scuro che sembrano
;;       promettenti:
;;    
;;       I file di configurazione sono in ~/.MyCfg/emacs/templates/solarized-css, mentre le
;;       relative risorse le ho messe in ~/Pub/.Styles/solarized-css.
;;    
;;       Per applicare, il thema chiaro, utilizzare il seguente metadata sul file org:
;;       - Versione con risorse locali:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-light_local.org
;;       - Versione con risorse remote:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-light.org
;;    
;;       Per applicare, il thema scuro, utilizzare il seguente metadata sul file org:
;;       - Versione con risorse locali:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-dark_local.org
;;       - Versione con risorse remote:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/solarized-css/solarized-dark.org
;;    
;;    ** thi.ng/org-spec
;;       Dal sito https://github.com/thi-ng/org-spec ricavo un thema semplice ma con la TOC a
;;       sinistra:
;;    
;;       I file di configurazione sono in ~/.MyCfg/emacs/templates/thi.ng, mentre le
;;       relative risorse le ho messe in ~/Pub/.Styles/thi.ng.
;;    
;;       Per applicarlo utilizzare il seguente metadata sul file org:
;;       - Versione con risorse locali:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/thi.ng/thi.ng_local.org
;;       - Versione con risorse remote:
;;         : #+SETUPFILE:    ~/.MyCfg/emacs/templates/thi.ng/thi.ng.org
;;    
;;    ** org-html-themes (Bigblow e ReadTheOrg)
;;       Vi sono più versioni, il reposity di [[https://github.com/fniessen/org-html-themes][fniessen]] è stato forkato da [[https://github.com/paulzql/org-html-themes][paulzql]] che io avevo
;;       inizialmente preso a riferimento. Però questo è fermo al 2015, mentre fniessen è più
;;       attivo e quindi faccio l'upgrade sperando che così risolva i piccoli errori riscontrati
;;       nella toc laterale quando ho molte headline.
;;    
;;    *** Repository fniessen/org-html-themes 
;;       Sito di riferimento: [[https://github.com/fniessen/org-html-themes][GitHub]]
;;    
;;    *** Repository paulzql/org-html-themes 
;;       Sito di riferimento: [[https://github.com/paulzql/org-html-themes][GitHub]]
;;    
;;       Da questo sito, ho ricavato il reposity del 2020/04, ho copiato i file di setup in
;;       ~/.MyCfg/emacs/templates/org-html-themes dopo aver corretto i riferimenti locali; le
;;       risorse le ho copiate nella cartella C:\_Home\Pub\.Styles\org-html-themes-master.
;;    
;;    **** Bigblow
;;         Per applicarlo utilizzare il seguente metadata sul file org:
;;         - Versione con risorse locali:
;;           : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-bigblow-local.setup
;;         - Versione con risorse remote:
;;           : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-bigblow.setup
;;    
;;         Questo tema permette di utilizzare le seguenti abbreviazioni per navigare:
;;         | Shortcut | What it does                      |
;;         |----------+-----------------------------------|
;;         | ? or h   | Access the dashboard              |
;;         | n        | Move to the next main heading     |
;;         | p        | Move to the previous main heading |
;;         | b        | Scroll up                         |
;;         | <        | Scroll to top                     |
;;         | >        | Scroll to bottom                  |
;;         | -        | Collapse all                      |
;;         | +        | Expand all                        |
;;         | r        | Go to next task in list           |
;;         | R        | Go to previous task in list       |
;;         | q        | Stop reviewing the list of tasks  |
;;         | g        | Reload the page                   |
;;         |----------+-----------------------------------|
;;    
;;    **** ReadTheOrg
;;         Per applicarlo utilizzare il seguente metadata sul file org:
;;         - Versione con risorse locali:
;;           : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-readtheorg-local.setup
;;         - Versione con risorse remote:
;;           : #+SETUPFILE:    ~/.MyCfg/emacs/templates/org-html-themes/theme-readtheorg.setup

** Custom function :
:PROPERTIES:
:ID:       8ec057af-778a-4a65-b5a7-4f68b2348386
:END:

*** MRK/save-then-publish
:PROPERTIES:
:ID:       f1cacac0-0d4b-433f-8d81-992a5e0b72cf
:END:

Funzione ricavata dall'esempio in [[http://doc.norang.ca/org-mode.html][Org Mode - Organize Your Life In Plain Text!]] per:
- salvare tutti i buffer
- inserire per ciascun file la validazione dell'html
- richiamare per ciascuno l'esportazione in html
- infine richiamare la pubblicazione dell'intero progetto

#+begin_src emacs-lisp :tangle  "~/.emacs.d/org-init.el"
  (defun MRK/save-then-publish (&optional force)
    (interactive "P")
    (save-buffer)
    (org-save-all-org-buffers)
    (let (
  	(org-html-head-extra)
  	(org-html-validation-link "<a href=\"http://validator.w3.org/check?uri=referer\">Validate XHTML 1.0</a>")
  	)
      (org-publish-current-project force)
    )
  )
#+end_src

*** MRK/hide-other
:PROPERTIES:
:ID:       77abf2b1-e72e-47cf-9efa-35b995a4a086
:END:

Funzione per aprire completamente il ramo in cui sono e ragruppare tutti gli altri.

#+BEGIN_SRC  emacs-lisp
  (defun bh/hide-other ()
    (interactive)
    (save-excursion
      (org-back-to-heading 'invisible-ok)
      (hide-other)
      (org-cycle)
      (org-cycle)
    )
  )
#+end_src

** Impostazione per l'uso del Package:  buffer-to-pdf             :@Disable:
:PROPERTIES:
:ID:       a2394c39-24e4-4d3b-a33a-021577e17213
:END:

[ Nel test fatto, risponde come se avesse creato tutto senza errore, ma in
realtà non crea nulla. ]

Dall'[[https://protesilaos.com/codelog/2026-05-02-emacs-buffer-to-pdf-new-package/][articolo]] di prot (vi è anche il relativo [[https://www.youtube.com/watch?v=JG4R-d0N-is][video]] e repository [[https://github.com/protesilaos/buffer-to-pdf][GitHub]]) mi
interessa esportare in pdf il buffer, rispettando ciò che si vede (il narrowin)
e quindi provo:

#+begin_src emacs-lisp :tangle no
  (use-package buffer-to-pdf
    :ensure nil
    :init
    ;; Then upgrade it with the command `package-vc-upgrade' or `package-vc-upgrade-all'.
    (unless (package-installed-p 'buffer-to-pdf)
      (package-vc-install "https://github.com/protesilaos/buffer-to-pdf.git"))
    :config
    ;; Configure `buffer-to-pdf-directory' to specify where PDF files are stored.
    ;; This is the default value:
    (setq buffer-to-pdf-directory "~/Doc/Org/Pdf/"))
#+end_src


* \xi From Old version to review
** Esplicito fine esportazione

Esplicito la fine delle esportazioni su ciascun file di configurazione per
essere sicuro che la seguent eparte da rivedere, non inserisca cose spurie.


#+begin_src emacs-lisp :tangle "~/.emacs.d/early-init.el"
  ;;
  ;; - - - - - - - - - - - - -  End File  - - - - - - - - - - - - -
#+end_src

#+begin_src emacs-lisp :tangle "~/.emacs.d/init.el"
  ;;
  ;; - - - - - - - - - - - - -  End File  - - - - - - - - - - - - -
#+end_src

#+begin_src emacs-lisp :tangle "~/.emacs.d/UI-init.el"
  ;;
  ;; - - - - - - - - - - - - -  End File  - - - - - - - - - - - - -
#+end_src

#+begin_src emacs-lisp :tangle "~/.emacs.d/mnbfr-init.el"
  ;;
  ;; - - - - - - - - - - - - -  End File  - - - - - - - - - - - - -
#+end_src

#+begin_src emacs-lisp :tangle "~/.emacs.d/org-init.el"
  ;;
  ;; - - - - - - - - - - - - -  End File  - - - - - - - - - - - - -
#+end_src



** Correttore ortografico:                                 :ToReview:Disable:
   Dal sito [[https://github.com/nobiot/Zero-to-Emacs-and-Org-roam][nobiot/Zero-to-Emacs-and-Org-roam]] ho preso spunto per installare il correttore
   ortografico Hunspell e in particolare ho scaricato la versione 1.7.0 e messa sulla
   cartella "~/.MyCfg/emacs/AddOn/hunspell-1.7.0". Qui ho inoltre messo anche i dizionari
   presi da quelli di libreoffice. Infine ho impostato emacs in questo modo:
   #+begin_src emacs-lisp :tangle no
     ;; Imposto l'italiano come lingua predefinita
     (setenv "LANG" "it_IT")
     ;; Indico dove trovare Hunspell
     (setq ispell-program-name "~/.MyCfg/emacs/AddOn/hunspell-1.7.0/Bin/hunspell.exe")
     ;; Indico che dizionario utilizzare.
     ;; Se voglio cambiarlo devo ridare il comando con il dizionario che voglio utilizzare.
     (setq ispell-local-dictionary "it_IT")
     ;; Imposto il path dei dizionari
     (setq ispell-hunspell-dict-paths-alist 
     '(("it_IT" "~/.MyCfg/emacs/AddOn/hunspell-1.7.0/Dictionaries/it_IT.aff")
       ("en_US" "~/.MyCfg/emacs/AddOn/hunspell-1.7.0/Dictionaries/en_US.aff")
       ("en_GB" "~/.MyCfg/emacs/AddOn/hunspell-1.7.0/Dictionaries/en_GB.aff")
       ("default" "~/.MyCfg/emacs/AddOn/hunspell-1.7.0/Dictionaries/it_IT.aff")
      )
     )
   #+end_src
   Ora posso avviare il correttore sul file aperto tramite il comando:
   : M-x ispell

   Come reference ho utilizzato anche i seguenti siti:
   - [[http://blog.binchen.org/posts/what-s-the-best-spell-check-set-up-in-emacs/][What's the best spell check setup in emacs]]
   - [[https://www.reddit.com/r/emacs/comments/dgj0ae/tutorial_spellchecking_with_hunspell_170_for/][Tutorial: spellchecking with hunspell (1.7.0) for emacs (26.2) on Windows (10)]]

** Colorization                                            :ToReview:Disable:
   #+begin_src emacs-lisp :tangle no
     ;; --->	;; use colorization for all modes
     ;; --->	(global-font-lock-mode t)
   #+end_src

** Reload file nel buffer                       :Disable:ToReview:KeyBinding:
   Per ricaricare il file sul buffer ed anullare tutte le modifiche fatte, si usa il
   comando
   : revert-buffer
   Per comodità è utile bindarlo ad un tasto:
   #+begin_src emacs-lisp :tangle no
     ;; --->	(global-set-key (kbd "<f5>") 'revert-buffer)
   #+end_src

** Modes                                                        :Minor_Mode:

*** IDO                                                  :ToReview:Disable:
   Mode per avere i suggerimenti e l'autocompletazione nei menu e dei comandi.

   Diverso materiale ed informazioni si possono trovare in:
   - [[https://www.emacswiki.org/emacs/InteractivelyDoThings][Ido from emacs wiki]]
   - [[https://www.gnu.org/software/emacs/manual/html_mono/ido.html][Ido from gnu.org]]

   #+begin_src emacs-lisp :tangle no
     ;; --->	;; Set ido  (https://www.gnu.org/software/emacs/manual/html_mono/ido.html)
     ;; --->	(setq ido-everywhere t)
     ;; --->	(setq ido-enable-flex-matching t)
     ;; --->	(ido-mode 1)
   #+end_src

*** Visual Basic Mode
   Dal sito [[http://www.emacswiki.org/emacs/visual-basic-mode.el][Wiki]], si ricava come installare il "visual-basic-mode" che permette di editare
   il visual basic in modo agevole e con l'evidenziazione sintattica.
   
   Per farlo occorre caricare il file [[file:~/.MyCfg/emacs/AddOn/visu][visual-basic-mode.el]] e per farlo lo metto sul path
   che carico di default all'avvio (vedi relativo #Add-AddOn paragrafo); per velocizzare si può anche
   compilare il file ma per ora non lo faccio.

   Configuro quindi il load del modo e gli associo i relativi file (in automatico i file
   li associo a "visual basic .net" e non a "visual basic 6").
   #+begin_src emacs-lisp :tangle no
     ;; Carico il modo Visual Basic
     ;(autoload 'visual-basic-mode "visual-basic-mode" "Visual Basic mode." t)
	 (require 'visual-basic-mode)
     ;;
     ;; Associo il modo VB automaticamente ai file *.frm, *.bas, *.cls, *.vb
     ;(setq auto-mode-alist (append '(("\\.\\(frm\\|bas\\|cls\\|vb\\)$" . visual-basic-mode)) auto-mode-alist))
	 (require 'vbnet-mode)
   #+end_src

*** Visual Basic .NET mode
   Dal sito [[http://www.emacswiki.org/emacs/VbDotNetMode][Wiki]], si ricava come installare il "vbnet-mode" che permette di editare il
   visual basic in modo agevole e con l'evidenziazione sintattica.
   
   Per farlo occorre caricare il file [[file:~/.MyCfg/emacs/AddOn/vbnet-mode.el][vbnet-mode.cs]] e per farlo lo metto sul path che
   carico di default all'avvio (vedi relativo #Add-AddOn paragrafo); per velocizzare si può anche
   compilare il file ma per ora non lo faccio.

   Configuro quindi il load del modo e gli associo i relativi file.
   #+begin_src emacs-lisp :tangle no
     ;; Carico il modo Visual Basic .Net
     (autoload 'vbnet-mode "vbnet-mode" "Mode for editing VB.NET code." t)
     ;; 
     ;; Associo il modo VBNet automaticamente ai file *.frm, *.bas, *.cls, *.vb
     ;(setq auto-mode-alist (append '(("\\.\\(frm\\|bas\\|cls\\|vb\\)$" . vbnet-mode)) auto-mode-alist))
   #+end_src

*** C#: csharp-mode
Da Stack Overflow: [[https://stackoverflow.com/questions/3954607/c-sharp-emacs-mode-questions-indentation-and-build][C# Emacs mode questions - indentation and build]] e successivamente dal
sito [[https://github.com/emacs-csharp/csharp-mode][GitHub csharp-mode]] ricavato i file [[file:~/.MyCfg/emacs/AddOn/elisp/csharp-mode.el][csharp-mode.el]] e [[file:~/.MyCfg/emacs/AddOn/elisp/csharp-compilation.el][csharp-compilation.el]] che
permettono di definire il csharp-mode utilizzabile direttamente nei blocchi org per avere
il codice con la colorazione sintattica.

Da quanto visto, non serve linkare il linguaggio con babel, ma basta inserire i file negli
AddOn e caricare i rispettivi modi:

#+begin_src emacs-lisp :tangle no
  ;; --->	;; --->	;; Carico il path dei file lisp che definiscono il modo C#:
  ;; --->	;; --->	(add-to-list 'load-path (expand-file-name "~/.MyCfg/emacs/AddOn/elisp"))
  ;; --->	;; Attivo il modo per C#
  ;; --->	(require 'csharp-mode)
  ;; --->	;; Vi assicio, di default, i file *.cs
  ;; --->	(setq auto-mode-alist
  ;; --->		(append '(("\\.cs$" . csharp-mode)) auto-mode-alist))
  ;; --->	;; Volendo posso definire la funzione di hook per impostarci una
  ;; --->	;; tabulazione predefinita valida in tutti i modi derivanti dal C:
  ;; --->	(defun my-c-mode-common-hook ()
  ;; --->	  (setq c-basic-offset 4)
  ;; --->	  (c-set-offset 'substatement-open 0)
  ;; --->	)
  ;; --->	;; Infine assegnare la funzione appena definita, all'hook:
  ;; --->	(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
#+end_src

**** Obsoleto:
   Dal sito [[https://code.google.com/p/csharpmode/][code.google]] e successivamente dal sito [[https://github.com/josteink/csharp-mode][GitHub]] ricavo il file [[file:~/.MyCfg/emacs/AddOn/csharp-mode.el][csharp-mode.el]]
   che permette di avere il csharp-mode per visualizzare il codice C# correttamente
   colorato.

   Il file lo ho copiato nella directory che carico allo startup (vedi relativo
   #Add-AddOn paragrafo); per velocizzare si può anche compilare il file ma per ora non lo faccio.

   Configuro quindi il load del modo e gli associo i relativi file:
   #+begin_src emacs-lisp :tangle no
     ;; --->	;; Carico il modo C#
     ;; --->	(autoload 'csharp-mode "csharp-mode" "Major mode for editing C# code." t)
     ;; --->	;;
     ;; --->	;; Associo il modo C# automaticamente ai file *.cs
     ;; --->	(setq auto-mode-alist (append '(("\\.cs$" . csharp-mode)) auto-mode-alist))
   #+end_src

** Power Shell mode                                       :Disable:Obsolete:
   Ricercando info per il vbnet-mode ho trovato il sito [[https://www.emacswiki.org/emacs/PowerShell][Wiki]] da cui si ricava il file
   [[file:~/.MyTools/_MyUp/Lisp/PowerShell-Mode.el][PowerShell-Mode.el]] per gestire il vpowershell-mode

   Il file lo ho messo sulla cartella da cui carico, all'avvio, i file lisp esterni,

   Configuro quindi il load del modo e gli associo i relativi file:
   #+begin_src emacs-lisp :tangle no
     ;; --->	;; Carico il modo PowerShell
     ;; --->	(autoload 'powershell-mode "vpowershell-mode" "PowerShell Mode" t)
     ;; --->	;; Associo il modo automaticamente ai file *.?1?, *.?2?
     ;;  --->	;(setq auto-mode-alist (append '(("\\.\\(?1?\\|?2?\\)$" . vpowershell-mode)) auto-mode-alist))
   #+end_src

   [2022-12-08 Thu] Nella revisione, si è visto che ora la modalità è compresa nel package
   di emacs e quindi si può installare direttamente con i comandi:
   : M-x package-install RET powershell RET

** Packages                                                        :Package:

*** Package:  Swiper / Ivy / Counsel                     :ToReview:Disable:
   Questo serve per estendere la funzione di search ed inoltre estende IDO, ma è da usare
   in modo esclusivo (occorre disattivare IDO). Per ora non lo uso, ma merita di darci
   un'occhiata. Si combina bene con HEM

   Permette di editare in contemporanea su più punti, autocompleta i comandi. ecc...

   Visto in Using Emacs Series [[https://www.youtube.com/watch?v=0mwwN0S1dnQ][Video 6]] e i siti di riferimento sono: [[https://melpa.org/#/swiper][Melpa]], [[https://github.com/abo-abo/swiper][GitHub]]
   #+begin_src emacs-lisp :tangle no
     ;;  --->	;; it looks like counsel is a requirement for swiper
     ;;  --->	(use-package counsel
     ;;  --->	:ensure t
     ;;  --->	)
     ;;  --->	;;
     ;;  --->	(use-package swiper
     ;;  --->	:ensure try
     ;;  --->	:config
     ;;  --->	(progn
     ;;  --->	(ivy-mode 1)
     ;;  --->	(setq ivy-use-virtual-buffers t)
     ;;  --->	(global-set-key "\C-s" 'swiper)
     ;;  --->	(global-set-key (kbd "C-c C-r") 'ivy-resume)
     ;;  --->	(global-set-key (kbd "<f6>") 'ivy-resume)
     ;;  --->	(global-set-key (kbd "M-x") 'counsel-M-x)
     ;;  --->	(global-set-key (kbd "C-x C-f") 'counsel-find-file)
     ;;  --->	(global-set-key (kbd "<f1> f") 'counsel-describe-function)
     ;;  --->	(global-set-key (kbd "<f1> v") 'counsel-describe-variable)
     ;;  --->	(global-set-key (kbd "<f1> l") 'counsel-load-library)
     ;;  --->	(global-set-key (kbd "<f2> i") 'counsel-info-lookup-symbol)
     ;;  --->	(global-set-key (kbd "<f2> u") 'counsel-unicode-char)
     ;;  --->	(global-set-key (kbd "C-c g") 'counsel-git)
     ;;  --->	(global-set-key (kbd "C-c j") 'counsel-git-grep)
     ;;  --->	(global-set-key (kbd "C-c k") 'counsel-ag)
     ;;  --->	(global-set-key (kbd "C-x l") 'counsel-locate)
     ;;  --->	(global-set-key (kbd "C-S-o") 'counsel-rhythmbox)
     ;;  --->	(define-key read-expression-map (kbd "C-r") 'counsel-expression-history)
     ;;  --->	))
   #+end_src

*** Package:  ox-Reveal                                  :ToReview:Disable:
   Permette di generare da org delle presentazioni web tramite lo script [[https://github.com/hakimel/reveal.js/][reveal.js]]

   Siti di riferimento: [[https://melpa.org/#/ox-reveal][Melpa]], [[https://github.com/yjwen/org-reveal][GitHub]] si capisce che:
   - tramite la variabile org-reveal-root si indica quale [[https://github.com/hakimel/reveal.js/][reveal.js]] utilizzare (locale o
     web)
   - org-reveal-mathjax permette di abilitare equazioni LaTex

   Per il tutto ho preso spunto da Using emacs series [[https://www.youtube.com/watch?v=psDpCpcIVYs][Video 11]]
   #+begin_src emacs-lisp :tangle no
     ;; --->	(use-package ox-reveal
     ;; --->	  :ensure ox-reveal)
     ;; --->	(setq org-reveal-root "http://cdn.jsdelivr.net/reveal.js/3.0.0/")
     ;; --->	(setq org-reveal-mathjax t)
   #+end_src

   Il tutto sembra non funzionare, se confronto la pagina html generata da me con quella
   dell'esempio dal [[https://www.youtube.com/watch?v=psDpCpcIVYs][sito]] si vede che io inserisco la linea:
   : <script src="http://cdn.jsdelivr.net/reveal.js/3.0.0/js/reveal.js"></script>
   mentre nell'esempio si ha:
   : <script src="http://cdn.jsdelivr.net/reveal.js/3.0.0/lib/js/head.min.js"></script>
   : <script src="http://cdn.jsdelivr.net/reveal.js/3.0.0/js/reveal.js"></script>
   Quindi sulla mia esportazione manca il codice:
   : <script src="http://cdn.jsdelivr.net/reveal.js/3.0.0/lib/js/head.min.js"></script>

   Alcune informazioni utili su come utilizzarlo anche in locale sono presenti
   sull'articolo sul portale opensource:
   [[https://opensource.com/article/18/2/how-create-slides-emacs-org-mode-and-revealjs][How to create slides with Emacs Org mode and Reveal.js]]

*** Package:  Yasnippet
   Permette di inserire testi tramite abbreviazioni e poi tab, estende quindi le
   funzionalità base di emacs. I vari sniptes si possono personalizzare a piacere.

   Siti di riferimento: [[https://melpa.org/#/yasnippet][Melpa]], [[https://github.com/joaotavora/yasnippet][GitHub]], [[http://joaotavora.github.io/yasnippet/][Manual]]
   #+begin_src emacs-lisp :tangle no
     (use-package yasnippet
       :ensure t
       :init
	 (yas-global-mode 1))
   #+end_src

*** Package:  Magit                                      :ToReview:Disable:
   I siti di riferimento sono: [[https://magit.vc/][magit.vc]], [[https://github.com/magit/magit][GitHub]], [[https://www.emacswiki.org/emacs/Magit][emacswiki]]

***      - :  org-manage:                                        :ToReview:
   Dal sito [[https://github.com/dmgerman/org-manage][github]] ricavo il file [[file:~/.MyCfg/emacs/AddOn/org-manage.el][org-manage.el]] che permette di avere un riepilogo dei
   file org. Il file lo ho copiato nella directory che carico allo startup (vedi relativo
   #Add-AddOn paragrafo); per velocizzare si può anche compilare il file ma per ora non lo faccio.

   Configuro quindi il load del modo e gli associo i relativi file:
   #+begin_src emacs-lisp :tangle no
     ;; Installo il pacchetto necessario:
     (require 'ctable)
     ;; Installo il pacchetto vero e propio:
     (require 'org-manage)
     ;; Inizializzo org-manage indicando la cartella da scansionare per i file org:
     (setq org-manage-directory-org       "~/Doc/Org")
     ;; Ora basta richiamare la funzione:
     ;;   M-x org-manage
     ;; o usare il bind 'Alt+F11'
   #+end_src
   Con la versione 28 di emacs, questo non funziona più, in particolare dà errore
   #+begin_comment
     ... remove-duplicates ...
   #+end_comment
   per risolverlo, ho dovuto cambiare il comando lisp 'remove-duplicates' che non è più
   supportato, con il comando 'seq-uniq'

   Inoltre si ha un problema con la funzione org-manage che non definisce bene il Hook al
   click e quindi quando clicco non mi porta al file corretto. Se invece copio la funzione
   sul buffer scratch e la valuto con C-j o C-M-q, poi funziona correttamente.

*** TODO Trovare come bypassare/risolvere il problema al Click
Servirebbe fare un eval automatico della funzione dopo l'avvio di emacs. Guardando in
internet ho vvisto un simil hook sull'avvio di emacs che richiama del codice e quindi
sarebbe da usare per richiamare il codice che compila la funzione.

*** ????  Hem  ????                                      :ToReview:Disable:
   Package per gestire autocompletamenti e abbreviazioni. Simile ma più potente di IDO,
   devo approfondire. [[https://github.com/emacs-helm/helm][helm from GitHub]]

*** ????  Projectile  ????                               :ToReview:Disable:
   Package per gestire i progetti in base alle directory (tipo i project di notepad++ o di
   sublimetext). Merita approfondimenti.

*** ????  Dashboard  ????                                :ToReview:Disable:
   Package per visualizzare un albero a sinistra con link ai file di una directory.

   visto sul video del corso di emacs di Lukewh [[https://www.youtube.com/watch?v=Bu7nF9hPSts][Video 10]] e come sito di riferimento ha
   [[https://github.com/emacs-dashboard/emacs-dashboard][dashboard]]

*** ????  Treemacs  ????                                 :ToReview:Disable:
   Package per mostrare l'albero del progetto a sinistra come faccio con
   notepad++. Gestisce più progetti e più cose, da approfondire.

   visto sul video del corso di emacs di Lukewh [[https://www.youtube.com/watch?v=Bu7nF9hPSts][Video 10]] e come sito di riferimento ha
   [[https://github.com/Alexander-Miller/treemacs][treemacs]].