.. _50: 50 Personalización ================== Este capítulo describe algunos métodos simples para personalizar el comportamiento de Emacs. Aparte de los métodos descritos aquí, vea :ref:`ApendiceD` para información sobre el uso de recursos X para personalizar Emacs, y vea :ref:`18` para información sobre grabación y reproducción de macros de teclado. Hacer cambios de mayor alcance y más abiertos implica escribir código Emacs Lisp; vea `Emacs Lisp `_ en **El Manual de Referencia Lisp**. Este capítulo describe algunos métodos simples para personalizar el comportamiento de Emacs. .. _50.1: 50.1 Interfaz de Personalización Fácil -------------------------------------- Emacs tiene muchas *configuraciones* que puede cambiar. La mayoría de los ajustes son variables personalizables (ver :ref:`50.2`), que también se llaman *opciones de Usuario*. Hay un gran número de variables personalizables, que controlan numerosos aspectos del comportamiento de Emacs; las variables documentadas en este manual están listadas en Índice de variables. Una clase separada de configuraciones son las *caras*, que determinan las fuentes, colores y otros atributos del texto (ver :ref:`15.8`). Para examinar y modificar los ajustes (tanto variables como caras), escriba :kbd:`Alt`:kbd:`x` ``customize`` (``M-x customize``). Esto crea un *búfer de personalización*, que le permite navegar a través de una lista lógicamente organizada de ajustes, editar y establecer sus valores, y guardarlos permanentemente. .. _50.1.1: 50.1.1 Grupos de Personalización ```````````````````````````````` Los ajustes de configuración se organizan en *grupos de personalización* . Estos grupos se agrupan en otros mayores, hasta llegar a un grupo maestro llamado Emacs. ``M-x customize`` crea un búfer de personalización que muestra el grupo Emacs de nivel superior. Se parece a esto, en parte: :: For help using this buffer, see [Easy Customization] in the [Emacs manual]. ________________________________________ [ Search ] Operate on all settings in this buffer: [ Revert... ] [ Apply ] [ Apply and Save ] Emacs group: Customization of the One True Editor. [State]: visible group members are all at standard values. See also [Manual]. [Editing] Basic text editing facilities. [Convenience] Convenience features for faster editing. ...more second-level groups... For help using this buffer, see [Easy Customization] in the [Emacs manual]. ________________________________________ [ Search ] Traducción: :: Para obtener ayuda sobre el uso de este búfer, consulte: [ Revertir... ] [ Aplicar ] [ Apliar y Guardar ] Grupo Emacs: Personalización del Único Editor Verdadero. [Estado]: los miembros visibles del grupo tienen todos valores estándar. Ver también [Manual] [Edición] Facilidades básicas de edición de texto [Conveniencia] Características convenientes para una edición más rápida. ... más grupos de segundo nivel Para obtener ayuda sobre el uso de este búfer, consulte [Personalización fácil] en el [Manual de Emacs]. ________________________________________ [ Buscar ] La parte principal de este búfer muestra el grupo de personalización ``Emacs``, que contiene varios otros grupos (``Editing`` (Edición), ``Convenience`` (Conveniente), etc.). Los contenidos de esos grupos no se listan aquí, sólo una línea de documentación cada uno. El *estado* del grupo indica si la configuración en ese grupo ha sido editada, establecida o guardada. Véase :ref:`50.1.3`. La parte principal del búfer de personalización es de sólo lectura, pero incluye algunos *campos editables* que puede modificar. Por ejemplo, en la parte superior del búfer de personalización hay un campo editable para buscar configuraciones (véase :ref:`50.1.2`). También hay *botones* y *enlaces*, que puede activar haciendo clic con el ratón, o moviendo el punto allí y escribiendo :kbd:`RETURN` (``RET``). Por ejemplo, los nombres de grupos como ``[Editing]`` son enlaces; al activar uno de estos enlaces se abre el búfer de personalización de ese grupo. En el búfer de personalización, puede teclear :kbd:`TAB` (``TAB``, ``widget-forward``) para avanzar al siguiente botón o campo editable. :kbd:`Shift`:kbd:`TAB` (``S-TAB``, ``widget-backward``) para retroceder al botón o campo editable anterior. .. _50.1.2: 50.1.2 Navegar y Buscar Configuraciones ``````````````````````````````````````` Desde el búfer de personalización de nivel superior creado por ``M-x customize``, puede seguir los enlaces a los subgrupos del grupo de personalización ``Emacs``. Estos subgrupos pueden contener configuraciones para personalizar; también pueden contener otros subgrupos, que tratan con subsistemas aún más especializados de Emacs. Mientras navega por la jerarquía de grupos de personalización, debería encontrar algunas opciones que quiera personalizar. Si está interesado en personalizar un parámetro en particular o un grupo de personalización, puede ir directamente allí con los comandos ``M-x customize-option``, ``M-x customize-face``, o ``M-x customize-group``. Véase :ref:`50.1.6`. Si no sabe exactamente qué grupos o ajustes desea personalizar, puede buscarlos utilizando el campo de búsqueda editable situado en la parte superior de cada búfer de personalización. Aquí puede introducir un término de búsqueda: una o varias palabras separadas por espacios o una expresión regular (véase :ref:`16.6`). A continuación, escriba :kbd:`RETURN` (``RET``) en el campo, o active el botón ``Search`` (Buscar) situado junto a él, para pasar a un búfer de personalización que contenga grupos y configuraciones que coincidan con esos términos. Tenga en cuenta, sin embargo, que esta función sólo encuentra grupos y configuraciones que estén cargados en la sesión actual de Emacs. Si no quiere que los búferes de personalización muestren el campo de búsqueda, cambie la variable ``custom-search-field`` a ``nil``. El comando ``M-x customize-apropos`` es similar al uso del campo de búsqueda, excepto que lee el término(s) de búsqueda usando el minibuffer. Véase :ref:`16.6`. ``M-x customize-browse`` es otra forma de navegar por las opciones disponibles. Este comando crea un búfer de personalización especial, que muestra sólo los nombres de grupos y configuraciones, en un diseño estructurado. Puede mostrar el contenido de un grupo, en el mismo búfer, invocando el botón ``[+]`` junto al nombre del grupo. Cuando se muestra el contenido del grupo, el botón cambia a ``[-]``; al invocarlo se vuelve a ocultar el contenido del grupo. Cada grupo o ajuste de este búfer tiene un enlace que dice ``[Group]`` (Grupo), ``[Option]`` (Opción) o ``[Face]`` (Cara). Al invocar este enlace se crea un búfer de personalización estándar que muestra sólo ese grupo, opción o cara; esta es la forma de cambiar los ajustes que se encuentran con ``M-x customize-browse``. .. _50.1.3: 50.1.3 Modificar una Variable ````````````````````````````` A continuación se muestra un ejemplo del aspecto de una variable, u opción de Usuario, en el búfer de personalización: :: [Hide] Kill Ring Max: 60 [State]: STANDARD. Maximum length of kill ring before oldest elements are thrown away. Traducción: :: [Oculto] Kill Ring Max: 60 [Estado]: STANDARD. Longitud máxima del anillo de muertes antes de que se desechen los elementos más antiguos. La primera línea muestra que la variable se llama ``kill-ring-max``, formateada como ``Kill Ring Max`` para facilitar la visualización. Su valor es ``120``. El botón ``[Hide]`` (Oculto), si está activado, oculta el valor y el estado de la variable; esto es útil para evitar saturar el búfer de personalización con valores muy largos (por esta razón, las variables que tienen valores muy largos pueden empezar ocultas). Si utiliza el botón ``[Hide]``, cambia a ``[Show Value]`` (Mostrar Valor), que puede activar para revelar el valor y el estado. En una pantalla gráfica, los botones ``[Hide]`` y ``[Show Value]`` se sustituyen por triángulos gráficos que apuntan hacia abajo y hacia la derecha, respectivamente. La línea que sigue al nombre de la variable indica el *estado de personalización* de la variable: en este ejemplo, ``STANDARD`` significa que no ha modificado la variable, por lo que su valor es el predeterminado. El botón ``[State]`` (Estado) ofrece un menú de operaciones para personalizar la variable. Debajo del estado de personalización se encuentra la documentación de la variable. Se trata de la misma documentación que mostraría el comando ``C-h v`` (véase :ref:`50.1.2`). Si la documentación tiene más de una línea, es posible que sólo se muestre una línea. Si es así, esa línea termina con un botón ``[More]`` (Más); actívelo para ver la documentación completa. Para introducir un nuevo valor para ``Kill Ring Max``, sólo tiene que mover el punto al valor y editarlo. Por ejemplo, teclee :kbd:`Alt`-:kbd:`d` (``M-d``) para borrar el ``60`` y teclear otro número. Cuando empiece a modificar el texto, la línea ``[State]`` cambiará: :: [State]: EDITED, shown value does not take effect until you set or save it. Traducción: :: [Estado]: EDITADO, el valor mostrado no tiene efecto hasta que Usted lo establezca o guarde. Editar el valor no hace que surta efecto inmediatamente. Para ello, debe establecer la variable activando el botón ``[State]` y eligiendo ``Set for Current Session`` (Establecer para la sesión actual). Entonces el estado de la variable pasa a ser: :: [State]: SET for current session only. No tiene que preocuparse por especificar un valor que no sea válido; la operación ``Set for Current Session`` comprueba la validez y no instalará un valor inaceptable. Mientras edita ciertos tipos de valores, como nombres de archivos, nombres de directorios y nombres de comandos Emacs, puedes realizar el completado con ``C-M-i`` (``widget-complete``), o las teclas equivalentes :kbd:`Alt`-:kbd:`TAB` (``M-TAB``) o :kbd:`ESC`:kbd:`TAB` (``ESC TAB``). Esto se comporta de forma muy parecida al completado del minibúfer (ver :ref:`9.4`). Al escribir :Kbd:`RETURN` (``RET``) en un campo de valor editable, se avanza al siguiente campo o botón, como ``TAB``. De este modo, puede escribir :kbd:`RETURN` (``RET``) cuando haya terminado de editar un campo, para pasar al siguiente botón o campo. Para insertar una nueva línea dentro de un campo editable, utilice ``C-o`` o ``C-q C-j``. Para algunas variables, sólo hay un conjunto fijo de valores legítimos, y no se le permite editar el valor directamente. En su lugar, aparece un botón ``[Value Menu]`` (Menú de ajustes) antes del valor; al activar este botón se presenta una selección de valores. Para un valor booleano ``on``/``off`` (activado o desactivado), el botón dice ``[Toggle]`` (Alternar), e invierte el valor. Después de utilizar el botón ``[Value Show]`` o ``[Toggle]``, debe volver a configurar la variable para que el valor elegido surta efecto. Algunas variables tienen valores con una estructura compleja. Por ejemplo, el valor de ``minibuffer-frame-alist`` es una lista de asociación. Así es como aparece en el búfer de personalización: :: [Hide] Minibuffer Frame Alist: [INS] [DEL] Parameter: width Value: 80 [INS] [DEL] Parameter: height Value: 2 [INS] [ State ]: STANDARD. Alist of parameters for the initial minibuffer frame. [Hide] […more lines of documentation…] Traducción: :: [Ocultar] Minibuffer Frame Alist: [INS] [DEL] Parámetro: width Valor: 80 [INS] [DEL] Parámetro: altura Valor: 2 [INS] [Estado] STANDARD. Lista de parámetros para el marco inicial del minibúfer. [Ocultar] [...más líneas de documentación...] En este caso, cada asociación de la lista consta de dos elementos, uno denominado ``Parameter`` (Parámetro) y otro denominado ``Value`` (Valor); ambos son campos editables. Puede eliminar una asociación de la lista con el botón ``[DEL]`` situado junto a ella. Para añadir una asociación, utilice el botón ``[INS]`` en la posición donde desee insertarla; el último botón ``[INS]`` inserta al final de la lista. Cuando fija una variable, el nuevo valor sólo tiene efecto en la sesión actual de Emacs. Para guardar el valor para futuras sesiones, usa el botón ``[State]`` y selecciona la operación ``Save for Future Sessions`` (Guardar para Futuras Sesiones). Véase :ref:`50.1.4`. También puede restaurar la variable a su valor estándar usando el botón ``[State]`` y seleccionando la operación ``Erase Customization`` (Borrar Personalización). En realidad hay cuatro operaciones de restablecimiento: ``Undo Edits`` (Deshacer Edición) Si ha modificado la variable pero aún no la ha establecido, esto restaura el texto en el búfer de personalización para que coincida con el valor real. ``Revert This Session's Customizations`` (Revertir Esta Sesión o Personalización) Esto restaura el valor de la variable al último valor guardado, si lo hubo. En caso contrario, restaura el valor estándar. Actualiza el texto en consecuencia. ``Erase Customization`` (Borrar Personalización) Esto establece la variable a su valor estándar. También se elimina cualquier valor guardado que tenga. ``Set to Backup Value`` (Establecer al Valor de Copia de Seguridad) Esto establece la variable a un valor anterior que se estableció en el búfer de personalización en esta sesión. Si personaliza una variable y luego la restablece, lo que descarta el valor personalizado, puede volver a obtener el valor descartado con esta operación. A veces resulta útil registrar un comentario sobre una personalización concreta. Utilice la opción ``Add Comment`` (Añadir comentario) del menú ``[State]`` para crear un campo en el que introducir el comentario. Cerca de la parte superior del búfer de personalización hay dos líneas de botones: :: Operate on all settings in this buffer: [Revert...] [Apply] [Apply and Save] Traducción: :: Opera sobre todos los ajustes de este búfer: [Revertir...] [Aplicar] [Aplicar y guardar] El botón ``[Revert...]`` (Revertir) despliega un menú con las 3 primeras operaciones de restablecimiento descritas anteriormente. El botón ``[Apply]`` (Aplicar) aplica la configuración para la sesión actual. El botón ``[Apply and Save]`` (Aplicar y Guardar) aplica la configuración y la guarda para futuras sesiones; este botón no aparece si Emacs se inició con la opción ``-q`` o ``-Q`` (ver :ref:`C.2`). El comando ``C-c C-c`` (``Custom-set``) es equivalente a usar el botón ``[Set for Current Session]``. El comando ``C-x C-s`` (``Custom-save``) equivale a utilizar el botón ``[Save for Future Sessions]``. El botón ``[Exit]`` (Salir) sale del búfer de personalización y lo entierra al final de la lista de búferes. Para eliminar el búfer de personalización, cambie la variable ``custom-buffer-done-kill`` a ``t``. .. _50.1.4: 50.1.4 Guardar Personalizaciones ```````````````````````````````` En el búfer de personalización, puede guardar un ajuste de personalización seleccionando la opción ``Save for Future Sessions`` de su botón ``[State]``. El comando ``C-x C-s`` (``Custom-save``, Guardar Personalización), o el botón ``[Apply and Save]`` en la parte superior del búfer de personalización, guarda todos los ajustes aplicables en dicho búfer. Guardar funciona escribiendo código en un fichero, normalmente su fichero de inicialización (ver :ref:`50.4`). Las futuras sesiones de Emacs leerán automáticamente este fichero al iniciarse, lo que configurará de nuevo las personalizaciones. Puede elegir guardar las personalizaciones en otro lugar que no sea tu fichero de inicialización. Para que esto funcione, debes añadir un par de líneas de código a su fichero de inicialización, para establecer la variable ``custom-file`` al nombre del fichero deseado, y para cargar ese fichero. Por ejemplo: :: (setq custom-file "~/.config/emacs-custom.el") (load custom-file) Incluso puede especificar diferentes archivos de personalización para diferentes versiones de Emacs, de esta forma: :: (cond ((< emacs-major-version 28) ;; Personalización Emacs 27. (setq custom-file "~/.config/custom-27.el")) ((and (= emacs-major-version 26) (< emacs-minor-version 3)) ;; Emacs 26 personalización, antes de la version 26.3. (setq custom-file "~/.config/custom-26.el")) (t ;; Emacs version 28.1 or superior. (setq custom-file "~/.config/emacs-custom.el"))) (load custom-file) Si Emacs fue invocado con las opciones ``-q`` o ``--no-init-file`` (ver :ref:`C.2`), no le dejará guardar sus personalizaciones en su fichero de inicialización. Esto se debe a que guardar las personalizaciones de dicha sesión borraría todas las demás personalizaciones que pudiera tener en su ardhivo de inicialización. Tenga en cuenta que cualquier personalización que no haya elegido guardar para futuras sesiones se perderá cuando termine Emacs. Si quiere que se le pregunte sobre las personalizaciones no guardadas en el momento de terminar, añada lo siguiente a su fichero de inicialización: :: (add-hook 'kill-emacs-query-functions 'custom-prompt-customize-unsaved-options) .. _50.1.5: 50.1.5. Personalización de Caras ```````````````````````````````` Puede personalizar las caras (ver :ref:`15.8`), que determinan cómo Emacs muestra los diferentes tipos de texto. Los grupos de personalización pueden contener tanto variables como caras. Por ejemplo, en los modos de lenguaje de programación, los comentarios del código fuente se muestran con ``font-lock-comment-face`` (ver :ref:`15.3`). En un búfer de personalización, esa cara aparece así, después de hacer clic en el enlace ``[Show All Atributes]`` (Mostrar todos los atributos) :: [Hide] Font Lock Comment Face:[sample] [State] : STANDARD. Font Lock mode face used to highlight comments. [ ] Font Family: -- [ ] Font Foundry: -- [ ] Width: -- [ ] Height: -- [ ] Weight: -- [ ] Slant: -- [ ] Underline: -- [ ] Overline: -- [ ] Strike-through: -- [ ] Box around text: -- [ ] Inverse-video: -- [X] Foreground: Firebrick [Choose] (sample) [ ] Background: -- [ ] Stipple: -- [ ] Inherit: -- [Hide Unused Attributes] Traducción: :: [Ocultar] Bloqueo de Fuente Cara de Comentario:[muestra] [Estado] : ESTÁNDAR. Cara del modo Font Lock utilizada para resaltar comentarios. [ ] Familia de fuentes: -- [ ] Funddido de fuentes: -- [ ] Ancho: -- [ ] Altura: -- [ ] Peso: -- [ ] Inclinación: -- [ ] Subrayado: -- [ ] Subrayado: -- [Tachado: -- [ ] Recuadro alrededor del texto: -- [ ] Vídeo inverso: -- [X] Primer plano: Ladrillo refractario [Elegir] (muestra) [ ] Fondo: -- [ ] Moteado: -- [ ] Heredar: -- [Ocultar atributos no utilizados] Las tres primeras líneas muestran el nombre, el botón ``[State]`` y la documentación de la cara. Debajo hay una lista de *atributos de la cara*. Delante de cada atributo hay una casilla de verificación. Una casilla de verificación rellena, ``[X]``, significa que la cara especifica un valor para este atributo; una casilla de verificación vacía, ``[ ]``, significa que la cara no especifica ningún valor especial para el atributo. Puede activar una casilla de verificación para especificar o no su atributo. No es necesario que una cara especifique todos y cada uno de los atributos; de hecho, la mayoría de las caras sólo especifican unos pocos atributos. En el ejemplo anterior, ``font-lock-comment-face`` sólo especifica el color de primer plano. Cualquier atributo no especificado se toma de la cara especial llamada default, cuyos atributos están todos especificados. La cara por defecto es la cara utilizada para mostrar cualquier texto que no tenga una cara explícitamente asignada; además, su atributo de color de fondo sirve como color de fondo del marco. El botón ``[Hide Unused Attributes]`` (Ocultar atributos no utilizados), al final de la lista de atributos, oculta los atributos no especificados de la cara. Cuando se ocultan atributos, el botón cambia a ``[Show All Attributes]`` (Mostrar todos los atributos), que muestra toda la lista de atributos. El búfer de personalización puede comenzar con los atributos no especificados ocultos, para evitar saturar la interfaz. Cuando se especifica un atributo, puede cambiar su valor de la forma habitual. Los colores de primer plano y de fondo pueden especificarse utilizando nombres de colores o tripletes RGB (véase :ref:`15.9`). También puede utilizar el botón ``[Choose]`` (Elegir) para cambiar a una lista de nombres de colores; seleccione un color con RET en ese búfer para poner el nombre del color en el campo de valor. Establecer, guardar y restablecer una cara funcionan como las mismas operaciones para las variables (véase :ref:`50.1.3`). Una cara puede especificar diferentes apariencias para diferentes tipos de pantallas. Por ejemplo, una cara puede hacer que el texto sea rojo en una pantalla en color, pero utilizar una fuente en negrita en una pantalla monocromo. Para especificar varias apariencias para una cara, seleccione ``For All Kinkds Displays`` (Para todo tipo de pantallas) en el menú que aparece al invocar ``[State]``. .. _50.1.6: 50.1.6 Personalización de elementos concretos ````````````````````````````````````````````` | :kbd:`Alt`-:kbd:`x` ``customize-option`` :kbd:`RETURN` *opcion* :kbd:`RETURN` | (``M-x customize-option RET`` *opción* ``RET``) | :kbd:`Alt`-:kbd:`x` ``customize-variable`` :kbd:`RETURN` *opcion* :kbd:`RETURN` | (``M-x customize-variable RET`` *opción* ``RET``) Configura un búfer de personalización para una sola opción de Usuario, *opción*. | :kbd:`Alt`-:kbd:`x` ``customize-face`` *cara* :kbd:`RETURN` | (``M-x customize-face RET`` *cara* ``RET``) Configura un búfer de personalización para una solca opción de Usuario, *cara*. | :kbd:`Alt`-:kbd:`x` ``customize-icon`` :kbd:`RETURN` *cara* :kbd:`RETURN` | (``M-x customize-icon RET`` *cara* ``RET``) Configura un búfer de personalización para una sola opción de Usuario, *icono*. | :kbd:`Alt`-:kbd:`x` ``customize-group`` :kbd:`RETURN` *grup* :kbd:`RETURN` | (``M-x customize-group RET`` *grupo* ``RET``) Configura un búfer de personalización para una sola opción de grupo, *grupo*. | :kbd:`Alt`-:kbd:`x` ``customize-apropos`` :kbd:`RETURN` *expreg* :kbd:`RETURN` | (``M-x customize-apropos RET`` *expreg* ``RET``) Configura un búfer de personalización para un grupo que contiene la expresión regular *expreg*. | :kbd:`Alt`-:kbd:`x` ``customize-changed`` *version* :kbd:`RETURN` | (``M-x customize-changed RET`` *version* ``RET``) Configura un búfer de personalización con todas las opciones de Usuario, caras y grupos cuyo significado ha cambiado desde (o ha sido añadido después de) la versión de Emacs. :kbd:`Alt`-:kbd:`x` ``customize-saved`` (``M-x customize-saved``) Configura un búfer de personalización que contenga todos los ajustes que haya guardado con los búferes de personalización. :kbd:`Alt`-:kbd:`x` ``customize-unsaved`` (``M-x customize-unsaved``) Configura un búfer de personalización que contenga todos los ajustes que haya establecido pero que no haya guardado. Si desea personalizar una opción de Usuario en particular, escriba :kbd:`Alt`-:kbd:`x` ``customize-optioin`` (``M-x customize-option``). Esto lee el nombre de la variable y configura el búfer de personalización sólo con esa opción de Usuario. Al introducir el nombre de la variable en el minibuffer, el completado está disponible, pero sólo para los nombres de las variables que han sido cargadas en Emacs. Del mismo modo, puede personalizar una cara específica usando ``M-x customize-face``. Puede configurar un búfer de personalización para un grupo de personalización específico utilizando ``M-x customize-group``. ``M-x customize-apropos`` solicita un término de búsqueda -ya sea una o más palabras separadas por espacios, o una expresión regular- y configura un búfer de personalización para todas las configuraciones y grupos cargados con nombres coincidentes. Es como utilizar el campo de búsqueda de la parte superior del búfer de personalización (véase :ref:`50.1.1`). Cuando actualice a una nueva versión de Emacs, puede que quiera considerar personalizar nuevas configuraciones, y otras cuyo significado o valores por defecto hayan cambiado. Para hacer esto, use ``M-x customize-changed`` y especifique un número de versión anterior de Emacs usando el minibuffer. Crea un buffer de personalización que muestra todas las configuraciones y grupos cuyas definiciones han sido cambiadas desde la versión especificada, cargándolas si es necesario. Si cambia configuraciones y luego decide que el cambio fue un error, puede usar dos comandos para revisar sus cambios. Utilice ``M-x customize-saved`` para personalizar los ajustes que haya guardado. Utilice ``M-x customize-unsaved`` para personalizar los ajustes que haya establecido pero que no haya guardado. 50.1.7 Temas personalizados ``````````````````````````` Los *temas personalizados* son colecciones de ajustes que pueden activarse o desactivarse como una unidad. Puede usar temas personalizados para cambiar fácilmente entre varias colecciones de configuraciones, y para transferir tales colecciones de un ordenador a otro. Un tema personalizado se almacena como un archivo fuente Emacs Lisp. Si el nombre del tema personalizado es nombre, el archivo del tema se llamará nombre-tema.el. Ver :ref:`50.1.8`, para el formato de un archivo de tema y cómo hacer uno. Teclee (``M-x customize-themes``) para cambiar a un búfer llamado ``*Custom Themes*`` (Temas Personalizados), que lista los temas personalizados que Emacs conoce. Por defecto, el Editor busca archivos de temas en dos localizaciones: el directorio especificado por la variable ``custom-theme-directory`` (que por defecto es ``~/.emacs.d/``), y un directorio llamado ``etc/themes`` en su instalación de Emacs (ver la variable ``data-directory``). Este último contiene varios temas personalizados distribuidos con Emacs que personalizan las caras del Editor para ajustarse a varios esquemas de color. (Tenga en cuenta, sin embargo, que los temas personalizados no tienen por qué restringirse a este propósito; también pueden usarse para personalizar variables). Si quiere que Emacs busque temas personalizados en algún otro directorio, añada el directorio a la variable de lista ``custom-theme-load-path``. Su valor por defecto es (``custom-theme-directory t``); aquí, el símbolo ``custom-theme-directory`` tiene el significado especial del valor de la variable ``custom-theme-directory``, mientras que ``t`` significa el directorio de temas incorporado ``etc/themes``. Los temas listados en el búfer ``*Custom Themes*`` son los que se encuentran en los directorios especificados por ``custom-theme-load-path``. En el búfer ``*Custom Themes*``, puede activar la casilla junto a un tema personalizado para habilitar o deshabilitar el tema para la sesión actual de Emacs. Cuando se activa un tema personalizado, todos sus ajustes (variables y caras) tienen efecto en la sesión de Emacs. Para aplicar la elección de tema(s) a futuras sesiones de Emacs, teclee :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`s` (``C-x C-s``, ``custom-theme-save``) o use el botón ``[Save Theme Settings]``. Cuando activa por primera vez un tema personalizado, Emacs muestra el contenido del archivo del tema y le pregunta si realmente quiere cargarlo. Dado que cargar un tema personalizado puede ejecutar código Lisp arbitrario, sólo debería decir que sí si sabe que el tema es seguro; en ese caso, Emacs le ofrece recordar en el futuro que el tema es seguro (esto se hace guardando el hash SHA-256 del fichero de tema en la variable ``custom-safe-themes``; si quiere tratar todos los temas como seguros, cambie su valor a ``t``). Los temas que vienen con Emacs (en el directorio ``etc/themes``) están exentos de esta comprobación, y siempre se consideran seguros. Para establecer o guardar temas personalizados, en realidad se personaliza la variable ``custom-enabled-themes``. El valor de esta variable es una lista de nombres de temas personalizados (como símbolos Lisp, por ejemplo, ``tango``). En lugar de utilizar el búfer ``*Custom Themes*`` para establecer ``custom-enabled-themes``, puede personalizar la variable utilizando la interfaz de personalización habitual, por ejemplo, con ``M-x customize-option``. Tenga en cuenta que los temas personalizados no pueden definir ellos mismos los temas personalizados habilitados. Cualquier personalización que realice a través del búfer de personalización tiene prioridad sobre la configuración del tema. Esto le permite anular fácilmente los ajustes individuales del tema con los que no esté de acuerdo. Si los ajustes de dos temas diferentes se solapan, el tema que aparece antes en ``custom-enabled-themes`` tiene prioridad. En el búfer de personalización, si un tema personalizado ha cambiado un ajuste respecto al predeterminado, su ``Theme`` (Tema) mostrará ``THEME`` (TEMA) en lugar de ``STANDARD`` (ESTÁNDAR). Puede activar un tema personalizado específico en la sesión actual de Emacs escribiendo :kbd:`Alt`-:kbd:`x` ``load-theme`` (``M-x load-theme``). Esto pide un nombre de tema, carga el tema desde el archivo de tema, y lo activa. Si un archivo de tema ha sido cargado antes, puede activar el tema sin cargar su archivo escribiendo ``M-x enable-theme``. Para desactivar un tema personalizado, escriba :kbd:`Alt`-:kbd:`x` ``disable-theme`` (``M-x disable-theme``). Para ver una descripción de un tema personalizado, escriba :kbd:`?` (``?``) en su línea en el búfer ``*Custom Themes*``; o escriba :kbd:`Alt`-:kbd:`x` ``describe-theme`` (``M-x describe-theme``) en cualquier lugar de Emacs e introduzca el nombre del tema. Algunos temas tienen variantes (en la mayoría de los casos, sólo dos: claro y oscuro). Puede cambiar a otra variante utilizando ``M-x theme-choose-variant``. Si el tema activo sólo tiene otra variante, se seleccionará; si hay más variantes, el comando le preguntará a cuál desea cambiar. Tenga en cuenta que ``theme-choose-variant`` sólo funciona si hay un único tema activo. .. _50.1.8: 50.1.8 Crear Temas Personalizados ````````````````````````````````` Puede definir un tema personalizado utilizando una interfaz similar a la del búfer de personalización, escribiendo :kbd:`Alt`-:kbd:`x` ``customize-create-theme`` (``M-x customize-create-theme``). Esto cambia a un búfer llamado ``*Custom Theme*`` (Tema personalizado). También ofrece insertar algunas caras Emacs comunes en el tema (una conveniencia, ya que los temas personalizados se usan a menudo para personalizar caras). Si contesta que no, el tema no contendrá inicialmente ninguna configuración. Cerca de la parte superior del búfer ``*Custom Theme*``, hay campos editables donde puede introducir el nombre y la descripción del tema. El nombre puede ser cualquier cosa excepto ``user`` (Usuario). La descripción es la que se mostrará cuando invoque ``M-x describe-theme`` para el tema. Su primera línea debe ser un breve resumen de una frase; en el búfer hecho por ``M-x customize-themes``, esta frase se muestra junto al nombre del tema. Para añadir una nueva configuración al tema, utilice los botones ``[Insert Additional Face]`` (Insertar Cara Adicional) o ``[Insert Additional Variable]`` (Insertar Variable Adicional). Cada botón lee un nombre de cara o variable utilizando el minibúfer, con finalización, e inserta una entrada de personalización para la cara o variable. Puede editar los valores de la variable o los atributos de la cara del mismo modo que en un búfer de personalización normal. Para eliminar una cara o variable del tema, desmarca la casilla situada junto a su nombre. Tras especificar las caras y variables del tema personalizado, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`s` (``C-x C-s``, ``custom-theme-write``) o utilice el botón ``[Save Theme]`` (Guardar tema) del búfer. Esto guarda el archivo del tema, llamado ``nombre-tema.el`` donde *nombre* es el nombre del tema, en el directorio nombrado por ``custom-theme-directory``. Desde el búfer ``*Custom Theme*``, puede ver y editar un tema personalizado existente activando el botón ``[Visit Theme]`` (Visitar Tema) y especificando el nombre del tema. También puede añadir la configuración de otro tema al búfer, utilizando el botón ``[Merge Theme]`` (Fusionar Tema). Puede importar la configuración de otro tema a un tema personalizado utilizando el botón ``[Merge Theme]`` y especificando el tema especial llamado ``user``. Un archivo de tema es simplemente un archivo fuente Emacs Lisp, y cargar el tema personalizado funciona cargando el archivo Lisp. Por lo tanto, puede editar un archivo de tema directamente en lugar de usar el búfer ``*Custom Theme*``. Vea `Temas Personalizados `_ en **El Manual de Referencia de Emacs Lisp**, para más detalles. .. _50.2: 50.2 Variables -------------- Una *variable* es un símbolo Lisp que tiene un valor. El nombre del símbolo también se denomina *nombre de la variable*. Un nombre de variable puede contener cualquier carácter que pueda aparecer en un fichero, pero la mayoría de los nombres de variable consisten en palabras ordinarias separadas por guiones. El nombre de la variable sirve como descripción compacta de su función. La mayoría de las variables también tienen una *cadena de documentación*, que describe cuál es el propósito de la variable, qué tipo de valor debe tener y cómo se utilizará el valor. Puede ver esta documentación utilizando el comando de ayuda ``C-h v`` (``describe-variable``). Véase :ref:`50.2.1`. Emacs usa muchas variables Lisp para el mantenimiento de registros internos, pero las variables más interesantes para un Usuario no programador son aquellas destinadas a que Ellos las cambien, estas se llaman *variables personalizables* u opciones de Usuario (ver :ref:`50.1`). En las siguientes secciones, describiremos otros aspectos de las variables de Emacs, como por ejemplo cómo configurarlas fuera de Personalizar. Emacs Lisp permite que cualquier variable (con unas pocas excepciones) tenga cualquier tipo de valor. Sin embargo, muchas variables sólo tienen sentido si se les asignan valores de un cierto tipo. Por ejemplo, sólo los números son valores significativos para ``kill-ring-max``, que especifica la longitud máxima del anillo de muertes (``kill-ring-max``, ver :ref:`13.2.2`); si le da a ``kill-ring-max`` un valor de cadena, comandos como ``C-y`` (``yank``) indicarán un error. Por otro lado, algunas variables no se preocupan por el tipo; por ejemplo, si una variable tiene un efecto para valores nulos y otro efecto para valores no nulos, entonces cualquier valor que no sea el símbolo nulo induce el segundo efecto, independientemente de su tipo (por convención, normalmente usamos el valor ``t`` ,un símbolo que significa ``true`` (verdadero), para especificar un valor no nulo). Si establece una variable utilizando el búfer de personalización, no debe preocuparse por darle un tipo no válido: el búfer de personalización normalmente sólo permite introducir valores significativos. En caso de duda, utilice ``C-h v`` (``describe-variable``) para comprobar la cadena de documentación de la variable y ver qué tipo de valor espera (consulte :ref:`50.2.1`). .. _50.2.1: 50.2.1 Examen y Configuración de Variables `````````````````````````````````````````` :kbd:`Ctrl`-:kbd:`h` :kbd:`v` *var* :kbd:`RETURN` (``C-h v`` *var* ``RET``) Muestra el valor y la documentación de la variable var (``describe-variable``). | :kbd:`Alt`-:kbd:`x` ``set-variable`` :kbd:`RETURN` *var* :kbd:`RETURN` *valor* :kbd:`RETURN` | (``M-x set-variable RET`` *var* ``RET`` *valor* ``RET``) Cambia el valor de la variable *var* a *valor*. Para examinar el valor de una variable, utilice ``C-h v`` (``describe-variable``). Esto lee un nombre de variable utilizando el minibúfer, con finalización, y muestra tanto el valor como la documentación de la variable. Por ejemplo, :: C-h v fill-column RET muestra algo como esto: :: fill-column is a variable defined in ‘C source code’. Its value is 70 Automatically becomes buffer-local when set. This variable is safe as a file local variable if its value satisfies the predicate ‘integerp’. Probably introduced at or before Emacs version 18. Documentation: Column beyond which automatic line-wrapping should happen. Interactively, you can set the buffer local value using C-x f. You can customize this variable. Traducción: :: fill-column es una variable definida en 'C source code'. Su valor es 70 Se convierte automáticamente en buffer-local cuando se establece. Esta variable es segura como variable local de fichero si su valor satisface el predicado 'integerp'. Probablemente introducida en o antes de la versión 18 de Emacs. Documentación: Columna más allá de la cual debe producirse el ajuste de línea automático. Interactivamente, puedes establecer el valor local del buffer usando C-x f. Puedes personalizar esta variable. La línea que dice ``You can customize the variable`` (Puede personalizar la variable) indica que esta variable es una opción de Usuario. ``C-h v`` no está restringido a dichas opciones; también permite variables no personalizables. La forma más conveniente de establecer una variable personalizable específica es con ``M-x set-variable``. Esto lee el nombre de la variable con el minibúfer (con finalización), y luego lee una expresión Lisp para el nuevo valor usando el minibúfer una segunda vez (puede insertar el valor antiguo en el minibúfer para editarlo mediante ``M-n``). Por ejemplo, :: M-x set-variable RET fill-column RET 75 RET establece la columna de relleno (``fill-columns``) en 75 ``M-x set-variable`` está limitado a variables personalizables, pero puede establecer cualquier variable con una expresión Lisp como ésta: :: (setq fill-column 75) Para ejecutar una expresión de este tipo, escriba :kbd:`Alt`-:kbd:`:` ``(eval-expression)`` (``M-: (eval-expression)``) e introduzca la expresión en el minibúfer (véase :ref:`28.9`). Alternativamente, vaya al búfer ``*scratch*``, teclee la expresión, y luego teclee :kbd:`Ctrl`-:kbd:`j` (``C-j``, vea :ref:`28.10`). Establecer variables, como todas las formas de personalizar Emacs excepto cuando se indique lo contrario, afecta sólo a la sesión actual de Emacs. La única manera de alterar la variable en futuras sesiones es poner algo en tu fichero de inicialización (ver :ref:`50.4`). Si está configurando una variable personalizable en su fichero de inicialización, y no quiere usar la interfaz Personalizar, puede usar la macro ``setopt``. Por ejemplo: :: (setopt fill-column 75) Funciona igual que ``setq``, pero si la variable tiene alguna función de configuración especial, se ejecutará automáticamente al usar ``setopt``. También puede utilizar esta función (``setopt``) en otras variables no personalizables, pero es menos eficiente que utilizar ``setq``. .. _50.2.2: 50.2.2 Ganchos (Hooks) `````````````````````` Los *ganchos* (hooks) son un mecanismo importante para personalizar Emacs. Un gancho es una variable Lisp que contiene una lista de funciones, para ser llamadas en alguna ocasión bien definida. (Esto se llama *ejecutar el gancho*) Las funciones individuales de la lista se denominan *funciones gancho* del gancho. Por ejemplo, el gancho ``kill-emacs-hook`` se ejecuta justo antes de salir de Emacs (ver :ref:`7`). La mayoría de los ganchos son *ganchos normales*. Esto significa que cuando Emacs ejecuta el gancho, llama a cada función del gancho sucesivamente, sin argumentos. Hemos hecho un esfuerzo para mantener la mayoría de los ganchos normales, para que pueda usarlos de forma uniforme. Cada variable cuyo nombre termina en ``-hook`` es un gancho normal. Algunos ganchos son *anómalos*. Sus nombres terminan en ``-functions``, en lugar de ``-hook`` (algunos códigos antiguos también pueden usar el sufijo obsoleto ``-hooks``). Lo que hace que estos ganchos sean no habituales es la forma en que se llama a sus funciones: quizás se les dan argumentos, o quizás los valores que devuelven se utilizan de alguna forma. Por ejemplo, ``find-file-not-found-functions`` es anormal porque tan pronto como una función hook devuelve un valor no nulo, el resto no son llamadas en absoluto (ver :ref:`19.2`). La documentación de cada variable gancho anormal explica cómo se utilizan sus funciones. Puede establecer una variable gancho con ``setq`` como cualquier otra variable Lisp, pero la forma recomendada de añadir una función a un gancho (ya sea normal o anormal) es usar ``add-hook``, como se muestra en los siguientes ejemplos. Vea `Ganchos `_ en **El Manual de Referencia de Emacs Lisp**, para más detalles. La mayoría de los modos principales ejecutan uno o más *ganchos de modo* como último paso de la inicialización. Los ganchos de modo son una forma conveniente de personalizar el comportamiento de los modos individuales; siempre son normales. Por ejemplo, aquí se muestra cómo configurar un gancho para activar el modo Relleno Automático (Auto Fill mode) en el modo Texto y otros modos basados en el modo Texto: :: (add-hook 'text-mode-hook 'auto-fill-mode) Esto funciona llamando a ``auto-fill-mode``, que activa el modo menor cuando no se suministra ningún argumento (véase :ref:`24.2`). A continuación, suponga que no desea activar el modo Autorrelleno en el modo LaTeX, que es uno de los modos basados en el modo Texto. Puede hacerlo con la siguiente línea adicional: :: (add-hook 'latex-mode-hook (lambda () (auto-fill-mode -1))) Aquí hemos usado la macro especial ``lambda`` para construir una función anónima (ver `Expresiones Lambda `_ en **El Manual de Referencia Emacs Lisp**), que llama a ``auto-fill-mode`` con un argumento de ``-1`` para deshabilitar el modo menor. Dado que el modo LaTeX ejecuta latex-mode-hook después de ejecutar ``text-mode-hook``, el resultado deja desactivado el modo autorrelleno. He aquí un ejemplo más complejo, que muestra cómo utilizar un gancho para personalizar la sangría del código C: :: (setq my-c-style '((c-comment-only-line-offset . 4) (c-cleanup-list . (scope-operator empty-defun-braces defun-close-semi)))) (add-hook 'c-mode-common-hook lambda () (c-add-style "my-style" my-c-style t))) Los ganchos de modo principal también se aplican a otros modos principales derivados del modo original (véase `Modos Derivados `_ en el **Manual de referencia de Emacs Lisp**). Por ejemplo, el modo HTML se deriva del modo Texto (véase :ref:`26.12`; cuando se activa el modo HTML, se ejecuta ``text-mode-hook`` antes de ejecutar ``html-mode-hook``. Esto proporciona una forma cómoda de utilizar un único gancho para afectar a varios modos relacionados. En particular, si desea aplicar una función gancho a cualquier modo de lenguaje de programación, añádala a ``prog-mode-hook``; el modo ``prog`` es un modo principal que no hace otra cosa que permitir que otros modos principales hereden de él, exactamente para este propósito. Es mejor diseñar sus funciones de gancho de modo que el orden en que se ejecutan no importe. Cualquier dependencia del orden es buscarse problemas. Sin embargo, el orden es predecible: las funciones de gancho se ejecutan en el orden en que aparecen en el gancho. Si juega a añadir varias versiones diferentes de una función hook llamando a ``add-hook`` una y otra vez, recuerde que todas las versiones que añada permanecerán juntas en la variable gancho. Puede borrar funciones individuales llamando a ``remove-hook``, o hacer ``(setq hook-variable nil)`` para eliminar todo. Si la variable hook (gancho) es buffer-local, se utilizará la variable buffer-local en lugar de la variable global. Sin embargo, si la variable buffer-local contiene el elemento ``t``, se ejecutará también la variable de gancho global. .. _50.2.3: 50.2.3 Variables Locales ```````````````````````` | :kbd:`Alt`-:kbd:`x` ``make-local-variable`` :kbd:`RETURN` *var* :kbd:`RETURN` | (``M-x make-local-variable RET`` *var* ``RET``) Hace que la variable *var* tenga un valor local en el búfer actual. | :kbd:`Alt`-:kbd:`x` ``kill-local-variable`` :kbd:`RETURN` *var* :kbd:`RETURN` | (``M-x kill-local-variable RET`` *var* ``RET``) Hacer que la variable *var* utilice su valor global en el búfer actual. | :kbd:`Alt`-:kbd:`x` ``make-variable-buffer-local`` :kbd:`RETURN` *var* :kbd:`RETURN` | (``M-x make-variable-buffer-local RET`` *var* ``RET``) Marca la variable *var* para que al establecerla se haga local al búfer actual en ese momento. Casi cualquier variable puede hacerse *local* a un búfer Emacs específico. Esto significa que su valor en ese búfer es independiente de su valor en otros búferes. Unas pocas variables son siempre locales en cada búfer. Cualquier otra variable Emacs tiene un valor *global* que está en efecto en todos los búferes que no han hecho local la variable. ``M-x make-local-variable`` lee el nombre de una variable y la hace local en el búfer actual. Cambiar su valor posteriormente en este búfer no afectará a otros, y los cambios en su valor global no afectarán a este búfer. ``M-x make-variable-buffer-local`` marca una variable para que se convierta en local automáticamente siempre que se establezca. Más precisamente, una vez que una variable ha sido marcada de esta manera, las formas habituales de establecer la variable automáticamente hacen ``make-local-variable`` primero. Llamamos a tales variables variables *per-buffer* (por-búfer). Muchas variables en Emacs son normalmente per-buffer; la cadena de documento de la variable le dice cuando esto es así. El valor global de una variable por búfer normalmente nunca es efectivo en ningún búfer, pero aún así tiene un significado: es el valor inicial de la variable para cada nuevo búfer. Los modos principales (ver :ref:`24.1`) siempre hacen que las variables sean locales al búfer antes de establecer las variables. Esta es la razón por la que cambiar los modos mayores en un búfer no tiene efecto en otros búferes. Los modos menores también funcionan estableciendo variables, normalmente, cada modo menor tiene una variable de control que no es nula cuando el modo está activado (ver :ref:`24.2`). Para muchos modos menores, la variable de control es por búfer, y por tanto siempre local al búfer. Si no, puede hacerla local en un buffer específico como cualquier otra variable. Unas pocas variables no pueden ser locales a un búfer porque son siempre locales a cada pantalla en su lugar (ver :ref:`22.10`). Si intenta hacer una de estas variables local al búfer, obtendrá un mensaje de error. ``M-x kill-local-variable`` hace que una variable especificada deje de ser local al búfer actual. El valor global de la variable a partir de ahora está en efecto en este búfer. Al establecer el modo mayor se matan todas las variables locales del búfer excepto algunas variables especialmente marcadas como *locales permanentes*. Para establecer el valor global de una variable, independientemente de si la variable tiene un valor local en el búfer actual, se puede utilizar la construcción Lisp ``setq-default``. Esta construcción se usa igual que ``setq``, pero establece los valores globales de las variables en lugar de sus valores locales (si los tienen). Cuando el búfer actual tiene un valor local, el nuevo valor global puede no ser visible hasta que cambie a otro búfer. He aquí un ejemplo: :: (setq-default fill-column 75) ``setq-default`` es la única forma de establecer el valor global de una variable que ha sido marcada con ``make-variable-buffer-local``. Los programas Lisp pueden utilizar ``default-value`` para consultar el valor por defecto de una variable. Esta función toma un símbolo como argumento y devuelve su valor por defecto. El argumento se evalúa; normalmente hay que citarlo explícitamente. Por ejemplo, así es como se obtiene el valor por defecto de ``fill-column``: :: (default-value 'fill-column) .. _50.2.4: 50.2.4. Variables locales en Archivos ````````````````````````````````````` Un archivo puede especificar valores de variables locales para usar cuando se edita el archivo con Emacs. Visitando el fichero o estableciendo un modo principal comprueba si hay especificaciones de variables locales; automáticamente hace estas variables locales al búfer, y las establece a los valores especificados en el archivo. Las variables locales de archivo anulan las variables locales de directorio (ver :ref:`50.2.5`), si se especifica alguna para el directorio de un archivo. 50.2.4.1 Especificación de variables de Archivo ''''''''''''''''''''''''''''''''''''''''''''''' Hay dos formas de especificar valores de variables locales de archivo: en la primera línea, o con una lista de variables locales. A continuación se explica cómo especificarlas en la primera línea: :: -*- mode: nombremodo; var: valor; … -*- Puede especificar cualquier número de pares variable/valor de esta forma, cada par con dos puntos y punto y coma. El par variable/valor especial ``mode: modename;``, si está presente, especifica un modo principal (sin el sufijo ``-mode``). Los *valores* se utilizan literalmente y no se evalúan. Puede utilizar ``M-x add-file-local-variable-prop-line`` en lugar de añadir entradas a mano. Este comando solicita una variable y un valor, y los añade a la primera línea de la forma adecuada. ``M-x delete-file-local-variable-prop-line`` solicita una variable y borra su entrada de la línea. El comando ``M-x copy-dir-locals-to-file-locals-prop-line`` copia las variables locales del directorio actual a la primera línea (ver :ref:`50.2.5`). He aquí un ejemplo de primera línea que especifica el modo Lisp y establece dos variables con valores numéricos: :: ;; -*- mode: Lisp; fill-column: 75; comment-column: 50; -*- Aparte de ``mode``, otras palabras clave que tienen significados especiales como variables de archivo son ``coding``, ``unibyte`` y ``eval``. Éstas se describen a continuación. En los scripts de shell, la primera línea se usa para identificar al intérprete del script, por lo que no puede poner ninguna variable local ahí. Para acomodar esto, Emacs busca especificaciones de variables locales en la segunda línea si la primera línea especifica un intérprete. Lo mismo ocurre con las páginas man que empiezan con la cadena mágica ``\"`` para especificar una lista de preprocesadores troff ( sin embargo, no todos lo hacen). Aparte de usar una línea ``-*-``, puede definir *variables locales* de archivo usando una lista de variables locales cerca del final del fichero. El comienzo de la lista de variables locales no debe estar a más de 3000 caracteres del final del archivo, y debe estar en la última página si el fichero está dividido en páginas. Si un archivo tiene tanto una lista de variables locales como una línea ``-*-``, Emacs procesa *todo* lo que hay en la línea ``-*-`` primero, y *todo* lo que hay en la lista de variables locales después. La excepción a esto es una especificación de modo principal. Emacs aplica esto primero, dondequiera que aparezca, ya que la mayoría de los modos principales matan todas las variables locales como parte de su inicialización. Una lista de variables locales comienza con una línea que contiene la cadena ``Local Variables:`` (Variables Locales), y termina con una línea que contiene la cadena ``End:`` (Fin). En medio vienen los nombres y valores de las variables, un conjunto por línea, así: :: /* Local Variables: */ /* mode: c */ /* comment-column: 0 */ /* End: */ En este ejemplo, cada línea comienza con el prefijo ``/*`` y termina con el sufijo ``*/``. Emacs reconoce el prefijo y el sufijo encontrándolos rodeando la cadena mágica ``Local Variables:``, en la primera línea de la lista; luego los descarta automáticamente de las otras líneas de la lista. La razón habitual para utilizar un prefijo y/o sufijo es incrustar la lista de variables locales en un comentario, para que no confunda a otros programas a los que va destinado el archivo. El ejemplo anterior es para el lenguaje de programación C, donde los comentarios comienzan con ``/*`` y terminan con ``*/``. Si algún texto no relacionado pudiera parecerle a Emacs una lista de variables locales, puede contrarrestarlo insertando un carácter de salto de página (un delimitador de página, ver :ref:`26.4`) después de ese texto. Emacs sólo busca variables locales de fichero en la última página de un fichero, después del último delimitador de página. En lugar de escribir directamente la lista de variables locales, puede utilizar el comando ``M-x add-file-local-variable``. Este comando solicita una variable y un valor, y los añade a la lista, añadiendo la cadena ``Local Variables:`` y los marcadores de inicio y fin según sea necesario. El comando ``M-x delete-file-local-variable`` borra una variable de la lista. ``M-x copy-dir-locals-to-file-locals`` copia variables locales de directorio a la lista (ver :ref:`50.2.5`). Al igual que con la línea ``-*-``, las variables de una lista de variables locales se utilizan literalmente, y no se evalúan primero. Si desea dividir un valor de cadena largo en varias líneas del archivo, puede utilizar la barra invertida-nueva línea, que se ignora en las constantes de cadena de Lisp; debe poner el prefijo y el sufijo en cada línea, incluso en las líneas que comienzan o terminan dentro de la cadena, ya que se eliminarán al procesar la lista. He aquí un ejemplo: :: # Local Variables: # comando-para-compilar: "cc foo.c -Dfoo=bar -Dhack=whatever \ # -Dmumble=blaah" # End: Algunos nombres tienen significados especiales en una lista de variables locales: * ``mode`` activa el modo principal especificado. * ``eval`` evalúa la expresión Lisp especificada (el valor devuelto por esa expresión se ignora). * ``coding`` especifica el sistema de codificación para la conversión del código de caracteres de este archivo. Véase :ref:`23.5`. * ``unibyte`` dice que se cargue o compile un archivo de Emacs Lisp en modo unibyte, si el valor es ``t``. Véase `Deshabilitar Caracteres Multibyte `_ en el **Manual de Referencia de GNU Emacs Lisp**. Estas cuatro palabras clave no son realmente variables; establecerlas en cualquier otro contexto no tiene ningún significado especial. Si está editando un fichero a través de diferentes versiones de Emacs, y un nuevo modo ha sido introducido para manejar un archivo en una nueva versión de Emacs, puede usar varias entradas de modo para usar el nuevo modo (llamado ``mi-nuevo-modo``) en el nuevo Emacs, y volver al modo anterior (llamado ``mi-modo-anterior``) en versiones anteriores de Emacs. Si habilita los modos en la primera línea del archivo, puede decir: :: -*- mode: mi-modo-anterior; mode: mi-nuevo-modo -*- Emacs usará el último modo definido que encuentre, así que en versiones antiguas de Emacs ignorará ``mi-nuevo-modo``, mientras que en versiones de Emacs donde ``mi-nuevo-modo`` está definido, ignorará ``mi-modo-anterior``. De forma similar, en un bloque de variables locales al final del archivo: :: Local variables: mode: mi-modo-anterior mode: mi-nuevo-modo No use la palabra clave ``mode`` para los modos menores. Para activar o desactivar un modo menor en una lista de variables locales, utilice la palabra clave ``eval`` con una expresión Lisp que ejecute la orden mode (consulte :ref:`24.2`). Por ejemplo, la siguiente lista de variables locales habilita el modo ElDoc (consulte :ref:`27.6.3`) llamando a ``eldoc-mode`` sin ningún argumento (llamándolo con un argumento de 1 haría lo mismo), y deshabilita el modo Font Lock (consulte :ref:`15.3`) llamando a ``font-lock-mode`` con un argumento de -1. :: ;; Local Variables: ;; eval: (eldoc-mode) ;; eval: (font-lock-mode -1) ;; End: Tenga en cuenta, sin embargo, que a menudo es un error especificar los modos menores de esta manera. Los modos menores representan preferencias individuales de usuario, y puede ser inapropiado imponer sus preferencias a otro Usuario que pueda editar el fichero. Si desea activar o desactivar automáticamente un modo menor en función de la situación, a menudo es mejor hacerlo en un gancho de modo mayor (ver :ref:`50.2.2`). Use el comando ``M-x normal-mode`` para restablecer las variables locales y el modo mayor de un búfer de acuerdo con el nombre y contenido del archivo, incluyendo la lista de variables locales si la hubiera. Véase :ref:`24.3`. .. _50.2.4.2: 50.2.4.2 Seguridad de las Variables de Archivo '''''''''''''''''''''''''''''''''''''''''''''' Las variables locales de archivo pueden ser peligrosas; cuando visita el fichero de otra persona, no se sabe lo que su lista de variables locales podría hacer a su Emacs. Valores inapropiados de la "variable" eval, y otras variables como ``load-path``, podrían ejecutar código Lisp que no tenía intención de ejecutar. Por lo tanto, siempre que Emacs encuentra valores de variables locales de archivo que no se sabe si son seguros, muestra la lista completa de variables locales del fichero, y le pide confirmación antes de establecerlos. Puede teclear :kbd:`y` (``y``) o :kbd:`SPCAE` (``SPC``) para poner en efecto la lista de variables locales, o :kbd:`n` (``n``) para ignorarla. Cuando Emacs se ejecuta en modo batch (ver :ref:`C.2`), no puede realmente preguntarle, así que asume la respuesta ``n``. Emacs normalmente reconoce ciertos pares variable/valor como seguros. Por ejemplo, es seguro dar a ``comment-columm`` (columna-comentario) o ``fill-column`` (columna-relleno) cualquier valor entero. Si un archivo especifica sólo pares variable/valor conocidos como seguros, Emacs no pide confirmación antes de establecerlos. Si no, puede decirle a Emacs que registre todos los pares variable/valor en este fichero como seguros, tecleando :kbd:`!` (``!``) en el prompt de confirmación. Cuando Emacs encuentre estos pares variable/valor posteriormente, en el mismo archivo o en otros, asumirá que son seguros. También puede decirle a Emacs que ignore permanentemente todos los pares variable/valor en el fichero, tecleando :kbd:`i` (``i``) en el prompt de confirmación, estos pares serán ignorados a partir de entonces en este archivo y en todos los demás ficheros. Algunas variables, como ``load-path``, se consideran particularmente arriesgadas: raramente hay alguna razón para especificarlas como variables locales, y cambiarlas puede ser peligroso. Si un archivo contiene sólo variables locales de riesgo, Emacs no ofrece ni acepta ``!`` como entrada en el prompt de confirmación. Si algunas de las variables locales en un fichero son arriesgadas, y algunas son sólo potencialmente inseguras, puede introducir ``!`` en el prompt. Se aplicarán todas las variables, pero sólo se marcarán como seguras para el futuro las que no sean peligrosas. Si realmente quiere registrar valores seguros para variables de riesgo, hágalo directamente personalizando ``safe-local-variable-values`` (vea :ref:`50.1`). Del mismo modo, si desea registrar valores de variables de riesgo que deben ser ignorados permanentemente, personalice ``ignored-local-variable-values``. La variable ``enable-local-variables`` permite cambiar la forma en que Emacs procesa las variables locales. Su valor por defecto es ``t``, que especifica el comportamiento descrito anteriormente. Si es ``nil``, Emacs simplemente ignora todas las variables locales de fichero. ``:safe` significa usar sólo los valores seguros e ignorar el resto. ``:all`` ordena a Emacs establecer todas las variables locales de fichero independientemente de si su valor es seguro o no (aconsejamos no usar esto permanentemente). Cualquier otro valor dice que pregunte por cada fichero que tenga variables locales, sin intentar determinar si los valores son conocidos como seguros. La variable ``enable-local-eval`` controla si Emacs procesa variables ``eval``. Las tres posibilidades para el valor de la variable son ``t``, ``nil``, y cualquier otra cosa, igual que para ``enable-local-variables``. El valor por defecto es ``maybe``, que no es ni ``t`` ni ``nil``, así que normalmente Emacs pide confirmación sobre el procesamiento de variables ``eval``. Como excepción, Emacs nunca pide confirmación para evaluar cualquier forma ``eval`` si esa forma ocurre dentro de la variable ``safe-local-eval-forms``. .. _50.2.5: 50.2.5 Variables Locales por Directorio ``````````````````````````````````````` A veces, es posible que desee definir el mismo conjunto de variables locales para todos los archivos de un determinado directorio y sus subdirectorios, como el árbol de directorios de un gran proyecto de software. Esto se puede conseguir con *variables locales de directorio*. Las variables locales de archivo anulan las variables locales de directorio, por lo que si algunos de los ficheros de un directorio necesitan ajustes especializados, puede especificar los ajustes para la mayoría de los archivos del directorio en variables de directorio, y luego definir variables locales de archivo en unos pocos ficheros que necesiten que se anulen los ajustes generales. La forma habitual de definir variables locales de directorio es poner un archivo llamado ``.dir-locals.el`` [24]_ en un directorio. Siempre que Emacs visite cualquier fichero en ese directorio o en cualquiera de sus subdirectorios, aplicará las variables locales de directorio especificadas en ``.dir-locals.el``, como si hubieran sido definidas como variables locales de archivo para ese fichero (ver :ref:`50.2.4`). Emacs busca ``.dir-locals.el`` empezando en el directorio del fichero visitado, y moviéndose hacia arriba en el árbol de directorios. Para evitar ralentizaciones, esta búsqueda se omite para archivos remotos. Si es necesario, la búsqueda puede extenderse para ficheros remotos estableciendo la variable ``enable-remote-dir-locals`` a ``t``. También puede usar ``.dir-locals-2.el``; si se encuentra, Emacs lo carga además de ``.dir-locals.el``. Esto es útil cuando ``.dir-locals.el`` está bajo control de versiones en un repositorio compartido y no puede ser usado para personalizaciones. El archivo ``.dir-locals.el`` debe contener una lista especialmente construida, que mapea nombres de modos principales (símbolos) a alists (ver `Listas de Asociación `_ en **El Manual de Referencia de Emacs Lisp**). Cada entrada *alist* consiste en un nombre de variable y el valor directorio-local a asignar a esa variable, cuando el modo principal especificado está habilitado. En lugar de un nombre de modo, puede especificar ``nil``, lo que significa que la lista se aplica a cualquier modo; o puede especificar un subdirectorio (una cadena), en cuyo caso la lista se aplica a todos los ficheros de ese subdirectorio. Este es un ejemplo de un archivo ``.dir-locals.el``: :: ((nil . ((indent-tabs-mode . t) (fill-column . 80) (mode . auto-fill))) (c-mode . ((c-file-style . "BSD") (subdirs . nil))) ("src/imported" . ((nil . ((change-log-default-name . "ChangeLog.local")))))) Establece las variables ``indent-tabs-mode`` y ``fill-column`` para cualquier archivo en el árbol de directorios, y el estilo de indentación para cualquier archivo fuente C. El elemento especial ``mode`` especifica el modo menor a activar. Así (``mode . auto-fill``) especifica que el modo menor ``auto-fill-mode`` debe estar habilitado. El elemento special ``subdirs`` no es una variable, sino una palabra clave especial que indica que la configuración del modo C sólo debe aplicarse en el directorio actual, no en ningún subdirectorio. Por último, especifica un nombre de archivo ``ChangeLog`` diferente para cualquier archivo del subdirectorio ``src/imported``. Si el archivo ``.dir-locals.el`` contiene múltiples valores diferentes para una variable utilizando diferentes nombres de modo o directorios, los valores se aplicarán en un orden tal que los valores para modos más específicos tengan prioridad sobre los modos más genéricos. Los valores especificados bajo un directorio tienen aún más prioridad. Por ejemplo: :: ((nil . ((fill-column . 40))) (c-mode . ((fill-column . 50))) (prog-mode . ((fill-column . 60))) ("narrow-files" . ((nil . ((fill-column . 20)))))) Los archivos que utilizan ``c-mode`` también coinciden con ``prog-mode`` porque el primero hereda del segundo. Sin embargo, el valor utilizado para la columna de relleno en los archivos C será ``50`` porque el nombre del modo es más específico que ``prog-mode``. Los archivos que utilicen otros modos que hereden de ``prog-mode`` utilizarán ``60``. Cualquier fichero bajo el directorio ``narrow-files`` usará el valor ``20`` aunque use ``c-mode`` porque las entradas de directorio tienen prioridad sobre las entradas de modo. Puede especificar las variables ``mode``, ``eval``, y ``unibyte`` en su ``.dir-locals.el``, y tienen los mismos significados que tendrían en variables locales de fichero. ``coding`` no puede especificarse como variable local de directorio. Véase :ref:`50.2.4`. La clave especial ``auto-mode-alist`` en un ``.dir-locals.el`` le permite establecer el modo principal de un archivo. Funciona de forma muy parecida a la variable ``auto-mode-alist`` (véase :ref:`24.3`). Por ejemplo, así es como puede decirle a Emacs que los archivos fuente ``.def`` en este directorio deben estar en modo C: :: ((auto-mode-alist . (("\\.def\\'" . c-mode)))) En lugar de editar el archivo ``.dir-locals.el`` a mano, puede utilizar el comando ``M-x add-dir-local-variable``. Esto solicita un modo o subdirectorio, y la variable y el valor, y añade la entrada que define la variable directorio-local. ``M-x delete-dir-local-variable`` borra una entrada. ``M-x copy-file-locals-to-dir-locals`` copia las variables ``file-local`` del archivo actual en ``.dir-locals.el``. Otro método de especificar variables locales de directorio es definir un grupo de pares variables/valores en una *clase de directorio*, usando la función ``dir-locals-set-class-variables``; entonces, digale a Emacs qué directorios corresponden a la clase usando la función ``dir-locals-set-directory-class``. Estas llamadas a funciones normalmente van en su archivo de inicialización (ver :ref:`50.4`). Este método es útil cuando no puede poner ``.dir-locals.el`` en un directorio por alguna razón. Por ejemplo, podría aplicar configuraciones a un directorio no escribible de esta manera: :: (dir-locals-set-class-variables 'unwritable-directory '((nil . ((some-useful-setting . value))))) (dir-locals-set-directory-class Si una variable tiene especificado tanto un valor directorio-local como un valor archivo-local, el valor archivo-local es el que tiene efecto. Las variables locales de directorio no seguras se tratan de la misma forma que las variables locales de archivo no seguras (véase :ref:`50.2.4.2`). Las variables locales de directorio también tienen efecto en ciertos búferes que no visitan un archivo directamente sino que realizan trabajo dentro de un directorio, como los búferes Dired (ver :ref:`31`). .. [24] En MS-DOS, el nombre de este archivo debe ser ``_dir-locals.el``, debido a las limitaciones de los sistemas de ficheros DOS. Si el sistema de archivos está limitado a 8+3 nombres de archivo, el nombre del fichero será truncado por el SO a ``_dir-locals.el``. .. _50.2.6: 50.2.6 Variables locales por conexión ````````````````````````````````````` La mayoría de las variables reflejan la situación en la máquina local. A menudo, deben utilizar un valor diferente cuando se opera en búferes con un directorio remoto por defecto. Piense en el comportamiento al llamar a ``shell``, en su máquina local, puede usar ``/bin/bash`` y confiar en termcap, pero en una máquina remota, puede ser ``/bin/ksh`` y terminfo. Esto se puede conseguir con *variables locales de conexión*. Las variables locales de directorio y archivo anulan las variables locales de conexión. Las variables locales de conexión inseguras se manejan de la misma manera que las variables locales de fichero inseguras (ver :ref:`50.2.4.2`). Las variables locales de conexión se declaran como un grupo de pares de variables/valores en un *perfil*, utilizando la función ``connection-local-set-profile-variables``. La función ``connection-local-set-profiles`` activa perfiles para un criterio dado, identificando una máquina remota: :: (connection-local-set-profile-variables 'remote-terminfo '((system-uses-terminfo . t) (comint-terminfo-terminal . "dumb-emacs-ansi"))) (connection-local-set-profile-variables 'remote-ksh '((shell-file-name . "/bin/ksh") (shell-command-switch . "-c"))) (connection-local-set-profile-variables 'remote-bash '((shell-file-name . "/bin/bash") (shell-command-switch . "-c"))) (connection-local-set-profiles '(:application tramp :machine "remotemachine") 'remote-terminfo 'remote-ksh) Este código declara tres perfiles diferentes, ``remote-terminfo``, ``remote-ksh`` y ``remote-bash``. Los perfiles ``remote-terminfo`` y ``remote-ksh`` se aplican a todos los búferes que tienen un directorio remoto por defecto que coincide con el regexp ``"maquinaremota"`` como nombre de host. Este criterio también puede discriminar las propiedades ``:protocol`` (este es el método Tramp) o ``:user`` (un nombre de Usuario remoto). El criterio nil coincide con todos los búferes con un directorio remoto por defecto. .. _50.3: 50.3 Personalizar las Combinaciones de Teclas --------------------------------------------- Esta sección describe las *combinaciones de teclas*, que asignan teclas a comandos, y los mapas de teclas, que registran estas combinaciones. También se explica cómo personalizar las dichas combinaciones, lo que se hace editando el fichero init (consulte :ref:`50.3.6`). Dado que la mayoría de los modos definen sus propias combinaciones de teclas, la activación de un modo puede anular las combinaciones de teclas personalizadas. Un pequeño número de teclas están reservadas para las combinaciones definidas por el Usuario, y no deberían ser utilizadas por los modos, por lo que las combinaciones de teclas que utilizan esas mismas teclas son más seguras en este sentido. Las secuencias de teclas reservadas son las que consisten en :kbd:`Ctrl`-:kbd:`c` (``C-c``) seguida de una letra (mayúscula o minúscula), y las teclas de función :kbd:`F5` (``F5``) a :kbd:`F9` (``F9``) sin modificadores (ver :ref:`50.3.7`). .. _50.3.1: 50.3.1 Mapas de teclas `````````````````````` Como se describe en :ref:`5`, cada comando Emacs es una función Lisp cuya definición permite su uso interactivo. Como toda función Lisp, un comando tiene un nombre de función, que normalmente consiste en letras minúsculas y guiones. Una *secuencia de teclas* (*tecla* (key), para abreviar) es una *secuencia de eventos* de entrada que tienen un significado como unidad. Los eventos de entrada incluyen caracteres, teclas de función y botones del ratón: todas las entradas que puede enviar al ordenador. Una secuencia de teclas obtiene su significado de su *vinculación*, que dice qué comando ejecuta. Los enlaces entre secuencias de teclas y funciones de comandos se registran en estructuras de datos llamadas *mapas de teclas* (keymaps). Emacs tiene muchos de estos, cada uno usado en ocasiones particulares. El mapa de teclado *global* es el más importante porque siempre está activo. El mapa de teclado global define las teclas para el modo Fundamental (ver :ref:`24.1`); la mayoría de estas definiciones son comunes a la mayoría o a todos los modos mayores. Cada modo mayor o menor puede tener su propio mapa de teclado que anula las definiciones globales de algunas teclas. Por ejemplo, un carácter de autoinserción como ``g`` se autoinserta porque el mapa de teclado global lo vincula al comando ``self-insert-command`` (autoinsertar-comando). Los caracteres de edición estándar de Emacs como ``C-a`` también obtienen sus significados estándar del mapa de teclado global. Los comandos para reasignar teclas, como ``M-x keymap-global-set``, funcionan almacenando la nueva asignación en el lugar apropiado del mapa global (ver :ref:`50.3.5`). Para ver las combinaciones de teclas actuales, utilice el comando ``C-h b``. La mayoría de los teclados modernos tienen teclas de función además de teclas de carácter. Las teclas de función envían eventos de entrada igual que las teclas de carácter, y los mapas de teclas pueden tener asignaciones para ellas. Las secuencias de teclas pueden mezclar teclas de función y caracteres. Por ejemplo, si su teclado tiene una tecla de función Inicio, Emacs puede reconocer secuencias de teclas como ``C-x Inicio``. Incluso puede mezclar eventos de ratón con eventos de teclado, como ``S-down-ratón-1``. En los terminales de texto, pulsar una tecla de función envía al ordenador una secuencia de caracteres; los detalles precisos de la secuencia dependen de la tecla de función y del tipo de terminal. (A menudo la secuencia empieza con ``ESC [``.) Si Emacs entiende tu tipo de terminal correctamente, automáticamente maneja tales secuencias como eventos de entrada individuales. Las secuencias de teclas que consisten en ``C-c`` seguida de una letra (mayúscula o minúscula; ASCII o no ASCII) están reservadas para los Usuarios. Emacs nunca enlazará esas secuencias de teclas, y las extensiones de Emacs deberían evitar enlazarlas. En otras palabras, los Usuarios pueden enlazar secuencias de teclas como :kbd:`Ctrl`-:kbd:`c` :kbd:`a` (``C-c a``) o :kbd:`Ctrl`-:kbd:`c` :kbd:`ç` (``C-c ç``) y confiar en que nunca serán ocultadas por otros enlaces de Emacs. 50.3.2. Mapas de teclado de prefijos ```````````````````````````````````` Internamente, Emacs sólo registra eventos individuales en cada mapa de teclado. Interpretar una secuencia de teclas de múltiples eventos implica una cadena de mapas de teclas: el primer mapa de teclas da una definición para el primer evento, que es otro mapa de teclas, que se usa para buscar el segundo evento en la secuencia, y así sucesivamente. De esta forma, una tecla de prefijo como :kbd:`Ctrl`-:kbd:`x` (``C-x``) o :kbd:`ESC` (``ESC``) tiene su propio mapa de teclas, que contiene la definición del evento que sigue inmediatamente a ese prefijo. La definición de una tecla de prefijo suele ser el mapa de teclas que se utiliza para buscar el evento siguiente. La definición también puede ser un símbolo Lisp cuya definición de función es el siguiente mapa de teclado; el efecto es el mismo, pero proporciona un nombre de comando para la tecla de prefijo que puede usarse como descripción de para qué sirve la tecla de prefijo. Así, la vinculación de :kbd:`Ctrl`-:kbd:`x` (``C-x``) es el símbolo ``Control-X-prefijo``, cuya definición de función es el mapa de teclas para comandos ``C-x``. Las definiciones de :kbd:`Ctrl`-:kbd:`c` (``C-c``), :kbd:`Ctrl`-:kbd:`x` (``C-x``), :kbd:`Ctrl`-:kbd:`h` (``C-h``) y :kbd:`ESC` (``ESC``) como teclas de prefijo aparecen en el mapa global, por lo que estas teclas de prefijo están siempre disponibles. Aparte de las teclas prefijo ordinarias, hay una "tecla prefijo" ficticia que representa la barra de menús; véase `Barra de Menús `_ en el **Manual de referencia de Emacs Lisp**, para información especial sobre las combinaciones de teclas de la barra de menús. Los eventos del botón del ratón que invocan menús emergentes son también teclas prefijo; ver `Mapas de Teclas `_ de menú en el **Manual de Referencia de Emacs Lisp**, para más detalles. Algunos mapas de teclas de prefijo se almacenan en variables con nombres: * ``ctl-x-map`` es el nombre variable del mapa utilizado para los caracteres que siguen a ``C-x``. * ``help-map`` es para los caracteres que siguen a ``C-h``. * ``esc-map`` es para los caracteres que siguen a ``ESC``. Por lo tanto, todos los caracteres Meta están definidos por este mapa. * ``ctl-x-4-map`` es para los caracteres que siguen a ``C-x 4``. * ``mode-specific-map`` es para los caracteres que siguen a ``C-c``. * ``project-prefix-map`` es para los caracteres que siguen a ``C-x p``, utilizados para comandos relacionados con proyectos (véase :ref:`29.2`). .. _50.3.3: 50.3.3 Mapas de teclas locales `````````````````````````````` Hasta ahora hemos explicado los entresijos del mapa global. Los modos principales personalizan Emacs proporcionando sus propias combinaciones de teclas en mapas de teclado locales. Por ejemplo, el modo C sobreescribe ``TAB`` para hacer sangrar la línea actual para el código C. Los modos menores también pueden tener mapas de teclado locales; siempre que un modo menor esté en efecto, las definiciones de su mapa de teclado anulan tanto el mapa de teclado local del modo mayor como el mapa de teclado global. Además, las porciones de texto en el búfer pueden especificar sus propios mapas de teclado, que anulan todos los demás mapas de teclado. Un mapa de teclado local puede redefinir una tecla como tecla de prefijo definiéndola como mapa de teclado de prefijo. Si la tecla también se define globalmente como prefijo, sus definiciones local y global (ambos mapas de teclas) se combinan: ambas definiciones se utilizan para buscar el evento que sigue a la tecla de prefijo. Por ejemplo, si un mapa de teclado local define ``C-c`` como prefijo, y ese mapa de teclado define ``C-z`` como comando, esto proporciona un significado local para ``C-c C-z``. Esto no afecta a otras secuencias que empiecen por ``C-c``; si esas secuencias no tienen sus propias combinaciones locales, sus combinaciones globales seguirán vigentes. Otra forma de ver esto es que Emacs maneja una secuencia de teclas multievento buscando en varios mapas de teclas, uno por uno, un enlace para toda la secuencia de teclas. Primero comprueba los mapas de teclado de los modos menores que están activados, luego comprueba el mapa de teclado del modo mayor, y luego comprueba el mapa de teclado global. Esto no es exactamente como funciona la búsqueda de teclas, pero es suficiente para entender los resultados en circunstancias normales. 50.3.4. Mapas de Teclado del Minibúfer `````````````````````````````````````` El minibúfer tiene su propio conjunto de mapas de teclado locales; contienen varios comandos de finalización y salida. * ``minibuffer-local-map`` se utiliza para la entrada ordinaria (sin finalización). * ``minibuffer-local-ns-map`` es similar, excepto que ``SPC`` sale igual que ``RET``. * ``minibuffer-local-completion-map`` es para la finalización permisiva. * ``minibuffer-local-must-match-map`` es para terminación estricta y para terminación cautelosa. * ``minibuffer-local-filename-completion-map`` es como los dos anteriores, pero específicamente para completar nombres de archivo. No vincula ``SPC``. Por defecto, ``TAB``, ``SPC`` y ``?`` completan en ``minibuffer-local-completion-map``. Si suele completar colecciones que tienen elementos con espacios o signos de interrogación, puede ser conveniente desactivar el completado en esas teclas poniendo esto en su archivo init: :: (keymap-set minibuffer-local-completion-map "SPC" 'self-insert-command) (keymap-set minibuffer-local-completion-map "?" 'self-insert-command) .. _50.3.5: 50.3.5. Cambiar las combinaciones de teclas interactivamente ```````````````````````````````````````````````````````````` La forma de redefinir una tecla de Emacs es cambiar su entrada en un mapa de teclas. Puede cambiar el mapa de teclado global, en cuyo caso el cambio es efectivo en todos los modos principales (excepto en aquellos que tienen sus propios enlaces locales para la misma tecla). O puede cambiar un mapa de teclado local, que afecta a todos los buffers que utilizan el mismo modo principal. En esta sección, describimos cómo reasignar teclas para la sesión actual de Emacs. Vea :ref:`50.3.6`, para una descripción de cómo hacer que el reasignado de teclas afecte a futuras sesiones de Emacs. | :kbd:`Alt`-:kbd:`x` ``keymap-global-set`` :kbd:`RETURN` *clave* ``cmd`` :kbd:`RETURN` | (``M-x keymap-global-set RET`` *clave* ``cmd RET``) Define *clave* globalmente para ejecutar *cmd*. | :kbd:`Alt`-:kbd:`x` ``keymap-local-set`` :kbd:`RETURN` *clave* ``cmd`` :kbd:`RETURN` | (``M-x keymap-local-set RET`` *clave* ``cmd RET``) Define *clave* localmente (en el modo mayor ahora en curso) para ejecutar *cmd*. | :kbd:`Alt`-:kbd:`x` ``keymap-global-unset`` :kbd:`RETURN` *clave* | (``M-x keymap-global-unset RET`` *clave*) Hace indefinida *clave* en el mapa global. | :kbd:`Alt`-:kbd:`x` ``keymap-local-unset`` :kbd:`RETURN` *clave* | (``M-x keymap-local-unset`` ``RET`` *clave*) Hace que *clave* sea indefinida localmente (en el modo mayor actualmente en curso). Por ejemplo, lo siguiente vincula ``C-z`` al comando ``shell`` (véase :ref:`39.2`), sustituyendo la definición global normal de ``C-z``: :: M-x keymap-global-set RET C-z shell RET El comando ``keymap-global-set`` lee el nombre del comando después de la tecla. Después de pulsar la tecla, aparece un mensaje como este para que pueda confirmar que está vinculando la tecla que desea: :: Set key C-z to command: Puede redefinir las teclas de función y los eventos del ratón de la misma forma; sólo tiene que escribir la tecla de función o hacer clic con el ratón cuando llegue el momento de especificar la tecla que desea volver a vincular. Puede redefinir una tecla que contenga más de un evento de la misma manera. Emacs sigue leyendo la tecla a reenlazar hasta que es una tecla completa (es decir, no una tecla prefijo). De esta forma, si teclea :kbd:`Ctrl`-:kbd:`f` (``C-f``) para clave, eso es el final; entra en el minibúfer inmediatamente para leer *cmd*. Pero si escribe :kbd:`Ctrl`-:kbd:`x` (``C-x``), como es un prefijo, lee otro carácter; si es 4, otro carácter prefijo, lee un carácter más, y así sucesivamente. Por ejemplo, :: M-x keymap-global-set RET C-x 4 $ spell-other-window RET redefine ``C-x 4 $`` para ejecutar el comando (ficticio) ``spell-other-window``. Puede eliminar la definición global de una tecla con ``keymap-global-unset``. Esto hace que la tecla no esté definida; si la teclea, Emacs sólo emitirá un pitido. De forma similar, ``keymap-local-unset`` hace que una tecla no esté definida en el mapa de teclas del modo principal actual, lo que hace que la definición global (o la falta de ella) vuelva a tener efecto en ese modo principal. Si ha redefinido (o indefinido) una tecla y posteriormente desea anular el cambio, la redefinición de la tecla no será suficiente: tendrá que redefinir la tecla con su definición estándar. Para encontrar el nombre de la definición estándar de una tecla, vaya a un búfer del modo Fundamental en un Emacs nuevo y use ``C-h c``. La documentación de las teclas en este manual también enumera sus nombres de comando. Si quiere evitar invocar un comando por error, es mejor desactivar el comando que indefinir la tecla. Un comando desactivado es menos trabajoso de invocar cuando realmente lo desea. Consulte :ref:`50.3.11`. .. _50.3.6: 50.3.6. Reasignación de Teclas en el Archivo de Inicio `````````````````````````````````````````````````````` Si tiene un conjunto de combinaciones de teclas que le gustaría usar todo el tiempo, puede especificarlas en su archivo de inicialización escribiendo código Lisp. Vea :ref:`50.4`, para una descripción de este archivo. La forma recomendada de escribir una combinación de teclas usando Lisp es usar las funciones ``keymap-global-set`` o ``keymap-set``. Por ejemplo, aquí está cómo enlazar :kbd:`Ctrl`-:kbd:`z` (``C-z``) al comando ``shell`` en el mapa de teclas global (ver :ref:`39.2`): :: (keymap-global-set "C-z" 'shell) El primer argumento de ``keymap-global-set`` describe la secuencia de teclas. Es una cadena formada por una serie de caracteres separados por espacios, cada uno de los cuales corresponde a una tecla. Las teclas con modificadores pueden especificarse anteponiendo el modificador, como ``C-`` para *Control*, o ``M-`` para *Alt* (en este Manual se nombra: *Meta*). Las teclas especiales, como :kbd:`TAB` y :kbd:`RET`, pueden especificarse entre paréntesis angulares como en ```` y ````. La comilla simple delante del nombre de la orden que se asocia a la secuencia de teclas, como en el ejemplo anterior, lo marca como un símbolo constante en lugar de como una variable. Si omite las comillas, Emacs intentará evaluar shell como una variable. Esto probablemente causará un error; ciertamente no es lo que quiere. Aquí tiene algunos ejemplos adicionales, incluyendo la vinculación de teclas de función y eventos de ratón: :: (keymap-global-set "C-c y" 'clipboard-yank) (keymap-global-set "C-M-q" 'query-replace) (keymap-global-set "" 'flyspell-mode) (keymap-global-set "C-" 'display-line-numbers-mode) (keymap-global-set "C-" 'forward-sentence) (keymap-global-set "" 'mouse-save-then-kill) El idioma y los sistemas de codificación pueden causar problemas con las combinaciones de teclas para caracteres no ASCII. Consulte :ref:`50.4.5`. Como alternativa, puede utilizar las funciones de bajo nivel ``define-key`` y ``global-set-key``. Por ejemplo, para asociar ``C-z`` al comando ``shell``, como en el ejemplo anterior, utilizando estas funciones de bajo nivel, utilice: :: (global-set-key (kbd "C-z") 'shell) Hay varias formas de especificar la secuencia de teclas, pero la más sencilla es usar la función ``kbd``, como se muestra en el ejemplo anterior. ``kbd`` toma un único argumento de cadena que es una representación textual de una secuencia de teclas, y la convierte en una forma adecuada para funciones de bajo nivel como ``global-set-key``. Para más detalles sobre la vinculación de telas usando Lisp, vea `Mapa de Teclas `_ en **El Manual de Referencia de Emacs Lisp**. Como se describe en :ref:`50.3.3`, los modos mayores y menores pueden definir mapas de teclado locales. Estos mapas de teclado se construyen cuando el modo se carga por primera vez en una sesión. La función ``keymap-set`` puede utilizarse para realizar cambios en un mapa de teclado específico. Para eliminar una combinación de teclas, utilice ``keymap-unset``. Dado que los mapas de teclado de un modo no se construyen hasta que se ha cargado, debe retrasar la ejecución del código que los modifica, por ejemplo, poniéndolo en un *gancho de modo* (ver :ref:`50.2.2`). Por ejemplo, el modo Texinfo ejecuta el gancho ``texinfo-mode-hook``. Así es como puede usar el gancho para añadir enlaces a combinaciones de teclas (bindings) locales para ``C-c n`` y ``C-c p``, y eliminar el de ``C-c C-x x`` en modo Texinfo: :: (add-hook 'texinfo-mode-hook (lambda () (keymap-set texinfo-mode-map "C-c p" 'backward-paragraph) (keymap-set texinfo-mode-map "C-c n" 'forward-paragraph))) (keymap-set texinfo-mode-map "C-c C-x x" nil) .. _50.3.7: 50.3.7. Teclas Modificadoras ```````````````````````````` Las combinaciones de teclas por defecto en Emacs están configuradas para que los caracteres alfabéticos modificados no distingan mayúsculas de minúsculas. En otras palabras, ``C-A`` hace lo mismo que :kbd:`Ctrl`-:kbd:`a` (``C-a``), y :kbd:`Alt`-:kbd:`A` (``M-A``) hace lo mismo que :kbd:`Alt`-:kbd:`a` (``M-a``). Esto sólo afecta a los caracteres alfabéticos y no se aplica a las versiones modificadas de otras teclas; por ejemplo, :kbd:`Ctrl`-:kbd:`@` (``C-@``) no es lo mismo que :Kbd:`Ctrl`-:kbd:`2` (``C-2``). Un carácter alfabético modificado por Control se considera generalmente insensible a mayúsculas y minúsculas: Emacs siempre trata :kbd:`Ctrl`-:kbd:`A` (``C-A``) como :kbd:`Ctrl`-:kbd:`a` (``C-a``), :Kbd:`Ctrl`-:kbd:`B` (``C-B``) como :kbd:`Ctrl`-:kbd:`b` (``C-b``), y así sucesivamente. La razón de esto es histórica: en entornos no gráficos no hay distinción entre esas pulsaciones. Sin embargo, puede enlazar pulsaciones de teclas alfabéticas con control de mayúsculas en marcos GUI: :: (keymap-global-set "C-S-n" #'previous-line) Para el resto de modificadores, puede hacer que los caracteres alfabéticos modificados distingan entre mayúsculas y minúsculas (incluso en marcos no gráficos) cuando personalice Emacs. Por ejemplo, puede hacer que :kbd:`Alt`-:kbd:`a` (``M-a``) y :kbd:`Alt`-:kbd:`A` (``M-A``) ejecuten comandos diferentes. Aunque sólo las teclas modificadoras :kbd:`Ctrl` (Control) y :kbd:`Alt` (Meta) se usan habitualmente, Emacs soporta otras tres teclas modificadoras. Se llaman :kbd:`Shift` (``s-``, Super), (``h-``, Hyper) y :kbd:`Alt` (``A-``, Alt). Pocos terminales proporcionan formas de usar estos modificadores; la tecla etiquetada ``Alt`` en la mayoría de los teclados normalmente emite el modificador *Meta*, no *Alt*. Las combinaciones de teclas estándar en Emacs no incluyen ningún carácter con los modificadores *Super* e *Hyper*, y sólo un pequeño número de combinaciones de teclas estándar usan *Alt*. Sin embargo, puede personalizar Emacs para asignar significados a las combinaciones de teclas que usan estos modificadores. Los bits modificadores están etiquetados como ``s-``, ``H-`` y ``A-`` respectivamente. Incluso si su teclado carece de estas teclas modificadoras adicionales, puede introducirlas utilizando ``C-x @``: ``C-x @ h`` añade la bandera Hyper al carácter siguiente, ``C-x @ s`` añade la bandera Super y ``C-x @ a`` añade la bandera *Alt*. Por ejemplo, ``C-x @ h C-a`` es una forma de introducir ``Hiper-Control-a``. (Desafortunadamente, no hay forma de añadir dos modificadores utilizando ``C-x @`` dos veces para el mismo carácter, porque el primero va a trabajar en la ``C-x``). De forma similar, puede introducir los modificadores *Shift*, *Control* y *Meta* utilizando :literal:`C-x \ S`, :literal:`C-x \ c` y :literal:`C-x \ m`, respectivamente, aunque esto rara vez es necesario. 50.3.8 Reenlazar Teclas de Función `````````````````````````````````` Las secuencias de teclas pueden contener teclas de función así como caracteres ordinarios. Del mismo modo que los caracteres Lisp (en realidad enteros) representan caracteres del teclado, los símbolos Lisp representan teclas de función. Si la tecla de función tiene una palabra como etiqueta, entonces esa palabra es también el nombre del símbolo Lisp correspondiente. Éstos son los nombres Lisp convencionales de las teclas de función más comunes: :kbd:`←` :kbd:`↑` :kbd:`→` :kbd:`↓` (``left``, ``up``, ``right``, ``down`` izquierda, arriba, derecha, abajo) Teclas de flechas del cursor :kbd:`Inicio` :kbd:`Fin` :kbd:`RePag` :kbd:`AvPag` (``home``, `end``, ``next``, ``prev``,inicio, fin, siguiente, anterior) Otras teclas de desplazamiento del cursor. | ``select``, ``print``, ``execute``, ``backtab`` | ``insert``, ``undo``, ``redo``, ``clearline`` | ``insertline``, ``deleteline``, ``insertchar``, ``deletechar`` Teclas de funciones varias. ``f1``, ``f2``, ..., ``f35`` Teclas de función numeradas (en la parte superior del teclado). | ``kp-add``, ``kp-subtract``, ``kp-multiply``, ``kp-divide`` | ``kp-backtab``, ``kp-space``, ``kp-tab``, ``kp-enter`` | ``kp-separator``, ``kp-decimal``, ``kp-equal`` | ``kp-prior``, ``kp-next``, ``kp-end``, ``kp-home`` | ``kp-left``, ``kp-up``, ``kp-right``, ``kp-down`` | ``kp-insert`` , ``kp-delete`` Se trata de las teclas del teclado numéricoa (a la derecha del teclado normal), con nombres o signos de puntuación. ``kp-0``, ``kp-1``, … ``kp-9`` Teclas del teclado con dígitos. ``kp-f1``, ``kp-f2``, ``kp-f3``, ``kp-f4`` Teclas PF del teclado numérico. Estos nombres son convencionales, pero algunos sistemas (especialmente cuando se utiliza X) pueden usar nombres diferentes. Para asegurarse de qué símbolo se utiliza para una determinada tecla de función en su terminal, escriba :kbd:`Ctrl`-:kbd:`h` :kbd:`c` (``C-h c``) seguido de esa tecla. Consulte :ref:`50.3.6` en el archivo de inicio para ver ejemplos de vinculación de teclas de función. Muchos teclados tienen un teclado numérico en el lado derecho. Las teclas numéricas del teclado sirven también para mover el cursor, y se activan con una tecla llamada ``Bloq Num``. Por defecto, Emacs traduce estas teclas a las correspondientes del teclado principal. Por ejemplo, cuando ``Num Lock`` está activado, la tecla etiquetada ``8`` en el teclado numérico produce ``kp-8``, que se traduce a ``8``; cuando ``Num Lock`` está desactivado, la misma tecla produce ``kp-up``, que se traduce a ``UP``. Si vuelve a vincular una tecla como ``8`` o ``UP``, también afectará a la tecla equivalente del teclado numérico. Sin embargo, si revincula una tecla ``kp-`` directamente, no afectará a su equivalente sin teclado. Tenga en cuenta que las teclas modificadas no se traducen: por ejemplo, si mantiene pulsada la tecla Meta mientras pulsa la tecla ``8`` en el teclado numérico, eso genera ``M-kp-8``. Emacs proporciona un método conveniente para enlazar las teclas del teclado numérico, usando las variables ``keypad-setup``, ``keypad-numlock-setup``, ``keypad-shifted-setup``, y ``keypad-numlock-shifted-setup``. Estas variables se encuentran en el grupo de personalización "Teclado" (véase :ref:`50.1`). Puede volver a vincular las teclas para realizar otras tareas, como emitir argumentos de prefijo numérico. 50.3.9 Caracteres de control ASCII con nombre ````````````````````````````````````````````` ``TAB``, ``RET``, ``BS``, ``LFD``, ``ESC``, y ``DEL`` empezaron como nombres para ciertos caracteres de control ASCII, usados tan a menudo que tienen teclas especiales propias. Por ejemplo, :kbd:`TAB` (``TAB``) era otro nombre para :kbd:`Ctrl`-:kbd:`i` (``C-i``). Más tarde, los Usuarios encontraron conveniente distinguir en Emacs entre estas teclas y los caracteres de control correspondientes pulsados con la tecla :kbd:`Ctrl` (``Ctrl``). Por lo tanto, en la mayoría de los terminales modernos, ya no son lo mismo: :kbd:`TAB` (``TAB``) es diferente de :kbd:`Ctrl`-:kbd:`i` (``C-i``). Emacs puede distinguir estos dos tipos de entrada si el teclado lo hace. Trata las teclas especiales como teclas de función llamadas ``tab`` (tabulador), ``return`` (retorno), ``backspace`` (retroceso), ``linefeed`` (salto de línea), ``escape`` y ``delete`` (suprimir). Estas teclas de función se traducen automáticamente en los caracteres ASCII correspondientes si no tienen vinculaciones propias. Como resultado, ni los Usuarios ni los programas Lisp necesitan prestar atención a la distinción, a menos que les interese. Si no desea distinguir entre (por ejemplo) :kbd:`TAB` (``TAB``) y :kbd:`Ctrl`-:kbd:`i` (``C-i``), cree un único enlace para el carácter ASCII TAB (código octal 011). Si desea hacer una distinción, cree un enlace para este carácter ASCII y otro para la tecla de función tabulador. Con un terminal ASCII normal, no hay forma de distinguir entre ``TAB`` y ``C-i`` (y lo mismo para otros pares de este tipo), porque el terminal envía el mismo carácter en ambos casos. .. _50.3.10: 50.3.10. Reenlazar los Botones del Ratón ```````````````````````````````````````` Emacs también usa símbolos Lisp para designar los botones del ratón. Los eventos ordinarios del ratón en Emacs son *eventos de clic;* estos ocurren cuando pulsa un botón y lo suelta sin mover el ratón. También puede obtener *eventos de arrastre*, cuando mueve el ratón mientras mantiene pulsado el botón. Los eventos de arrastre ocurren cuando finalmente suelta el botón. Los símbolos para los eventos de clic básicos son ``mouse-1`` (ratón-1) para el botón situado más a la izquierda, ``mouse-2`` (ratón-2) para el siguiente, y así sucesivamente. Así es como puede redefinir el segundo botón del ratón para dividir la ventana actual: :: (keymap-global-set "" 'split-window-below) Los símbolos para los eventos de arrastre son similares, pero tienen el prefijo ``drag-`` antes de la palabra ``mouse`` (ratón). Por ejemplo, arrastrar el primer botón genera un evento ``drag-mouse-1``. También puede definir los eventos que se producen al pulsar el botón del ratón. Estos eventos comienzan con ``down-`` en lugar de ``drag-``. Estos eventos se generan sólo si tienen vinculaciones de teclas. Cuando se produce un evento de botón pulsado, siempre le sigue el correspondiente evento de clic o arrastre. Si lo desea, puede distinguir entre clics simples, dobles y triples. Un *doble clic* significa pulsar el botón del ratón dos veces aproximadamente en el mismo lugar. El primer clic genera un evento de clic ordinario. El segundo clic, si se produce lo suficientemente pronto, genera un evento de doble clic. El tipo de evento de doble clic empieza por ``doble-``: por ejemplo, ``double-mouse-3`` (doble-ratón-3). Esto significa que puede dar un significado especial al segundo clic en el mismo lugar, pero debe actuar asumiendo que la definición ordinaria de un solo clic se ha ejecutado cuando se recibió el primer clic. Esto limita lo que se puede hacer con los dobles clics, pero los diseñadores de interfaces de Usuario dicen que esta restricción debe respetarse en cualquier caso. Un doble clic debería hacer algo similar al clic simple, sólo que más. El comando para el evento de doble clic debería realizar el trabajo extra para el doble clic. Si un evento de doble clic no tiene vinculación, cambia al evento de un solo clic correspondiente. Por lo tanto, si no define un doble clic en particular especialmente, ejecuta el comando de un solo clic dos veces. Emacs también soporta eventos de triple clic cuyos nombres empiezan por ``triple-``. Emacs no distingue los cuádruples clics como tipos de eventos; los clics más allá del tercero generan eventos adicionales de triple clic. Sin embargo, el número completo de clics se registra en la lista de eventos, así que si conoces Emacs Lisp puedes distinguirlos si realmente quiere (ver `Eventos de Clic `_ en **El Manual de Referencia de Emacs Lisp**). No recomendamos significados distintos para más de tres pulsaciones, pero a veces es útil que las pulsaciones subsiguientes hagan un ciclo a través del mismo conjunto de tres significados, de modo que cuatro pulsaciones equivalgan a una pulsación, cinco equivalgan a dos y seis equivalgan a tres. Emacs también registra pulsaciones múltiples en eventos de arrastrar y pulsar botón. Por ejemplo, cuando pulsa un botón dos veces, y luego mueve el ratón mientras mantiene pulsado el botón, Emacs obtiene un evento ``double-drag`` (doble-arrastre). Y en el momento en que lo pulsa por segunda vez, Emacs recibe un evento ``double-down`` (doble-abajo, que se ignora, como todos los eventos de ``button-down`` (botón-abajo), si no tiene vinculación). La variable ``double-click-time`` (tiempo de doble clic) especifica cuánto tiempo puede transcurrir entre clics y permitir que se agrupen como un clic múltiple. Su valor está en unidades de milisegundos. Si el valor es nulo, no se detectan los dobles clics. Si el valor es ``t``, no hay límite de tiempo. El valor por defecto es 500. La variable ``double-click-fuzz`` especifica cuánto puede moverse el ratón entre los clics y permitir que se agrupen como un clic múltiple. Su valor está en unidades de píxeles en pantallas con ventanas y en unidades de 1/8 de una celda de caracteres en terminales en modo texto; el valor por defecto es 3. Los símbolos para los eventos del ratón también indican el estado de las teclas modificadoras, con los prefijos habituales ``C-``, ``M-``, ``H-``, ``s-``, ``A-`` y ``S-``. Éstas preceden siempre a ``doble-`` o ``triple-``, que preceden siempre a ``down-`` (arrastrar) o ``down-`` (abajo). Un marco incluye áreas que no muestran texto del búfer, como la línea de modo y la barra de desplazamiento. Puede saber si un botón del ratón procede de una zona especial de la pantalla mediante teclas prefijo ficticias. Por ejemplo, si hace clic con el ratón en la línea de modo, obtendrá el prefijo clave modo-línea (mode line) antes del símbolo ordinario del botón del ratón. Así, aquí está cómo definir el comando para hacer clic en el primer botón en una línea de modo para ejecutar ``scroll-up-command``: :: (keymap-global-set " " 'scroll-up-command) Aquí está la lista completa de estas teclas de prefijo ficticias y sus significados: ``mode-line`` Cuando el ratón se situó en la línea de modo de una ventana. ``vertical-line`` Cuando el ratón aparecía en la línea vertical que separa las ventanas contiguas. (Si utilizas barras de desplazamiento, éstas aparecen en lugar de estas líneas verticales). ``verticall-scroll-line`` Cuando el ratón estuvo en una barra de desplazamiento vertical. (Este es el único tipo de barra de desplazamiento que Emacs soporta actualmente). ``menu-bar`` Cuando el ratón estaba en la barra de menús. ``tab-bar`` Cuando el ratón se situó en una barra de pestañas. ``tab-line`` Cuando el ratón estuvo en una línea de tabulación. ``header-line`` Cuando el ratón aparecía en una línea de cabecera. Se puede poner más de un botón del ratón en una secuencia de teclas, pero no es habitual hacerlo. .. _50.3.11: 50.3.11 Deshabilitar Comandos ````````````````````````````` Deshabilitar un comando significa que al invocarlo interactivamente se pide confirmación al Usuario. El propósito de deshabilitar un comando es prevenir que los Usuarios lo ejecuten por accidente; hacemos esto para comandos que pueden ser confusos para los no iniciados. Al intentar invocar un comando deshabilitado interactivamente en Emacs se muestra una ventana que contiene el nombre del comando, su documentación, y algunas instrucciones sobre qué hacer inmediatamente; luego Emacs pregunta si se desea ejecutar el comando como se solicita, habilitarlo y ejecutarlo, o cancelarlo. Si decide activar el comando, debe responder a otra pregunta: si desea hacerlo permanentemente o sólo para la sesión actual. (La habilitación permanente funciona editando automáticamente su archivo de inicialización). También puede escribir :kbd:`!` (``!``) para activar todos los comandos, sólo para la sesión actual. El mecanismo directo para desactivar un comando es poner una propiedad disabled no nula en el símbolo Lisp del comando. Aquí está el programa Lisp para hacer esto: :: (put 'delete-region 'disabled t) Si el valor de la propiedad disabled es una cadena, esa cadena se incluye en el mensaje que aparece cuando se utiliza el comando: :: (put 'delete-region 'disabled "En su lugar es mejor usar `kill-region'.\n") Como una alternativa menos pesada a la desactivación de comandos, es posible que desee ser consultado antes de ejecutar un comando. Por ejemplo, para ser consultado antes de ejecutar el comando ``M-> (end-off-buffer)``, podría poner algo como lo siguiente en su archivo init: :: (command-query 'end-of-buffer "¿Realmente quieres ir al final del búfer?" Por defecto, se le preguntará ``y/n`` (si/no), pero si da un valor no nulo al tercer argumento opcional, se le preguntará ``yes/no`` (si/no). Puede desactivar un comando editando directamente el archivo de inicialización o con el comando ``M-x disable-command``, que edita el archivo de inicialización por usted. Del mismo modo, ``M-x enable-command`` edita el archivo de inicialización para habilitar un comando permanentemente. Ver :ref:`50.4`. Si Emacs fue invocado con las opciones ``-q`` o ``--no-init-file`` (ver :ref:`C.2`), no editará su archivo de inicialización. Si lo hace podría perder información porque Emacs no ha leído su fichero de inicialización. Que un comando esté deshabilitado es independiente de la tecla que se use para invocarlo; la deshabilitación también se aplica si el comando se invoca usando ``M-x``. Sin embargo, deshabilitar un comando no tiene ningún efecto sobre su invocación como función desde programas Lisp. .. _50.4: 50.4. El Archivo de Inicialización de Emacs ------------------------------------------- Cuando Emacs se inicia, normalmente intenta cargar un programa Lisp desde un *archivo de inicialización*, o *archivo init* para abreviar. Si este fichero existe, especifica cómo inicializar Emacs por Ud. Tradicionalmente, el archivo ``~/.emacs`` se usa como archivo init, aunque el Editor también busca en ``~/.emacs.el``, ``~/.emacs.d/init.el``, ``~/.config/emacs/init.el``, u otras localizaciones. Ver :ref:`50.4.4`. Puede que encuentre conveniente tener toda la configuración de Emacs en un directorio, en cuyo caso debería usar ``~/.emacs.d/init.el`` o el ``~/.config/emacs/init.el`` compatible con XDG. Puede utilizar el modificador de línea de comandos ``-q`` para evitar que se cargue su archivo de init, y ``-u`` (o ``--user``) para especificar el archivo de init de un Usuario diferente (consulte :ref:`C.2`). También puede haber un *archivo de inicio por defecto*, que es la librería llamada ``default.el``, encontrada a través de la ruta de búsqueda estándar para librerías. La distribución de Emacs no contiene tal biblioteca; su instalación puede crear una para personalizaciones locales. Si esta biblioteca existe, se cargará siempre que inicies Emacs (excepto cuando especifique ``-q``). Pero su archivo de inicio, si existe, se carga primero; si establece ``inhibit-default-init`` no nulo (no``nul``), entonces default no se carga. Su instalación también puede tener un archivo de inicio del sitio; este se llama ``site-start.el``, si existe. Al igual que ``default.el``, Emacs encuentra este fichero a través de la ruta de búsqueda estándar para bibliotecas Lisp. Emacs carga esta librería antes de cargar su fichero init. Para inhibir la carga de esta biblioteca, use la opción ``--no-site-file``. Vea :ref:`C.2`. Recomendamos no usar ``site-start.el`` para cambios que pueden no gustar a algunos Usuarios. Es mejor ponerlos en ``default.el``, para que los Usuarios puedan anularlos más fácilmente. Puede colocar ``default.el`` y ``site-start.el`` en cualquiera de los directorios en los que Emacs busca librerías Lisp. La variable ``load-path`` (ver :ref:`28.8`) especifica estos directorios. Muchos sitios ponen estos ficheros en un subdirectorio llamado site-lisp en el directorio de instalación de Emacs, como ``/usr/local/share/emacs/site-lisp``. La compilación por bytes de su fichero init no es recomendable (vea `Compilación por bytes `_ en el **Manual de Referencia de Emacs Lisp**). Generalmente no acelera mucho el arranque, y a menudo lleva a problemas cuando olvida recompilar el fichero. Una mejor solución es usar el servidor Emacs para reducir el número de veces que tiene que arrancar Emacs (ver :ref:`40`). Si su archivo de inicio define muchas funciones, considera moverlas a un fichero separado (compilado en bytes) que carga en su fichero init. Si va a escribir programas Emacs Lisp reales que vayan más allá de una personalización menor, debería leer el Manual de Referencia de Emacs Lisp. Vea `Emacs Lisp `_ en el **Manual de Referencia de Emacs Lisp**. 50.4.1 Sintaxis del Archivo init ```````````````````````````````` El fichero init contiene una o más expresiones Lisp. Cada una de ellas consiste en un nombre de función seguido de argumentos, todos ellos rodeados de paréntesis. Por ejemplo, (``setq fill-column 60``) llama a la función ``setq`` para establecer la variable ``fill-column`` (ver :ref:`26.6`) a 60. Puede establecer cualquier variable Lisp con ``setq``, pero con ciertas variables ``setq`` no hará lo que probablemente desee en el fichero de inicio. Algunas variables se convierten automáticamente en búfer-local cuando se fijan con esta variable; lo que Usted quiere en el fichero init es fijar el valor por defecto, usando ``setq-default``. (La siguiente sección tiene ejemplos de ambos métodos). Algunas variables personalizables de modo menor hacen cosas especiales para habilitar el modo cuando las configura con Customize (Personalizar), pero ``setq`` ordinario no lo hará; para habilitar el modo en su archivo init, llama al comando minor mode. Finalmente, algunas opciones de Usuario personalizables se inicializan de formas complejas, y éstas tienen que establecerse a través de la interfaz customize (ver :ref:`50`), o usando ``customize-set-variable/setopt`` (ver :ref:`50.2.1`). El segundo argumento de ``setq`` es una expresión para el nuevo valor de la variable. Puede ser una constante, una variable o una expresión de llamada a función. En el archivo de inicio, la mayoría de las veces se utilizan constantes. Pueden ser: Números Los números se escriben en decimal, con un signo menos (guión del medio) inicial opcional. Cadenas La sintaxis de cadenas de Lisp es la misma que la de C, con algunas características adicionales. Utilice un carácter de comillas dobles para iniciar y finalizar una constante de cadena. En una cadena, puede incluir literalmente nuevas líneas y caracteres especiales. Pero a menudo es más limpio utilizar secuencias de barras invertidas para ellos: ``\n`` para nueva línea (newline), ``\b`` para retroceso (backspace), ``\r`` para retorno de carro (carriage return), ``\t`` para tabulador (tab), ``\f`` para salto de línea (formfeed, control-L), ``\e`` para escape, ``\\a`` para barra invertida (backslash), ``\"`` para comilla doble (double-quote), o ``\ooo`` para el carácter cuyo código octal es ``ooo``. La barra invertida y la comilla doble son los únicos caracteres para los que las secuencias de barra invertida son obligatorias. ``\C-`` puede usarse como prefijo para un carácter de control, como en ``\C-s`` para ASCII control-S, y ``\M-`` puede usarse como prefijo para un carácter Meta, como en ``\M-a`` para ``Meta-A`` o ``\M-\C-a`` para ``Ctrl-Meta-A``. Consulte :ref:`50.4.5` para obtener información sobre la inclusión de caracteres no ASCII en su archivo de inicio. Caracteres La sintaxis de las constantes de caracteres de Lisp consiste en un ``?`` seguido de un carácter o de una secuencia de escape que empieza por ``\``. Ejemplos: ``?x``, ``?\n``, ``?\"``, ``?\``). Tenga en cuenta que las cadenas y los caracteres no son intercambiables en Lisp; algunos contextos requieren uno y otros requieren el otro. Consulte :ref:`50.4.5`, para obtener información sobre la vinculación de comandos a teclas que envían caracteres no ASCII. True ``t`` significa "true" (verdadero). False ``nil`` es la abreviatura de "false" (falso). Otros Obejtos Lisp Escriba una comilla simple (``'``) seguida del objeto Lisp que desee. Para más información sobre la sintaxis de Emacs Lisp, vea `Introducción `_ en El Manual de Referencia de Emacs Lisp. 50.4.2. Ejemplos de Archivos de Inicio `````````````````````````````````````` He aquí algunos ejemplos de cómo hacer ciertas cosas comúnmente deseadas con expresiones Lisp: * Añade un directorio a la variable ``load-path``. Desde donde Emacs puede poner bibliotecas Lisp que no estén incluidas con Emacs en este directorio, y cargarlas con ``M-x load-library``. Ver :ref:`28.8`. :: (add-to-list 'load-path "/ruta/a/librería/lisp") * Hace ``TAB`` en modo C sólo inserta un tabulador si el punto está en medio de una línea. :: (setq c-tab-always-indent nil) Aquí tenemos una variable cuyo valor, normalmente es ``t`` para "true" (verdadero) y la alternativa es ``nil`` para "false". * Hace que las búsquedas distingan entre mayúsculas y minúsculas por defecto (en todos los búferes que no anulen esto). :: (setq user-mail-address "tano@texto-plano.xyz") Varios paquetes de Emacs, como el modo Mensaje, consultan ``user-mail-address`` cuando necesitan conocer su dirección de correo electrónico. Ver :ref:`33.2`. * Hace que el modo Texto sea el modo por defecto para los nuevos búferes. :: (setq-default major-mode 'text-mode) Note que se utiliza ``text-mode`` porque es el comando para entrar en modo Texto. La comilla simple que lo precede hace que el símbolo sea una constante; de lo contrario, ``text-mode`` se trataría como un nombre de variable. * Configura por defecto el juego de caracteres Latin-1, que soporta la mayoría de los idiomas de Europa Occidental. :: (set-language-environment "Latin-1") * Desactiva el modo Número de línea, un modo global menor. :: (line-number-mode 0) * Activa automáticamente el modo Relleno Automático en el modo Texto y modos relacionados (ver :ref:`50.2.2`). :: (add-hook 'text-mode-hook 'auto-fill-mode) * Cambia el sistema de codificación utilizado al hacer uso el portapapeles (véase :ref:`23.10`). :: (setopt selection-coding-system 'utf-8) * Carga la biblioteca Lisp instalada llamada ``foo`` (en realidad un archivo ``foo.elc`` o ``foo.el`` en un directorio Emacs estándar). :: (load "foo") Cuando el argumento a cargar es un nombre de archivo relativo, que no empieza por ``/`` o ``~``, ``load`` busca en los directorios de ``load-path`` (ver :ref:`28.8`). * Carga el archivo Lisp compilado ``foo.elc`` desde su directorio personal. :: (load "~/foo.elc") Aquí se usa un nombre de fichero completo, por lo que no se hace ninguna búsqueda. * Le puede decir a Emacs que encuentre la definición de la función ``mifunción`` cargando una biblioteca Lisp llamada ``mipaquete`` (es decir, un fichero ``mipaquete.elc`` o ``mipaquete.el``): :: (autoload 'mifunción "mipaquete" "Haz lo que digo." t) Aquí la cadena ``"Haz lo que digo"`` es la cadena de documentación de la función. Se especifica en la definición de autocarga para que esté disponible para los comandos de ayuda incluso cuando el paquete no esté cargado. El último argumento, ``t``, indica que esta función es interactiva; es decir, puede ser invocada interactivamente tecleando :kbd:`Alt`-:kbd:`x` *mifunción* :kbd:`RETURN` (``M-x`` *mifunción* ``RET``) o vinculándola a una tecla. Si la función no es interactiva, omita ``t`` o utilice ``nil``. * Vuelve a vincular la combinación de teclas :kbd:`Ctrl`-:kbd:`x` :kbd:`l` (``C-x l``) para ejecutar la función ``make-symbolic-link`` (consulte :ref:`50.3.6`). :: (keymap-global-set "C-x l" 'make-symbolic-link) o :: (keymap-set global-map "C-x l" 'make-symbolic-link) Observe una vez más la comilla simple utilizada para referirse al símbolo ``make-symbolic-link`` en lugar de a su valor como variable. * Puede hacer lo mismo sólo para el modo Lisp. :: (keymap-set lisp-mode-map "C-x l" 'make-symbolic-link) * Redefine todas las teclas que ahora se ejecutan en la línea siguiente en el modo Fundamental para que se ejecuten en la línea anterior. :: (keymap-substitute global-map 'next-line 'forward-line) * Hace que ``C-x C-v`` sea indefinido. :: (keymap-global-unset "C-x C-v") Una razón para indefinir una clave es para poder convertirla en prefijo. Simplemente definiendo ``C-x C-v`` cualquier cosa hará que ``C-x C-v`` sea un prefijo, pero ``C-x C-v`` debe liberarse primero de su definición habitual de no prefijo. * Hace que ``$`` tenga la sintaxis de puntuación en modo Texto. Nótese el uso de una constante de carácter para ``$``. :: (modify-syntax-entry ?\$ "." text-mode-syntax-table) * Puede habilitar el uso del comando ``narrow-to-region`` sin confirmación. :: (put 'narrow-to-region 'disabled nil) * Ajusta la configuración a varias plataformas y versiones de Emacs. Los Usuarios normalmente quieren que Emacs se comporte igual en todos los sistemas, por lo que el mismo fichero init es el adecuado para todas las plataformas. Sin embargo, a veces ocurre que una función que usa para personalizar Emacs no está disponible en algunas plataformas o en versiones antiguas de Emacs. Para lidiar con esa situación, coloque la personalización dentro de una condicional que compruebe si la función o facilidad está disponible, así: :: (if (fboundp 'blink-cursor-mode) (blink-cursor-mode 0)) (if (boundp 'coding-category-utf-8) (set-coding-priority '(coding-category-utf-8))) También puede hacer caso omiso de los errores que se producen si la función no está definida. :: (ignore-errors (set-face-background 'region "grey75")) Un ``setq`` en una variable que no existe es generalmente inofensivo, por lo que no necesitan un condicional. * Usa ``use-package`` para cargar y configurar automáticamente un paquete. :: (use-package hi-lock :defer t :init (add-hook 'some-hook 'hi-lock-mode) :config (use-package my-hi-lock) :bind (("M-o l" . highlight-lines-matching-regexp) ("M-o r" . highlight-regexp) ("M-o w" . highlight-phrase))) Esto cargará ``hi-lock`` cuando algunos de sus comandos o variables se usen por primera vez, enlazará 3 teclas a sus comandos, y adicionalmente cargará el paquete ``my-hi-lock`` (presumiblemente personalizando ``hi-lock``) después de cargar ``hi-lock``. La utilidad ``use-package`` está completamente documentada en su propio manual. 50.4.3. Inicialización Específica de Terminal ````````````````````````````````````````````` Cada tipo de terminal puede tener una biblioteca Lisp que se cargará en Emacs cuando se ejecute en ese tipo de terminal. Para un tipo de terminal llamado *termtype*, la biblioteca se llama ``term/termtype``. (Si hay una entrada de la forma (``termtype . alias``) en la lista de asociación ``term-file-aliases``, Emacs usa *alias* en lugar de *termtype*). La biblioteca se encuentra buscando en los directorios ``load-path`` como de costumbre y probando los sufijos ``.elc`` y ``.el``. Normalmente aparece en el subdirectorio term del directorio donde se guardan la mayoría de las bibliotecas de Emacs. El propósito habitual de la biblioteca específica del terminal es asignar las secuencias de escape utilizadas por las teclas de función del terminal a nombres más significativos, utilizando ``input-decode-map``. Consulte el archivo ``term/lk201.el`` para ver un ejemplo de cómo se hace esto. Muchas teclas de función se asignan automáticamente según la información de la base de datos Termcap; la biblioteca específica del terminal sólo necesita asignar las teclas de función que Termcap no especifica. Cuando el tipo de terminal contiene un guión, sólo la parte del nombre antes del primer guión es significativa a la hora de elegir el nombre de la biblioteca. Así, los tipos de terminal ``aaa-48`` y ``aaa-30-rv`` utilizan ambos el término de ``biblioteca/aaa``. El código de la biblioteca puede utilizar (``getenv "TERM"``) para encontrar el nombre completo del tipo de terminal. El nombre de la biblioteca se construye concatenando el valor de la variable ``term-file-prefix`` y el tipo de terminal. Su archivo ``.emacs`` puede evitar la carga de la biblioteca específica del terminal poniendo ``term-file-prefix`` a ``nil``. Emacs ejecuta el ``gancho tty-setup-hook`` al final de la inicialización, después de que su fichero ``.emacs`` y cualquier biblioteca específica de terminal hayan sido leídos. Añade funciones de gancho a este si desea sobreescribir parte de cualquiera de las librerías específicas del terminal y definir inicializaciones para terminales que no tienen una librería. Ver :ref:`50.2.2`. .. _50.4.4: 50.4.4. Cómo encuentra Emacs su Archivo de Inicio ````````````````````````````````````````````````` Emacs normalmente encuentra su archivo de inicio en una ubicación bajo su directorio home. Ver :ref:`50.4`. Emacs busca su fichero init usando los nombres de archivo ``~/.emacs.el``, ``~/.emacs``, o ``~/.emacs.d/init.el`` en ese orden; puede elegir usar cualquiera de estos nombres. (Tenga en cuenta que sólo las ubicaciones directamente en su directorio personal tienen un punto inicial en el nombre base de la ubicación). Emacs también puede buscar ``init.el`` en una ubicación compatible con XDG, por defecto es el directorio ``~/.config/emacs``. Esto puede anularse configurando ``XDG_CONFIG_HOME`` en su entorno, su valor reemplaza ``~/.config`` en el nombre del archivo init.el por defecto XDG. Sin embargo ``~/.emacs.d``, ``~/.emacs``, y ``~/.emacs.el`` son siempre preferidos si existen, lo que significa que debes borrarlos o renombrarlos para poder usar la localización XDG. Tenga en cuenta también que si ni la localización XDG ni ``~/.emacs.d`` existen, entonces Emacs creará ``~/.emacs.d`` (y por tanto lo usará durante las invocaciones posteriores). Emacs establecerá ``user-emacs-directory`` al directorio que decida usar. Aunque esto es compatible con versiones anteriores de Emacs, las plataformas POSIX modernas prefieren poner sus archivos de inicialización bajo ``~/.config`` para que la resolución de un problema que pueda deberse a un fichero init erróneo, o archivar una colección de archivos init, pueda hacerse renombrando ese directorio. Para ayudar a las versiones antiguas de Emacs a encontrar los ficheros de configuración en sus ubicaciones actuales por defecto, puede ejecutar el siguiente código Emacs Lisp: :: (make-symbolic-link ".config/emacs" "~/.emacs.d") Sin embargo, si ejecuta Emacs desde una shell iniciada por ``su`` y ``XDG_CONFIG_HOME`` no está configurado en tu entorno, Emacs intenta encontrar sus propios archivos de inicialización, no los del Usuario que está pretendiendo ser en ese momento. La idea es que obtenga sus propias personalizaciones del editor incluso si está corriendo como superusuario. Más precisamente, Emacs primero determina qué archivo de init de Usuario usar. Obtiene su nombre de usuario de las variables de entorno ``LOGNAME`` y ``USER``; si ninguna de ellas existe, usa el ID de Usuario efectivo. Si ese nombre de Usuario coincide con el ID de Usuario real, entonces Emacs usa ``HOME``; si no, busca el directorio home correspondiente a ese nombre de Usuario en la base de datos de Usuarios del sistema. Por brevedad, el resto de la documentación de Emacs generalmente usa sólo la localización por defecto ``~/.emacs.d/init.el`` para el archivo init. .. _50.4.5: 50.4.5. Caracteres no ASCII en Archivos de Inicio ````````````````````````````````````````````````` Los sistemas de lenguaje y codificación pueden causar problemas si su archivo init contiene caracteres no ASCII, como letras acentuadas, en cadenas o combinaciones de teclas. Si desea utilizar caracteres no ASCII en su archivo init, debe poner una etiqueta ``-*-coding: coding-system-*-`` en la primera línea de dicho archivo, y especificar un sistema de codificación que soporte el carácter o caracteres en cuestión. Véase :ref:`23.6`. Esto se debe a que los valores por defecto para decodificar texto no ASCII pueden no estar aún configurados en el momento en que Emacs lee las partes de su archivo init que usan tales cadenas, posiblemente llevando a Emacs a decodificar esas cadenas incorrectamente. Entonces debería evitar añadir código Emacs Lisp que modifique el sistema de codificación de otras formas, como llamadas a ``set-language-environment``. Una alternativa al uso directo de caracteres no ASCII es usar una de las sintaxis de escape de caracteres descritas en `Sintaxis de Escape General `_ en el **Manual de Referencia Lisp**, ya que permiten especificar todos los puntos de código Unicode usando sólo caracteres ASCII. Para vincular claves no ASCII, debe utilizar un vector (consulte :ref:`50.3.6`). No se puede utilizar la sintaxis de cadena, ya que los caracteres no ASCII se interpretarán como metateclas. Por ejemplo :: (global-set-key [?caracter] alguna-función) Escriba :kbd:`Ctrl`-:kbd:`q` (``C-q``), seguido de la tecla que quiera enlazar, para insertar el carácter. .. _50.4.6: 50.4.6. El Archivo de Inicio Temprano ````````````````````````````````````` La mayoría de las personalizaciones para Emacs deberían ponerse en el archivo de inicio normal. Ver :ref:`50.4`. Sin embargo, a veces es necesario que las personalizaciones tengan efecto durante el arranque de Emacs antes de que se procese el fichero init normal. Tales personalizaciones pueden ser puestas en el fichero early init (archivo de inicio temprano), ``~/.config/emacs/early-init.el`` o ``~/.emacs.d/early-init.el``. Este fichero se carga antes de que el sistema de paquetes y la GUI se inicialicen, así que en él puede personalizar variables que afectan al proceso de inicialización de paquetes, como ``package-enable-at-startup``, ``package-load-list``, y ``package-user-dir``. Tenga en cuenta que variables como ``package-archives`` que sólo afectan a la instalación de nuevos paquetes, y no al proceso de hacer disponibles los paquetes ya instalados, pueden personalizarse en el archivo init normal. Véase :ref:`49.3`. No recomendamos que traslade a ``early-init.el`` personalizaciones que pueden dejarse en los archivos init normales. Esto se debe a que el dicho archivo de inicio temprano se lee antes de que se inicialice la GUI, por lo que las personalizaciones relacionadas con las características de la GUI no funcionarán de forma fiable en ``early-init.el``. Por el contrario, los archivos init normales se leen después de que se inicialice la GUI. Si debe tener personalizaciones en el archivo ``early-init`` que dependen de características de la GUI, haga que se ejecuten con ganchos proporcionados por el arranque de Emacs, como ``window-setup-hook`` o ``tty-setup-hook``. Ver :ref:`50.2.2`. Para más información sobre el archivo early init, vea `Archivo de Inicio `_ en el **Manual de Referencia de Emacs Lisp**. 50.5 Mantener Información de Autenticación Persistente ------------------------------------------------------ Algunos paquetes de Emacs, que conectan con otros servicios, requieren autentificación (ver :ref:`9.7`), por ejemplo, ver `Gnus `_ en **El Manual de Gnus**, o `Tramp `_ en el **Manual de Tramp**. Debido a que puede ser molesto proporcionar el mismo nombre de Usuario y contraseña una y otra vez, Emacs ofrece mantener esta información persistente a través de la librería auth-source. Por defecto, la información de autenticación se toma del archivo ``~/.authinfo`` o ``~/.authinfo.gpg`` o ``~/.netrc``. Estos archivos tienen una sintaxis similar a los archivos netrc conocidos del programa ``ftp``, así: :: machine mi-maquina login nombre-inicio-sesion password mi-contraseña port mi-puerto De forma similar, la biblioteca ``auth-source`` soporta múltiples backend de almacenamiento, actualmente el clásico backend netrc, archivos JSON, la API del Servicio Secreto, y pass, el gestor de contraseñas estándar de unix. Todas estas alternativas pueden personalizarse mediante la opción de Usuario ``auth-sources``, ver `Emacs auth-source `_ en **Emacs auth-source**. Cuando se introduce una contraseña de forma interactiva, que no se encuentra a través del backend configurado, algunos de los backends ofrecen guardarla de forma persistente. Esto puede cambiarse personalizando la opción de Usuario ``auth-source-save-behavior``.