NewCfg/Old - MyInit.org

-*- coding: utf-8 -*-
#+TITLE:        la mia configurazione di emacs Vrs 0.9
#+AUTHOR:       CSiCoAlm
#+DESCRIPTION:  File in formato org con la configurazione di emacs
#+SETUPFILE:    ~/.MyCfg/emacs/templates/norang/norang_local.org

* Intro:
  Fino ad ora (2020/04) utilizzavo direttamente il file ~/.emacs da cui caricavo i veri e
  propi file di configurazione dal reposity GIT "~/.dotemacs" su cui avevo tutti i singoli
  file con le varie personalizzazioni. Vedendo in internet vari esempi, voglio cambiare
  per portare il tutto su un file org che mi permetta non solo di configurare emacs
  secondo i miei desideri, ma anche che mi permetta di inserire ulteriori informazioni in
  modo che posso esplicitare le varie scelte fatte per poterle ricordare in futuro senza
  perdere tempo e sopratutto per potermi ricordare cosa intendevo ottenere.  In questo
  file racchiuderò tutta la configurazione e la personalizzazione di emacs, descrivendo il
  più possibile tutti i vari passaggi per renderlo il più utile ed interessante possibile.

  Cercherò quindi di espicitare il più possibile le scelte fatte, non solo descrivendo le
  singole funzionalità, ma cercando anche di esplicitare cosa si voleva ottenere e come si
  è fatto, in modo che in futuro rileggendo posso ricordare tutto senza perdere tempo.

  I punti che non sono chiari o che devo rivedere li evidenzio tramite l'abbreviazione
  {???} oppure tramite il tag ToReview.

  Vedere di utilizzare anche tag o altre cose di org per chiarire meglio il tutto. Magari
  utilizzare i link per connettere la parte in cui ad esempio setto il gestore dei
  packages con le parti in cui utilizzo un package.


* References:
  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]]


* Esigenze:                                                        :ToReview:
  - 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.

** TODO [[https://katherine.cox-buday.com/blog/2015/03/14/writing-specs-with-org-mode/][Writing Specs with Org-mode]]                                :ToReview:
   esempio di come produrre documentazione tecnica con
   org-mode, LaTeX, PlantUML per ottenere pdf. Mostra anche il relativo file di
   configurazione.
   
** TODO Created a new HTML export back-end that uses Tailwind.css classes :ToReview:
    - 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]]
    : (load "~/.MyTools/private-packages/ox-tailwind/ox-tailwind.el")

** TODO Socially isolating my Emacs with Docker!                   :ToReview:
   - Link [[https://www.youtube.com/watch?v=D2E1Eh9Hxdg&feature=youtu.be][video]]

** TODO 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.


* Set home path
  Essendo nato in linux, emacs utilizza molto la directory home e perciò ho trovato utile
  crearne un riferimento in windows. In particolare imposto la cartella C:\_Home come
  cartella home.

  Per inserire _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

  Come emacs, utilizzo direttamente quello scaricabile dal progetto [[https://www.gnu.org/software/emacs/][GNU Emacs]]
  (Emacs 28.2 al 2022/12) disarchiviando lo zip, sulla cartella:
  : C:/MyTools/emacs
  e lo eseguo lanciando:
  : C:/MyTools/emacs/bin/runemacs.exe


* init.el o .emacs
  Questa parte, descrive cosa inserire nel file iniziale che viene automaticamente letto
  all'avvio di emacs (~/.emacs o ~/.emacs.d/init.el). In esso occorre impostare le
  funzioni base che sono "obbligatorie", mentre tutto il resto viene delegato ad un file
  ottenuto compilando questo file org.

  Preferisco evitare che il file org venga compilato ad ogni avvio di
  emacs perchè perdo tempo, ed inoltre cambierei sempre il file sul
  reposity e quindi non è utile per la gestione con GIT.

  Quindi sul file di inizializzazione non metterò il codice di
  compilazione, ma caricherò direttamente il file compilato.

  Per compilare il file a mano, basta eseguire lo stesso codice:
  : (org-babel-load-file (expand-file-name "~/.MyCfg/emacs/dotEmacs/MyInit.org"))
  copiandolo sul buffer scrach ed eseguendolo, oppure più
  semplicemente, basta dare il comando:
  : M-x org-babel-load-file "~/.MyCfg/emacs/dotEmacs/MyInit.org RET

  #+BEGIN_SRC emacs-lisp
	;;  Emacs is unable to open this file properly: 	-*- coding: utf-8 -*-
    ;;		;; 
    ;;		;; 
    ;;		;; 
    ;;		;; Imposto la gestione dei Packages
    ;;		;; 
    ;;		(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)
    ;;		;; 
    ;;		;; 
    ;;		;;    ;; Carico come configurazione direttamente il file compilato a mano (tramite ...)
    ;;		;;    (load "~/.MyCfg/emacs/dotEmacs/MyInit.el")
    ;;		;; 
    ;;		;; Compilo il file in formato org e lo carico:
    ;;		(org-babel-load-file (expand-file-name "~/.MyCfg/emacs/dotEmacs/MyInit.org"))
    ;;		;; 
    ;;		;; 
    ;;		;; 
    ;;		;; 
    ;;		;; 
    ;;		;; 
    ;;		;; Altre configurazioni gestite in automatico da emacs
    ;;		;; 
  #+END_SRC


* Impostazioni generali
** Imposto modalità server
   Per evitare di aprire più istanze di emacs, abilito la modalità server.
   #+BEGIN_SRC emacs-lisp
     ;; --->	;; Abilito il server emacs
     ;; --->	(server-start)
   #+END_SRC
   Dal sito [[https://qastack.it/emacs/146/set-up-emacs-on-windows-to-start-a-single-instance-and-open-files-in-the-existin][Configura Emacs su Windows per avviare una singola istanza]] ricavo che per
   avviare il server di emacs in automatico si utilizza:
   #+BEGIN_SRC emacs-lisp
     ;; Abilito il server emacs e lo avvio se non già in run
     (require 'server)
     (unless (server-running-p) (server-start)) 	 
   #+END_SRC   
   Quindi avvia emacs semplicemente eseguendo l' runemacs.exe eseguibile fornito con la
   build.
   
   La build di Windows di Emacs include un emacsclientw.exe eseguibile nella
   bin/directory. Usa il percorso completo di tale eseguibile come editor di tua scelta su
   tutti gli strumenti di terze parti che devi configurare per editare il file utilizzando
   il server già aperto.
   
** Imposto formato UTF-8
   Imposto come formato di default dei file: UTF8
   #+BEGIN_SRC emacs-lisp
     ;; 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

** Carico i file lisp aggiuntivi
:PROPERTIES:
:CUSTOM_ID: Add-AddOn
:END:
   Per abilitare delle funzionalità particolari, si deve caricare dei file lisp
   particolari che nella mia configurazione metterò nel path:
   : ~/.MyCfg/emacs/AddOn
   e li caricherò sempre tutti:
   #+BEGIN_SRC emacs-lisp
     ;; Carico il path dei file lisp che aggiungo:
     (add-to-list 'load-path (expand-file-name "~/.MyCfg/emacs/AddOn/elisp"))
   #+END_SRC

** Nascondo la schermata di benvenuto
   #+BEGIN_SRC emacs-lisp
     ;; Don't show startup message
     (setq inhibit-startup-message t)
   #+END_SRC

** Blinking del cursore
   #+BEGIN_SRC emacs-lisp
     ;; Stop al blinking del cursore
     (blink-cursor-mode -1)     ;; (setq blink-cursor-delay 2  blink-cursor-interval 0.5)
   #+END_SRC

** menu bar
   #+BEGIN_SRC emacs-lisp
     ;; menu bar (1=enable, -1=disable)
     (menu-bar-mode 1)
   #+END_SRC

** scroll bar
   #+BEGIN_SRC emacs-lisp
     ;; scroll bar (1=enable, -1=disable)         
     (toggle-scroll-bar 1)
   #+END_SRC

** tools bar
   #+BEGIN_SRC emacs-lisp
     ;; tool bar (1=enable, -1=disable)
     (tool-bar-mode -1)
   #+END_SRC

** Highlight line
   #+BEGIN_SRC emacs-lisp
     ;; Higlight line (1=enable, -1=disable)
     (global-hl-line-mode 1)
   #+END_SRC

** Edit selected text
   Se si edita del testo selezionato, emacs di default non lo sostituisce, ma si limita ad
   inserire il nuovo testo prima di quello selezionato. Per fare in modo che si comporti
   come sono abituato in windows, occorre abilitare la cancellazione del testo
   selezionato.
   #+BEGIN_SRC emacs-lisp
     ;; delete selection when edited  (1=enable, -1=disable)
     (delete-selection-mode 1)
   #+END_SRC

** Gestione Autosave e Autobackup dei file
   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.

   #+BEGIN_SRC emacs-lisp
     ;; disable autosave
     (setq delete-auto-save-files t)
     ;; disable autobackup
     (setq make-backup-files nil)
   #+END_SRC

** Calendario in Italiano                                           :ToCheck:
   Personalizzazione del calendario per visualizzarlo in Italiano ed inserire le
   festività italiane:
   #+BEGIN_SRC emacs-lisp
     ;; 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

** Mostro il numero delle righe durante la programmazione
   #+BEGIN_SRC emacs-lisp
     ;; Show line numbers on programming mode
     (add-hook 'prog-mode-hook 'display-line-numbers-mode)
   #+END_SRC

** Colum number
   #+BEGIN_SRC emacs-lisp
     ;; Show the column number
     (column-number-mode 1)
   #+END_SRC

** Abbrevio Yes or No
   #+BEGIN_SRC emacs-lisp
     ;; Make all "yes or no" prompts be "y or n" instead
     (fset 'yes-or-no-p 'y-or-n-p)
   #+END_SRC

** Matching delle parentesi
   Abilito l'evidenziazione delle coppie di parentesi e riduco al minimo il tempo di
   attesa
   #+BEGIN_SRC emacs-lisp
     ;; Show the matching parenthesis and do it immediately, we are in a hurry
     (show-paren-mode t)
     (setq show-paren-delay 0)
   #+END_SRC

** Mostro Ora nella modeline
   Visualizzo l'ora attuale nella barra di sistema nel formato 24 ore.
   #+BEGIN_SRC emacs-lisp
     ;; Time in the modeline
     (display-time)
     (setq display-time-24hr-format t)
   #+END_SRC

** Completamento dinamico sul minibuffer:
   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
     ;; 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

** Directory iniziale
   Imposto la directory iniziale che è quella da cui partire per ricercare o inserire file
   #+BEGIN_SRC emacs-lisp
     ;; Directory iniziale
     (setq default-directory "~/Doc/Org/")
   #+END_SRC

** Kill buffer automatico                                :Disable:KeyBinding:
   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
     ;; --->	(global-set-key (kbd "C-x k") 'kill-this-buffer)
   #+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
     ;; 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)]]


* UI
** emacs Custom Themes:
   Per ora disativo i temi e quindi scelgo uno fra quelli di default di emacs.

   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
     ;; dichromacy -- Face colors suitable for red/green color-blind users.
	 (load-theme 'dichromacy t)
     ;; --->	;; tsdh-dark -- A dark theme used and created by Tassilo Horn.
     ;; --->	(load-theme 'tsdh-dark t)
     ;; --->	;; tsdh-light -- A light Emacs theme.
     ;; --->	(load-theme 'tsdh-light t)
     ;; --->	;; whiteboard -- Face colors similar to markers on a whiteboard.
     ;; --->	(load-theme 'whiteboard t)
     ;; --->	;; wombat -- Med
     ;; --->	(load-theme 'wombat t)
   #+END_SRC

** Dimensioni font
   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
     ;; Imposto la dimensione del testo:
     (set-face-attribute 'default nil :height 110)
   #+END_SRC

** Dimensione finestra
   Ridimensiono la finestra di emacs in base a quanto visto nella pagina della
   [[https://www.emacswiki.org/emacs/FrameSize][wiki]].
   #+BEGIN_SRC emacs-lisp
     ;; 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

** Wordwrap
   Inoltre imposto il wordwrap a 90 caratteri in modo da sfruttare opportunamente le
   righe.
   #+BEGIN_SRC emacs-lisp
     ;; Imposto wordwrap
     (setq-default fill-column 90)
   #+END_SRC

** Colorization                                            :ToReview:Disable:
   #+BEGIN_SRC emacs-lisp
     ;; --->	;; 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
     ;; --->	(global-set-key (kbd "<f5>") 'revert-buffer)
   #+END_SRC

** Buzzer visibile
   Dal sito [[http://pragmaticemacs.com/emacs/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
     ;; Buzzer visibile
     (setq visible-bell t)
   #+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
     ;; --->	;; 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
     ;; 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
     ;; 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
  ;; --->	;; --->	;; 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
     ;; --->	;; 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
     ;; --->	;; 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:
  
  Emacs ha una gestione dei packages che mi permette di installare ed utilizzare
  differenti pacchetti o funzionalità in modo semplice.

  Qui inserisco tutte le configurazioni sui package inserendo le
  descrizioni varie ed eventuali esempi di utilizzo, in modo che anche
  fra qualche tempo se vado a vedere, ritrovo tutte le informazioni
  base ed importanti.

  Vi sono diversi reposity, ma i principali, non chè ufficiali, sono:
  - [[https://melpa.org/][MELPA]] o [[https://github.com/melpa/melpa][MELPA GitHub]]
  - [[https://github.com/melpa/melpa][MELPA Stable]]
  - gnu
  - org
  - ????

  Di seguito inserisco la configurazione del gestore dei package ed a seguire tutte le
  configurazioni sui package che installo inserendo le descrizioni varie ed eventuali
  esempi di utilizzo, in modo che anche fra qualche tempo se vado a vedere, ritrovo tutte
  le informazioni base ed importanti.

  Spunti inizialmente presi da https://orgmode.org/elpa.html e
  http://pages.sachachua.com/.emacs.d/Sacha.html. Nel 2020/04 rivisto il tutto
  in base alla serie [[https://cestlaz.github.io/stories/emacs/][Using emacs]]

** Note sull'utilizzo e sui comandi:
   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.

** Setup generale:
   Per utilizzare i reposity, occorre inizializzarli. Il relativo codice è già stato
   inserito nel file init.el perchè deve essere una delle prime cose da fare.
   #+BEGIN_SRC emacs-lisp
     ;;  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

** Package:  Try                                                   
   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
     (use-package try
       :ensure t)
   #+END_SRC

** Package:  Which-key
   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
     (use-package which-key
       :ensure t
       :config
	 (which-key-mode))
   #+END_SRC

** Package:  Org-bullet                                    :Disable:Obsolete:
   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
     ;;(use-package org-bullets
     ;;     :ensure t
     ;;     :config
     ;;	(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))
   #+END_SRC

** Package:  Org-superstar
   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.
   #+BEGIN_SRC emacs-lisp
     (use-package org-superstar
       :ensure t
       :config
	 (add-hook 'org-mode-hook (lambda () (org-superstar-mode 1))))
     ;; Per velocizzare la gestione del font 
     (setq inhibit-compacting-font-caches t)
   #+END_SRC
   
** 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
     ;;  --->	;; 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:  Auto-complete
   Simile alla funzione di autocompletamento nativa di emacs (M-/) questa visualizza i
   suggerimenti tipo intellisense e quindi è carina da vedere. per ora provo ad usarla e
   poi vedo se tenerla o no.
   
   I siti di riferimento sono: [[https://melpa.org/#/auto-complete][Melpa]], [[https://github.com/auto-complete/auto-complete][GitHub]]
   #+BEGIN_SRC emacs-lisp
     (use-package auto-complete
       :ensure t
       :init
       (progn
	 (ac-config-default)
	 (global-auto-complete-mode t)
       ))
   #+END_SRC
   
** Package:  Htmlize
   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
     (use-package htmlize
       :ensure t)
   #+END_SRC

** Package:  Theme Zenburn                                          :Disable:
   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
     ;; --->	;;    ;; 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

** Package:  Theme Spacemacs                                        :Disable:
   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.

   Si possono ridefinire i colori andando a ridefinire la variabile
   zenburn-override-colors-alist come in questo esempio.
   #+BEGIN_SRC emacs-lisp
     ;; --->	;;
     ;; --->	;; Load theme
     ;; --->	(use-package spacemacs-theme
     ;; --->	  :ensure t
     ;; --->	  :config (load-theme 'spacemacs-light t))
   #+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
     ;; --->	(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
     (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]]

** Package:  Org-mode                                               :MISSING:
*** Installazione e attivazione:
    Dal sito di riferimento di org: [[https://orgmode.org/][orgmode.org]] ricavo l'installazione del pacchetto (per
    averlo aggiornato):
    #+BEGIN_SRC emacs-lisp
      ;; 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

*** Visibilità iniziale:
    Imposto la visibilità iniziale a tutto ragruppato per velocizzare la vista dall'alto.
    #+BEGIN_SRC emacs-lisp
      ;; Visibilità iniziale: tutto ragruppato
      (setq org-startup-folded t)
    #+END_SRC

*** Use utf-8 as the default coding system for all of my org files.
    #+BEGIN_SRC emacs-lisp
      ;; 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

*** Key Binding                                            :ToReview:MISSING:
    Impostiamo alcuni dei key binding di default:
    #+BEGIN_SRC emacs-lisp
      ;;(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

    Analisi dei tasti funzioni disponibili:
    | Key     | Binding originale                                  |
    |---------+----------------------------------------------------|
    | <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                                       |
    | S-<F9>  | Non Definito                                       |
    | C-<F9>  | Non Definito                                       |
    | 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> | Passa la visualizzazione a schermo Intero/Finestra |
    |---------+----------------------------------------------------|
    | <F11>   | Passa la visualizzazione a schermo Intero/Finestra |
    | S-<F11> | Passa la visualizzazione a schermo Intero/Finestra |
    | C-<F11> | Non Definito                                       |
    | M-<F11> | Non Definito                                       |
    |---------+----------------------------------------------------|
    | <F12>   | Non Definito                                       |
    | S-<F12> | Non Definito                                       |
    | C-<F12> | Non Definito                                       |
    | M-<F12> | Non Definito                                       |
    |---------+----------------------------------------------------|

    Quindi assegnerò con questi principi i tasti:
    - *F9* - /Visibilità/ -  per la visibilità sul file
      | Key    | Origin       | My Bingind                   |
      |--------+--------------+------------------------------|
      | <F9>   | Non Definito | Visualizza tutto             |
      | S-<F9> | Non Definito | Visualizza solo ramo attuale |
      | C-<F9> | Non Definito | nascondi ramo attuale        |
      | M-<F9> | Non Definito | ...                          |
      #+BEGIN_SRC emacs-lisp
	(global-set-key (kbd   "<f9>") 'widen)
	(global-set-key (kbd "C-<f9>") 'MRK/hide-other)
	(global-set-key (kbd "S-<f9>") 'narrow-to-region)
	;(global-set-key (kbd "M-<f9>") )
      #+END_SRC
      */ToReview:/*

      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.


    - *F11* - /Loggin Work/ - per la gestione del log dei tempi
      | Key     | Origin                              | My Binding |
      |---------+-------------------------------------+------------|
      | <F11>   | Visualizza dove c'è il clock attivo | Clock Goto |
      | S-<F11> | Fa partire il clock di timing       | Clock In   |
      | C-<F11> | Termina il clock di timng           | Clock Out  |
      | M-<F11> | Org manage per navigare fra i file  | Org-Manage |
      #+BEGIN_SRC emacs-lisp
	(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 )
      #+END_SRC
      */ToReview:/*

      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)

    - *F12* - /Navigazione/ -  per la navigazione fra i file (e la pubblicazione per compatibilità)
      | <F12>     | Apre aggenda (C-c a)    |
      | S-<F12>   | Aprire subito Trash.org |
      | C-<F12>   | Aprire subito InBox.org |
      | M-<F12>   | Aprire subito Mrk.org   |
      | C-S-<F12> | Pubblicazione file org  |
      #+BEGIN_SRC emacs-lisp
	(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










    Mentre imposto anche questi miei key binding custom:
    #+BEGIN_SRC emacs-lisp
      ;; 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
    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/MyInit.org_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/MyInit.org_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/MyInit.org_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
      ;; 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
      ;; --->	;; 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
      ;; 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
      ;; 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                                                   :ToReview:MISSING:
    imposto i tag generali in uso

*** Capture Setup                                          :ToReview:MISSING:
    imposto i form di cattura veloce

*** Refiling Tasks:                                        :ToReview:MISSING:
    imposto il refill

*** org-protocol Setup:                                    :ToReview:MISSING:
    imposto org protocol

*** Agenda Setup                                           :ToReview:MISSING:
    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
      ;; 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           :ToReview:MISSING:
Dal manuale, si ricavano i seguenti comandi per la retentività dei clock:
#+begin_src emacs-lisp
  (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)                        :ToReview:MISSING:
    imposto i set per usare GTD ed eventualmente projetile e treemacs

*** Publishing and Exporting                               :ToReview:MISSING:
Impostazioni generali utili per l'esportazione (anche del singolo file):
#+begin_src emacs-lisp
  ;; 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
  ;; 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
  ;; 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
  ;; 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


;; 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

*** Reminders                                              :ToReview:MISSING:
    Imposto i remainder e come utilizzarli.

*** Funzioni in uso:
**** MRK/save-then-publish
     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
      (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 
     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
     
**      - :  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
     ;; 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]].


* KeyBinding
  Qui imposto dei key binding generali.

  Per riepilogare tutti i keybinding, riporto anche quelli fatti in altri punti della
  configurazione commentandoli e lincandoli al punto in cui sono definiti.

** Assegnami i caratteri non presenti: 
   Per facilitare l'editazione rimappo alcuni caratteri non presenti:
   #+BEGIN_SRC emacs-lisp
     ;; 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

** Org-mode
   Riepilogo qui i keybinding fatti per org-mode. In realtà sono stati fatti nella
   relativa sezione in package. Qui li riepilogo solo per facilitare una revisione e la
   creazione di un resume.
   #+BEGIN_SRC emacs-lisp
     ;(global-set-key "\C-cl" 'org-store-link)                    ;; Link all'editor dei links
     ;(global-set-key "\C-ca" 'org-agenda)                        ;; Link normale per aprire l'aggenda.
     ;(global-set-key "\C-cb" 'org-iswitchb)                      ;; Link a iswitch
     ;(global-set-key (kbd "C-M-r") 'org-capture)                 ;; Link a Capture

      ;;   ;;(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)
      ;;   (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>") 'bh/save-then-publish)
   #+END_SRC



* Upgrade
;;    * Upgrade
;;    
;;    ** 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
;;         ;; 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]]
;;    
;;    ** 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
;;         (use-package ox-twbs
;;           :ensure t)
;;       #+END_SRC