.. _15: 15 Controlando la Pantalla ========================== Como sólo una parte de un búfer grande cabe en la ventana, Emacs tiene que mostrar sólo parte del mismo. Este capítulo describe comandos y variables que le permiten especificar qué parte del texto quiere ver, y cómo se mostrará. .. _15.1: 15.1 Desplazamiento ------------------- Si una ventana es demasiado pequeña para mostrar todo el texto de su búfer, sólo muestra una parte del mismo. Los comandos de *desplazamiento* cambian la parte del búfer que se muestra. Desplazarse hacia delante o hacia arriba hace avanzar la parte del búfer que se muestra en la ventana; de forma equivalente, mueve el texto del búfer hacia arriba en relación con la ventana. El desplazamiento hacia atrás o hacia abajo muestra una parte anterior del búfer y desplaza el texto hacia abajo con respecto a la ventana. En Emacs, desplazarse hacia arriba o hacia abajo se refiere a la dirección en que se mueve el texto en la ventana, *no* a la dirección en que se mueve la ventana en relación con el texto. Esta terminología fue adoptada por Emacs antes de que se generalizara el significado moderno de "desplazarse hacia arriba" y "desplazarse hacia abajo". De ahí el extraño resultado de que ``PageDown`` se desplace hacia arriba en el sentido de Emacs. La porción de un búfer que se muestra en una ventana siempre contiene un punto. Si mueve el punto más allá de la parte inferior o superior de la ventana, el desplazamiento se produce automáticamente para traerlo de vuelta a la pantalla (vea :ref:`15.3`). También puede desplazarse explícitamente con estos comandos: | :kbd:`Ctrl`-:kbd:`v` (``C-v``) | ``PageDown`` | ``next`` Avanza casi una ventana completa (``scroll-up-command``). | :kbd:`Alt`-:kbd:`v` (``M-v``) | ``PageUp`` | ``prior`` Se desplaza hacia atrás (``scroll-down-command``). ``C-v`` (``scroll up-command``) se desplaza hacia delante casi toda la altura de la ventana. El efecto es tomar las dos líneas de la parte inferior de la ventana y colocarlas en la parte superior, seguidas de líneas que antes no eran visibles. Si había un punto en el texto que se desplazaba hacia arriba, éste termina en la nueva línea superior de la ventana. La tecla ``PageDown`` (o ``next``) equivale a :kbd:`Ctrl`-:kbd:`v` (``C-v``). ``M-v`` (``scroll-down-command``) se desplaza hacia atrás de forma similar. La tecla ``PageUp`` (o ``prior``) equivale a :kbd:`Alt`-:kbd:`v` (``M-v``). El número de líneas de solapamiento que dejan estos comandos de desplazamiento está controlado por la variable ``next-screen-context-lines``, cuyo valor por defecto es 2. Puede suministrar a los comandos un argumento prefijo numérico, *n*, para desplazarse *n* líneas; Emacs intenta dejar el punto sin cambios, de modo que el texto y el punto se muevan juntos hacia arriba o hacia abajo. ``C-v`` con un argumento negativo es como ``M-v`` y viceversa. Por defecto, estos comandos señalan un error (pitando o parpadeando la pantalla) si no es posible más desplazamiento, porque la ventana ha alcanzado el principio o el final del buffer. Si cambia la variable ``scroll-error-top-bottom`` a ``t``, estos comandos mueven el punto a la posición más lejana posible. Si el punto ya está allí, los comandos indican un error. A algunos Usuarios les gusta que los comandos de desplazamiento mantengan el punto en la misma posición de la pantalla, de modo que el desplazamiento de vuelta a la misma pantalla devuelva convenientemente el punto a su posición original. Puede activar este comportamiento mediante la variable ``scroll-preserve-screen-position``. Si el valor es ``t``, Emacs ajusta el punto para mantener el cursor en la misma posición de la pantalla cada vez que un comando de desplazamiento lo mueve fuera de la ventana, en lugar de moverlo a la línea superior o inferior. Con cualquier otro valor que no sea nulo, Emacs ajusta el punto de esta manera incluso si el comando de desplazamiento deja el punto en la ventana. Esta variable afecta a todos los comandos de desplazamiento documentados en esta sección, así como al desplazamiento con la rueda del ratón (ver :ref:`22.1`); en general, afecta a cualquier comando que tenga una propiedad ``scroll-command`` no nula. Ver **Lista de Propiedades** en el Manual de Referencia de Emacs Lisp. La misma propiedad también causa que Emacs no salga de la búsqueda incremental cuando uno de estos comandos es invocado y luego, ``isearch-allow-scroll`` es no-``nil`` (ver :ref:`16.1.6`). A veces, particularmente cuando mantenemos pulsadas teclas como :kbd:`Ctrl`-:kbd:`v` (``C-v``) y :kbd:`Alt`-:kbd:`v` (``M-v``), activando la auto-repetición de teclado, Emacs no consigue mantener el ritmo rápido de desplazamiento solicitado; la pantalla no se actualiza y el Editor puede dejar de responder a las entradas durante bastante tiempo. Podemos contrarrestar esta lentitud estableciendo la variable ``fast-but-imprecise-scrolling`` a un valor no nulo. Esto indica a los comandos de desplazamiento que no tipifiquen (ver :ref:`15.13`) cualquier texto no tipificado sobre el que se desplacen, asumiendo en su lugar que tiene la fuente por defecto. Esto puede hacer que Emacs se desplace a posiciones de búfer algo erróneas cuando las caras en uso no son todas del mismo tamaño, incluso con operaciones de desplazamiento simples (es decir, sin repetición automática). Como alternativa a configurar el desplazamiento rápido-pero-impreciso (``fast-but-imprecise-scrolling``), puede que prefiera activar la fontificación diferida de ``jit-lock`` (vea :ref:`15.13`). Para ello, personalice ``jit-lock-defer-time`` a un pequeño número positivo como 0.25, o incluso 0.1 si escribe rápido. De este modo, el desplazamiento será menos brusco cuando mantenga pulsada la tecla :kbd:`Ctrl`-:kbd:`v` (``C-v``), pero el contenido de la ventana después de cualquier acción que se desplace a una nueva porción del búfer estará momentáneamente sin fuente. Por último, una tercera alternativa a estas variables es ``redisplay-skip-fontification-on-input``. Si esta variable no es nula, salta algunas fontificaciones si hay entrada pendiente. Esto normalmente no afecta a la visualización porque la redisplay se salta completamente de todos modos si había entrada pendiente, pero puede hacer que el desplazamiento sea más suave al evitar la fontificación innecesaria. Los comandos :kbd:`Alt`-:kbd:`x` ``scroll-up`` (``M-x scroll-up``) y :kbd:`Alt`-:kbd:`x` ``scroll-down`` (``M-x scroll-down``) se comportan de forma similar a ``scroll-up-command`` y ``scroll-down-command``, excepto que no obedecen a ``scroll-error-top-bottom``. Antes de Emacs 24, estos eran los comandos por defecto para desplazarse arriba y abajo. Los comandos :kbd:`Alt`-:kbd:`x` ``scroll-up-line`` (``M-x scroll-up-line``) y :kbd:`Alt`-:kbd:`x` ``scroll-down-line`` (``M-x scroll-down-line``) desplazan la ventana actual una línea cada vez. Si tiene intención de usar cualquiera de estos comandos, puede que quiera asignarles teclas (vea :ref:`50.3.6`). 15.2 Recentrado --------------- :kbd:`Ctrl`-:kbd:`l` (``C-l``) Desplaza la ventana seleccionada de modo que la línea actual sea la línea de texto situada más al centro; en invocaciones consecutivas posteriores, convierte la línea actual en la línea superior, la inferior y así sucesivamente en orden cíclico. Es posible que también redistribuya la pantalla (``recenter-top-bottom``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`Shift`-:kbd:`l` (``C-M-S-l``) Desplaza la otra ventana; esto equivale a que ``C-l`` actúe sobre la otra ventana. :kbd:`Alt`-:kbd:`x` ``recenter`` (``M-x recenter``) Desplaza la ventana seleccionada de modo que la línea actual sea la línea de texto situada más al centro. Posiblemente también vuelva a mostrar la pantalla. :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`l` (``C-M-l``) Desplaza heurísticamente la información útil en la pantalla (``reposition-window``, reposiciona la ventana). El comando ``C-l`` (``recenter-top-bottom``) *recentra* la ventana seleccionada, desplazándola de modo que la línea actual de la pantalla esté exactamente en el centro de la ventana, o lo más cerca posible del centro. Si se teclea :kbd:`Ctrl`-:kbd:`l` (``C-l``) dos veces seguidas (:kbd:`Ctrl`-:kbd:`l` :kbd:`Ctrl`-:kbd:`l`, ``C-l C-l``), la ventana se desplaza de modo que el punto se encuentre en la línea superior de la pantalla. Si teclea una tercera :kbd:`Ctrl`-:kbd:`l`, la ventana se desplazará hasta que el punto se encuentre en la línea inferior de la pantalla. Cada ``C-l`` sucesiva recorre estas tres posiciones. Puede cambiar el orden de los ciclos personalizando la variable de lista ``recenter-positions``. Cada elemento de la lista debe ser el símbolo superior, medio o inferior, o un número; un número entero significa mover la línea a la línea de pantalla especificada, mientras que un número de punto flotante entre 0.0 y 1.0 especifica un porcentaje del espacio de la pantalla desde la parte superior de la ventana. El valor por defecto, (``middle``, ``top``, ``bottom``, centro arriba abajo), es el orden cíclico descrito anteriormente. Además, si cambia la variable ``scroll-margin`` a un valor *n* distinto de cero, ``C-l`` siempre deja al menos *n* líneas de pantalla entre el punto y la parte superior o inferior de la ventana (véase :ref:`15.3`). También puede dar a ``C-l`` un argumento prefijo. Un argumento prefijo simple, :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`l` (``C-u C-l``), simplemente recentra la línea que muestra el punto. Un argumento positivo *n* mueve la línea que muestra el punto *n* líneas hacia abajo desde la parte superior de la ventana. Un argumento de cero mueve la línea del punto a la parte superior de la ventana. Un argumento negativo *-n* mueve la línea del punto *n* líneas desde la parte inferior de la ventana. Cuando se le da un argumento, ``C-l`` no limpia la pantalla ni recorre las diferentes posiciones de la pantalla. Si la variable ``recenter-redisplay`` tiene un valor no nulo, cada invocación de ``C-l`` también limpia y vuelve a mostrar la pantalla; el valor especial ``tty`` (el predeterminado) dice que se haga esto sólo en marcos de terminal de texto. Redisplaying (volver a visualizar) es útil en caso de que la pantalla se vuelva confusa por cualquier razón (ver :ref:`52.2`). El comando más primitivo ``M-x recenter`` se comporta como ``recenter-top-bottom``, pero no cicla entre las posiciones de la pantalla. ``C-M-l`` (``reposition-window``) desplaza la ventana actual de forma heurística para obtener información útil en la pantalla. Por ejemplo, en un archivo Lisp, este comando trata de poner todo el defun actual en la pantalla si es posible. .. _15.3: 15.3 Desplazamiento Automático ------------------------------ Emacs realiza un *desplazamiento automático* cuando el punto se mueve fuera de la porción visible del texto. Normalmente, el desplazamiento automático centra el punto verticalmente en la ventana, pero hay varias formas de alterar este comportamiento. Si establece ``scroll-conservatively`` a un número pequeño *n*, entonces mover el punto sólo un poco fuera de la pantalla (no más de *n* líneas) hace que Emacs se desplace lo suficiente para traer el punto de vuelta a la pantalla; si al hacerlo no consigue que el punto sea visible, el Editor se desplaza lo suficiente para centrar el punto en la ventana. Si establece ``scroll-conservatively`` a un número grande (mayor que 100), el desplazamiento automático nunca centra el punto, no importa lo lejos que se mueva; Emacs siempre desplaza el texto lo suficiente para traer el punto a la vista, ya sea en la parte superior o inferior de la ventana dependiendo de la dirección de desplazamiento. Por defecto, ``scroll-conservatively`` es 0, lo que significa centrar siempre el punto en la ventana. Dicho esto, en las ventanas minibuffer, el desplazamiento es siempre conservador por defecto porque ``scroll-minibuffer-conservatively`` es no-``nil``, que tiene prioridad sobre ``scroll-conservatively``. Otra forma de controlar el desplazamiento automático es personalizar la variable ``scroll-step``. Su valor determina el número de líneas por las que desplazarse automáticamente, cuando el punto se desplaza fuera de la pantalla. Si al desplazarse ese número de líneas no se vuelve a visualizar el punto, éste se centra en su lugar. El valor por defecto es cero, que (por defecto) hace que el punto siempre se centre después del desplazamiento. Una tercera forma de controlar el desplazamiento automático es personalizar las variables ``scroll-up-aggressively`` y ``scroll-down-aggressively``, que especifican directamente la posición vertical del punto tras el desplazamiento. El valor de ``scroll-up-aggressively`` debería ser o bien nil (por defecto), o un número de coma flotante *f* entre 0 y 1. Esto último significa que cuando el punto va por debajo del borde inferior de la ventana (es decir, desplazándose hacia delante), Emacs desplaza la ventana de modo que el punto esté a *f* partes de la altura de la ventana desde el borde inferior de la ventana. Por lo tanto, un *f* mayor significa un desplazamiento más agresivo: más texto nuevo aparece a la vista. El valor por defecto, ``nil``, equivale a 0.5. Del mismo modo, el desplazamiento agresivo hacia abajo se utiliza cuando el punto sobrepasa el borde superior de la ventana (es decir, cuando se desplaza hacia atrás). El valor especifica a qué distancia debe estar el punto del margen superior de la ventana después del desplazamiento. Por lo tanto, al igual que con el desplazamiento agresivo hacia arriba, un valor mayor es más agresivo. Tenga en cuenta que las variables ``scroll-conservatively`` (desplazamiento-conservador), ``scroll-step`` (desplazamiento por pasos) y ``scroll-up-aggressively`` (desplazamiento-ascendente-agresivo) / ``scroll-down-aggressively`` (desplazamiento-descendente-agresivo) controlan el desplazamiento automático de forma contradictoria. Por lo tanto, no debería elegir más de uno de estos métodos para personalizar el desplazamiento automático. En caso de que personalice varias variables, el orden de prioridad es: ``scroll-conservatively``, ``scroll-step`` y, por último, ``scroll-up-aggressively``/``scroll-down-aggressively``. La variable ``scroll-margin restringe`` limita lo cerca que se puede llegar a la parte superior o inferior de una ventana (incluso si el desplazamiento agresivo especifica una fracción *f* mayor que la porción de ventana entre los márgenes superior e inferior). Su valor es un número de líneas de pantalla; si el punto se acerca a ese número de líneas de la parte superior o inferior de la ventana, Emacs realiza un desplazamiento automático. Por defecto, ``scroll-margin`` es 0. El tamaño efectivo del margen está limitado a un cuarto de la altura de la ventana por defecto, pero este límite puede incrementarse hasta la mitad (o reducirse hasta cero) personalizando ``maximum-scroll-margin``. .. _15.4: 15.4 Desplazamiento Horizontal ------------------------------ El *desplazamiento horizontal* significa desplazar todas las líneas lateralmente dentro de una ventana, de modo que parte del texto cercano al margen izquierdo no se muestra. Cuando el texto de una ventana se desplaza horizontalmente, las líneas de texto se truncan en lugar de continuar (véase :ref:`15.22`). Si una ventana muestra líneas truncadas, Emacs realiza un desplazamiento horizontal automático cada vez que un punto se aleja del borde izquierdo o derecho de la pantalla. Por defecto, todas las líneas de la ventana se desplazan horizontalmente juntas, pero si establece la variable ``auto-hscroll-mode`` al valor especial de ``current-line``, sólo se desplazará la línea que muestra el cursor. Para desactivar por completo el desplazamiento horizontal automático, establezca la variable ``auto-hscroll-mode`` en ``nil``. Tenga en cuenta que cuando el desplazamiento horizontal automático está desactivado, si el punto se desplaza fuera del borde de la pantalla, el cursor desaparece para indicarlo. (En los terminales de texto, en cambio, el cursor se deja en el borde). La variable ``hscroll-margin`` controla lo cerca que se puede llegar a los bordes izquierdo y derecho de la ventana antes de que se produzca el desplazamiento automático. Se mide en columnas. Por ejemplo, si el valor es 5, al mover el punto a menos de 5 columnas de un borde se produce un desplazamiento horizontal desde ese borde. La variable ``hscroll-step`` determina cuántas columnas se desplazará la ventana cuando el punto se acerque demasiado al borde. Cero, el valor por defecto, significa centrar el punto horizontalmente dentro de la ventana. Un valor entero positivo especifica el número de columnas por las que desplazarse. Un número de coma flotante (cuyo valor debe estar entre 0 y 1) especifica la fracción del ancho de la ventana por la que desplazarse. También puede realizar un desplazamiento horizontal explícito con los siguientes comandos: :kbd:`Ctrl`-:kbd:`x` :kbd:`<` (``C-x <``) Desplaza el texto de la ventana actual hacia la izquierda (``scroll-left``). :kbd:`Ctrl`-:kbd:`x` :kbd:`>` (``C-x >``) Desplaza hacia la derecha (``scroll-right``). ``C-x <`` (``scroll-left``) desplaza el texto de la ventana seleccionada hacia la izquierda el ancho total de la ventana, menos dos columnas. (En otras palabras, el texto de la ventana se desplaza a la izquierda en relación con la ventana.) Con un argumento numérico *n*, se desplaza n columnas. Si el texto se desplaza hacia la izquierda, y el punto se mueve fuera del borde izquierdo de la ventana, el cursor se congelará en el borde izquierdo de la ventana, hasta que el punto se mueva de nuevo a la parte del texto que se muestra. Esto es independiente de la configuración actual del modo de desplazamiento automático, que, para el texto desplazado hacia la izquierda, sólo afecta al comportamiento en el borde derecho de la ventana. ``C-x >`` (``scroll-right``, desplazamiento hacia la derecha) se desplaza de forma similar hacia la derecha. La ventana no puede desplazarse más a la derecha una vez que se muestra normalmente, con cada línea comenzando en el margen izquierdo de la ventana; intentar hacerlo no tiene ningún efecto. Esto significa que no es necesario calcular con precisión el argumento para ``C-x >``; cualquier argumento suficientemente grande restablecerá la visualización normal. Si utiliza estos comandos para desplazar una ventana horizontalmente, se establece un límite inferior para el desplazamiento horizontal automático. El desplazamiento automático continuará desplazando la ventana, pero nunca más a la derecha de la cantidad que haya establecido previamente con ``scroll-left`` (desplazamiento hacia la izquierda). Cuando ``auto-hscroll-mode`` se establece en ``current-line``, todas las líneas que no sean la que muestra el cursor se desplazarán en esa cantidad mínima. .. _15.5: 15.5 Estrechamiento ------------------- *Estrechar* significa centrarse en una parte del búfer, haciendo que el resto sea temporalmente inaccesible. La parte a la que aún se puede acceder se denomina *parte accesible*. La anulación del estrechamiento, que hace que el búfer entero vuelva a ser accesible, se denomina *ensanchamiento*. Los límites del estrechamiento en vigor en un búfer se denominan *restricción* del búfer. El estrechamiento puede facilitar la concentración en una sola subrutina o párrafo al eliminar el desorden. También puede usarse para limitar el rango de operación de un comando de reemplazo o una macro de teclado repetitiva. :kbd:`Ctrl`-:kbd:`x` :kbd:`n` :kbd:`n` (``C-x n n``) Reduce (acota) la zona entre el punto y la marca (``narrow-to-region``). :kbd:`Ctrl`-:kbd:`x` :kbd:`n` :kbd:`w` (``C-x n w``) Ensancha, amplía para que todo el búfer vuelva a ser accesible (``widen``). :kbd:`Ctrl`-:kbd:`x` :Kbd:`n` :kbd:`p` (``C-x n p``) Se limita a la página actual (``narrow-to-page``). :kbd:`Ctrl`-:kbd:`x` :kbd:`n`:kbd:`d` (``C-x n d``) Reduce la definición de función (defun) actual (``narrow-to-defun``). Cuando se ha limitado a una parte del búfer, esa parte parece ser todo lo que hay. No puede ver el resto, no puede moverse dentro de ella (los comandos de movimiento no saldrán de la parte accesible), no puede cambiarla de ninguna manera. Sin embargo, no ha desaparecido, y si guarda el archivo se guardará todo el texto inaccesible. La palabra ``Narrow`` (Estrechar) aparece en la línea de modo siempre que el narrowing esté en efecto. El comando principal de estrechamiento es ``C-x n n`` (``narrow-to-region``, estrechar la región). Establece las restricciones del búfer actual de modo que el texto de la región actual sigue siendo accesible, pero todo el texto anterior o posterior a la región es inaccesible. El punto y la marca no cambian. Como alternativa, use ``C-x n p`` (``narrow-to-page``, reducir la página) para reducir a la página actual. Véase :ref:`26.4`, para la definición de una página. ``C-x n d`` (``narrow-to-defun``) se limita a la definición que contiene el punto (consulte :ref:`27.2`). La forma de cancelar el acotamiento (o estrechamiento) es ampliar con ``C-x n w`` (``widen``). Esto hace que todo el texto del búfer sea accesible de nuevo. Puede obtener información sobre a qué parte del buffer se ha estrechado usando el comando ``C-x =``. Véase :ref:`8.9`. Debido a que el estrechamiento puede confundir fácilmente a los Usuarios que no lo entienden, ``narrow-to-region`` es normalmente un comando desactivado. Al intentar usar este comando se pide confirmación y se da la opción de habilitarlo; si habilita el comando, ya no se pedirá confirmación para él. Consulte :ref:`50.3.11`. .. _15.6: 15.6 Modo Vista --------------- El modo Vista (View mode) es un modo menor que le permite explorar un búfer por pantallazos secuenciales. Proporciona comandos para desplazarse por el buffer convenientemente pero no para cambiarlo. Aparte de los comandos habituales de Emacs para mover el cursor, puede teclear :kbd:`SPACE` (``SPC``) para avanzar una ventana, :kbd:`Shift`-:kbd:`SPACE` (``S-SPC``) o ``DEL`` para retroceder, y :kbd:`s` (``s``) para iniciar una búsqueda incremental. Tecleando :kbd:`q` (``q``, ``View-quit``) se desactiva el modo Vista, y se vuelve al búfer y a la posición anterior a la activación del modo Vista. Tecleando :kbd:`e` (``e``, ``View-exit``) desactiva el modo Vista, manteniendo el buffer y la posición actuales. ``M-x view-buffer`` pide un buffer Emacs existente, cambia a él, y activa el modo Vista. ``M-x view-file`` pide un archivo y lo visita con el modo Vista activado. .. _15.7: 15.7 Modo de Seguimiento ------------------------ El modo Follow (*modo de Seguimiento*) es un modo menor que hace que dos ventanas, ambas mostrando el mismo búfer, se desplacen como una única ventana virtual alta. Para usar este modo, vaya a un marco con una sola ventana, divídala en dos ventanas contiguas usando :kbd:`Ctrl`-:kbd:`x` :kbd:`3` (``C-x 3``), y luego escriba :kbd:`Alt`-:kbd:`x` ``follow-mode`` (``M-x follow-mode``). A partir de ese momento, puede editar el búfer en cualquiera de las dos ventanas, o desplazarse por cualquiera de ellas; la otra ventana la sigue. En el modo de Seguimiento, si mueve el punto fuera de la parte visible en una ventana y dentro de la parte visible en la otra ventana, eso selecciona la otra ventana, de nuevo, tratando las dos como si fueran partes de una ventana grande. Para desactivar el modo de Seguimiento, escriba :kbd:`Alt`-:kbd:`x` ``follow-mode`` (``M-x follow-mode``) por segunda vez. .. _15.8: 15.8. Caras de Texto -------------------- Emacs puede mostrar texto en varios estilos diferentes, llamados *caras* (faces). Cada cara puede especificar varios *atributos de cara*, como la fuente, altura, peso, inclinación, color de primer plano y de fondo, y subrayado o superposición. La mayoría de los modos principales asignan caras al texto automáticamente, mediante el modo Bloqueo de Fuente (Font Lock mode). Consulte :ref:`15.13`, para más información sobre cómo se asignan estas caras. Para ver qué fuentes están actualmente definidas y qué aspecto tienen, escriba :kbd:`Alt`-:kbd:`x` ``list-faces-display`` (``M-x list-faces-display``). Con un prefijo como argumento, se pide una expresión regular y se muestran sólo las caras cuyos nombres coincidan con esa expresión regular (véase :ref:`16.6`). Es posible que una misma cara tenga un aspecto diferente en distintos marcos. Por ejemplo, algunos terminales de texto no soportan todos los atributos de las carátulas, particularmente fuente, altura y anchura, y algunos soportan una gama limitada de colores. Además, la mayoría de las caras de Emacs están definidas para que sus atributos sean diferentes en fondos claros y oscuros, por razones de legibilidad. Por defecto, Emacs elige automáticamente qué conjunto de atributos de cara mostrar en cada marco, basándose en el color de fondo actual del marco. Sin embargo, se puede anular esto dando a la variable ``frame-background-mode`` un valor no nulo. Un valor de ``dark`` que Emacs trate todos los marcos como si tuvieran un fondo oscuro, mientras que un valor de ``light`` hace que trate todos los marcos como si tuvieran un fondo claro. Puede personalizar una cara para alterar sus atributos, y guardar esas personalizaciones para futuras sesiones de Emacs. Ver :ref:`50.1.5`, para más detalles. La cara por defecto es la predeterminada para mostrar texto, y todos sus atributos están especificados. Su color de fondo también se usa como color de fondo del marco. Ver :ref:`15.9`. Otra cara especial es la cara ``cursor``. En las pantallas gráficas, el color de fondo de esta cara se usa para dibujar el cursor de texto. Ninguno de los otros atributos de esta cara tiene ningún efecto; el color de primer plano para el texto bajo el cursor se toma del color de fondo del texto subyacente. En los terminales de texto, el aspecto del cursor de texto viene determinado por el terminal, no por la cara de este. También puede utilizar recursos X para especificar los atributos de una cara determinada. Véase :ref:`D.1`. Emacs puede mostrar fuentes de anchura variable, pero algunos comandos de Emacs, en particular los comandos de sangrado, no tienen en cuenta la anchura variable de los caracteres. Por lo tanto, recomendamos no usar fuentes de ancho variable para la mayoría de las caras, particularmente aquellas asignadas por el modo Font Lock. .. _15.9: 15.9 Colores de las Caras ------------------------- Las caras pueden tener varios colores de primer plano y de fondo. Cuando se especifica un color para una cara, por ejemplo, al personalizar la cara (véase :ref:`50.1.5`), se puede usar un *nombre de color* o un *triplete RGB*. 15.9.1 Nombres de los Colores ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Un nombre de color es un nombre predefinido, como ``dark orange`` (naranja oscuro) o ``medium sea green`` (verde mar medio). Para ver una lista de nombres de colores, escriba :kbd:`Alt`-:kbd:`x` ``list-colors-display`` (``M-x list-colors-display``). Para controlar el orden en que se muestran los colores, personalice ``list-colors-sort``. Si ejecuta este comando en una pantalla gráfica, muestra toda la gama de nombres de color conocidos por Emacs (son los nombres de color estándar de X11, definidos en el archivo ``rgb.txt`` de X). Si ejecuta el comando en un terminal de texto, sólo muestra un pequeño subconjunto de colores que pueden mostrarse con seguridad en dichos terminales. Sin embargo, Emacs entiende los nombres de color X11 incluso en terminales de texto; si a una cara se le da un color especificado por un nombre de color X11, se muestra usando el color del terminal que más se aproxime. 15.9.2 Tripletes RGB ^^^^^^^^^^^^^^^^^^^^ Un triplete RGB es una cadena de la forma ``#RRGGBB``. Cada uno de los componentes primarios del color está representado por un número hexadecimal entre ``00`` (intensidad 0 (cero)) y ``FF`` (la intensidad máxima). También es posible usar uno, tres o cuatro dígitos hexadecimales para cada componente, por lo que ``red`` (rojo) puede representarse como ``#F00``, ``#fff000000`` o ``#ffff00000000``. Los componentes deben tener el mismo número de dígitos. Para los valores hexadecimales A a F, se aceptan mayúsculas o minúsculas. El comando ``M-x list-colors-display`` también muestra el triplete RGB equivalente para cada color nombrado. Por ejemplo, medium sea green equivale a ``#3CB371``. Puede cambiar los colores de primer plano y fondo de una cara con ``M-x set-face-foreground`` y ``M-x set-face-background``. Estos comandos preguntan en el minibuffer por el nombre de una cara y un color, con completado, y luego establecen que esa cara use el color especificado. Afectan a los colores de las caras en todos los marcos, pero sus efectos no persisten para futuras sesiones de Emacs, a diferencia del uso del buffer de personalización o de los recursos X. También puede usar parámetros de marco para establecer los colores de primer plano y fondo para un marco específico; Vea :ref:`22.11`. .. _15.10: 15.10 Caras Normalizadas ------------------------ Estas son las caras estándar (o normalizadas) para especificar la apariencia del texto. Puede aplicarlas a un texto concreto cuando desee los efectos que producen. ``default`` Esta cara se usa para texto ordinario que no especifica ninguna cara. Su color de fondo se usa como color de fondo del marco. ``bold`` Esta cara usa una variante en negrita de la fuente por defecto. ``italic`` Esta cara usa una variante en cursiva de la fuente por defecto. ``bold-italic`` Esta cara usa una variante negrita cursiva de la fuente por defecto. ``undeline`` Esta cara subraya el texto. ``fixed-pitch`` Esta cara fuerza el uso de una fuente de ancho fijo. Es razonable personalizar esta cara para usar una fuente de ancho fijo diferente, si lo desea, pero no debe convertirla en una fuente de ancho variable. ``fixed-pitch-serif`` Este tipo de letra es similar a la de paso fijo (``fixed-pitch``), salvo que tiene serifs y se parece más a la tipografía tradicional. ``variable-pitch`` Esta cara fuerza el uso de una fuente de ancho variable (es decir, proporcional). El tamaño de fuente elegido para esta cara coincide con la fuente elegida por defecto (normalmente de ancho fijo). ``variable-pitch-text`` Es como la fuente de paso variable (``variable-pitch``, de la que hereda), pero ligeramente más grande. Una fuente proporcional de la misma altura que una fuente monoespaciada suele parecer visualmente más pequeña y, por tanto, más difícil de leer. Cuando se trata de textos largos, esta fuente puede ser una buena opción frente a la fuente de paso variable (ligeramente más pequeña). ``shadow`` Esta cara se usa para hacer que el texto sea menos perceptible que el texto ordinario circundante. Normalmente, esto se consigue usando tonos de gris en contraste con el color de primer plano por defecto, blanco o negro. He aquí una lista incompleta de caras usadas para resaltar partes del texto temporalmente con fines específicos. (Muchos otros modos definen sus propias caras para este fin). ``highlight`` Cara se usa para resaltar texto en varios contextos, como cuando el cursor del ratón se desplaza sobre un hipervínculo. ``isearch`` Esta cara se usa para resaltar la coincidencia actual de Isearch (ver :ref:`16.1`). ``query-replace`` Cara se usa para resaltar la coincidencia actual de Query Replace (Consulta Reemplazo, ver :ref:`16.10`). ``lazy-highlight`` Esta cara se usa para resaltar coincidencias imprecisas para Isearch y Query Replace (coincidencias distintas de la actual). ``region`` Cara se usa para mostrar una región activa (ver :ref:`12`). Cuando Emacs se construye con soporte GTK+, sus colores se toman del tema GTK+ actual. ``secondary-selection`` Esta cara se usa para mostrar una selección X secundaria (véase :ref:`13.3.3`). ``trailing-whitespace`` La cara para resaltar el exceso de espacios y tabuladores al final de una línea cuando ``show-trailing-whitespace`` es distinto de nil (véase :ref:`15.17`). ``escape-glyph`` Cara para mostrar caracteres de control y secuencias de escape (véase :ref:`15.20` ). ``homoglyph`` La cara para mostrar caracteres semejantes, es decir, caracteres que se parecen pero no son los caracteres representados (véase :ref:`15.20`). ``nobreak-space`` Cara para mostrar caracteres espaciados sin salto (véase :ref:`15.20`). ``nobreak-hyphen`` La cara para mostrar caracteres de guión sin ruptura (véase :ref:`15.20`). Las siguientes caras controlan la apariencia de partes del marco de Emacs: ``mode-line`` Es la cara base usada para las líneas de modo, así como para las líneas de cabecera y para las barras de menú cuando no se usan menús de herramientas. Por defecto, se dibuja con sombras para un efecto de relieve en pantallas gráficas, y se dibuja como la inversa de la cara por defecto en terminales sin ventanas. Las caras ``mode-line-active`` y ``mode-line-inactive`` (que son las que se usan en las líneas de modo) heredan de esta cara. ``mode-line-active`` Como ``mode-line``, pero se usa para la línea de modo de la ventana seleccionada en ese momento. Esta cara hereda de ``mode-line``, por lo que los cambios en esa cara afectan a las líneas de modo de todas las ventanas. ``mode-line-inactive`` Como ``mode-line``, pero se utiliza para las líneas de modo de las ventanas distintas de la seleccionada (si ``mode-line-in-non-selected-windows`` es distinto de ``nil``). Esta cara hereda de ``mode-line``, por lo que los cambios en esa cara afectan a las líneas de modo de todas las ventanas. ``mode-line-highlight`` Como ``highlight``, pero se usa para porciones de texto sensibles al ratón en líneas de modo. Estas porciones de texto suelen mostrar información sobre herramientas (véase :ref:`22.19`) cuando el puntero del ratón pasa por encima de ellas. ``mode-line-buffer-id`` Esta cara se usa para las partes de identificación del búfer en la línea de modo. ``header-line`` Similar a línea de modo (``mode-line``) para la línea de encabezado de una ventana, que aparece en la parte superior de una ventana al igual que la línea de modo aparece en la parte inferior. La mayoría de las ventanas no tienen línea de cabecera; sólo algunos modos especiales crean una, como el modo Info. ``header-line-hightlight`` Similar a ``highlight`` (resaltar) y ``mode-line-highlight`` (resaltar línea de modo), pero se usa para porciones de texto sensibles al ratón en las líneas de encabezado. Se trata de una cara independiente porque la cara de la línea de encabezado puede personalizarse de forma que no interactúe bien con el resaltado. ``tab-line`` Similar a la línea de modo para la línea de pestañas de una ventana, que aparece en la parte superior de una ventana con pestañas que representan los búferes de las ventanas. Véase :ref:`21.8`. ``vertical-border`` Esta cara se utiliza para el divisor vertical entre ventanas en los terminales de texto. ``minibuffer-prompt`` Esta cara se usa para las cadenas del prompt mostradas en el minibuffer. Por defecto, Emacs añade automáticamente esta cara al valor de ``minibuffer-prompt-properties``, que es una lista de propiedades de texto (ver **Propiedades de Texto** en el Manual de Referencia de Emacs Lisp) usadas para mostrar el texto del prompt. (Esta variable tiene efecto cuando entra en el minibuffer). ``fringe`` La cara de los márgenes a la izquierda y a la derecha de las ventanas en las pantallas gráficas. (La franja son las partes estrechas del marco de Emacs entre el área de texto y los bordes derecho e izquierdo de la ventana). Véase :ref:`15.15`. ``cursor`` El atributo ``background`` de esta cara especifica el color del cursor de texto. Véase :ref:`15.21`. ``tooltip`` Esta cara se usa para el texto de la información sobre herramientas. Por defecto, si Emacs está construido con soporte GTK+, los tooltips se dibujan vía GTK+ y esta cara no tiene efecto. Ver :ref:`22.19`. ``mouse`` Esta cara determina el color del puntero del ratón. Las siguientes caras también controlan la apariencia de partes del marco de Emacs, pero sólo en terminales de texto, o cuando Emacs se construye en X sin soporte del toolkit. (Para todos los demás casos, la apariencia de los respectivos elementos del marco viene determinada por los ajustes de todo el sistema). ``scroll-bar`` Esta cara determina el aspecto visual de la barra de desplazamiento. Véase :ref:`22.12`. ``tool-bar`` Esta cara determina el color de los iconos de la barra de herramientas. Véase :ref:`22.16`. ``tab-bar`` Esta cara determina el color de los iconos de la barra de pestañas. Véase :ref:`22.17`. ``menu`` Esta cara determina los colores y la fuente de los menús de Emacs. Ver :ref:`22.15`. ``tty-menu-enable-face`` Esta cara se usa para mostrar los elementos de menú activados en terminales de modo texto. ``tty-menu-disable-face`` Esta cara se usa para mostrar elementos de menú desactivados en terminales de modo texto. ``tty-menu-selected-face`` Esta cara se usa para mostrar en terminales en modo texto el elemento de menú que se seleccionaría si se hace clic con el ratón o se pulsa :kbd:`RETURN` (``RET``). .. _15.11: 15.11 Iconos ------------ Emacs a veces muestra botones clicables (u otros iconos informativos), y puede personalizar cómo se ven en pantalla. El principal punto de personalización aquí es la opción de usuario ``icon-preference``. Usando esto, puede decirle a Emacs sus preferencias generales para los iconos. Esta es una lista de tipos de iconos, y se usará el primer tipo de icono soportado. Los tipos soportados son: ``image`` Usa una imagen para el icono. ``emoji`` Usa un emoji colorido para el icono. ``symbol`` Usa un símbolo monocromo para el icono. ``text`` Usa un texto sencillo para el icono. Además, cada icono individual puede personalizarse con ``M-x customize-icon``, y los temas pueden alterar aún más el aspecto de los iconos. Para obtener una descripción rápida de un icono, use el comando ``M-x describe-icon``. .. _15.12: 15.12 Escala de Texto --------------------- Para aumentar el tamaño de fuente de la cara por defecto en el buffer actual, teclee :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`+` (``C-x C-+``) o :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`e` (``C-x C-=``). Para disminuirlo, teclee :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`-` (``C-x C--``). Para restablecer el tamaño de fuente predeterminado (global), escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`x` :kbd:`0` (``C-x C-0``). Todas estas teclas están vinculadas al mismo comando, ajuste de escala de texto, que se basa en la última tecla pulsada para determinar qué acción realizar y ajusta el tamaño de la fuente en consecuencia cambiando la altura de la cara por defecto. La mayoría de las caras no tienen un ajuste explícito del atributo ``:height`` por lo que heredan la altura de la cara por defecto. Estas caras también se escalan con los comandos anteriores. Las caras distintas de la predeterminada que tienen un ajuste explícito del atributo ``:height`` no se ven afectadas por estos cambios de tamaño de fuente. La cara de la línea de cabecera es una excepción: se escalará incluso si tiene un ajuste explícito del atributo ``:height``. Del mismo modo, al desplazar la rueda del ratón con el modificador ``Ctrl`` (:kbd:`Ctrl`) pulsado, cuando el puntero del ratón está sobre el texto del búfer, aumentará o disminuirá el tamaño de fuente de las caras afectadas, dependiendo de la dirección del desplazamiento. La tecla final de estos comandos puede repetirse sin la combinación de teclas :kbd:`Ctrl`-:kbd:`x` (``C-x``) inicial y sin los modificadores. Por ejemplo, :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`=` :kbd:`Ctrl`-:kbd:`=` :kbd:`Ctrl`-:kbd:`=` (``C-x C-= C-= C-=``) y :kbd:`Ctrl`-:kbd:`x` :kbd:`=`:kbd:`=`:kbd:`=` (``C-x C-= = =``) aumentan la altura de la cara en tres pasos. Cada paso escala la altura del texto en un factor de 1,2; para cambiar este factor, personalice la variable ``text-scale-mode-step``. Un argumento numérico de 0 al comando ``text-scale-adjust`` restaura la altura por defecto, lo mismo que teclear :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`0` (``C-x C-0``). Del mismo modo, para cambiar el tamaño de las fuentes globalmente, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`+` (``C-x C-M-+``), :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`=` (``C-x C-M-=``), :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`-` (``C-x C-M--``) o :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`0` (``C-x C-M-0``), o desplace la rueda del ratón con los modificadores ``Ctrl`` (:kbd:`Ctrl`) y ``Meta`` (:kbd:`Alt`) pulsados. Para activar el cambio de tamaño de los marcos cuando se modifica globalmente el tamaño de la fuente, personalice la variable ``global-text-scale-adjust-resizes-frames`` (véase :ref:`50.1`). Los comandos ``text-scale-increase`` y ``text-scale-decrease`` aumentan o disminuyen el tamaño de la fuente en el búfer actual, igual que ``C-x C-+`` y ``C-x C--`` respectivamente. Puede que le resulte más cómodo usar estos comandos en lugar de ajustar la escala de texto. El comando ``text-scale-set`` escala el tamaño de la fuente en el búfer actual a un nivel absoluto especificado por su argumento prefijo. Los comandos anteriores activan automáticamente el modo menor ``text-scale-mode`` si el escalado de la fuente actual es distinto de 1, y lo desactivan en caso contrario. El comando ``text-scale-pinch`` aumenta o disminuye la escala del texto en función de la distancia entre los dedos en un panel táctil cuando se realiza un gesto de pellizco colocando dos dedos en un panel táctil y acercándolos o separándolos entre sí. Sólo está disponible en algunos sistemas con hardware compatible. El comando ``mouse-wheel-text-scale`` también cambia la escala del texto. Normalmente, se ejecuta al pulsar :kbd:`Ctrl` (``Ctrl``) mientras se mueve la rueda del ratón. La escala del texto aumenta cuando la rueda se mueve hacia abajo, y disminuye cuando la rueda se mueve hacia arriba. .. _15.13: 15.13 Modo de Bloqueo de Fuente ------------------------------- El modo Font Lock es un modo menor, siempre local a un búfer en particular, que asigna caras (o *tipografía*) al texto del búfer. El modo principal de cada búfer indica al modo Font Lock qué texto debe tipificar; por ejemplo, los modos del lenguaje de programación tipifican construcciones sintácticamente relevantes como comentarios, cadenas y nombres de funciones. El modo Font Lock está activado por defecto en los modos principales que lo admiten. Para activarlo en el búfer actual, escriba :kbd:`Alt`-:kbd:`x` ``font-lock-mode`` (``M-x font-lock-mode``). Un argumento numérico positivo activa incondicionalmente el modo Font Lock, y un argumento negativo o cero lo desactiva. Escriba :kbd:`Alt`-:kbd:`x` ``global-font-lock-mode`` (``M-x global-font-lock-mode``) para activar el modo Font Lock en todos los búferes. Para imponer esta configuración para futuras sesiones de Emacs, personalice la variable ``global-font-lock-mode`` (ver :ref:`50.1`), o añada la siguiente línea a su fichero init: :: (global-font-lock-mode 0) Si ha desactivado el modo de Bloqueo de Fuente Global, aún puede activar el Bloqueo de Fuente para modos principales específicos añadiendo la función ``font-lock-mode`` a los ganchos de modo (ver :ref:`50.2.2`). Por ejemplo, para habilitar el modo Font Lock para editar archivos C, puede hacer esto: :: (add-hook 'c-mode-hook 'font-lock-mode) El modo Font Lock usa varias caras específicamente nombradas para hacer su trabajo, incluyendo ``font-lock-string-face``, ``font-lock-comment-face``, y otras. La forma más sencilla de encontrarlas es utilizar :kbd:`Alt`-:kbd:`x` ``customize-group`` :kbd:`RETURN` ``font-lock-faces`` :kbd:`RETURN` (``M-x customize-group RET font-lock-faces RET``). A continuación, puede usar ese búfer de personalización para cambiar el aspecto de estas caras. Véase :ref:`50.1.5`. Fontificar búferes muy grandes puede llevar mucho tiempo. Para evitar grandes retrasos cuando se visita un fichero, Emacs inicialmente tipifica sólo la porción visible de un búfer. A medida que se desplaza por el búfer, cada porción que se hace visible se tipifica tan pronto como se muestra; este tipo de Bloqueo de Fuente se llama *Just-In-Time* (o JIT, Bloqueo Justo-a-Tiempo). Puede controlar cómo se comporta el bloqueo JIT, incluso indicándole que realice la fuentetificación mientras está inactivo, personalizando variables en el grupo de personalización ``jit-lock``. Consulte :ref:`50.1.6` . La información que utilizan los modos principales para determinar qué partes del texto del búfer se van a tipificar y qué fuentes se van a utilizar puede basarse en varias formas diferentes de analizar el texto: * Búsqueda de palabras clave y otros patrones textuales basados en expresiones regulares (véase :ref:`16.5`). * Encuentra partes de texto sintácticamente distintas basándose en las tablas de sintaxis incorporadas (ver **Tablas de Sintaxis** en el Manual de Referencia de Emacs Lisp). * Usa el árbol sintáctico producido por un analizador sintáctico completo, a través de una biblioteca de propósito especial, como la biblioteca tree-sittercc (ver **Analizando el Código Fuente del Programa** en el Manual de Referencia de Emacs Lisp), o un programa externo. * Bloqueo de Fuente Tradicional * Bloqueo de Fuentes basado en Parser 15.13.1 Bloqueo de Fuente Tradicional ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Los métodos "tradicionales" de proporcionar información sobre el bloqueo de fuentes se basan en la búsqueda por expresiones regulares y en el análisis sintáctico usando tablas de sintaxis incorporadas en Emacs. Esta subsección describe el uso y personalización de ``font-lock`` para los modos principales que usan estos métodos tradicionales. Puede controlar la cantidad de fontificación aplicada por el modo Font Lock personalizando la variable ``font-lock-maximum-decoration``, para los modos principales que soportan esta característica. El valor de esta variable debe ser un número (con 1 representando una cantidad mínima de fontificación; algunos modos soportan niveles tan altos como 3); o ``t``, significando "tan alto como sea posible" (por defecto). Para que sea efectiva para un búfer de archivo determinado, la personalización de ``font-lock-maximum-decoration`` debe realizarse *antes* de visitar el archivo; si ya tiene el archivo visitado en un búfer cuando personalice esta variable, elimine el búfer y vuelva a visitar el archivo después de la personalización. También puede especificar diferentes números para determinados modos principales; por ejemplo, para utilizar el nivel 1 para los modos C/C++, y el nivel por defecto en caso contrario, utilice el valor :: '((c-mode . 1) (c++-mode . 1))) La fontificación de comentarios y cadenas (o fontificación "sintáctica") se basa en el análisis de la estructura sintáctica del texto del búfer. En aras de la velocidad, algunos modos, incluido el modo Lisp, se basan en una convención especial: un paréntesis o un corchete abierto en la columna más a la izquierda siempre define el comienzo de un defun y, por lo tanto, siempre está fuera de cualquier cadena o comentario. Por lo tanto, debe evitar colocar un paréntesis abierto en la columna de la izquierda si está dentro de una cadena o comentario. Véase :ref:`27.2.1`, para más detalles. Los patrones de resaltado Font Lock ya existen para la mayoría de los modos, pero es posible que desee tipificar patrones adicionales. Puede utilizar la función ``font-lock-add-keywords``, para añadir sus propios patrones de resaltado para un modo en particular. Por ejemplo, para resaltar palabras ``FIXME:`` en comentarios en C, use esto: :: (add-hook 'c-mode-hook (lambda () (font-lock-add-keywords nil '(("\\<\\(FIXME\\):" 1 font-lock-warning-face t))))) Para eliminar palabras clave de los patrones de resaltado de ``font-lock``, use la función ``font-lock-remove-keywords``. Vea **Fontificación Basada en Búsquedas** en El Manual de Referencia de Emacs Lisp. Alternativamente, puede deshabilitar selectivamente el resaltado debido a algunas palabras clave personalizando la opción ``font-lock-ignore``, vea **Personalizando Palabras Clave** en El Manual de Referencia de Emacs Lisp. 15.13.2 Bloqueo de Fuentes basado en Parser ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Si su Emacs fue construido con la librería *tree-sitter*, puede usar los resultados de analizar el texto del búfer por esa librería para los propósitos de la fontificación. Esto suele ser más rápido y preciso que los métodos "tradicionales" descritos en la subsección anterior, ya que esta biblioteca proporciona analizadores completos para lenguajes de programación y otros tipos de texto formateado que soporta. Los modos principales que utilizan la biblioteca *tree-sitter* se denominan ``foo-ts-mode``, con la parte ``-ts-`` indicando el uso de la biblioteca. Esta subsección documenta el soporte de Font Lock basado en dicha biblioteca. Puede controlar la cantidad de fontificación aplicada por el modo Font Lock de los modos principales basados en *tree-sitter* personalizando la variable ``treesit-font-lock-level``. Su valor es un número entre 1 y 4: Nivel 1 En este nivel se suelen tipificar sólo los comentarios y los nombres de función de las definiciones de función. Nivel 2 Este nivel añade la tipificación de palabras clave, cadenas y tipos de datos. Nivel 3 Este es el nivel por defecto; añade fontificación de asignaciones, números, etc. Nivel 4 Este nivel añade todo lo demás que se puede tipificar: operadores, delimitadores, corchetes, otros signos de puntuación, nombres de funciones en llamadas a funciones, búsquedas de propiedades, variables, etc. Lo que constituye exactamente cada una de las categorías sintácticas mencionadas depende del modo principal y de la gramática del analizador sintáctico utilizada por *tree-sitter* para el lenguaje del modo principal. Sin embargo, en general las categorías siguen las convenciones del lenguaje de programación o del formato de fichero soportado por el modo principal. El valor buffer-local de la variable ``treesit-font-lock-feature-list`` contiene las características de fontificación soportadas por un modo principal basado en *tree-sitter*, donde cada sub-lista muestra las características proporcionadas por el nivel de fontificación correspondiente. Una vez que cambie el valor de ``treesit-font-lock-level`` mediante ``M-x customize-variable`` (véase :ref:`50.1.6`), tendrá efecto inmediato en todos los buffers existentes y para los archivos que visite en el futuro en la misma sesión. .. _15.14: 15.14 Resaltado Interactivo --------------------------- El modo Highlight Changes (Resaltar cambios) es un modo menor que *resalta* las partes del búfer que se han modificado más recientemente, dándole a ese texto una cara diferente. Para activar o desactivar este modo, utilice ``M-x highlight-changes-mode``. El modo Hi Lock es un modo menor que resalta el texto que coincide con las expresiones regulares que especifique. Por ejemplo, puede usarlo para resaltar todas las referencias a una determinada variable en un archivo fuente de un programa, resaltar ciertas partes en una salida voluminosa de algún programa o resaltar ciertos nombres en un artículo. Para activar o desactivar el modo Hi Lock, use el comando ``M-x hi-lock-mode``. Para activar el modo Hi Lock para todos los búferes, use ``M-x global-hi-lock-mode`` o coloque ``(global-hi-lock-mode 1)`` en su archivo ``.emacs``. El modo Hi Lock funciona como el modo Font Lock (ver :ref:`15.3`), excepto que Usted especifica explícitamente las expresiones regulares a resaltar. Puede controlarlas con los siguientes comandos. (Las combinaciones de teclas de abajo que empiezan por :kbd:`Ctrl`-:kbd:`x` :kbd:`w` (``C-x w``) están obsoletas en favor de las combinaciones globales :kbd:`Alt`-:kbd:`s` :kbd:`h` (``M-s h``), y serán eliminadas en alguna versión futura de Emacs). | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`r` *expreg* :kbd:`RETURN` *cara* :kbd:`RETURN` (``M-s h r`` *expreg* ``RET`` *cara* ``RET``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`h` *expreg* :kbd:`RETURN` *cara* :kbd:`RETURN` (``C-x w h`` *expreg* ``RET`` *cara* ``RET``) Resalta el texto que coincida con *expreg* (expresión regular) usando la cara de nombre *cara* (``highlight-regexp``). El resaltado permanecerá mientras esté cargada en el búfer. Por ejemplo, para resaltar todas las apariciones de la palabra "capricho" usando la cara por defecto (un fondo amarillo), escriba :kbd:`Alt`-:kbd:`s` :kbd:`s`:kbd:`r` *capricho* :kbd:`RETURN` :kbd:`RETURN` (``M-s h r`` *capricho* ``RET RET``). Se puede utilizar cualquier cara para resaltar, Hi Lock proporciona varias propias y éstas están precargadas en una lista de valores por defecto. Mientras se le pide una cara use :kbd:`Alt`-:kbd:`n` (``M-n``) y :kbd:`Alt`-:kbd:`p` (``M-p``) para recorrerlas. Un argumento numérico prefijado limita el resaltado a la subexpresión correspondiente. Si se establece la opción ``hi-lock-auto-select-face`` a un valor no nulo, este comando (y otros comandos Hi Lock que leen caras) elige automáticamente la siguiente cara de la lista predeterminada sin preguntar. Puede usar este comando varias veces, especificando varias expresiones regulares para resaltar de diferentes maneras. | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`u` *expreg* :kbd:`RETURN` (``M-s h u`` *expreg* ``RET``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`r` *expreg* :kbd:`RETURN` (``C-x w r`` *expreg* ``RET``) Destaca la expresión regular *expreg* (``unhighlight-regexp``). Si se invoca desde el menú, se selecciona de una lista la expresión que se va a resaltar. Si se invoca desde el teclado, se usa el minibúfer. Mostrará la expresión regular añadida más recientemente; use ``M-n`` para mostrar la siguiente expresión más antigua y ``M-p`` para seleccionar la siguiente expresión más reciente. (También puede escribir la expresión a mano, con completado.) Cuando la expresión que desea desmarcar aparezca en el minibúfer, pulse :kbd:`RETURN` (``RET``) para salir del minibúfer y desmarcarla. | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`l` *expreg* :kbd:`RETURN` *cara* :kbd:`RETURN` (``M-s h l`` *expreg* ``RET`` *cara* ``RET``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`l` *expreg* :kbd:`RETURN` *cara* :kbd:`RETURN` (``C-x w l`` *expreg* ``RET`` *cara* ``RET``) Resalta líneas enteras que contengan una coincidencia para *regexp*, usando la face de nombre *cara* (``highlight-lines-matching-regexp``). | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`p` *frase* :kbd:`RETURN` *cara* :kbd:`RETURN` (``M-s h p`` *frase* ``RET`` *cara* ``RET``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`p` *frase* :kbd:`RETURN` *cara* :kbd:`RETURN` (``C-x w p`` *frase* ``RET`` *cara* ``RET``) Resalta coincidencias de *frase*, usando la face de nombre *cara* (``highlight-phrase``). *frase* puede ser cualquier expreg, pero los espacios serán reemplazados por coincidencias con espacios en blanco y las minúsculas iniciales pasarán a ser insensibles a mayúsculas y minúsculas. | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`.` (``M-s h .``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`.` (``C-x w .``) Resalta el símbolo que se encuentra cerca del punto, utilizando la siguiente cara disponible (``highlight-symbol-at-point``). | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`w` (``M-s h w``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`b` (``C-x w b``) Inserta todos los pares de resaltado expreg/cara actuales en el búfer en el punto, con delimitadores de comentario para evitar que cambien su programa. (Esta combinación de teclas ejecuta el comando ``hi-lock-write-interactive-patterns``). Estos patrones se extraen de los comentarios, si procede, si invoca ``M-x hi-lock-find-patterns``, o si visita el archivo mientras el modo Hi Lock está activado (ya que eso ejecuta ``hi-lock-find-patterns``). | :kbd:`Alt`-:kbd:`s` :kbd:`h`:kbd:`f` (``M-s h f``) | :kbd:`Ctrl`-:kbd:`x` :kbd:`w`:kbd:`i` (``C-x w i``) Extrae pares expreg/cara de los comentarios en el buffer actual (``hi-lock-find-patterns``). Así, puede introducir patrones interactivamente con ``highlight-regexp``, almacenarlos en el archivo con ``hi-lock-write-interactive-patterns``, editarlos (quizás incluyendo diferentes caras para diferentes partes de la coincidencia entre paréntesis), y finalmente usar este comando (``hi-lock-find-patterns``) para que Hi Lock resalte los patrones editados. La variable ``hi-lock-file-patterns-policy`` controla si el modo Hi Lock debe extraer y resaltar automáticamente los patrones encontrados en un archivo cuando es visitado. Su valor puede ser ``nil`` (nunca resaltar), ``ask`` (consultar al usuario), o una función. Si es una función, ``hi-lock-find-patterns`` la llama con los patrones como argumento; si la función devuelve un valor no nulo, se utilizan los patrones. El valor predeterminado es ``ask``. Tenga en cuenta que los patrones siempre se resaltan si llama a ``hi-lock-find-patterns`` directamente, independientemente del valor de esta variable. Además, ``hi-lock-find-patterns`` no hace nada si el símbolo del modo principal actual es un miembro de la lista ``hi-lock-exclude-modes``. .. _15.15: 15.15 Bordes de ventana ----------------------- En las pantallas gráficas, cada ventana de Emacs tiene normalmente *franjas* estrechas en los bordes izquierdo y derecho. Las franjas se usan para mostrar símbolos que proporcionan información sobre el texto de la ventana. Puede escribir ``M-x fringe-mode`` para alternar la visualización de dichas franjas o para modificar su anchura. Este comando afecta a las franjas de todos los cuadros; para modificar las franjas sólo en el cuadro seleccionado, utilice ``M-x set-fringe-style``. Puede hacer que sus cambios en las franjas sean permanentes personalizando la variable ``fringe-mode``. El uso más común de las franjas es indicar una línea de continuación (véase :ref:`8.8`). Cuando una línea de texto se divide en varias líneas de pantalla, la franja izquierda muestra una flecha curva para cada línea de pantalla excepto la primera, lo que indica que no es el comienzo real. La franja derecha muestra una flecha curva para cada línea de pantalla excepto la última, indicando que no es el final real. Si la dirección de la línea es de derecha a izquierda (véase :ref:`23.20`), los significados de las flechas curvas en las franjas se intercambian. Las franjas indican cuando hay truncamiento de línea (ver :ref:`15.22`) con flechas horizontales cortas que significan que hay más texto en esta línea que se desplaza horizontalmente fuera de la vista. Al hacer clic con el ratón en una de las flechas, la pantalla se desplaza horizontalmente en la dirección de la flecha. Las franjas también pueden indicar otras cosas, como los límites del búfer (ver Visualizar :ref:`15.16`), líneas no usadas cerca del final de la ventana (ver 4º párrafo de :ref:`15.17`), y dónde se está ejecutando un programa que estás depurando (ver :ref:`28.6`). La franja también se usa para dibujar el cursor, si la línea actual es exactamente tan ancha como la ventana y el punto está al final de la línea. Para desactivar esto, cambie la variable ``overflow-newline-into-fringe`` a ``nil``; esto hace que Emacs continúe o trunque las líneas que son exactamente tan anchas como la ventana. Si personaliza el modo franja (fringe-mode) para eliminar las franjas en uno o ambos lados de la ventana de visualización, las características que se muestran en la franja no están disponibles. Los indicadores de continuación y truncamiento de línea son una excepción: cuando las franjas no están disponibles, Emacs usa las celdas de caracteres más a la izquierda y más a la derecha para indicar la continuación y el truncamiento con caracteres ASCII especiales, véase :ref:`8.8` y :ref:`15.22`. Esto reduce el ancho disponible para mostrar texto en cada línea, porque las celdas de caracteres usadas para los indicadores de truncamiento y continuación están reservadas para ese propósito. Dado que el texto del búfer puede incluir texto bidireccional y, por tanto, párrafos tanto de izquierda a derecha como de derecha a izquierda (véase :ref:`23.20`), al eliminar sólo una de las franjas se siguen reservando dos celdas de caracteres, una a cada lado de la ventana, para los indicadores de truncamiento y continuación, ya que estos indicadores se muestran en lados opuestos de la ventana en los párrafos de derecha a izquierda. .. _15.16: 15.16 Mostrar Límites --------------------- Emacs puede mostrar una indicación de la posición de la columna de relleno (véase :ref:`26.6.2`). El indicador de columna de relleno es una funcionalidad útil especialmente en modo prog y sus descendientes (ver :ref:`24.1`) para indicar la posición de una columna específica que tiene algún significado especial para formatear el código fuente de un programa. Esto supone que el búfer usa una fuente de paso fijo, donde todos los caracteres (con la posible excepción de los caracteres de doble ancho) tienen el mismo ancho en pantalla. Si el búfer usa fuentes de paso variable, los indicadores de relleno de columna en diferentes líneas pueden aparecer desalineados. Para activar la indicación de columna de relleno, use los modos menores ``display-fill-column-indicator-mode`` y ``global-display-fill-column-indicator-mode``, que activan el indicador local o globalmente, respectivamente. Alternativamente, puede establecer las dos variables locales del búfer ``display-fill-column-indicator`` y ``display-fill-column-indicator-character`` para activar el indicador y controlar el carácter utilizado para la indicación. Tenga en cuenta que ambas variables deben ser no nulas para que se muestre la indicación. (Activar el modo menor activa ambas variables). Hay 2 variables locales de búfer y una cara para personalizar este modo: ``display-fill-column-indicator-column`` Especifica el número de columna donde debe fijarse el indicador. Puede tomar valores numéricos positivos para la columna, o el valor especial ``t``, que significa que se utilizará el valor de la variable ``fill-column``. Cualquier otro valor desactiva el indicador. El valor por defecto es ``t``. ``display-fill-column-indicator-character`` Especifica el carácter usado para el indicador. Este carácter puede ser cualquier carácter válido incluyendo los Unicode si la fuente los soporta. El valor ``nil`` desactiva el indicador. Cuando el modo se activa a través de las funciones ``display-fill-column-indicator-mode`` o ``global-display-fill-column-indicator-mode``, éstas usarán el carácter especificado por esta variable, si es no ``nil``; en caso contrario Emacs usará el carácter U+2502 BOX DRAWINGS LIGHT VERTICAL, retrocediendo a ``|`` si U+2502 no puede mostrarse. ``fill-column-indicator`` Especifica la cara usada para mostrar el indicador. Hereda sus valores por defecto de la cara sombra, pero sin color de fondo. Para cambiar el color del indicador, basta con establecer el color de primer plano de esta cara. En pantallas gráficas, Emacs puede indicar los límites del búfer en las franjas. Si activa esta función, la primera última línea se marcan con imágenes angulares en las franjas. Esto puede combinarse con imágenes de flechas arriba y abajo que indican si es posible desplazarse por la ventana. La variable local del búfer ``indicate-buffer-boundaries`` controla cómo se indican los límites del búfer y el desplazamiento de la ventana en las franjas. Si el valor es ``left`` o ``right``, los mapas de bits de los ángulos y las flechas se muestran en la franja izquierda o derecha, respectivamente. Si el valor es una lista de asociación (véase **Listas de Asociación** en el Manual de Referencia de Emacs Lisp), cada elemento (``indicador . posición``) especifica la *posición* de uno de los indicadores. El indicador debe ser uno de ``top`` (arriba), ``bottom`` (abajo), ``up`` (subir), ``down`` (bajar), o ``t`` que especifica la posición por defecto para los indicadores no presentes en la alist. La *posición* es una de las siguientes: ``left`` (izquierda), ``right`` (derecha) o ``nil``, que especifica que no se muestre este indicador. Por ejemplo, ``((top . left) (t . right))`` ((arriba . izquierda) (t . derecha)) coloca el mapa de bits de ángulo superior en la franja izquierda, el mapa de bits de ángulo inferior en la franja derecha y ambos mapas de bits de flecha en la franja derecha. Para mostrar sólo los mapas de bits de ángulo en la franja izquierda, pero no los mapas de bits de flecha, use ``((top . left) (bottom . left))`` ((arriba . izquierda) (abajo . izquierda)). .. _15.17: 15.17 Espacios en Blanco Innecesarios ------------------------------------- Es fácil dejar espacios innecesarios al final de una línea, o líneas vacías al final de un búfer, sin darse cuenta. En la mayoría de los casos, estos *espacios en blanco* al final no tienen ningún efecto, pero a veces pueden ser una molestia. Puede hacer visibles los espacios en blanco al final de una línea estableciendo la variable local del buffer ``show-trailing-whitespace`` a ``t``. Entonces Emacs muestra los espacios en blanco al final de la línea, usando la cara ``trailing-whitespace``. Esta característica no se aplica cuando el punto está al final de la línea que contiene el espacio en blanco. Estrictamente hablando, eso no deja de ser un espacio en blanco final, pero mostrarlo especialmente en ese caso queda feo mientras escribe un nuevo texto. En este caso especial, la ubicación del punto es suficiente para mostrar que los espacios están presentes. Escriba :kbd:`Alt`-:kbd:`x` ``delete-trailing-whitespace`` (``M-x delete-trailing-whitespace``) para borrar todos los espacios blancos finales. Este comando borra todos los espacios extra al final de cada línea del búfer, y todas las líneas vacías al final de este; para ignorar estas últimas, cambie la variable ``delete-trailing-lines`` a ``nil``. Si la región está activa, el comando elimina los espacios adicionales al final de cada línea de la región. En pantallas gráficas, Emacs puede indicar las líneas no usadas al final de la ventana con una pequeña imagen en la franja izquierda (ver :ref:`15.15`). La imagen aparece para las líneas de pantalla que no corresponden a ningún texto del búfer, por lo que las líneas en blanco al final del búfer destacan porque carecen de esta imagen. Para activar esta función, ajuste la variable local del búfer ``indicate-empty-lines`` a un valor no nulo. Puede activar o desactivar esta función para todos los nuevos búferes estableciendo el valor predeterminado de esta variable, por ejemplo, ``(setq-default indicate-empty-lines t)``. El modo de espacios en blanco es un modo menor localizado en el búfer que permite visualizar muchos tipos de espacios en blanco en el búfer, ya sea dibujando los caracteres de los espacios en blanco con una cara especial o mostrándolos como glifos especiales. Para activar este modo, escriba :kbd:`Alt`-:kbd:`x` ``whitespace-mode`` (``M-x whitespace-mode``). Los tipos de espacios en blanco visualizados están determinados por la variable de lista ``whitespace-style``. Los elementos individuales de esa lista pueden activarse o desactivarse en el búfer actual escribiendo :kbd:`Alt`-:kbd:`x` ``whitespace-toggle-options`` (``M-x whitespace-toggle-options``). A continuación se muestra una lista parcial de los posibles elementos (consulte la documentación de la variable para ver la lista completa): ``face`` Habilita todas las visualizaciones que usan caras especiales. Este elemento tiene un significado especial: si está ausente de la lista, ninguna de las otras visualizaciones tiene efecto excepto ``space-mark`` (la marca de espacio), ``tab-mark`` (la marca de tabulación) y ``newline-mark`` (la marca de nueva línea). ``trailing`` Resalta los espacios en blanco finales. ``tabs`` Resalta los caracteres de tabulación. ``spaces`` Resalta los espacios en blanco y los caracteres de espacio sin separación. ``lines`` Resalta las líneas de más de 80 columnas. Para cambiar el límite de columnas, personalice la variable ``whitespace-line-column``. ``newline`` Resalta las nuevas líneas. ``missing-newline-at-eof`` Resalta el carácter final si el búfer no termina con un carácter de nueva línea. ``empty`` Resalta las líneas vacías al principio y/o al final del búfer. ``big-indent`` Resalta las sangrías demasiado profundas. Por defecto, se resalta cualquier secuencia de al menos 4 caracteres de tabulación consecutivos o 32 caracteres de espacio consecutivos. Para cambiar esto, personalice la expresión regular ``whitespace-big-indent-regexp``. ``space-mark`` Dibuja espacios y caracteres de no separación con un glifo especial. ``tab-mark`` Dibuja caracteres de tabulación con un glifo especial. ``newline-mark`` Dibuja caracteres de nueva línea con un glifo especial. .. _15.18: 15.18 Visualización Selectiva ----------------------------- Emacs tiene la capacidad de ocultar líneas con sangría superior a un número determinado de columnas. Puede usar esto para obtener una visión general de una parte de un programa. Para ocultar líneas en el búfer actual, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`$` :kbd:`(` ``set-selective-dislplay`` :kbd:`)` (``C-x $ (set-selective-display)``) con un argumento numérico *n*. Entonces, las líneas con al menos *n* columnas de sangría desaparecen de la pantalla. La única indicación de su presencia es que aparecen tres puntos (``...``) al final de cada línea visible que va seguida de una o más líneas ocultas. Los comandos ``C-n`` y ``C-p`` se desplazan por las líneas ocultas como si no estuvieran allí. Las líneas ocultas siguen presentes en el búfer, y la mayoría de los comandos de edición las ven como de costumbre, por lo que es posible que encuentre un punto en medio del texto oculto. Cuando ocurre esto, el cursor aparece al final de la línea anterior, después de los tres puntos. Si el punto está al final de la línea visible, antes de la nueva línea que la termina, el cursor aparece antes de los tres puntos. Para volver a hacer visibles todas las líneas, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`$` (``C-x $``) sin argumento. Si establece la variable ``selective-display-ellipses`` a ``nil``, los tres puntos no aparecen al final de una línea que precede a líneas ocultas. Entonces no hay indicación visible de las líneas ocultas. Cuando se configura esta variable, automáticamente se convierte en local. Véase también :ref:`26.9` para otra forma de ocultar parte del texto en un búfer. .. _15.19: 15.19 Características Opcionales de la Línea de Modo ---------------------------------------------------- El porcentaje del búfer *pos* indica el porcentaje del búfer por encima de la parte superior de la ventana. Además, puede mostrar el tamaño del búfer escribiendo ``M-x size-indication-mode`` para activar el modo de indicación de tamaño. El tamaño se mostrará inmediatamente después del porcentaje del búfer, de la siguiente manera: :: pos del tamaño Aquí tamaño es la representación legible por humanos del número de caracteres en el búfer, lo que significa que para abreviar se utiliza ``k`` para 10^3 (10\ :sup:`3`\ ), ``M`` para 10^6 (10\ :sup:`6`\ ), ``G`` para 10^9 (10\ :sup:`9`\ ), etc. El número de línea actual de punto aparece en la línea de modo cuando el modo de número de línea está activado. Use el comando ``M-x column-number-mode`` para activar y desactivar este modo; normalmente está activado. El número de línea aparece después del porcentaje *pos* del búfer, con la letra ``L`` para indicar de qué se trata. Del mismo modo, puede mostrar el número de columna actual activando el modo número de columna con ``M-x column-number-mode``. El número de columna se indica con la letra ``C``. Sin embargo, cuando ambos modos están activados, los números de línea y columna se muestran entre paréntesis, el número de línea primero, en lugar de con ``L`` y ``C``. Por ejemplo: ``(561,2)``. Consulte :ref:`24.2`, para obtener más información sobre los modos menores y sobre cómo utilizar estos comandos. 20En el modo Número de columna (Column Numbermode), el número de columna mostrado cuenta desde cero a partir del margen izquierdo de la ventana. Si prefiere que el número de columna mostrado cuente a partir de uno, puede establecer ``column-number-indicator-zero-based`` a ``nil``. Si ha reducido el búfer (véase :ref:`15.5`), el número de línea mostrado es relativo a la parte accesible del búfer. Por lo tanto, no es adecuado como argumento para ``goto-line``. (El comando ``what-line`` muestra el número de línea relativo a todo el archivo.) Puede usar el comando ``goto-line-relative`` para mover el punto a la línea relativa a la porción accesible del búfer estrechado. Si el búfer es muy grande (mayor que el valor de ``line-number-display-limit``), Emacs no calculará el número de línea, porque eso sería demasiado lento; por lo tanto, el número de línea no aparecerá en el modo-línea (mode-line). Para eliminar este límite, establezca ``line-number-display-limit`` a ``nil``. El cálculo de los números de línea también puede ser lento si las líneas del búfer son demasiado largas. Por esta razón, Emacs no muestra los números de línea si la anchura media, en caracteres, de las líneas cercanas al punto es mayor que el valor de ``line-number-display-limit-width``. El valor por defecto es de 200 caracteres. Emacs puede mostrar opcionalmente la hora y la carga del sistema en todas las líneas de modo. Para activar esta característica, escriba ``M-x display-time`` o personalice la opción ``display-time-mode``. La información añadida a la línea de modo tiene este aspecto: :: hh:mmPM l.ll Aquí *hh* y *mm* son la hora y el minuto, seguidos siempre de ``AM`` o ``PM`` *. l.ll* es el número medio, recogido durante los últimos minutos, de procesos en todo el sistema que estaban en ejecución o listos para ejecutarse (es decir, estaban esperando un procesador disponible). (Algunos campos pueden faltar si su sistema operativo no los soporta.) Si prefiere la visualización de la hora en formato de 24 horas, ajuste la variable ``display-time-24hr-format`` a ``t``. La palabra ``Mail`` (Correo) aparece después del nivel de carga si hay correos para Usted que todavía no ha leído. En pantallas gráficas, puede usar un icono en lugar de ``Mail`` personalizando ``display-time-use-mail-icon``; esto puede ahorrar algo de espacio en la línea de modo. Puede personalizar ``display-time-mail-face`` para que el indicador de correo sea prominente. Use ``display-time-mail-file`` para especificar el archivo de correo a comprobar, o configure ``display-time-mail-directory`` para especificar el directorio a comprobar para el correo entrante (cualquier archivo regular no vacío en el directorio se considera correo recién llegado). Cuando se ejecuta Emacs en un ordenador portátil, se puede mostrar la carga de la batería en la línea de modo, usando el comando ``display-battery-mode`` o personalizando la variable ``display-battery-mode``. La variable ``battery-mode-line-format`` determina la forma en que se muestra la carga de la batería; el mensaje exacto de la línea de modo depende del sistema operativo, y normalmente muestra la carga actual de la batería como un porcentaje de la carga total. Las funciones en ``battery-update-functions`` se ejecutan después de actualizar la línea de modo, y se pueden usar para activar acciones basadas en el estado de la batería. En las pantallas gráficas, la línea de modo se dibuja como una caja 3D. Si no le gusta este efecto, puede desactivarlo personalizando la cara de la línea de modo y estableciendo su atributo ``box`` en ``nil``. Véase :ref:`50.1.5`. Por defecto, la línea de modo de las ventanas no seleccionadas se muestra en una cara diferente, llamada ``mode-line-inactive`` (línea de modo inactiva). Sólo la ventana seleccionada se muestra en la línea de modo. Esto ayuda a mostrar qué ventana está seleccionada. Cuando se selecciona el minibúfer, como no tiene línea de modo, la ventana desde la que se activó el minibúfer tiene su línea de modo mostrada usando mode-line; como resultado, la entrada ordinaria al minibúfer no cambia ninguna línea de modo. Puede desactivar el uso de ``mode-line-inactive`` estableciendo la variable ``mode-line-in-non-selected-windows`` a ``nil``; entonces todas las líneas de modo se muestran en la cara ``mode-line``. Puede personalizar la visualización de la línea de modo para cada uno de los formatos de fin de línea estableciendo cada una de las variables ``eol-mnemonic-unix``, ``eol-mnemonic-dos``, ``eol-mnemonic-mac`` y ``eol-mnemonic-undecided`` a las cadenas que prefiera. .. _15.20: 15.20 Cómo se Muestra el Texto ------------------------------ La mayoría de los caracteres son *caracteres de impresión*: cuando aparecen en un búfer, se muestran literalmente en la pantalla. Los caracteres de impresión incluyen números ASCII, letras y caracteres de puntuación, así como muchos caracteres no ASCII. El conjunto de caracteres ASCII contiene *caracteres de control* no imprimibles. Dos de ellos se muestran de forma especial: el carácter de nueva línea (punto de código Unicode U+000A) se muestra iniciando una nueva línea, mientras que el carácter de tabulación (U+0009) se muestra como un espacio que se extiende hasta la siguiente columna de tabulación (normalmente cada 8 columnas). El número de espacios por tabulación se controla mediante la variable ``tab-width`` del búfer-local, que debe tener un valor entero entre 1 y 1000, ambos inclusive. Tenga en cuenta que la forma en que se muestra el carácter de tabulación en el búfer no tiene nada que ver con la definición de ``TAB`` como comando. Otros caracteres de control ASCII, cuyos códigos son inferiores a U+0020 (octal 40, decimal 32), se muestran como un signo de intercalación (``^``) seguido de la versión sin control del carácter, con la cara del glifo de escape. Por ejemplo, el carácter ``control-A``, U+0001, se muestra como ``^A``. Los bytes en bruto con los códigos U+0080 (octal 200) a U+009F (octal 237) se muestran como *secuencias de escape octales*, con la cara ``escape-glyph``. Por ejemplo, el código de carácter U+0098 (octal 230) se muestra como ``\230``. Si cambia la variable local del búfer ``ctl-arrow`` a ``nil``, los caracteres de control ASCII también se muestran como secuencias de escape octales en lugar de secuencias de escape caret. (También puede solicitar que los bytes sin procesar se muestren en hexadecimal, consulte :ref:`15.24`). Algunos caracteres no ASCII tienen la misma apariencia que un espacio ASCII o un guión (menos). Tales caracteres pueden causar problemas si se introducen en un búfer sin que se dé cuenta, por ejemplo, tirando; por ejemplo, los compiladores de código fuente normalmente no tratan los espacios no ASCII como caracteres de espacio en blanco. Para solucionar este problema, Emacs muestra estos caracteres de forma especial: muestra U+00A0 NO-BREAK SPACE y otros caracteres de la clase de espacio horizontal Unicode con la cara ``nobreak-space``, y muestra U+00AD SOFT HYPHEN, U+2010 HYPHEN, y U+2011 NON-BREAKING HYPHEN con la cara ``nobreak-hyphen``. Para desactivarlo, cambie la variable ``nobreak-char-display`` a ``nil``. Si le da a esta variable un valor que no sea ``nil`` ni ``t``, Emacs mostrará dichos caracteres como una barra invertida resaltada seguida de un espacio o guión. Puede personalizar la forma en que se muestra cualquier código de carácter concreto mediante una tabla de visualización. Ver **Tablas de Visualización** en el Manual de Referencia de Emacs Lisp. En pantallas gráficas, algunos caracteres pueden no tener glifos en ninguna de las fuentes disponibles para Emacs. Estos *caracteres sin glifos* se muestran normalmente como cuadros que contienen el código hexadecimal del carácter. De forma similar, en los terminales de texto, los caracteres que no pueden mostrarse usando la codificación del terminal (ver :ref:`23.13`) se muestran normalmente como signos de interrogación. Puede controlar el método de visualización personalizando la variable ``glyphless-char-display-control``. También puede personalizar la variable de cara ``glyphless-char`` para hacer que estos caracteres destaquen más en pantalla. Vea **Visualización de Caracteres sin Glifos** en el Manual de Referencia de Emacs Lisp, para más detalles. El modo menor ``glyphless-display-mode`` puede usarse para alternar la visualización de caracteres sin glifos en el búfer actual. Los caracteres sin glifo se mostrarán como cajas con acrónimos de sus nombres dentro. Emacs intenta determinar si las comillas curvas ``‘`` y ``’`` pueden mostrarse en la pantalla actual. Por defecto, si esto parece ser así, entonces Emacs traducirá las comillas ASCII (````` y ``'``), cuando aparezcan en mensajes y textos de ayuda, a estas comillas curvas. Puede influir o inhibir esta traducción personalizando la opción de Usuario ``text-quoting-style`` (ver **Teclas en Documentación** en El Manual de Referencia de Emacs Lisp). Si se sabe que las comillas curvas ``‘``, ``’``, ``“``, y ``”`` se parecen a los caracteres ASCII, se muestran con la cara del homoglifo. Las comillas curvas que se sabe que no son visualizables se muestran como sus aproximaciones ASCII ``´``, ``'``, y ``"`` la cara del homoglifo. .. _15.21: 15.21 Visualización del Cursor ------------------------------ En un terminal de texto, la apariencia del cursor está controlada por el terminal, en gran parte fuera del control de Emacs. Algunos terminales ofrecen dos cursores diferentes: un cursor estático visible, y un cursor parpadeante muy visible. Por defecto, Emacs usa el cursor muy visible, y cambia a él cuando arranca o reanuda Emacs. Si la variable ``visible-cursor`` es nula (``nil``) cuando Emacs arranca o se reanuda, usa el cursor normal. En una pantalla gráfica, pueden modificarse muchas más propiedades del cursor de texto. Para personalizar su color, cambie el atributo ``:background`` de la cara denominada cursor (véase :ref:`50.1.5`). (Los demás atributos de esta cara no tienen ningún efecto; el texto que se muestra bajo el cursor se dibuja utilizando el color de fondo del marco). Para cambiar su forma, personalice la variable local del búfer ``cursor-type``; los valores posibles son ``box`` (por defecto), ``(box . size)`` (el cursor en forma de caja se convierte en una caja hueca bajo imágenes enmascaradas de tamaño superior a píxeles en cualquiera de sus dimensiones), ``hollow`` (una caja hueca), ``bar`` (una barra vertical), ``(bar . n)`` (una barra vertical de *n* píxeles de ancho), ``hbar`` (una barra horizontal), ``(hbar . n)`` (una barra horizontal de *n* píxeles de alto), o ``nil`` (no hay cursor). Por defecto, el cursor deja de parpadear después de 10 destellos, si Emacs no recibe ninguna entrada durante ese tiempo; cualquier evento de entrada reinicia la cuenta. Puede personalizar la variable ``blink-cursor-blinks`` para controlar eso: su valor dice cuántas veces parpadear sin entrada antes de parar. Establecer esa variable a cero o a un valor negativo hará que el cursor parpadee para siempre. Para desactivar completamente el parpadeo del cursor, cambie la variable ``blink-cursor-mode`` a ``nil`` (vea :ref:`50.1`), o añada la línea :: (blink-cursor-mode 0) en su archivo init. Alternativamente, puede cambiar el aspecto del cursor cuando se apaga personalizando la variable de lista ``blink-cursor-alist``. Cada elemento de la lista debe tener la forma ``(on-type . off-type)``; esto significa que si el cursor se muestra como *on-type* cuando parpadea encendido (donde *on-type* es uno de los tipos de cursor descritos anteriormente), entonces se muestra como *off-type* cuando parpadea apagado. Algunos caracteres, como los de tabulación, son muy anchos. Cuando el cursor se sitúa sobre un carácter de este tipo, normalmente se dibuja con el ancho de carácter por defecto. Puede hacer que el cursor se estire para cubrir caracteres anchos, cambiando la variable ``x-stretch-cursor`` a un valor no nulo. El cursor aparece normalmente en las ventanas no seleccionadas como un cuadro hueco que no parpadea. (Para desactivar los cursores en las ventanas no seleccionadas, cambie la variable ``cursor-in-selected-windows`` a ``nil``. Para que el cursor sea aún más visible, puede usar el modo Línea HL, un modo menor que resalta la línea que contiene el punto. Use ``M-x hl-line-mode`` para activarlo o desactivarlo en el búfer actual. ``M-x global-hl-line-mode`` activa o desactiva el mismo modo globalmente. .. _15.22: 15.22 Truncado de Línea ----------------------- Como alternativa a la continuación (véase :ref:`8.8`), Emacs puede mostrar líneas largas mediante *truncamiento*. Esto significa que todos los caracteres que no caben en el ancho de la pantalla o ventana no aparecen en absoluto. En las pantallas gráficas, una pequeña flecha recta en la franja indica el truncamiento en cualquiera de los extremos de la línea. En los terminales de texto, esto se indica con signos ``$`` en las columnas del extremo derecho y/o izquierdo. El desplazamiento horizontal provoca automáticamente el truncamiento de la línea (véase :ref:`15.4`). Puede activar explícitamente el truncamiento de líneas para un búfer en particular con el comando ``C-x x t`` (``toggle-truncate-lines``). Esto funciona cambiando localmente la variable ``truncate-lines``. Si esta variable no es nula, las líneas largas se truncan; si es nula, continúan en varias líneas de la pantalla. Cualquier cambio en la variable ``truncate-lines`` (truncar-líneas) la hace local al búfer actual; hasta ese momento, el valor por defecto, que normalmente es ``nil``, está en efecto. Dado que el truncamiento y el ajuste de línea (descrito en la siguiente sección) son contradictorios, ``toggle-truncate-lines`` desactiva el ajuste de línea cuando activa el truncamiento de línea. Si una ventana dividida se vuelve demasiado estrecha, Emacs puede activar automáticamente el truncamiento de línea. Ver :ref:`21.3`, para la variable ``truncate-partial-width-windows`` que controla esto. .. _15.23: 15.23 Modo de Línea Visual -------------------------- Otra alternativa a la continuación de línea ordinaria es usar el *ajuste de línea*. Aquí, cada línea lógica larga se divide en dos o más líneas de pantalla, como en la continuación de línea ordinaria. Sin embargo, Emacs intenta ajustar la línea en los límites de palabra cercanos al borde derecho de la ventana. (si la dirección de la línea es de derecha a izquierda, se envuelve en el borde izquierdo de la ventana). Esto hace que el texto sea más fácil de leer, ya que el ajuste no se produce en medio de las palabras. El ajuste de palabras se activa mediante el modo Línea Visual (Visual Line), un modo secundario opcional. Para activar este modo en el búfer actual, escriba ``M-x visual-line-mode``; repitiendo este comando se desactiva. También puede activar el modo Visual Line mediante la barra de menús: en el menú ``Options`` (Opciones), seleccione el submenú ``Line Wrapping in this Buffer`` (Ajuste de línea en este búfer), seguido del elemento de menú ``modo Visual Line`` (Ajuste de línea). Mientras el modo Visual Line está activado, la línea de modo muestra la cadena ``wrap`` en la pantalla de modo. El comando ``M-x global-visual-line-mode`` activa el modo Visual Line en todos búferes. Dado que el ajuste de línea y el truncamiento de línea (descritos en la sección anterior) son contradictorios, al activar el modo de línea visual (``visual-line-mode``) se desactiva el truncamiento de línea. En el modo de línea visual, algunos comandos de edición funcionan en líneas de pantalla en lugar de líneas lógicas: :kbd:`Ctrl`-:kbd:`a` (``C-a``, ``beginning of visual-line``) se mueve al principio de la línea de la pantalla, :kbd:`Ctrl`-:kbd:`e` (``C-e``, ``end-of-visual-line``) se mueve al final de la línea de la pantalla, y :kbd:`Ctrl`-:kbd:`k` (``C-k``, ``kill-visual-line``) mata el texto al final de la línea de la pantalla. Para desplazarse por líneas lógicas, utilice los comandos ``M-x next-logical-line`` y ``M-x previous-logical-line``. Estos comandos mueven el punto a la siguiente línea lógica y a la línea lógica anterior, respectivamente, independientemente de si está activado el modo Visual Line. Si usa estos comandos con frecuencia, puede ser conveniente asignarles combinaciones de teclas. Consulte :ref:`50.3.6`. De forma predeterminada, las líneas envueltas en palabras no muestran indicadores de franja. El modo Visual Line se usa a menudo para editar archivos que contienen muchas líneas lógicas largas, por lo que tener un indicador de franja (o margen) para cada línea ajustada sería una distracción visual. Puede cambiar esto personalizando la variable ``visual-line-fringe-indicators``. Por defecto, Emacs sólo interrumpe líneas después de caracteres de espacio en blanco como ``SPC`` y ``TAB``, pero no interrumpe después de caracteres de espacio en blanco como ``EN QUAD`` (AL CUADRADO). Emacs proporciona un modo menor llamado ``word-wrap-whitespace-mode`` que activa el ajuste de palabras en el modo actual, y establece en qué caracteres ajustar las líneas basándose en la opción de usuario ``word-wrap-whitespace-characters``. También hay una versión globalizada de ese modo llamada ``global-word-wrap-whitespace-mode``. Romper sólo después de un carácter de espacio en blanco produce resultados incorrectos cuando se mezclan texto CJK y latino (porque los caracteres CJK no usan espacios en blanco para separar palabras). Puede personalizar la opción ``word-wrap-by-category`` para permitir que Emacs rompa las líneas después de cualquier carácter con categoría ``|`` (vea **Categorías** en el Manual de Referencia de Emacs Lisp), lo que proporciona un mejor soporte para los caracteres CJK. Además, si esta variable se establece usando Personalizar (Customize), Emacs carga automáticamente ``kinsoku.el``. Cuando se carga ``kinsoku.el``, 30Emacs respeta las reglas kinsoku al romper líneas. Eso significa que los caracteres con la categoría ``>`` no aparecen al principio de una línea (por ejemplo, U+FF0C FULLWIDTH COMMA), y los caracteres con la categoría ``<`` no aparecen al final de una línea (por ejemplo, U+300A LEFT DOUBLE ANGLE BRACKET). Puede ver el conjunto de categorías de un carácter usando los comandos ``char-category-set`` y ``category-set-mnemonics``, o tecleando :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`x` :kbd:`=` (``C-u C-x =``) con punto sobre el carácter y mirando la sección "categoría" en el informe. Puede añadir categorías a un carácter usando el comando ``modify-category-entry``. .. _15.24: 15.24 Personalización de la Pantalla ------------------------------------ Esta sección describe variables que controlan varios aspectos de la apariencia de la pantalla de Emacs. Los Usuarios principiantes pueden saltársela. Si quiere que Emacs muestre números de línea para cada línea en el búfer, personalice la variable de búfer local ``display-line-numbers``; por defecto es ``nil``. Esta variable puede tener varios valores diferentes para soportar varios modos de mostrar números de línea: ``t`` Muestra un número de línea (absoluto) antes de cada línea de pantalla que no sea de continuación y que muestre texto del búfer. Si la línea es una línea de continuación, o si toda la línea de pantalla muestra una cadena de visualización o superposición, esa línea no se numerará. ``relative`` Muestra los números de línea relativos antes de las líneas de no-continuación que muestran el texto del búfer. Los números de línea son relativos al punto de visualización de la línea, por lo que los números crecen tanto hacia arriba como hacia abajo a medida que las líneas se alejan de la línea actual. ``visual`` Este valor hace que Emacs cuente las líneas visualmente: sólo se contarán las líneas que se muestren realmente en la pantalla (sin tener en cuenta las líneas en partes invisibles del texto), y las líneas que se enrollan o envuelven para consumir más de una línea de pantalla se contarán ese número de veces. Los números mostrados son relativos, como en el valor ``relative`` anterior. Esto es útil en modos que pliegan el texto, como el modo Contorno (ver :ref:`26.9`), y cuando necesita moverse por el número exacto de líneas de pantalla. **cualquier otra cosa** Cualquier otro valor no nulo se trata como ``t``. El comando ``M-x display-line-numbers-mode`` permite activar la visualización de los números de línea. Este modo tiene una variante globalizada, ``global-display-line-numbers-mode``. La opción de Usuario ``display-line-numbers-type`` controla qué submodo de visualización de números de línea, descrito anteriormente, activarán estos modos. Tenga en cuenta que los números de línea no se muestran en el minibúfer ni en las sugerencias (o caja de herramientas, tooltips), incluso si activa el modo global ``display-line-numbers-mode``. Cuando Emacs muestra números de línea relativos, puede controlar el número mostrado antes de la línea actual, el punto de visualización de dicha línea. Por defecto, Emacs muestra el número absoluto de la línea actual, aunque todos los demás números de línea sean relativos. Si personaliza la variable ``display-line-numbers-current-absolute`` a un valor nulo (``nil``), el número mostrado para la línea actual será cero. Esto es útil si no le importa el número de la línea actual, y quiere dejar más espacio horizontal para el texto en búferes grandes. En un búfer estrechado (ver :ref:`15.5`) las líneas se numeran normalmente empezando por el principio del estrechamiento. Sin embargo, si personaliza la variable ``display-line-numbers-widen`` con un valor distinto de cero, los números de línea ignorarán cualquier estrechamiento y comenzarán en el primer carácter del búfer. Si el valor de ``display-line-numbers-offset`` es distinto de cero, se añade a cada número de línea absoluto, y las líneas se cuentan desde el principio del búfer, como si ``display-line-numbers-widen`` fuera distinto de cero. No tiene ningún efecto cuando se pone a cero, o cuando los números de línea no son absolutos. En el modo de visualización selectiva (ver :ref:`15.8`), y otros modos que ocultan muchas líneas de la visualización (como los modos Outline y Org), puede que desee personalizar las variables ``display-line-numbers-width-start`` y ``display-line-numbers-grow-only``, o establecer ``display-line-numbers-width`` a un valor suficientemente grande, para evitar errores de cálculo ocasionales del espacio reservado para los números de línea. Los números de línea se muestran con una cara especial (``line-number``). El número de línea actual se muestra en una cara diferente (``line-number-current-line``), para que pueda hacer que el número de la línea actual tenga un aspecto distinto, lo que ayudará a localizar el punto de visualización de la línea. Se pueden usar caras adicionales (``line-number-major-tick`` y ``line-number-minor-tick``) para resaltar los números de línea de las líneas que son múltiplos de ciertos números. Personalice ``display-line-numbers-major-tick`` y ``display-line-numbers-minor-tick`` respectivamente para establecer esos números. Si la variable ``visible-bell`` no es nula, Emacs intenta hacer que toda la pantalla parpadee cuando normalmente haría sonar una campana. Esta variable no tiene efecto si su terminal no tiene una forma de hacer que la pantalla parpadee. La variable ``echo-keystrokes`` controla el eco de las teclas multicarácter; su valor es el número de segundos de pausa necesarios para que comience el eco, o cero, lo que significa que no se hace eco en absoluto. El valor tiene efecto cuando hay algo de lo que hacerse eco. Véase :ref:`1.2`. En pantallas gráficas, Emacs muestra el puntero del ratón como un reloj de arena si Emacs está ocupado. Para desactivar esta característica, establezca la variable ``display-hourglass`` a ``nil``. La variable ``hourglass-delay`` determina el número de segundos de tiempo ocupado antes de que se muestre el reloj de arena; el valor por defecto es 1. Si el puntero del ratón se encuentra dentro de un marco de Emacs, este lo hace invisible cada vez que escribe un carácter para insertar texto, para evitar que oscurezca el texto. (Para ser precisos, el ocultamiento ocurre cuando escribe un carácter de auto-inserción. Véase :ref:`8.1`). Al mover el puntero del ratón, vuelve a hacerse visible. Para desactivar esta función, establezca la variable ``make-pointer-invisible`` a ``nil``. En las pantallas gráficas, la variable ``underline-minimum-offset`` determina la distancia mínima entre la línea de base y el subrayado, en píxeles, para el texto subrayado. Por defecto, el valor es 1; aumentarlo puede mejorar la legibilidad del texto subrayado para ciertas fuentes. (La variable ``x-underline-at-descent-line`` determina cómo dibujar el texto subrayado. Por defecto es ``nil``, lo que significa dibujarlo al nivel de la línea de base de la fuente; si cambia este valor a ``t``, Emacs dibuja el subrayado a la misma altura que la línea de bajada de la fuente. (Si se especificó un interlineado no predeterminado para el texto subrayado, véase **Altura de Línea** en El manual de referencia de Emacs Lisp, Emacs dibuja el subrayado por debajo del interlineado adicional). La variable ``overline-margin`` especifica la posición vertical de una sobrelínea sobre el texto, incluyendo la altura de la propia sobrelínea, en píxeles; el valor por defecto es 2. En algunos terminales de texto, la negrita y el vídeo inverso juntos hacen que el texto sea difícil de leer. Llame a la función ``tty-suppress-bold-inverse-default-colors`` con un argumento no nulo para suprimir el efecto de la negrita en este caso. Los bytes en bruto se muestran en formato octal por defecto, por ejemplo un byte con un valor decimal de 128 se muestra como ``\200``. Para cambiar la visualización al formato hexadecimal de ``\x80``, establezca la variable ``display-raw-bytes-as-hex`` a ``t``. Puede ser necesario tener cuidado al interpretar un byte crudo cuando se copia texto de un terminal que contiene una sesión de Emacs, o cuando la cara del glifo de escape de un terminal se parece a la cara por defecto. Por ejemplo, por defecto Emacs muestra los cuatro caracteres ``\``, ``2``, ``0``, ``0`` con los mismos caracteres que muestra un byte con valor decimal 128. El problema puede ser peor con las visualizaciones hexadecimales, donde el byte bruto 128 seguido del carácter ``7`` se muestra como ``\x807``, que Emacs Lisp lee como el único carácter U+0807 LETRA SAMARITANA IT; esta confusión no ocurre con la correspondiente visualización octal ``\2007`` porque los escapes octales contienen como máximo tres dígitos.