emacs-humanities/config.org

#+title: Emacs Humanities
#+author: Aabm
#+startup: overview

* Sobre esta configuração

O Emacs Humanities é uma configuração para o GNU Emacs preparada para 
a produção de documentos acadêmicos das Ciências Humanas, usando o
Emacs por ser um dos editores de LaTeX mais poderosos e por seu
org-mode. 

A documentação inclusa aqui ainda está em elaboração.

** TODO Coisas a fazer
*** TODO Adicionar melhor suporte para escrita de LaTeX pelo AucTeX

Atualmente o Emacs Humanities não possui configuração específica para 
a produção de documentos LaTeX diretamente. Por enquanto recomendo que  
façam tais documentos pelo org-mode com inserção de blocos LaTeX. 
É perfeitamente possível escrever LaTeX na configuração atual; só não
há nenhum aprimoramento em relação à experiência padrão. De qualquer
maneira, o Emacs é completamente extensível e programável, e esta
configuração é software livre: você tem a liberdade e a possibilidade
de modificá-la como quiser e adicionar o que quiser.

*** TODO Adicionar suporte para pacotes de Estatística, mais especificamente o ESS
  - O ESS pode ser usado para programação em R, Julia e outras linguagens
  - Código em R pode ser incluído em documentos org e exportado para PDFs pela compilação de LaTeX
    
* Licensa

#+begin_src emacs-lisp
;;; ------------------------------------------------------------------
;; LICENSE
;; Copyright © 2020 Aabm <aabm@disroot.org>
;; Author: Aabm <aabm@disroot.org>
;; URL: <https://git.snopyta.org/aabm/emacs-humanities/>

;; This file is not part of GNU Emacs.
;;
;; This program is free software: you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program, see the file LICENSE. If not, see
;; <http://www.gnu.org/licenses/>
;;; ------------------------------------------------------------------
#+end_src

Uma tradução não oficial para português brasileiro da licensa acima
pode ser encontrada em:
http://licencas.softwarelivre.org/gpl-3.0.pt-br.html 

* Credenciais do usuário

Esta seção carrega um arquivo de credenciais pessoais, que podem ser
utilizadas em diversas situações. 

#+begin_src emacs-lisp 
  ;;; Carrega o arquivo de credenciais se possível
  (when (file-readable-p (concat user-emacs-directory "creds.el"))
    (load-file (concat user-emacs-directory "creds.el")))
#+end_src

Se você quiser utilizar suas credenciais, basta criar um arquivo
chamado "creds.el" no mesmo diretório desta configuração com conteúdo
similar ao exemplo, menos os comentários:

#+begin_src emacs-lisp 
  ;;; Exemplo de configuração de credenciais pessoais:
  ;; (setq user-full-name "Seu Nome Aqui"
  ;;       user-mail-address "seu@email.aqui"
  ;;       calendar-location-name "Cidade, Estado")
#+end_src

Estas credenciais podem ser utilizadas automaticamente por algumas
funções, como a inserção automática de nome de autor em arquivos =org=
exportados para PDF pelo LaTeX.

* Configurações gerais
** Habilitando teclas de atalho "avançadas" 

Por padrão, o Emacs considera algumas funções como "avançadas", e
portanto não recomendadas para usuários inexperientes. Quando
acessadas, um prompt aparece perguntando se o usuário deseja seguir em
frente. Essas funções são raramente usadas pela maior parte dos
usuários, mas reabilitamos elas para evitarmos o aviso.

#+begin_src emacs-lisp
  (put 'dired-find-alternate-file 'disabled nil)
  (put 'upcase-region 'disabled nil)
  (put 'downcase-region 'disabled nil)
  (put 'narrow-to-region 'disabled nil)
  (setq disabled-command-function nil)
#+end_src

** Formatação de texto

Aqui garantimos que toda a codificação de texto seja feita sob o
padrão UTF-8, que é universal. Também configuramos indentação de
código, para programação ocasional.

#+begin_src emacs-lisp 
  ;;; Usar UTF-8 por padrão
  (prefer-coding-system 'utf-8)
  (set-terminal-coding-system 'utf-8) 
  (set-keyboard-coding-system 'utf-8) 
  (set-selection-coding-system 'utf-8) 
  (set-language-environment 'utf-8)
  (set-default-coding-systems 'utf-8)
  (setq locale-coding-system 'utf-8) 
  (setq org-export-coding-system 'utf-8) 

  ;;; Configurações de indentação
  (setq-default tab-width 4) 

  ;;; Carregar pacote para caracteres não ingleses
  (require 'iso-transl)
#+end_src

** Exibição de texto

As configurações encontradas aqui são um pouco mais variadas, mas em
geral se tratam da maneira que texto e informações textuais são
exibidas ao usuário; Coisas como números de linha, realce de sintaxe,
etc. 
#+begin_src emacs-lisp
  ;;; Exibir números de linha em modos de programação
  (add-hook 'prog-mode-hook 'display-line-numbers-mode)

  ;;; Realçar linha do cursorn
  (add-hook 'prog-mode-hook 'hl-line-mode)
  (add-hook 'text-mode-hook 'hl-line-mode)
  (add-hook 'org-mode-hook 'hl-line-mode)

  ;;; Desabilitar a continuação de linhas extensas
  (setq truncate-lines nil)
  (setq org-startup-truncated nil)

  ;;; Realçar parênteses
  (show-paren-mode 1)

  ;;; Melhor navegação de linhas dobradas
  (global-visual-line-mode t)

  ;;; Embelezar símbolos. 
  (global-prettify-symbols-mode t)
#+end_src

** Opções da interface gráfica

Estas são configurações básicas relacionadas à interface gráfica.
#+begin_src emacs-lisp
  ;; Desabilitar tela e mensagem de início padrão
  (setq inhibit-startup-message t)
  (setq inhibit-startup-echo-area-message t)

  ;; Desabilitar mensagem do scratch buffer 
  (setq initial-scratch-message nil)

  ;; org-mode como modo padrão do scratch buffer
  (setq initial-major-mode 'org-mode)

  ;; Melhores nomes para buffers de arquivos com mesmos nomes
  (require 'uniquify)
  (setq uniquify-buffer-name-style 'forward)

  ;; Exibir números de linha e coluna na modeline
  (line-number-mode t)
  (column-number-mode t)
#+end_src

** Changing defaults

Aqui alteramos ou desabilitamos alguns comportamentos indesejáveis que
são padrão no Emacs. Mais notáveis são o chamado "scroll
não-conservador", em que todo o buffer rola quando o cursor muda para
uma linha fora da tela, e o não uso da área de transferência do
sistema.

#+begin_src emacs-lisp
  ;;; Habilitar o scroll conservador. Difícil viver sem essa opção.
  (setq scroll-conservatively 100)

  ;;; Desabilitar o sinal auditivo de aviso
  (setq ring-bell-function 'ignore)

  ;;; Usar área de transferência do Xorg
  (setq x-select-enable-clipboard t)

  ;;; Nada de backups ou autosaves.
  (setq make-backup-files nil) 
  (setq auto-save-default nil) 

  ;;; Substituir todos os prompts de "yes or no" por "y or n".
  (defalias 'yes-or-no-p 'y-or-n-p)

  ;;; Recarregar buffers automaticamente quando eles forem alterados no disco.
  (global-auto-revert-mode t)
#+end_src

** Configuring other basic features
*** Electric pairs

Os electric pairs servem para completar caracteres de abertura como
parênteses com seus respectivos caracteres de fechamento. Útil para
uso com parênteses e aspas.

#+begin_src emacs-lisp
  (setq electric-pair-pairs '(
                             (?\{ . ?\})
                             (?\( . ?\))
                             (?\[ . ?\])
                             (?\" . ?\")
                             ))

  (electric-pair-mode t)
#+end_src

* Pacotes básicos
** Async

Uma biblioteca para processamento assíncrono. Utilizamos ela para
facilitar algumas operações, como cópia e movimento de arquivos.

#+begin_src emacs-lisp
  (use-package async
			   :ensure t
			   :init
			   (dired-async-mode t)
			   (async-bytecomp-package-mode t))
#+end_src

** Which-key

O which-key é um pacote muito utilizado em configurações prontas do
Emacs. Serve para exibir um "menu guia" das teclas de atalho ao
usuário. É ele que aparece quando se aperta alguma tecla de atalho
incompleta, como C-x. Permite ao usuário descobrir tanto sobre atalhos
de teclas padrão quanto customizados, de maneira intuitiva.

#+begin_src emacs-lisp
  (use-package which-key
	:ensure t
	:init
	(which-key-mode))
#+end_src

** General

O General.el é um pacote feito para simplificar as declarações de
teclas de atalho customizadas.

#+begin_src emacs-lisp
  (use-package general
    :ensure t)
#+end_src

** Swiper/Ivy/Counsel

O Ivy é um pacote leve porém poderoso para autocompleção de prompts e
pesquisa /fuzzy matching/. Aqui é utilizado para substituir ações como
find-file ou switch-buffer. Também o combinamos com o Counsel, que
aprimora as funções do Ivy e adiciona novas, ainda mais úteis. O
ivy-rich é uma extensão que adiciona mais informação aos menus do
Ivy.

O Swiper é uma ferramenta de busca, utilizada para buscar por texto ou
expressões regulares dentro de um buffer.

Todas essas ferramentas tem suas teclas de atalho definidas em outra
seção desta configuração. 

#+begin_src emacs-lisp
  (use-package ivy
    :ensure t 
    :init
    (ivy-mode)
    :custom
    (enable-recursive-minibuffers t))

  (use-package counsel
    :ensure t
    :init
    (counsel-mode))

  (use-package ivy-rich
    :ensure t
    :init
    (ivy-rich-mode))

  (use-package swiper
    :ensure t)
#+end_src

** Magit

O Magit é uma das mais populares extensões do Emacs. É uma interface
completa para o git, um dos principais sistemas de controle de versão
existentes. O Magit torna o uso do git muito mais simples, e elimina a
necessidade de se aprender os comandos mais esotéricos e obscuros que
acabam sendo necessários para se usar o git devidamente. O git não é
só um programa para programadores; é na verdade uma excelente
ferramenta para produção de quaisquer projetos colaborativos com
colegas. Pode ser acessado pressionando C-x g.

#+begin_src emacs-lisp
  (use-package magit
    :ensure t)
#+end_src

* Edição de texto
** Expand-region

O expand-region é um pacote para seleção de texto por meio de expansão
de unidades semânticas. Pode ser acessado pressionando C-=.
#+begin_src emacs-lisp
  (use-package expand-region
    :ensure t)
#+end_src

** Undo Tree

O undo-tree é uma extensão que permite visualizar todo as suas
alterações de undo e redo (desfazer e refazer) a um buffer como uma
árvore com galhos divergentes. Assim, é possível visualizar todas as
iterações de um texto, e fazer decisões sobre quais versões manter ao
final. Pode ser acessado pressionando C-x u.

#+begin_src emacs-lisp
  (use-package undo-tree
    :ensure t
    :init
    (undo-tree-mode))
#+end_src

* Escrita, anotações e leitura 
** Básicos de org-mode
*** Configurações gerais

#+begin_src emacs-lisp
  ;; Diretório padrão org.
  (setq org-directory "~/docs/org/")

  ;; Impedir tarefa de ser marcada como feita se ainda tiver
  ;; dependências incompletas.
  (setq org-enforce-todo-dependencies t)
  (setq org-enforce-todo-checkbox-dependencies t)

  ;; Opções cosméticas
  (setq org-ellipsis "⬎") 
  (setq org-hide-leading-stars t)
  (add-hook 'org-mode-hook 'org-indent-mode)

  ;; Inserir estampa de data ao fechar TODOs
  (setq org-log-done 'time)
  ;; (setq org-log-done 'note)

  ;; Habilitar indentação nativa em blocos de código fonte
  (setq org-src-tab-acts-natively t)
  ;; Habilitar realce de sintaxe em blocos de código fonte
  (setq org-src-fontify-natively t)
  ;; Usar janela atual para editar blocos de código fonte
  (setq org-src-window-setup 'current-window)
#+end_src

*** Capture

#+begin_src emacs-lisp
  ;; Diretório padrão para anotações do org-capture
  (setq org-default-notes-file (concat org-directory "agenda.org"))
#+end_src

*** Agenda

#+begin_src emacs-lisp
  ;; Arquivos para serem lido pela agenda
  (setq org-archive-location (concat org-directory "agenda.org"))

#+end_src

*** Modelos estruturais

#+begin_src emacs-lisp
  (setq org-structure-template-alist
        '(("c" . "center\n")
          ("d" . "src text :tangle ~/.\n")
          ("e" . "src emacs-lisp\n")
          ("h" . "export html\n")
          ("l" . "export latex\n")
          ("q" . "quote\n")
          ("s" . "src")
          ("v" . "verse\n")))
#+end_src

*** Teclas de atalho

#+begin_src emacs-lisp
    (general-define-key
       :keymaps 'org-mode-map
       "C-M-n" 'org-metadown
       "C-M-p" 'org-metaup
       "M-n" 'org-forward-element
       "M-p" 'org-backward-element)
#+end_src

** Mapas mentais com org-roam

O org-roam é um sistema para interligação de anotações, seguindo o
método Zettelkasten. Sua principal função é possbilitar a criação de
um verdadeiro mapa mental do usuário. O mapa pode então ser
visualizado usando o org-roam-server, facilitando sua navegação.

#+begin_src emacs-lisp
  (use-package org-roam
    :ensure t
    :config
    (org-roam-mode)
    (require 'org-roam-protocol)
    :custom
    (org-roam-directory "~/docs/roam/")
    (org-roam-index-file "~/docs/roam/index.org")
    (org-roam-completion-system 'ivy)
    (org-roam-graph-executable "/usr/bin/neato")
    (org-roam-graph-extra-config '(("overlap" . "false"))))

  (use-package org-roam-server
    :ensure t
    :custom
    (org-roam-server-host "127.0.0.1")
    (org-roam-server-port 8080)
    (org-roam-server-export-inline-images t)
    (org-roam-server-authenticate nil)
    (org-roam-server-network-poll t)
    (org-roam-server-network-arrows nil)
    (org-roam-server-network-label-truncate t)
    (org-roam-server-network-label-truncate-length 60)
    (org-roam-server-network-label-wrap-length 20))

  (use-package org-roam-bibtex
    :ensure t)

  ;; Deft is useful for searching through notes
  (use-package deft
    :ensure t
    :bind
    :custom
    (deft-recursive t)
    (deft-use-filter-string-for-filename t)
    (deft-default-extension "org")
    (deft-directory "~/docs/roam/"))

  ;; Templates for creating new notes
    (setq org-roam-capture-templates
            '(("t" "tagged" plain (function org-roam--capture-get-point)
             "#+date:%T\n#+startup: overview\n#+roam_tags: %?\n#+roam_alias:"
             :file-name "%<%Y%m%d%H%M%S>-${slug}"
             :head "#+title: ${title}\n"
             :unnarrowed t)))
#+end_src

** Visualização de texto com olivetti-mode

O olivetti-mode serve para centralizar texto na tela para melhor
concentração durante a escrita ou leitura.

#+begin_src emacs-lisp 
  (use-package olivetti
    :ensure t)
#+end_src

** Leitura de PDFs com pdf-tools

O pdf-tools é um leitor de PDFs dentro do Emacs, utilizando o epdfinfo
e a biblioteca poppler como backend. Aqui definimos teclas de atalho e
algumas funções de utilidade.

#+begin_src emacs-lisp
  (use-package pdf-tools
    :ensure t
    :defer nil
    :config
    (pdf-loader-install)
    :custom
    (pdf-view-resize-factor 1.1)
    (pdf-view-continuous nil)
    (pdf-view-display-size 'fit-page)
    :bind (:map pdf-view-mode-map
                ("C-s" . isearch-forward)
                ("C-r" . isearch-backward)
                ("C-c d" . pdf-view-midnight-minor-mode)
                ("C-c z" . ehum/pdf-view-open-in-zathura)
                ("C-c p" . ehum/pdf-view-show-current-page)
                ("C-c t" . ehum/pdf-view-continuous-toggle )
                ("C-a" . image-scroll-right)
                ("C-e" . image-scroll-left)))


  (defun ehum/pdf-view-continuous-toggle ()
    (interactive)
    (cond ((not pdf-view-continuous)
           (setq pdf-view-continuous t)
           (message "Page scrolling: Continous"))
          (t
           (setq pdf-view-continuous nil)
           (message "Page scrolling: Constrained"))))

  (defun ehum/pdf-view-open-in-zathura ()
    "Open the current PDF with ‘zathura’."
    (interactive)
    (save-window-excursion
      (let ((current-file (buffer-file-name))
            (current-page (number-to-string (pdf-view-current-page))))
        (async-shell-command
         (format "zathura -P %s \"%s\"" current-page current-file))))
    (message "Sent to Zathura"))

  (defun ehum/pdf-view-show-current-page ()
    "Show the current page."
    (interactive)
    (message "Page: %s" (pdf-view-current-page)))
#+end_src

** Leitura de epubs com nov.el

O nov.el é um leitor de livros digitais em formato epub. Aqui
garantimos que ele seja sempre usado junto com o Olivetti-mode para
uma melhor experiência.

#+begin_src emacs-lisp 
  (use-package nov
    :ensure t
    :init
    (add-to-list 'auto-mode-alist '("\\.epub\\'" . nov-mode))
    :custom
    (olivetti-body-width 104)
    :hook
    (nov-mode . olivetti-mode))
#+end_src

** Gerenciamento de referências bibliográficas com BibTeX

O ivy-bibtex é uma ferramenta para inserção de referências
bibliográficas no formato BibTeX, usando o Ivy.

#+begin_src emacs-lisp 
  ;; Ivy-bibtex is a 
  (use-package ivy-bibtex
    :ensure t
    :bind*
    ("C-x C-r" . ivy-bibtex)
    :custom
    (bibtex-completion-bibliography "~/docs/tex/refs.bib")
    ;; default is to open pdf - change that to insert citation
    (ivy-bibtex-default-action #'ivy-bibtex-insert-citation))
  (defalias 'helm-bibtex 'ivy-bibtex)
#+end_src

** Edição de LaTeX com AUCTeX

#+begin_src emacs-lisp
  (use-package auctex
    :ensure t
    :custom
    ;; Sempre compilar TeX para PDFs
    (TeX-PDF-mode t)
    ;; Utilizar o pdf-tools para visualizar PDFs
    (TeX-view-program-selection '((output-pdf "PDF Tools")))
    (TeX-source-correlate-start-server t)
    :hook
    ;; Automaticamente atualizar o PDF visualizado após compilação
    (TeX-after-compilation-finished-functions . TeX-revert-document-buffer))
#+end_src

** Verificação ortográfica com Flyspell

#+begin_src emacs-lisp
  (use-package flyspell
    :ensure t
    :custom
    (ispell-program-name "aspell")
    :hook
    (text-mode . flyspell-mode)
    (org-mode . flyspell-mode)
    (prog-mode . flyspell-prog-mode))
#+end_src

* Funções customizadas
** Atualizar o Emacs Humanities

#+begin_src emacs-lisp
  (defun ehum/atualizar-configuração ()
        "Atualiza o Emacs Humanities para sua versão mais recente. Requer git instalado no sistema."
        (interactive)
        (let ((dir (expand-file-name user-emacs-directory)))
          (if (file-exists-p dir)
              (progn
                (message "Atualizando configuração")
                (cd dir)
                (shell-command "git pull")
                (message "Atualização finalizada com sucesso. Reinicie o Emacs para que quaisquer mudanças tomem efeito."))
            (message "\"%s\" arquivo não encontrado." dir))))
#+end_src

** Gerar scratch buffers

#+begin_src emacs-lisp
  (defun ehum/generate-org-buffer ()
    "Cria um sratch buffer em org-mode. Útil para fazer anotações descartáveis rapidamente."
    (interactive)
    (switch-to-buffer (make-temp-name "org-"))
    (org-mode))
#+end_src

** Eliminar buffer e janela

#+begin_src emacs-lisp
  (defun ehum/kill-buffer-and-window ()
	"Elimina o buffer e a janela atuais"
	(interactive)
	(progn
	  (kill-buffer)
	  (delete-window)))
#+end_src

** Melhor divisão de janelas

#+begin_src emacs-lisp
  (defun ehum/split-follow-window-below ()
	"Cria uma janela abaixo e muda o foco para ela. Substitui a função padrão split-window-below"
	(interactive)
	(split-window-below)
	(balance-windows)
	(other-window 1))

  (defun ehum/split-follow-window-right ()
	"Cria uma janela à direita e muda o foco para ela. Substitui a função padrão split-window-right"
	(interactive)
	(split-window-right)
	(balance-windows)
	(other-window 1))
#+end_src

** Encontrar arquivo de agenda

#+begin_src emacs-lisp 
  (defun ehum/find-org-agenda-file ()
    "Abre o arquivo de agenda"
    (interactive)
    (find-file (car (org-agenda-files))))
#+end_src

* Teclas de atalho globais
** Definindo teclas de prefixo

#+begin_src emacs-lisp 
  ;; Configura as teclas começando com C-z.
  (global-unset-key "\C-z")
  (defalias 'C-z-keymap (make-sparse-keymap))
  (defvar C-z-map (symbol-function 'C-z-keymap)
    "Global keymap for characters following C-z.")
  (define-key global-map "\C-z" 'C-z-keymap)
#+end_src

** Definindo teclas de atalho

#+begin_src emacs-lisp 
  (general-define-key
     ;; Teclas C-z
     ;; Gerenciando buffers
     "C-z b o" 'ehum/generate-org-buffer

     ;; Teclas com prefixos comuns
     ;; Gerenciamento de janelas
     "C-x 2" 'ehum/split-follow-window-below
     "C-x 3" 'ehum/split-follow-window-right

     ;; Gerenciando buffers
     "C-x k" 'kill-this-buffer
     "C-x C-k" 'ehum/kill-buffer-and-window
     "C-x C-b" 'ibuffer

     ;; Ivy/Counsel/Swiper
     "C-s" 'swiper
     "C-r" 'swiper-backward
     "C-x C-f" 'counsel-find-file
     "C-x b" 'counsel-switch-buffer
     "C-x r b" 'counsel-bookmark
     "M-x" 'counsel-M-x
     "C-h f" 'counsel-describe-function
     "C-h v" 'counsel-describe-variable
     "C-h o" 'counsel-describe-symbol

     ;; Org-mode
     "C-x a" 'org-agenda
     "C-x C-a" 'ehum/find-org-agenda-file	
     "C-x c" 'org-capture
     "C-c l" 'org-store-link

     ;; Org-roam
     "C-z C-f" 'org-roam-find-file
     "C-z C-l" 'org-roam-insert
     "C-z C-x" 'org-roam-graph
     "C-z C-c" 'org-roam-server-mode
     "C-z C-s" 'deft

     ;; Outras utilidades
     "C-x g" 'magit
     "C-x u" 'undo-tree
     "M-/" 'hippie-expand
     "C-=" 'er/expand-region
  )
#+end_src

* Tema e aparência
** Beacon

O beacon é um pacote bem simples. Ele simplesmente faz seu cursor
piscar levemente quando você muda pra outra janela ou buffer ou faz um
movimento grande, tornando mais fácil localizar o cursor depois de se
mover.

#+begin_src emacs-lisp
  (use-package beacon
	:ensure t
	:init
	(beacon-mode))
#+end_src

** Dashboard

O dashboard é o pacote utilizado pelo Emacs Humanities para criar a
tela de início customizada que você vê quando abre o Emacs. Aqui estão
todas as configurações dele, sinta-se livre para alterá-las como
quiser. Uma modificação simples seria mudar a logo exibida no
Dashboard alterando o valor da variável dashboard-startup-banner. 

#+begin_src emacs-lisp
  (use-package all-the-icons
    :ensure t
    :defer nil)

  (use-package dashboard
    :ensure t
    :defer nil
    :config
    (dashboard-setup-startup-hook)
    :custom
    (dashboard-set-heading-icons t)
    (dashboard-set-file-icons t)
    (dashboard-items
     '((recents . 5)
       (agenda . 10)))
    (dashboard-banner-logo-title "Bem-vindo ao Emacs Humanities!")
    (dashboard-startup-banner 'logo)
    (dashboard-center-content t)
    (dashboard-show-shortcuts t)
    (dashboard-set-init-info t)
    (dashboard-set-footer nil)
    (dashboard-set-navigator t)
    (dashboard-navigator-buttons
          `(;; line1
            ((,nil
              "Sobre"
              "Abrir a documentação local do Emacs Humanities"
              (lambda (&rest _) (find-file "~/.emacs.d/README.org"))
              'default)
             (nil
              "Gitea"
              "Abra a página do gitea desta configuração"
              (lambda (&rest _) (browse-url "https://git.snopyta.org/aabm/emacs-humanities"))
              'default)
             (nil
              "Tutorial"
              "Abrir o tutorial do Emacs no idioma desejado"
              (lambda (&rest _) (help-with-tutorial-spec-language))
              'default)		   
             )
              ;; segunda linha
              ((,nil
                "Configuração"
                "Abrir o arquivo de configuração"
                (lambda (&rest _) (find-file "~/.emacs.d/config.org"))
                'default)
             (nil
              "Referência"
              "Abrir a referência rápida do Emacs Humanities"
              (lambda (&rest _) (find-file "~/.emacs.d/referencia.org"))
              'default)			 
               ))))

  (setq initial-buffer-choice (lambda () (get-buffer "*dashboard*")))
#+end_src

** Doom modeline

A Doom Modeline é a barra de status customizada na parte inferior da
sua tela. Aqui estão todas as configurações que usamos para ela.

#+begin_src emacs-lisp
  (use-package doom-modeline
    :ensure t
    :init
    (doom-modeline-mode)
    :custom
    (doom-modeline-height 25)
    (doom-modeline-bar-width 5)
    (doom-modeline-project-detection 'project)
    (doom-modeline-icon (display-graphic-p))
    (doom-modeline-major-mode-icon t)
    (doom-modeline-major-mode-color-icon t)
    (doom-modeline-buffer-state-icon t)
    (doom-modeline-buffer-modification-icon nil)
    (doom-modeline-minor-modes nil)
    (doom-modeline-enable-word-count t)
    (doom-modeline-buffer-encoding nil)
    (doom-modeline-persp-name nil))
#+end_src

** Org Superstar
#+begin_src emacs-lisp
  (use-package org-superstar
    :ensure t
    :hook
    (org-mode . org-superstar-mode))
#+end_src

** Elegance

Seção ainda em fase de testes e modificações.

#+begin_src emacs-lisp
  ;; (when (file-readable-p (concat user-emacs-directory "elegance.el"))
  ;;   (load-file (concat user-emacs-directory "elegance.el")))

  ;; (when (file-readable-p (concat user-emacs-directory "Welcome.org"))
  ;;   (find-file-read-only (concat user-emacs-directory "Welcome.org")))
#+end_src

** Tema

Aqui instalamos os temas de cores Modus Operandi e Modus
Vivendi. Estes temas são feitos com acessibilidade visual em mente, e
seguindo especificações oficiais contraste e mais. O Modus Operandi é
o tema padrão do Emacs Humanities, por ter aparência simples e
profissional. Mais informações na [[https://protesilaos.com/modus-themes/][página dos temas Modus]].

Também instalamos o pacote de temas do [[https://github.com/hlissner/doom-emacs][Doom Emacs]], que inclui temas
mais coloridos, assim como reimplementações de esquemas de cores
populares como [[https://ethanschoonover.com/solarized/][Solarized]], [[https://github.com/morhetz/gruvbox][Gruvbox]] e [[https://draculatheme.com/][Dracula]].

Para mudar o tema utilizado pelo Emacs, altere a declaração de
=load-theme= abaixo para utilizar o nome do seu tema preferido, depois
reinicie o Emacs. Você pode ver e testar os temas disponíveis
utilizando =M-x load-theme=
#+begin_src emacs-lisp
  (use-package modus-operandi-theme
    :ensure t)
  (use-package modus-vivendi-theme
    :ensure t)

  (use-package doom-themes
    :ensure t
    :custom
    (doom-themes-enable-bold t)
    (doom-themes-enable-italic t)
    :config
    (doom-themes-org-config))

  (load-theme 'modus-operandi t)
#+end_src

** Opções do frame

Aqui definimos opções do frame (janela) do Emacs, como título, tamanho
inicial e fonte padrão. Encorajamos você a mudar a fonte de acordo com
sua preferência pessoal. O ideal é usar uma fonte monospace, ou de
espaçamento único, como a Source Code Pro aqui usada. Algumas
recomendações de fontes monospace: Iosevka, Inconsolata, Roboto Mono e
Terminus.

#+begin_src emacs-lisp
  ;; Título do frame
  (setq frame-title-format "%b")

  ;; Tamanho padrão do frame
  (add-to-list 'default-frame-alist '(width  . 90))
  (add-to-list 'default-frame-alist '(height . 35))

  ;; Fontes.
  (set-frame-font "Source Code Pro 13" nil t)
  (add-to-list 'default-frame-alist '(font . "Source Code Pro 13"))
#+end_src