.. _26: 26 Comandos para Lenguajes Humanos ================================== Este capítulo describe los comandos de Emacs que actúan sobre *texto*, es decir, secuencias de caracteres en un lenguaje humano (en oposición a, por ejemplo, un lenguaje de programación informática). Estos comandos actúan teniendo en cuenta las convenciones sintácticas y estilísticas de los lenguajes humanos: convenciones que implican palabras, frases, párrafos y mayúsculas. También hay comandos para *rellenar*, lo que significa reordenar las líneas de un párrafo para que tengan aproximadamente la misma longitud. Estos comandos, aunque están pensados principalmente para editar texto, también suelen ser útiles para editar programas. Emacs tiene varios modos principales para editar texto en lenguaje humano. Si el archivo contiene texto ordinario, use el modo Texto, que personaliza Emacs en pequeños aspectos para las convenciones sintácticas del texto. El modo Esquema proporciona comandos especiales para operar sobre texto con una estructura de esquema. Ver :ref:`26.9`. El modo Org extiende el modo Outline y convierte a Emacs en un organizador en toda regla: puede gestionar listas TODO, almacenar notas y publicarlas en muchos formatos. Ver el **Manual Org Info**, que se distribuye con Emacs. Emacs tiene otros modos importantes para texto que contiene comandos incrustados, como TeX y LaTeX (ver :ref:`26.11`); HTML y SGML (ver :ref:`26.12`); XML (ver el manual **Info** del modo nXML, que se distribuye con Emacs); y Groff y Nroff (ver :ref:`26.13`). Si necesita editar imágenes artísticas ASCII hechas a partir de caracteres de texto, use el modo Imagen, un modo principal especial para editar dichas imágenes. Véase :ref:`43`. .. _26.1: 26.1 Palabras ------------- Emacs define varios comandos para moverse u operar sobre palabras: :kbd:`Alt`-:kbd:`f` (``M-f``) Avanza sobre una palabra (``forward-word``). :kbd:`Alt`-:kbd:`b` (``M-b``) Retrocede sobre una palabra (``backward-word``). :kbd:`Alt`-:kbd:`d` (``M-d``) Mata hasta el final de una palabra (``kill-word``). :kbd:`Alt`-:kbd:`DEL` (``M-DEL``) Elimina hacia atrás hasta el principio de una palabra (``backward-kill-word``). :kbd:`Alt`-:Kbd:`@` (``M-@``) Fija marca al final de la palabra siguiente (``mark-word``). :kbd:`Alt`-:kbd:`t` (``M-t``) Transpone dos palabras o arrastra una palabra a través de otras (``transpose-words``). Observe cómo estas teclas forman una serie paralela a los caracteres ``C-f``, ``C-b``, ``C-d``, ``DEL`` y ``C-t``. ``M-@`` es afín a ``C-@``, que es un alias de ``C-SPC``. Los comandos ``M-f`` (``forward-word``, avanzar palabra) y ``M-b`` (``backward-word``, retroceder palabra) permiten avanzar y retroceder palabras. Estas secuencias de teclas basadas en ``Meta`` (:kbd:`Alt`) son análogas a las secuencias de teclas ``C-f`` y ``C-b``, que se mueven sobre caracteres individuales. La analogía se extiende a los argumentos numéricos, que sirven para contar repeticiones. ``M-f`` con un argumento negativo se mueve hacia atrás, y ``M-b`` con un argumento negativo se mueve hacia adelante. El movimiento hacia adelante se detiene justo después de la última letra de la palabra, mientras que el movimiento hacia atrás se detiene justo antes de la primera letra. ``M-d`` (``kill-word``) mata la palabra después del punto. Para ser precisos, mata todo desde el punto hasta el lugar al que ``M-f`` se movería. Así, si el punto está en medio de una palabra, ``M-d`` elimina sólo la parte después del punto. Si hay algún signo de puntuación entre el punto y la palabra siguiente, se elimina junto con la palabra. (Si desea matar sólo la palabra siguiente pero no la puntuación anterior, simplemente haga M-f para obtener el final, y mate la palabra hacia atrás con ``M-DEL``). ``M-d`` tiene los mismos argumentos que ``M-f``. ``M-DEL`` (``backward-kill-word``) elimina la palabra anterior al punto. Elimina todo desde el punto hasta donde ``M-b`` se movería. Por ejemplo, si el punto está después del espacio en ``FOO, BAR``, elimina ``FOO, ``. Si desea eliminar sólo ``FOO``, y no la coma y el espacio, use ``M-b M-d`` en lugar de ``M-DEL``. ``M-t`` (``transpose-words``) intercambia la palabra que precede o contiene al punto por la palabra siguiente. Los caracteres delimitadores entre las palabras no se desplazan. Por ejemplo, ``FOO, BAR`` se transpone a ``BAR, FOO`` en lugar de ``BAR FOO,``. Para más información sobre la transposición, véase :ref:`17.2`. Para operar sobre palabras con una operación que actúe sobre la región, use el comando ``M-@`` (``mark-word``, marcar-palabra). Este comando establece la marca a la que se movería ``M-f``. Consulte :ref:`12.2`, para más información sobre este comando. La comprensión de los límites de palabra por parte de los comandos de palabra está controlada por la tabla de sintaxis. Cualquier carácter puede, por ejemplo, ser declarado delimitador de palabra. Ver **Tablas de Sintaxis** en el Manual de Referencia de Emacs Lisp. Además, vea :ref:`8.9` para los comandos ``M-=`` (``count-words-region``) y ``M-x count-words``, que cuentan y reportan el número de palabras en la región o búfer. .. _26.2: 26.2 Frases (u oraciones) ------------------------- Los comandos de Emacs para manipular frases y párrafos en su mayoría se los emplea usando la combinación de teclas que incluye a :kbd:`Alt` (``Meta``), como los comandos de manipulación de palabras. :kbd:`Alt`-:kbd:`a` (``M-a``) Retrocede al principio de la frase (``backward-sentence``). :kbd:`Alt`-:kbd:`` (``M-e``) Avanza hasta el final de la frase (``forward-sentence``). :kbd:`Alt`-:kbd:`k` (``M-k``) Avanza hasta el final de la frase (``kill-sentence``). :kbd:`Ctrl`-:kbd:`x` :kbd:`DEL` (``C-x DEL``) Mata hacia atrás hasta el principio de la frase (``backward-kill-sentence``). Los comandos ``M-a`` (``backward-sentence``) y ``M-e`` (``forward-sentence``) se desplazan al principio y al final de la frase actual, respectivamente. Se han elegido para que se parezcan a ``C-a`` y ``C-e``, que se desplazan al principio y al final de una línea. A diferencia de ellas, ``M-a`` y ``M-e`` se desplazan sobre frases sucesivas si se repiten. Si se mueve hacia atrás sobre una frase, el punto se sitúa justo antes del primer carácter de la frase; si se mueve hacia delante, el punto se sitúa justo después de la puntuación que termina la frase. Ninguno de los dos se desplaza sobre el espacio en blanco en el límite de la frase. Al igual que ``C-a`` y ``C-e`` tienen un comando de eliminación, ``C-k``, que los acompaña, ``M-a`` y ``M-e`` tienen su correspondiente comando de eliminación: ``M-k`` (``kill-sentence`` ) mata desde el punto hasta el final de la oración. Con un argumento numérico positivo *n*, mata las siguientes *n* frases; con un argumento negativo *-n*, mata hasta el principio de la *enésima* frase anterior. El comando ``C-x DEL`` (``backward-kill-sentence``) vuelve al principio de una frase. Los comandos de oraciones asumen que Usted sigue la convención del mecanógrafo americano que coloca dos espacios al final de una frase. Es decir, una frase termina donde hay un ``.``, ``?`` o ``!`` seguido del final de una línea o dos espacios, con cualquier número de caracteres ``)``, ``]``, ``'``, o ``"`` permitidos entre ellos. Una frase también empieza o acaba donde empieza o acaba un párrafo. Es útil seguir esta convención, porque permite a los comandos de oraciones de Emacs distinguir entre puntos que terminan una frase y puntos que indican abreviaturas. Si desea usar sólo un espacio entre frases, puede establecer la variable ``sentence-end-double-space`` (fin-de-oración-con-doble-espacio) a ``nil`` para que los comandos de frase se detengan ante espacios simples. Sin embargo, esto tiene un inconveniente: no hay forma de distinguir entre los puntos que terminan las frases y los que indican abreviaturas. Para una edición cómoda y fiable, le recomendamos que siga la convención de los dos espacios. La variable ``sentence-end-double-space`` también afecta al relleno (véase :ref:`26.6.2`). La variable ``sentence-end`` (fin-de-frase) controla cómo reconocer el final de una frase. Si no es ``nil``, su valor debe ser una expresión regular, que se usa para coincidir con los últimos caracteres de una oración, junto con el espacio en blanco que la sigue (vea :ref:`16.6`). Si el valor es ``nil``, el valor por defecto, entonces Emacs computa los finales de frase de acuerdo a varios criterios como el valor de ``sentence-end-double-space``. Algunos idiomas, como el tailandés, no usan puntos para indicar el final de una frase. En estos casos, establezca la variable ``sentence-end-without-period`` (fin-de-frase-sin-punto) en ``t``. .. _26.3: 26.3 Párrafos ------------- Los comandos de Emacs para manipular párrafos también usan las combinaciones de teclas que inlcuyen :kbd:`Alt` (``Alt``). :kbd:`Alt`-:Kbd:`{` (``M-{``) Retrocede al principio del párrafo anterior (``backward-paragraph)``. :kbd:`Alt`-:kbd:`}` (``M-}``) Avanza hasta el final del párrafo siguiente (``forward-paragraph``). :kbd:`Alt`-:kbd:`h` (``M-h``) Pone punto y aparte en este párrafo o en el siguiente (``mark-paragraph``). ``M-{`` (``backward-paragraph``, párrafo hacia atrás) se desplaza al principio del párrafo actual o anterior, dependiendo de dónde se encuentre el punto cuando se invoque el comando (véase más abajo la definición de párrafo). ``M-}`` (``forward-paragraph``, párrafo anterior) se desplaza de forma similar al final del párrafo actual o del siguiente. Si hay una línea en blanco antes del párrafo, ``M-{`` se mueve a la línea en blanco. Cuando desee operar sobre un párrafo, escriba ``M-h`` (``mark-paragraph``, marcar-párrafo) para fijar la región que lo rodea. Por ejemplo, ``M-h C-w`` marca el párrafo alrededor o después de punto. ``M-h`` coloca el punto al principio y la marca al final del párrafo en el que estaba el punto. Si el punto está entre párrafos (en una serie de líneas en blanco, o en un límite), ``M-h`` establece la región alrededor del párrafo que sigue al punto. Si hay líneas en blanco antes de la primera línea del párrafo, una de estas líneas en blanco se incluye en la región. Si la región ya está activa, el comando establece la marca sin cambiar el punto, y cada ``M-h`` posterior avanza la marca un párrafo. La definición de párrafo depende del modo fundamental. En el modo Fundamental (Fundamental mode), así como en el modo Texto (Text mode) y otros modos relacionados, un párrafo está separado de los párrafos vecinos por una o más líneas en blanco, líneas que están vacías o que consisten únicamente en espacios, tabuladores y/o caracteres de salto de página. En los modos de lenguaje de programación, los párrafos suelen definirse de forma similar, de modo que puede usar los comandos de párrafo aunque no haya párrafos como tales en un programa. Tenga en cuenta que una línea sangrada no es en sí misma un salto de párrafo en el modo Texto. Si desea que las líneas sangradas separen párrafos, use en su lugar el modo Texto (Text mode) con sangría de párrafo. Véase :ref:`26.8`. Si establece un prefijo de relleno, los párrafos estarán delimitados por todas las líneas que no empiecen con el prefijo de relleno. Véase :ref:`26.6`. La definición precisa de un límite de párrafo se controla mediante las variables ``paragraph-separate`` y ``paragraph-start``. El valor de ``paragraph-start`` es una expresión regular que debe coincidir con las líneas que inician o separan párrafos (véase :ref:`16.6`). El valor de ``paragraph-separate`` es otra expresión regular que debe coincidir con líneas que separan párrafos sin formar parte de ningún párrafo (por ejemplo, líneas en blanco). Las líneas que inician un nuevo párrafo y están contenidas en él deben coincidir sólo con ``paragraph-start``, no con ``paragraph-separate``. Por ejemplo, en el modo Fundamental, el inicio de párrafo (``paragraph-start``) es ``"\f\|[ \t]*$"``, y la separación de párrafo (``paragraph-separate``) es ``"[ \t\f]*$"``. Tenga en cuenta que ``paragraph-start`` y ``paragraph-separate`` se comparan con el texto del margen izquierdo, que no es necesariamente el principio de la línea, por lo que estas expresiones regulares no deberían usar ``^`` como ancla, para garantizar que las funciones de párrafo funcionen igualmente dentro de una región de texto sangrado por un ajuste de margen. .. _26.4: 26.4 Páginas ------------ En algunos archivos de texto, el texto se divide en *páginas* delimitadas por el carácter de salto de página (código ASCII 12, también denominado ``control-L``), que en Emacs se muestra como la secuencia de escape ``^L`` (véase :ref:`15.20`). Tradicionalmente, cuando estos archivos de texto se imprimen en papel, cada carácter de salto de página fuerza un salto de página. La mayoría de los comandos de Emacs lo tratan como cualquier otro carácter, así que puede insertarlo con ``C-q C-l``, borrarlo con ``DEL``, etc. Además, Emacs proporciona comandos para desplazarse por las páginas y operar sobre ellas. :kbd:`Alt`-:kbd:`x` ``what-page`` (``M-x what-page``) Muestra el número de página del punto, y el número de línea dentro de esa página. :kbd:`Ctrl`-:kbd:`x` :kbd:`[` (``C-x [``) Mueve el punto al límite de la página anterior (``backward-page``). :kbd:`Ctrl`-:kbd:`x` :kbd:`]` (``C-x ]``) Mueve el punto al límite de la página siguiente (``forward-page``). :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`p` (``C-x C-p``) Coloca punto y marca alrededor de esta página (u otra página) (``mark-page``). :kbd:`Ctrl`-:kbd:`x` :kbd:`l` (``C-x l``) Cuenta las líneas de esta página (``count-lines-page``). ``M-x what-page`` cuenta las páginas desde el principio del archivo, y cuenta las líneas dentro de la página, mostrando ambos números en el área de eco. El comando ``C-x [`` (``backward-page``) mueve el punto inmediatamente después del delimitador de página anterior. Si el punto ya está justo después de un delimitador de página, se lo salta y se detiene en el anterior. Un argumento numérico sirve como contador de repeticiones. El comando ``C-x ]`` (``forward-page``) avanza más allá del siguiente delimitador de página. El comando ``C-x C-p`` (``mark-page``) pone el punto al principio de la página actual (después del delimitador de página al principio), y la marca al final de la página (después del delimitador de página al final). ``C-x C-p C-w`` es una forma práctica de eliminar una página para moverla a otro lugar. Si se desplaza a otro delimitador de página con ``C-x [`` y ``C-x ]`` y, a continuación, elimina la página eliminada, todas las páginas volverán a estar delimitadas correctamente. La razón por la que ``C-x C-p`` incluye sólo el siguiente delimitador de página en la región es para garantizar que esto funciona como se espera. Un argumento numérico para ``C-x C-p`` especifica a qué página ir, en relación a la actual. Cero significa la página actual, uno la siguiente y -1 la anterior. El comando ``C-x l`` (``count-lines-page``) es bueno para decidir dónde dividir una página en dos. Muestra en el área de eco el número total de líneas en la página actual, y luego lo divide en las que preceden a la línea actual y las que siguen, como en :: Page has 96 (72+25) lines Observe que la suma está desviada en uno; esto es correcto si el punto no está al principio de una línea. La variable delimitador (``page-delimiter``) de página controla dónde empiezan las páginas. Su valor es una expresión regular que coincide con el comienzo de una línea que separa páginas (véase :ref:`16.6`). El valor normal de esta variable es ``"^\f"``, que coincide con un carácter de salto de página al principio de una línea. .. _26.5: 26.5 Comillas ------------- Una forma habitual de entrecomillar es la convención de la máquina de escribir, que cita utilizando apóstrofos rectos ``'así'`` o comillas dobles ``"así"``. Otra forma común es la convención de las comillas curvas, que usa comillas simples o dobles a izquierda y derecha ``‘así’`` o ”así ” [12]_. En los archivos de texto, las comillas de máquina de escribir son sencillas y portátiles; las comillas curvas son menos ambiguas y suelen quedar mejor. El modo de comillas eléctricas facilita la escritura de comillas curvas. A medida que escribe caracteres, convierte opcionalmente ````` en ``‘``, ``'`` en ``’``, `````` en ``”``, y ``''`` en ``”``. Es posible cambiar las comillas por defecto enumeradas anteriormente, personalizando la variable ``electric-quote-chars``, una lista de cuatro caracteres, donde los elementos corresponden a la comilla simple izquierda, la comilla simple derecha, la comilla doble izquierda y la comilla doble derecha, respectivamente, cuyo valor por defecto es ``'(?’ ?’ ?” ?”)``. Puede personalizar el comportamiento del modo Comillas Eléctricas (Electric Quote mode) personalizando las variables que controlan dónde está activo. Está activo en párrafos de texto si ``electric-quote-paragraph`` es distinto de ``nil``, en comentarios en lenguaje de programación si ``electric-quote-comment`` es distinto de ``nil``, y en cadenas en lenguaje de programación si ``electric-quote-string`` es distinto de ``nil``. El valor predeterminado es ``nil`` para ``electric-quote-string`` y ``t`` para las demás variables. También puede establecer la opción ``electric-quote-replace-double`` a un valor no nulo. Entonces, tecleando ``"`` inserta una comilla doble curva apropiada dependiendo del contexto: ``“`` al principio del búfer o después de un salto de línea, espacio en blanco, paréntesis de apertura o carácter de comilla, y ``”`` en caso contrario. El modo de comillas eléctricas está desactivado por defecto. Para activarlo en un único búfer, use ``M-x electric-quote-local-mode``. Para activarlo globalmente, escriba ``M-x electric-quote-mode``. Para suprimirlo en un solo uso, escriba :kbd:`Ctrl`-:kbd:`q` (``C-q ```) o (``C-q '``) en lugar de ````` o ``'``. Para insertar una comilla curva incluso cuando la opción Comilla Eléctrica está desactivada o inactiva, puede escribir :kbd:`Ctrl`-:kbd:`x` :kbd:`8`:kbd:`[` (``C-x 8 [``) para ``‘``, :kbd:`Ctrl`-:kbd:`x` :kbd:`8`:kbd:`]` (``C-x 8 ]``) para ``’``, :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`{` (``C-x 8 {``) para ``“`` y :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`}` (``C-x 8 }``) para ``”``. Véase :ref:`8.1`. Tenga en cuenta que el valor de ``electric-quote-chars`` no afecta a estas combinaciones de teclas, ya que no son combinaciones de teclas de ``electric-quote-mode``, sino combinaciones de teclas de ``global-map``. .. [12] Los caracteres de comilla simple curvada son U+2018 MARCA DE COMILLA SIMPLE IZQUIERDA y U+2019 MARCA DE COMILLA SIMPLE DERECHA; las comillas dobles curvadas son U+201C MARCA DE COMILLA DOBLE IZQUIERDA y U+201D MARCA DE COMILLA DOBLE DERECHA. En los terminales de texto que no pueden mostrar estos caracteres, el lector Info puede mostrarlos como caracteres de comillas ASCII de máquina de escribir. .. _26.6: 26.6 Rellenar Texto ------------------- *Rellenar* texto significa dividirlo en líneas que se ajusten a un ancho especificado. Emacs rellena el texto de dos maneras. En el modo Relleno automático (Auto Fill mode), la inserción de texto con caracteres autoinsertables también lo rellena automáticamente. También hay comandos de relleno explícitos que puede usar al editar texto. .. _26.6.1: 26.6.1 Modo de Relleno Automático (Auto Fill) ````````````````````````````````````````````` El *modo de Relleno Automático* (Auto Fill Mode) es un modo menor local del búfer (ver :ref:`24.2`) en el que las líneas se rompen automáticamente cuando la línea se vuelve demasiado ancha y se teclea :kbd:`SPACE` (``SPC``) o :kbd:`RETURN` (``RET``). :kbd:`Alt`-:kbd:`x` ``auto-fill-mode`` (``M-x auto-fill-mode``) Activa o desactiva el modo Relleno Automático (Auto Fill mode). | :kbd:`SPACE` (``SPC``) | :kbd:`RETURN` (``RET``) En el modo Relleno Automático, rompe las líneas cuando corresponda. El comando de modo ``M-x auto-fill-mode`` activa el modo Auto Fill en el búfer actual. Como cualquier otro modo menor, con un argumento numérico positivo, activa el modo Auto Fill, y con un argumento negativo lo desactiva. Para activar el modo Auto Fill automáticamente en ciertos modos mayores, añada ``auto-fill-mode`` a los ganchos de modo (ver :ref:`24.1`). Cuando el modo Auto Fill está activado, el indicador de modo ``Fill`` (Relleno) aparece en la línea de modo (ver :ref:`1.3`). El modo Relleno automático rompe las líneas automáticamente en los lugares apropiados siempre que las líneas superan el ancho previsto. Este salto de línea sólo se produce cuando escribe :kbd:`SPACE` (``SPC``) o :kbd:`RETURN` (``RET``). Si desea insertar un espacio o una nueva línea sin permitir el salto de línea, escriba :kbd:`Ctrl`-:kbd:`q` :kbd:`SPACE` (``C-q SPC``) o :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`j` (``C-q C-j``) respectivamente. Además, ``C-o`` inserta una nueva línea sin salto de línea. El lugar donde Auto Fill rompe una línea depende de los caracteres de la línea. Para caracteres ASCII, latinos y la mayoría de los otros scripts, Emacs rompe una línea en caracteres de espacio, para mantener las palabras intactas. Pero para las escrituras CJK, una línea puede romperse entre dos caracteres cualesquiera. (Si carga la biblioteca kinsoku, Emacs evitará romper una línea entre ciertos pares de caracteres CJK, donde reglas especiales lo prohíben). Cuando el modo Relleno automático rompe una línea, intenta obedecer el prefijo de *relleno adaptativo*: si se puede deducir un prefijo de relleno de la primera y/o segunda línea del párrafo actual, se inserta en la nueva línea (véase :ref:`26.6.4`). En caso contrario, la nueva línea se sangrará, como si hubiera tecleado :kbd:`TAB` (``TAB``) en ella (véase :ref:`25`). En un modo de lenguaje de programación, si se interrumpe una línea en medio de un comentario, éste se divide insertando nuevos delimitadores de comentario según corresponda. El modo Relleno automático (Auto Fill mode) no rellena párrafos enteros; rompe líneas pero no las une. Por lo tanto, la edición en medio de un párrafo puede dar como resultado un párrafo que no se rellena correctamente. Para rellenarlo, llame a los comandos de relleno explícito (véase :ref:`26.6.2`). Una función similar que rellena automáticamente las líneas largas en el momento de la visualización es el Modo de Línea Visual (véase :ref:`15.23`). .. _26.6.2: 26.6.2 Comandos de Relleno Explícito ```````````````````````````````````` :kbd:`Alt`-:kbd:`q` (``M-q``) Rellena el párrafo actual (``fill-paragraph``). :kbd:`Ctrl`-:kbd:`x` :kbd:`f` (``C-x f``) Establece la columna de relleno (``set-fill-column``). :kbd:`Alt`-:kbd:`x` ``fill-region`` (``M-x fill-region``) Rellena cada párrafo de la región (``fill-region``). :kbd:`Alt`-:kbd:`x` ``fill-region-as-paragraph`` (``M-x fill-region-as-paragraph``) Rellena la región, considerándola como un párrafo. :kbd:`Alt`-:kbd:`x` ``center-line`` (``M-x center-line``) Centra una línea. El comando ``M-q`` (``fill-paragraph``) *rellena* el párrafo actual. Redistribuye los saltos de línea dentro del párrafo y elimina cualquier exceso de caracteres de espacio y tabulación que se produzcan dentro del párrafo, de tal forma que las líneas terminan encajando dentro de una determinada anchura máxima. Al igual que el modo Relleno automático (Auto Fill mode), éste y otros comandos de relleno normalmente rompen las líneas en los caracteres de espacio, pero para los caracteres CJK estos comandos pueden romper una línea entre casi cualquier par de caracteres, y también pueden obedecer las reglas kinsoku. Véase :ref:`26.6.1`. Normalmente, ``M-q`` actúa en el párrafo donde está el punto, pero si el punto está entre párrafos, actúa en el párrafo después del punto. Si la región está activa, actúa sobre el texto de la región. También puede llamar a ``M-x fill-region`` para rellenar específicamente el texto de la región. ``M-q`` y ``fill-region`` usan los criterios habituales de Emacs para encontrar los límites de los párrafos (ver :ref:`26.3`). Para un mayor control, puede usar ``M-x fill-region-as-paragraph`` (rellenar-región-como-párrafo), que rellena todo entre el punto y la marca como un único párrafo. Este comando borra cualquier línea en blanco dentro de la región, de modo que los bloques de texto separados acaban combinados en un solo bloque. Un argumento numérico para ``M-q`` le indica que *justifique* el texto además de rellenarlo. Esto significa que se insertan espacios adicionales para que el margen derecho quede alineado exactamente con la columna de relleno. Para eliminar los espacios adicionales, usar ``M-q`` sin argumento. (Lo mismo ocurre con ``fill-region`` (rellenar-región)). El ancho máximo de línea para el relleno se especifica mediante la variable local del búfer ``fill-column``. El valor por defecto (ver :ref:`50.2.3`) es 70. La forma más sencilla de establecer el valor de la variable ``fill-column`` (columna de relleno) en el búfer actual es usar el comando ``C-x f`` (``set-fill-column``, configurar columna de relleno). Con un argumento numérico, lo usará como nueva columna de relleno. Con sólo ``C-u`` como argumento, establece la columna de relleno en la posición horizontal actual del punto. Tenga en cuenta que, por su propia naturaleza, la columna de relleno se mide en unidades de columna; la posición real de esa columna en una pantalla gráfica depende de la fuente que se esté usando. En particular, usar fuentes de paso variable hará que la columna de relleno ocupe diferentes posiciones horizontales en la pantalla en diferentes líneas. El comando ``M-x center-line`` centra la línea actual dentro de la columna de relleno actual. Con un argumento *n*, centra *n* líneas individualmente y se desplaza más allá de ellas. Esta combinación de teclas se efectúa en el modo Texto y sólo está disponible en ese modo y en otros relacionados (véase :ref:`26.8`). Por defecto, Emacs considera un punto seguido de dos espacios o de una nueva línea como el final de una frase; un punto seguido de un solo espacio indica una abreviatura, no el final de una frase. En consecuencia, los comandos de relleno no romperán una línea después de un punto seguido de un solo espacio. Si establece la variable ``sentence-end-double-space`` a ``nil``, los comandos de relleno romperán una línea después de un punto seguido de un espacio, y pondrán sólo un espacio después de cada punto. Vea :ref:`26.2`, para otros efectos y posibles inconvenientes de esto. Si la variable ``colon-double-space`` no es nula, los comandos de relleno ponen dos espacios después de dos puntos. Para especificar condiciones adicionales en las que no se permite el salto de línea, personalice la variable de gancho anormal ``fill-nobreak-predicate`` (ver :ref:`50.2.2`). Cada función en este hook (gancho) es llamada sin argumentos, con el punto posicionado donde Emacs está considerando romper una línea. Si una función devuelve un valor no nulo, Emacs no romperá la línea allí. Las funciones que puede usar aquí incluyen: ``fill-single-word-nobreak-p`` (no rompe después de la primera palabra de una frase o antes de la última); ``fill-single-char-nobreak-p`` (no rompe después de una palabra de una letra precedida por un carácter de espacio en blanco); ``fill-french-nobreak-p`` (no rompe después de ``(`` o antes de ``)``, ``:`` o ``?``); y ``fill-polish-nobreak-p`` (no rompe después de una palabra de una letra, incluso si va precedida de un carácter que no sea un espacio en blanco). Emacs puede mostrar un indicador en la posición de columna de relleno usando el modo Indicador de Columna de Relleno (Display fill column indicator) (ver :ref:`15.6`). .. _26.6.3: 26.6.3 El Prefijo de Relleno ```````````````````````````` La característica *prefijo de relleno* permite rellenar párrafos de forma que cada línea comience con una cadena especial de caracteres (como una secuencia de espacios, dando un párrafo sangrado). Puede especificar un prefijo de relleno explícitamente; de lo contrario, Emacs intenta deducir uno automáticamente (véase :ref:`26.6.4`). :kbd:`Ctrl`-:kbd:`x` :kbd:`.` (``C-x .``) Establece el prefijo de relleno (``set-fill-prefix``). :kbd:`Alt`-:kbd:`q` (``M-q``) Rellena un párrafo usando el prefijo de relleno actual (``fill-paragraph``). :kbd:`Alt`-:kbd:`x` ``fill-individual-paragraph`` (``M-x fill-individual-paragraphs``) Rellena la región, considerando cada cambio de sangría como el inicio de un nuevo párrafo. :kbd:`Alt`-:kbd:`x` ``fill-nonuniform-paragraphs`` (``M-x fill-nonuniform-paragraphs``) Rellena la región, considerando sólo las líneas separadoras de párrafo como inicio de un nuevo párrafo. Para especificar un prefijo de relleno para el búfer actual, desplácese a una línea que comience con el prefijo deseado, ponga punto al final del prefijo y escriba ``C-x .`` (``set-fill-prefix``). (Para desactivar el prefijo de relleno, especifique un prefijo vacío: escriba ``C-x .`` con punto al principio de una línea. Cuando un prefijo de relleno está en efecto, los comandos de relleno eliminan el prefijo de relleno de cada línea del párrafo antes del relleno, y lo insertan en cada línea después del relleno. (El comienzo de la primera línea del párrafo se deja sin cambios, ya que a menudo es intencionadamente diferente). El modo de relleno automático también inserta el prefijo de relleno automáticamente cuando hace una nueva línea (véase :ref:`26.6.1`). El comando ``C-o`` inserta el prefijo de relleno en las nuevas líneas que crea, cuando lo usa al principio de una línea (vea :ref:`8.7`). A la inversa, el comando ``M-^`` borra el prefijo (si aparece) después de la nueva línea que borra (véase :ref:`25`). Por ejemplo, si ``fill-column`` (relleno-columna) es 40 y establece el prefijo de relleno en :literal:`;;\ `, entonces ``M-q`` en el siguiente texto :: ;; Este es un ;; ejemplo de un párrafo ;; dentro de un comentario estilo Lisp. produce esto: :: ;; Este es un ejemplo de un párrafo ;; dentro de un comentario estilo Lisp. Se considera que las líneas que no empiezan con el prefijo de relleno inician párrafos, tanto en ``M-q`` como en los comandos de párrafo; esto da buenos resultados para párrafos con indentación ascendente o colgante (cada línea indentada excepto la primera). Las líneas que quedan en blanco o sangradas una vez eliminado el prefijo también separan o inician párrafos; esto es lo que desea si está escribiendo comentarios de varios párrafos con un delimitador de comentario en cada línea. Puede usar ``M-x fill-individual-paragraphs`` para establecer automáticamente el prefijo de relleno de cada párrafo. Este comando divide la región en párrafos, tratando cada cambio en la cantidad de sangría como el comienzo de un nuevo párrafo, y rellena cada uno de estos párrafos. Así, todas las líneas de un párrafo tienen la misma sangría. Esa sangría sirve como prefijo de relleno para ese párrafo. ``M-x fill-nonuniform-paragraphs`` es un comando similar que divide la región en párrafos de forma diferente. Sólo considera las líneas que separan párrafos (definidas por ``paragraph-separate``) como el inicio de un nuevo párrafo. Como esto significa que las líneas de un párrafo pueden tener diferentes cantidades de sangría, el prefijo de relleno usado es la menor cantidad de sangría de cualquiera de las líneas del párrafo. Esto da buenos resultados con estilos que sangren la primera línea de un párrafo más o menos que el resto del párrafo. El prefijo de relleno se almacena en la variable ``fill-prefix``. Su valor es una cadena, o ``nil`` cuando no hay prefijo de relleno. Esta es una variable por búfer; alterar la variable afecta sólo al búfer actual, pero hay un valor por defecto que también puede cambiar. Ver :ref:`50.2.3`. La propiedad de texto de sangría proporciona otra forma de controlar la cantidad de sangría que reciben los párrafos. Véase :ref:`26.14.5`. .. _26.6.4: 26.6.4 Relleno Adaptativo ````````````````````````` Los comandos de relleno pueden deducir automáticamente el prefijo de relleno adecuado para un párrafo en determinados casos: los espacios en blanco o determinados caracteres de puntuación al principio de una línea se propagan a todas las líneas del párrafo. Si el párrafo tiene dos o más líneas, el prefijo de relleno se toma de la segunda línea del párrafo, pero sólo si aparece también en la primera línea. Si un párrafo sólo tiene una línea, los comandos de relleno pueden tomar un prefijo de esa línea. La decisión es complicada porque hay tres cosas razonables que hacer en tal caso: * Usar el prefijo de la primera línea en todas las líneas del párrafo. * Las líneas siguientes se sangrarán con espacios en blanco, de modo que queden alineadas bajo el texto que sigue al prefijo de la primera línea, pero sin copiar el prefijo de la primera línea. * No haga nada especial con la segunda línea y las siguientes. Estos tres estilos de formato se usan habitualmente. Así que los comandos de relleno intentan determinar lo que quiere, basándose en el prefijo que aparece y en el modo principal. He aquí cómo. Si el prefijo encontrado en la primera línea coincide con ``adaptive-fill-first-line-regexp``, o si parece ser una secuencia de inicio de comentario (esto depende del modo principal), entonces el prefijo encontrado se usa para rellenar el párrafo, siempre que no actúe como inicio de párrafo en líneas posteriores. En caso contrario, el prefijo encontrado se convierte a un número equivalente de espacios, y esos espacios se usan como prefijo de relleno para el resto de las líneas, siempre que no actúen como inicio de párrafo en líneas posteriores. En el modo Texto (Text mode), y en otros modos en los que sólo las líneas en blanco y los delimitadores de página separan los párrafos, el prefijo elegido por el relleno adaptativo nunca actúa como inicio de párrafo, por lo que siempre puede usarse para el relleno. La variable ``adaptive-fill-regexp`` determina qué tipos de principios de línea pueden servir como prefijo de relleno: se usa cualquier carácter de principio de línea que coincida con esta expresión regular. Si establece la variable ``adaptive-fill-mode`` en ``nil``, el prefijo de relleno nunca se elige automáticamente. Puede especificar formas más complejas de elegir un prefijo de relleno automáticamente estableciendo la variable ``adaptive-fill-function`` a una función. Esta función se llama con un punto después del margen izquierdo de una línea, y debería devolver el prefijo de relleno apropiado basado en esa línea. Si devuelve ``nil``, ``adaptive-fill-regexp`` tiene la oportunidad de encontrar un prefijo. .. _26.7: 26.7. Comandos de Conversión de Mayúsculas y Minúsculas ------------------------------------------------------- Emacs tiene comandos para convertir una sola palabra o cualquier rango arbitrario de texto a mayúsculas o minúsculas. :kbd:`Alt`-:kbd:`l` (``M-l``) Convierte la siguiente palabra a minúsculas (``downcase-word``). :kbd:`Alt`-:kbd:`u` (``M-u``) Convierte la siguiente palabra a mayúsculas (``upcase-word``). :kbd:`Alt`-:kbd:`c` (``M-c``) Pone en mayúsculas la palabra siguiente (``capitalize-word``). :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`l` (``C-x C-l``) Convierte la región a minúsculas (``downcase-region``). :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`u` (``C-x C-u``) Convertir región a mayúsculas (``upcase-region``). ``M-l`` (``downcase-word``) convierte la palabra que sigue al punto en minúscula, pasando por delante de él. Así, repitiendo ``M-l`` se convierten palabras sucesivas. ``M-u`` (``upcase-word``) convierte a mayúsculas, mientras que ``M-c`` (``capitalize-word``) pone la primera letra de la palabra en mayúsculas y el resto en minúsculas. Todos estos comandos convierten varias palabras a la vez si se les da un argumento. Son especialmente convenientes para convertir una gran cantidad de texto de mayúsculas a minúsculas, porque puede moverse por el texto usando ``M-l``, ``M-u`` o ``M-c`` en cada palabra según convenga, usando ocasionalmente ``M-f`` para saltarse una palabra. Cuando se le da un argumento negativo, los comandos de conversión de mayúsculas y minúsculas se aplican al número apropiado de palabras antes del punto, pero no mueven el punto. Esto resulta práctico cuando se acaba de escribir una palabra en mayúsculas y minúsculas incorrectas: se puede dar la orden de conversión de mayúsculas y minúsculas y continuar escribiendo. Si se da una orden de conversión de mayúsculas y minúsculas en medio de una palabra, sólo se aplica a la parte de la palabra que sigue al punto. (Esto es comparable a lo que hace ``M-d`` (``kill-word``)). Con un argumento negativo, la conversión de mayúsculas y minúsculas se aplica sólo a la parte de la palabra anterior al punto. Los otros comandos de conversión de mayúsculas y minúsculas son ``C-x C-u`` (``upcase-region``) y ``C-x C-l`` (``downcase-region``), que convierten todo lo que hay entre punto y marca a la mayúscula o minúscula especificada. El punto y la marca no se mueven. Los comandos de conversión de casos de región ``upcase-region`` y ``downcase-region`` normalmente están desactivados. Esto significa que piden confirmación si intenta usarlos. Cuando confirme, puede activar el comando, lo que significa que no volverá a pedir confirmación. Consulte :ref:`50.3.11`. .. _26.8: 26.8 Modo Texto --------------- El modo Texto es un modo para editar archivos de texto en lenguaje humano. Los archivos cuyos nombres terminan en la extensión ``.txt`` suelen abrirse en modo Texto (véase :ref:`24.3`). Para cambiar explícitamente al modo Texto, escriba :kbd:`Alt`-:kbd:`x` ``text-mode`` (``M-x text-mode``). En modo Texto, sólo las líneas en blanco y los delimitadores de página separan los párrafos. Como resultado, los párrafos pueden tener sangría, y el relleno adaptativo determina qué sangría usar al rellenar un párrafo. Véase :ref:`26.6.4`. En el modo Texto, el comando ``TAB`` (``indent-for-tab-command``, indentar por tabulación) suele insertar espacios en blanco hasta la siguiente tabulación, en lugar de sangrar la línea actual. Véase :ref:`25`, para más detalles. El modo Texto desactiva las funciones relacionadas con los comentarios, excepto cuando las invoca explícitamente. Cambie la tabla sintáctica para que los apóstrofes se consideren parte de las palabras (por ejemplo, "no" se considera una palabra). Sin embargo, si una palabra empieza por un apóstrofo, se trata como un prefijo a efectos de mayúsculas (por ejemplo, ``M-c`` convierte ``'hola'`` en ``'Hola'``, como es de esperar). Si indenta las primeras líneas de los párrafos, debe usar el modo Texto con sangría de párrafo (``M-x paragraph-indent-text-mode``) en lugar del modo Texto. En este modo, no es necesario que haya líneas en blanco entre párrafos, ya que la sangría de la primera línea es suficiente para iniciar un párrafo; sin embargo, los párrafos en los que cada línea está sangrada no son compatibles. Use ``M-x paragraph-indent-minor-mode`` para habilitar un modo menor equivalente para situaciones en las que no debería cambiar el modo mayor-en la composición de correo, por ejemplo. El modo texto (Texto mode) vincula ``M-TAB`` a ``ispell-complete-word``. Este comando realiza la terminación de la palabra parcial en el búfer antes del punto, usando el diccionario ortográfico como espacio de palabras posibles. Véase :ref:`17.4`. Si su gestor de ventanas define ``M-TAB`` para cambiar de ventana, puede escribir :kbd:`ESC` (``ESC``) :kbd:`TAB` (``TAB``) o :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`i` (``C-M-i``) en su lugar. Al entrar en el modo Texto se ejecuta el gancho de modo ``text-mode-hook`` (véase :ref:`24.1`). Las siguientes secciones describen varios modos principales derivados del modo Texto. Estos derivados comparten la mayoría de las características del modo Texto descritas anteriormente. En particular, los derivados del modo Texto ejecutan ``text-mode-hook`` antes de ejecutar sus propios ganchos de modo. .. _26.9: 26.9 Modo Esquema (mode Outilne) -------------------------------- El modo Esquema (Outilne mode) es un modo principal derivado del modo Texto (mode Text), que está especializado en la edición de esquemas. Proporciona comandos para navegar entre las entradas de la estructura del esquema, y comandos para hacer temporalmente invisibles partes de un búfer, de forma que la estructura del esquema pueda verse más fácilmente. Escriba ``M-x outline-mode`` para cambiar al modo Outline. Al entrar en modo Esquema se ejecuta el gancho ``text-mode-hook`` seguido del gancho ``outline-mode-hook`` (ver :ref:`50.2.2`). Cuando usa un comando del modo Esquema para hacer invisible una línea (ver :ref:`26.9.4`), la línea desaparece de la pantalla. Se muestra una elipsis (tres puntos seguidos) al final de la línea visible anterior, para indicar el texto oculto. Varias líneas invisibles consecutivas producen una sola elipsis. Los comandos de edición que operan sobre líneas, como ``C-n`` y ``C-p``, tratan el texto de la línea invisible como parte de la línea visible anterior. Matar la elipsis al final de una línea visible realmente mata todo el texto invisible siguiente asociado con la elipsis. 26.9.1 Modo Menor Esquema ````````````````````````` El modo Outline minor (modo menor Esquema) es un modo menor local del búfer que proporciona los mismos comandos que el modo mayor, Outline mode (modo Esquema), pero puede usarse junto con otros modos mayores. Puede usar ``M-x outline-minor-mode`` para activar el modo Outline minor en el búfer actual, o usar una variable local de archivo para activarlo en un archivo específico (ver :ref:`50.2.4`). El modo mayor, Outline mode, proporciona atajos de teclado especiales en el prefijo ``C-c``. El modo menor Outline, ofrece funciones similares con ``C-c @`` como prefijo; esto es para reducir los conflictos con los comandos especiales del modo mayor. (La variable ``outline-minor-mode-prefix`` controla el prefijo usado). Si ``outline-minor-mode-use-buttons`` es distinto de cero, Outline minor mode usará botones al principio de las líneas de encabezamiento, además de elipsis, para mostrar que una sección está oculta. Al hacer clic con el ratón en el botón, se activa la visualización de la sección. Si el valor de esta variable es ``insert`` (insertar), los botones se insertan directamente en el texto del búfer, por lo que ``RET`` sobre el botón también alternará la visualización de la sección, como lo hace un clic del ratón. Si el valor es ``in-margins`` (en márgenes), el modo Outline minor usará los márgenes de la ventana para indicar que una sección está oculta. Los botones se pueden personalizar como iconos (véase :ref:`15.11`). Si la opción de usuario ``outline-minor-mode-cycle`` no es nula, las teclas :kbd:`TAB` (``TAB``) y :kbd:`Shift`-:kbd:`TAB` (``S-TAB``) que ciclan la visibilidad están habilitadas en las líneas de encabezado del esquema (ver ``outline-cycle`` en :ref:`26.9.4`). ``TAB`` permite ocultar, mostrar el subtítulo y mostrar todo para la sección actual. ``S-TAB`` hace lo mismo para todo el búfer. .. _26.9.2: 26.9.2 Formato de los Esquemas `````````````````````````````` El modo Esquema supone que las líneas del búfer son de dos tipos: *líneas de encabezado* (heading lines) y *líneas de cuerpo* (body lines). Una línea de encabezado representa un tema en el esquema. Estas líneas comienzan con uno o más asteriscos (``*``); el número de asteriscos determina la profundidad del encabezado en la estructura del esquema. Así, una línea de este tipo con un ``*`` es un tema principal; todas las líneas de encabezado con dos ``*`` entre ella y el siguiente encabezado con un ``*`` son sus subtemas; y así sucesivamente. Cualquier línea que no sea de encabezado es una línea de cuerpo. Las líneas de cuerpo pertenecen a la línea de título precedente. He aquí un ejemplo: :: * Alimentos Este es el cuerpo lo que dice algo sobre el tema de la comida. ** Comida deliciosa Este es el cuerpo del encabezado de segundo nivel. ** Comida desagradable También podría tener un cuerpo también, con varias líneas. *** Comida Dormitorio * Albergue Otro tema de primer nivel con su línea de encabezado. Una línea de encabezado junto con todas las líneas de cuerpo siguientes en su conjunto, se denomina una *entrada*. Una línea de encabezado junto con todas las líneas de encabezado siguientes más profundas y sus líneas de cuerpo se denomina *subárbol*. Puede personalizar el criterio para distinguir las líneas de encabezado configurando la variable ``outline-regexp``. (Las formas recomendadas de hacerlo son en una función de modo principal o con una variable local de archivo). Cualquier línea cuyo comienzo tenga una coincidencia con esta expreg (expresión regular) se considera una línea de encabezado. Las coincidencias que comienzan dentro de una línea (no en el margen izquierdo) no cuentan. La longitud del texto coincidente determina el nivel del encabezado; las coincidencias más largas forman un nivel anidado más profundo. Así, por ejemplo, si un formateador de texto tiene los comandos ``@chapter`` (@capítulo), ``@section`` (@sección) y ``@subsection`` (@subsección) para dividir el documento en capítulos y secciones, podría hacer que esas líneas contaran como líneas de encabezado estableciendo ``outline-regexp`` como ``"@cap\|@\(sub\\)*section"``. Fíjese en el truco: las dos palabras ``chapter`` (capítulo) y ``section`` (sección) son igual de largas, pero al definir la expreg para que coincida sólo con ``chap`` nos aseguramos de que la longitud del texto coincidente en un encabezado de capítulo es más corta, de modo que el modo Esquema sabrá que las secciones están contenidas en capítulos. Esto funciona siempre que ningún otro comando empiece por ``@chap``. Puede especificar explícitamente una regla para calcular el nivel de una línea de encabezado estableciendo la variable ``outline-level``. El valor de ``outline-level`` debe ser una función que no reciba argumentos y devuelva el nivel del encabezado actual. Las formas recomendadas de establecer esta variable son en un comando de modo principal o con una variable local de archivo. .. _26.9.3: 26.9.3 Comandos de Movimiento en el Modo Esquema ```````````````````````````````````````````````` El modo Esquema (Outilne mode) proporciona comandos de movimiento especiales que se mueven hacia adelante y hacia atrás en las líneas de encabezado. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`n` (``C-c C-n``) Mueve el punto a la siguiente línea de encabezado visible (``outline-next-visible-heading``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`p` (``C-c C-p``) Mueve el punto a la línea de encabezado visible anterior (``outline-previous-visible-heading``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`f` (``C-c C-f``) Mueve el punto a la siguiente línea de título visible en el mismo nivel en el que se encuentra el punto (``outline-forward-same-level``). :kbd:`Ctrlf`-:kbd:`c` :kbd:`Ctrl`-:kbd:`b` (``C-c C-b``) Mueve el punto a la línea de título visible anterior en el mismo nivel (``outline-backward-same-level``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`u` (``C-c C-u``) Mueve el punto hacia arriba a una línea de encabezado visible de nivel inferior (más inclusivo) (``outline-up-heading``). Todos los comandos anteriores aceptan argumentos numéricos como cuentas de repetición. Por ejemplo, ``C-c C-f``, cuando se le da un argumento, avanza tantas líneas de encabezado visibles en el mismo nivel, y ``C-c C-u`` con un argumento sale de tantos niveles anidados. .. _26.9.4: 26.9.4 Comandos de Visibilidad del Modo Esquema ``````````````````````````````````````````````` El modo Esquema proporciona varios comandos para ocultar o revelar temporalmente partes del búfer, basándose en la estructura del esquema. Estos comandos no se pueden deshacer; sus efectos simplemente no son registrados por el mecanismo de deshacer, por lo que se puede deshacer justo después de ejecutarlos (véase :ref:`17.1`). Muchos de estos comandos actúan sobre la línea de rumbo actual. Si el punto está en una línea de encabezado, esa es la línea de encabezado actual; si el punto está en una línea de cuerpo, la línea de encabezado actual es la línea de encabezado precedente más cercana. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`c` (``C-c C-c``) Hace invisible el cuerpo de la línea de encabezado actual (``outline-hide-entry``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`e` (``C-c C-e``) Hace visible el cuerpo de la línea de encabezado actual (``outline-show-entry``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`d` (``C-c C-d``) Hace invisible todo lo que está bajo el encabezado actual, sin incluir el propio encabezado (``outline-hide-subtree``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`s` (``C-c C-s``) Hace visible todo lo que está bajo el encabezado actual, incluyendo el cuerpo, los subencabezados y sus cuerpos (``outline-show-subtree``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`l` (``C-c C-l``) Hace invisible el cuerpo de la línea de encabezado actual y de todos sus subencabezados (``outline-hide-leaves``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`k` (``C-c C-k``) Hace visibles todos los subtítulos de la línea de encabezado actual, en todos los niveles (``outline-show-branches``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`i` (``C-c C-i``) Hace visibles los subtítulos inmediatos (un nivel por debajo) de la línea de encabezado actual (``outline-show-children``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`t` (``C-c C-t``) Hace invisibles todas las líneas del cuerpo del búfer (``outline-hide-body``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`a` (``C-c C-a``) Hace invisibles a todas las líneas del búfer (``outline-show-all``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`q` (``C-c C-q``) Oculta todo excepto los *n* niveles superiores de las líneas de encabezado (``outline-hide-sublevels``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`o` (``C-c C-o``) Oculta todo excepto el encabezado o cuerpo en el que está ese punto, más los encabezados que van desde ahí hasta el nivel superior del esquema (``outline-hide-other``). Los comandos más sencillos son ``C-c C-c`` (``outline-hide-entry``), que oculta las líneas del cuerpo que siguen directamente a la línea del encabezado actual, y ``C-c C-e`` (``outline-show-entry`` ), que las revela. Los subtítulos y sus cuerpos no se ven afectados. Los comandos ``C-c C-d`` (``outline-hide-subtree``) y ``C-c C-s`` (``outline-show-subtree``) son más potentes. Se aplican al subárbol de la línea de encabezado actual: su cuerpo, todos sus subencabezados y todos sus cuerpos tanto directos como indirectos,. El comando ``C-c C-l`` (``outline-hide-leaves``) oculta el cuerpo de la línea de encabezado actual, así como todos los cuerpos de su subárbol; los propios subencabezados quedan visibles. El comando ``C-c C-k`` (``outline-show-branches``) revela los subencabezados, si previamente habían sido ocultados (por ejemplo, por ``C-c C-d``). El comando ``C-c C-i`` (``outline-show-children``) es una versión más ligera; sólo muestra los subtítulos directos, es decir, los que están un nivel por debajo. El comando ``C-c C-o`` (``outline-hide-other``) oculta todo excepto la entrada en la que está ese punto, además de sus padres (los encabezados que suben desde ahí hasta el nivel superior en el esquema) y los encabezados de nivel superior. También revela las líneas del cuerpo que preceden al primer encabezado del búfer. Los demás comandos afectan a todo el búfer. ``C-c C-t`` (``outline-hide-body``) hace invisibles todas las líneas del cuerpo, de forma que sólo se ve la estructura del contorno (como excepción especial, no ocultará las líneas de la parte superior del archivo, que preceden a la primera línea del encabezado, aunque técnicamente sean líneas del cuerpo). ``C-c C-a`` (``outline-show-all``) hace visibles todas las líneas. ``C-c C-q`` (``outline-hide-sublevels``) oculta todos los encabezados excepto los de nivel superior en y por encima del nivel de la línea de encabezado actual (por defecto a 1 si el punto no está en un encabezado); con un argumento numérico *n*, oculta todo excepto los *n* niveles superiores de líneas de encabezado. Tenga en cuenta que revela completamente los *n* niveles superiores y las líneas del cuerpo antes del primer encabezado. El modo Esquema (Outline Mode) también proporciona dos comandos para cambiar la visibilidad de cada sección y de todo el búfer. Si escribe :kbd:`TAB` (``TAB``) (``outline-cycle``) en un encabezado, la sección actual se mueve entre los estados "hide all" (ocultar todo), "subheadings" (subencabezados) y "show all" (mostrar todo). Si teclea :kbd:`Shift`-:kbd:`TAB` (``S-TAB``, ``outline-cycle-buffer``), el búfer completo se mueve entre los estados "only top-level headings" (sólo los títulos de nivel superior), "all headings and subheadings" (todos los títulos y subtítulos) y "show all" (mostrar todo). Cuando la búsqueda incremental encuentra texto oculto por el modo Esquema, hace visible esa parte del búfer. Si sale de la búsqueda en esa posición, el texto permanece visible. Para cambiar si una búsqueda incremental activa puede coincidir o no con texto oculto, escriba :kbd:`Alt`-:kbd:`s` :kbd:`i` (``M-s i``). Para cambiar el valor predeterminado para futuras búsquedas, personalice la opción ``search-invisible``. (Esta opción también afecta al modo en que las funciones ``query-replace`` (funciones de consulta-reemplazo) y otras relacionadas tratan el texto oculto; véase :ref:`16.10.4`). También puede hacer visible automáticamente el texto a medida que navega por él usando el modo Mostrar (``M-x reveal-mode``), un modo menor del búfer local. La variable ``outline-default-state`` controla qué encabezados serán visibles después de activar el modo Outline. Si no es nula, algunos 3'encabezados se muestran inicialmente. Si es igual a un número, sólo se muestran los encabezados hasta el nivel correspondiente. Si es igual a ``outline-show-all``, se muestra todo el texto del búfer. Si es igual a ``outline-show-only-headings``, sólo se muestran los encabezados, sea cual sea su nivel. Si es igual a una función lambda o a un nombre de función, se espera que esta función conmute la visibilidad de los encabezados, y será llamada sin argumentos una vez activado el modo. .. _26.9.5: 26.9.5 Visualización de un Esquema en Varias Vistas ``````````````````````````````````````````````````` Puede visualizar dos vistas de un mismo esquema al mismo tiempo, en ventanas diferentes. Para ello, puede crear un búfer indirecto utilizando ``M-x make-indirect-buffer``. El primer argumento de este comando es el nombre del búfer de contorno existente, y su segundo argumento es el nombre a usar para el nuevo búfer indirecto. Véase :ref:`20.6`. Una vez que el búfer indirecto existe, puedes mostrarlo en una ventana de forma normal, con ``C-x 4 b u`` u otros comandos de Emacs. Los comandos del modo Esquema para mostrar y ocultar partes del texto operan en cada búfer independientemente; como resultado, cada búfer puede tener su propia vista. Si desea más de dos vistas en el mismo esquema, puede crear búferes indirectos adicionales. .. _26.9.6: 26.9.6 Edición de Plegado ````````````````````````` El paquete para Plegado (Foldout) amplía el modo Esquema (Outline) y el modo Esquema menor (Outline minor) con comandos de plegado. La idea del plegado es que amplíe una porción anidada del esquema, mientras oculta a sus padres en niveles superiores. Considere un búfer en modo Esquema con todo el texto y los subtítulos ocultos bajo los encabezados de nivel 1. Para ver lo que está oculto bajo uno de estos encabezados, puede usar ``C-c C-e`` (``M-x outline-show-entry``) para exponer el cuerpo, o ``C-c C-i`` para exponer los encabezados hijos (nivel-2). Con Foldout, se usa ``C-c C-z`` (``M-x foldout-zoom-subtree``). Esto expone el cuerpo y los subtítulos secundarios, y reduce el búfer de modo que sólo sean visibles el encabezado de nivel 1, el cuerpo y los encabezados de nivel 2. Ahora, para mirar debajo de uno de los encabezados de nivel 2, sitúe el cursor sobre él y utilice ``C-c C-z`` (``M-x foldout-zoom-subtree``). Ahora, para mirar debajo de uno de los títulos de nivel 2, sitúe el cursor sobre él y use ``C-c C-z`` de nuevo. De este modo, se mostrarán el cuerpo del nivel 2 y sus subtítulos secundarios de nivel 3, y el búfer se reducirá de nuevo. Se puede hacer tanto zoom en los sucesivos subtítulos como se desee. Una cadena en la línea de modo muestra la profundidad alcanzada. Cuando se amplía un título, para ver sólo los subtítulos secundarios, especifique un argumento numérico: ``C-u C-c C-z``. También se puede especificar el número de niveles de subtítulos secundarios (compare ``M-x outline-show-children``), por ejemplo, :kbd:`Alt`-:kbd:`2` :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`z` (``M-2 C-c C-z``) muestra dos niveles de subtítulos secundarios. Alternativamente, el cuerpo puede especificarse con un argumento negativo: :kbd:`Alt`-:kbd:`-` :kbd:`Ctrl`-:kbd:`c`-:kbd:`Ctrl`-:kbd:`z` (``M-- C-c C-z``). El subárbol completo puede expandirse, de forma similar a ``C-c C-s`` (``M-x outline-show-subtree``), especificando un argumento cero: :kbd:`Alt`-:kbd:`0` :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`z` (``M-0 C-c C-z``). Mientras esté ampliado, puede seguir usando las funciones de exposición y ocultamiento del modo Outline sin molestar a Foldout. Además, como el búfer está reducido, las acciones de edición global sólo afectarán al texto situado bajo el encabezado ampliado. Esto resulta útil para restringir los cambios a un capítulo o sección concretos del documento. Para salir de un pliegue, use ``C-c C-x`` (``M-x foldout-exit-fold``). Esto oculta todo el texto y los subtítulos bajo el título de nivel superior y le devuelve a la vista anterior del búfer. Especificando un argumento numérico se sale de ese número de niveles de pliegues. Si se especifica un argumento cero, se sale de todos los pliegues. Para cancelar el estrechamiento de un pliegue sin ocultar el texto y los subtítulos, especifique un argumento negativo. Por ejemplo, :kbd:`Alt`-:kbd:`-`:kbd:`2` :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`x` ``M--2 C-c C-x`` sale de dos pliegues y deja expuestos el texto y los subtítulos. El modo Plegado (Foldout mode) también proporciona comandos de ratón para entrar y salir de los pliegues, y para mostrar y ocultar texto: :kbd:`Ctrl`-``ratón-1`` (``C``-``ratón-1``) **hace zoom sobre el título pulsado** * un clic: muestra el cuerpo. * doble clic: muestra los subtítulos. * triple clic: muestra el cuerpo y los subtítulos. * cuádruple clic: muestra todo el subárbol. :kbd:`Ctrl`-``ratón-2`` (``C``-``ratón-2``) **expone el texto bajo el título sobre el que se ha hecho clic** * un clic: muestra el cuerpo. * doble clic: muestra los subtítulos. * triple clic: muestra el cuerpo y los subtítulos. * cuádruple clic: muestra todo el subárbol. :kbd:`Ctrl`-``ratón-3 (``C``-``ratón-3``) **oculta el texto bajo el encabezado sobre el que se ha hecho clic o sale del pliegue** * un clic: oculta el subárbol. * doble clic: salir del pliegue y ocultar el texto. * triple clic: salir del pliegue sin ocultar el texto. * cuádruple clic: salir de todos los pliegues y ocultar el texto. Puede especificar diferentes teclas modificadoras (en lugar de :kbd:`Ctrl`- :kbd:`Alt`- ``Ctrl-`` ``Meta-``) configurando ``foldout-mouse-modifiers``; pero si ya ha cargado la biblioteca ``foldout.el``, debe volver a cargarla para que esto surta efecto. Para usar el paquete Foldout, puede escribir :kbd:`Alt`-:kbd:`x` ``load-library`` :kbd:`RETURN` ``foldout`` :kbd:`RETURN` (``M-x load-library RET foldout RET``); o puede hacer que lo haga automáticamente poniendo lo siguiente en su archivo init: :: (with-eval-after-load "outline" (require 'foldout)) .. _26.10: 26.10. Modo Org (Org Mode) -------------------------- El modo Org es una variante del modo Outline para usar Emacs como organizador y/o sistema de composición. Los archivos cuyos nombres terminan en la extensión ``.org`` se abren en modo Org (ver :ref:`24.3`). Para cambiar explícitamente a Org mode, teclee :kbd:`Alt`-:kbd:`x` ``org-mode`` (``M-x org-mode``). En Org mode, como en Outline mode, cada entrada tiene una línea de encabezado que comienza con uno o más caracteres ``*``. Véase :ref:`26.9.2`. Además, cualquier línea que comience con el caracter ``#`` se trata como un comentario. Org mode proporciona comandos para ver y manipular fácilmente la estructura del esquema. El más sencillo de estos comandos es ``TAB`` (``org-cycle``). Si se invoca en una línea de encabezado, hace un ciclo a traves de los diferentes estados de visibilidad del subarbol: (i) mostrando solo esa línea de encabezado, (ii) mostrando solo la línea de encabezado y las líneas de encabezado de sus hijos directos, si los hay, y (iii) mostrando el subarbol entero. Si se invoca en una línea del cuerpo, se ejecuta el enlace global para ``TAB``. Tecleando :kbd:`Shift`-:kbd:`TAB` (``S-TAB``, ``org-shifttab``) en cualquier parte de un búfer Org mode cicla la visibilidad de toda la estructura del esquema, entre las siguientes opciones: (i) mostrando solo las lineas de encabezado de nivel superior, (ii) mostrando todas las lineas de encabezado pero no las de cuerpo, y (iii) mostrando todo. Puede mover una entrada entera arriba o abajo en el búfer, incluyendo sus líneas de cuerpo y subárbol (si lo hay), tecleando :kbd:`Alt`-:kbd:`↑` (``M-UP``, ``org-metaup``) o :kbd:`Alt`-:kbd:`↓` (``M-DOWN``, ``org-metadown``) en la línea de encabezado. Del mismo modo, puede promover o degradar una línea de encabezado con :kbd:`Alt`-:kbd:`←` (``M-LEFT``, ``org-metaleft``) y :kbd:`Alt`-:kbd:`→` (``M-RIGHT``, ``org-metaright``). Estos comandos ejecutan sus enlaces globales si se invocan en una línea de cuerpo. Las siguientes subsecciones dan instrucciones básicas para usar Org mode como organizador y como sistema de composición. Para detalles, ver **Introducción** en El Manual Org. 26.10.1 Org como Organizador ```````````````````````````` Puede etiquetar una entrada Org como un ítem *TODO* (HACER) tecleando :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`t` (``C-c C-t``, ``org-todo``) en cualquier parte de la entrada. Esto añade la palabra clave ``TODO`` a la línea de encabezado. Escribir :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`t` (``C-c C-t``) de nuevo cambia la palabra clave a ``DONE`` (HECHO); otro :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`t` (``C-c C-t``) elimina la palabra clave completamente, y así. Puede personalizar las palabras clave usadas por ``C-c C-t`` mediante la variable ``org-todo-keywords``. Aparte de marcar una entrada como TODO, puede adjuntarle una fecha, tecleando :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`s` (``C-c C-s``, ``org-schedule``) en la entrada. Esto pide una fecha haciendo aparecer el Calendario Emacs (ver :ref:`32`), y luego añade la etiqueta ``SCHEDULED`` (PROGRAMADO o AGENDADO), junto con la fecha seleccionada, bajo la línea de encabezado. El comando ``C-c C-d`` (``org-deadline``) tiene el mismo efecto, excepto que usa la etiqueta ``DEADLINE`` (FECHA LíMITE). Una vez que tenga algunos items TODO planificados en un archivo Org, puede añadir ese archivo a la lista de archivos de agenda tecleando :kbd:`Ctrl`-:kbd:`c` :kbd:`[` (``C-c [``, ``org-agenda-file-to-front``). Org mode esta disenado para permitirte mantener facilmente multiples *archivos de agenda*, por ejemplo, para organizar diferentes aspectos de su vida. La lista de archivos de agenda se almacena en la variable ``org-agenda-files``. Para ver los elementos de sus archivos de agenda, escriba :kbd:`Alt`-:kbd:`x` ``org-agenda`` (``M-x org-agenda``). Este comando pregunta por lo que quiere ver: una lista de cosas por hacer esta semana, una lista de items TODO con palabras clave especificas, etc. Ver **Vistas de Agenda** en El Manual de Org, para mas detalles. 26.10.2 Org como Sistema de Composición ``````````````````````````````````````` Puede que quiera dar un buen formato a sus notas Org y prepararlas para su exportación y publicación. Para exportar el búfer actual, teclee :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`e` (``C-c C-e``, ``org-export-dispatch``) en cualquier parte de un búfer Org. Este comando pide un formato de exportación; los formatos actualmente soportados incluyen HTML, LaTeX, Texinfo, OpenDocument (.odt), iCalendar, Markdown, man-page, y PDF. Algunos formatos, como PDF, requieren la instalación de determinadas herramientas del sistema. Para exportar varios archivos a la vez a un directorio específico, ya sea localmente o a través de la red, debe definir una lista de proyectos mediante la variable ``org-publish-project-alist``. Consulte su documentación para más detalles. Org soporta un esquema de marcado simple para aplicar formato de texto a los documentos exportados: :: - Este texto está /enfatizado/ - Este texto está *en negrita*. - Este texto está _subrayado_ - Este texto usa =un tipo de letra teletipo= #+begin_quote ``Esto es una cita''. #+end_quote #+begin_example Esto es un ejemplo. #+end_example Para más detalles, **Exportando** en Manual Org, y **Publicando** en En el Manual de Org. .. _26.11: 26.11 Modo TeX -------------- TeX es un potente formateador de texto escrito por Donald Knuth; al igual que GNU Emacs, es software libre. El formato TeX tiene varias variantes, incluyendo LaTeX, un formato de entrada simplificado para TeX; DocTeX, un formato de archivo especial en el que se escriben las fuentes LaTeX, combinando fuentes con documentación; y SliTeX, una forma especial obsoleta de LaTeX [13]_. Emacs proporciona un modo principal TeX para cada una de estas variantes: Modo TeX Plano, Modo LaTeX, Modo DocTeX y Modo SliTeX. Emacs selecciona el modo apropiado mirando el contenido del búfer. (Esto se hace invocando el comando tex-mode, que normalmente se invoca automáticamente cuando visita un archivo de tipo TeX. Véase :ref:`24.3`). Si el contenido es insuficiente para determinarlo, Emacs elige el modo especificado por la variable ``tex-default-mode``; su valor por defecto es ``latex-mode``. Si Emacs no adivina correctamente, puede seleccionar la variante correcta del modo TeX usando los comandos ``plain-tex-mode``, ``latex-mode``, ``slitex-mode``, o ``doctex-mode``. Las siguientes secciones documentan las características del modo TeX y sus variantes. Existen otros paquetes Emacs relacionados con TeX, que no se documentan en este manual: * El modo BibTeX es un modo principal para archivos BibTeX, que se usan habitualmente para guardar referencias bibliográficas de documentos LaTeX. Para más información, consulte la cadena de documentación del comando ``bibtex-mode``. * El paquete RefTeX proporciona un modo menor que puede usarse con el modo LaTeX para gestionar referencias bibliográficas. Para más información, consulte el manual RefTeX Info, que se distribuye con Emacs. * El paquete AUCTeX proporciona características más avanzadas para editar TeX y sus formatos relacionados, incluyendo la capacidad de previsualizar ecuaciones TeX dentro de los búferes de Emacs. A diferencia del modo BibTeX y del paquete RefTeX, AUCTeX no se distribuye con Emacs por defecto. Puede descargarse a través del menú de paquetes (véase :ref:`49`); una vez instalado, consulte el manual de AUCTeX, que se incluye con el paquete. .. [13] Ha sido reemplazado por la clase de documento ``slides`` (diapositivas), que viene con látex. 26.11.1 Comandos de edición TeX ``````````````````````````````` :kbd:`"` (``"``) Inserta, según el contexto, o bien `````` o ``"`` o ``''`` (``tex-insert-quote``). :kbd:`Ctrl`-:kbd:`j` (``C-j``) Inserta un salto de párrafo (dos nuevas líneas) y compruebe que el párrafo anterior no contenga llaves o signos de dólar desequilibrados (``tex-terminate-paragraph``). :kbd:`Alt`-:kbd:`x` ``tex-validate-region`` (``M-x tex-validate-region``) Comprueba cada párrafo de la región para ver si hay corchetes o signos de dólar desajustados. :kbd:`Ctrl`-:kbd:`c` :kbd:`{` (``C-c {``) Inserta ``{}`` y posiciona el punto entre ellos (``tex-insert-braces``). :kbd:`Ctrl`-:kbd:`c` :kbd:`}` (``C-c }``) Avanza hasta el siguiente corchete cerrado no emparejado (``up-list``, lista ascendente). En TeX, normalmente no se usa el carácter ``"``; en su lugar, las comillas empiezan con `````` y terminan con ``''``. Por lo tanto, el modo TeX vincula la tecla :kbd:`"` al comando ``tex-insert-quote``. Esto inserta `````` después de un espacio en blanco o una llave abierta, ``"`` después de una barra invertida y ``''`` después de cualquier otro carácter. Como excepción especial, si teclea :kbd:`"` cuando el texto anterior al punto es `````` o ``''``, Emacs sustituye el texto anterior por un único carácter ``"``. Por lo tanto, puede escribir ``""`` para insertar ``"``, si alguna vez lo necesita. (También puede usar ``C-q "`` para insertar este carácter). En el modo TeX, ``$`` tiene un código sintáctico especial que intenta comprender la forma en que coinciden los delimitadores del modo matemático de TeX. Cuando se inserta un ``$`` para salir del modo matemático, se muestra durante un segundo la posición del ``$`` coincidente que entró en el modo matemático. Esta es la misma función que muestra la llave abierta que coincide con una llave cerrada que se inserta. Sin embargo, no hay forma de saber si un ``$`` entra en modo matemático o sale de él; así que cuando se inserta un ``$`` que entra en modo matemático, la posición del ``$`` anterior se muestra como si coincidiera, aunque en realidad no estén relacionados. TeX usa las llaves como delimitadores que deben coincidir. Algunos Usuarios prefieren mantener las llaves compensadas en todo momento, en lugar de insertarlas individualmente. Use ``C-c {`` (``tex-insert-braces``) para insertar un par de llaves. Deje un punto entre las dos llaves para que pueda insertar el texto que pertenece dentro. Después, use el comando ``C-c }`` (``up-list``, lista ascendente) para avanzar más allá de la llave de cierre. También puede invocar ``C-c {`` después de marcar algún texto: entonces el comando encierra el texto marcado entre llaves. Hay dos comandos para comprobar la coincidencia de las llaves. ``C-j`` (``tex-terminate-paragraph``) comprueba el párrafo antes del punto, e inserta dos nuevas líneas para empezar un nuevo párrafo. Si se encuentra algún error, muestra un mensaje en el área de eco. ``M-x tex-validate-region`` comprueba una región, párrafo por párrafo. Los errores se listan en un búfer ``*Occur*``; puede usar los comandos habituales del modo Occur en ese búfer, como ``C-c C-c``, para visitar un error en particular (vea :ref:`16.11`). Tenga en cuenta que los comandos de Emacs cuentan los corchetes y paréntesis en modo TeX, no sólo las llaves. Esto no es estrictamente correcto para comprobar la sintaxis TeX. Sin embargo, es probable que los paréntesis y corchetes se usen en el texto como delimitadores de coincidencias, y es útil para los diversos comandos de movimiento y visualización automática de coincidencias trabajar con ellos. 26.11.2 Comandos de Edición LaTeX ````````````````````````````````` El modo LaTeX proporciona algunas características extra no aplicables al TeX plano: :kbd:`Ctrl`-:kbd:`c` :Kbd:`Ctrl`-:kbd:`o` (``C-c C-o``) Inserta ``\begin`` y ``\end`` para el bloque LaTeX y posiciona el punto en una línea entre ellos (``latex-insert-block``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`e` (``C-c C-e``) Cierra el bloque LaTeX más interno aún no cerrado (``latex-close-block``). En la entrada LaTeX, las etiquetas ``\begin`` (comienzo) y ``\end`` (final) se usan para agrupar bloques de texto. Para insertar un bloque, escriba ``C-c C-o`` (``latex-insert-block``). Esto solicita un tipo de bloque, e inserta las etiquetas ``\begin`` y ``\end`` apropiadas, dejando una línea en blanco entre las dos y moviendo el punto allí. Cuando introduzca el argumento de tipo de bloque en ``C-c C-o``, puede usar los comandos de completado habituales (vea :ref:`9.4`). La lista de finalización (o completado) por defecto contiene los tipos de bloque estándar de LaTeX. Si desea tipos de bloque adicionales para completar, personalice la variable de lista ``latex-block-names``. En la entrada LaTeX, las etiquetas ``\begin`` y ``\end`` deben estar en equilibrio. Puede usar ``C-c C-e`` (``latex-close-block``) para insertar una etiqueta ``\end`` que coincida con la última ``\begin`` no emparejada. También aplica sangría al ``\end`` para que coincida con el correspondiente ``\begin``, e inserta una nueva línea después de la etiqueta ``\end`` si el punto está al principio de una línea. El modo menor ``latex-electric-env-pair-mode`` inserta automáticamente una etiqueta ``\end`` o ``\begin`` por Usted cuando escribe la correspondiente. 26.11.3. Comandos de Impresión TeX `````````````````````````````````` Puede invocar TeX como un subproceso de Emacs, suministrando todo el contenido del búfer o sólo parte de él (por ejemplo, un capítulo de un documento más extenso). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`b` (``C-c C-b``) Invoca TeX en todo el búfer actual (``tex-buffer``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`r` (``C-c C-r``) Invoca TeX en la región actual, junto con la cabecera del búfer (``tex-region``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`f` (``C-c C-f``) Invoca TeX en el archivo actual (``tex-file``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`v` (``C-c C-v``) Previsualiza la salida del último comando ``C-c C-b``, ``C-c C-r`` o ``C-c C-f`` (``tex-view``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`p` (``C-c C-p``) Imprime la salida del último comando ``C-c C-b``, ``C-c C-r`` o ``C-c C-f`` (``tex-print``). :kbd:`Ctrl`-:kbd:`c` :kbd:`TAB` (``C-c TAB``) Invoca BibTeX en el archivo actual (``tex-bibtex-file``). :kbd:`Ctrl`-:kbd:`c` (``C-c C-l``) Vuelva a centrar la ventana que muestra la salida de TeX para que se pueda ver la última línea (``tex-recenter-output-buffer``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`k` (``C-c C-k``) Mata el subproceso TeX (``tex-kill-job``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`c` (``C-c C-c``) Invoca algún otro comando de compilación en todo el búfer actual (``tex-compile``). Para pasar el búfer actual por TeX, escriba :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`b` (``C-c C-b``, ``tex-buffer``). La salida formateada va a un archivo temporal, normalmente un archivo ``.dvi``. Después, puede teclear :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`v` (``C-c C-v``, ``tex-view``) para lanzar un programa externo, como ``xdvi``, para ver este archivo de salida. También puede escribir (``C-c C-p``, ``tex-print``) para imprimir una copia en papel del archivo de salida. Por defecto, ``C-c C-b`` ejecuta TeX en el directorio actual. La salida de TeX también se crea en este directorio. Para ejecutar TeX en un directorio diferente, cambie la variable ``tex-directory`` al directorio deseado. Si su variable de entorno ``TEXINPUTS`` contiene nombres relativos, o si sus archivos contienen comandos ``\input`` con nombres de archivo relativos, entonces ``tex-directory`` *debe* ser ``.`` u obtendrá resultados erróneos. De lo contrario, es seguro especificar algún otro directorio, como ``/tmp``. La variante TeX del búfer determina qué comando del shell ``C-c C-b`` se ejecuta realmente. En modo Plain TeX, se especifica mediante la variable ``tex-run-command``, que por defecto es ``tex``. En modo LaTeX, se especifica mediante ``latex-run-command``, que por defecto es ``latex``. El comando de shell que ``C-c C-v`` ejecuta para ver la salida ``.dvi`` viene determinado por la variable ``tex-dvi-view-command``, independientemente de la variante TeX. El comando de shell que ``C-c C-p`` ejecuta para imprimir la salida está determinado por la variable ``tex-dvi-print-command``. La variable ``tex-print-file-extension`` puede establecerse a la extensión de archivo requerida para ver e imprimir archivos compilados en TeX. Por ejemplo, puede establecerla a ``.pdf``, y actualizar ``tex-dvi-view-command`` y ``tex-dvi-print-command`` en consecuencia, así como ``latex-run-command`` o ``tex-run-command``. Normalmente, Emacs añade automáticamente el nombre del archivo de salida a las cadenas de comandos del shell descritas en el párrafo anterior. Por ejemplo, si ``tex-dvi-view-command`` es ``xdvi``, ``C-c C-v`` ejecuta ``xdvi nombre-archivo-salida``. En algunos casos, sin embargo, el nombre del archivo necesita ser incrustado en el comando, por ejemplo, si Usted necesita proporcionar el nombre del archivo como un argumento a un comando cuya salida es canalizada a otro. Puede especificar dónde colocar el nombre del archivo con ``*`` en la cadena de comandos. Por ejemplo, :: (setq tex-dvi-print-command "dvips -f * | lpr") La salida de terminal de TeX, incluyendo cualquier mensaje de error, aparece en un búfer llamado ``*tex-shell*``. Si TeX obtiene un error, puede cambiar a este búfer y darle entrada (esto funciona como en el modo Shell; vea :ref:`29.2`). Sin cambiar a este búfer puede desplazarlo para que su última línea sea visible tecleando :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`l` (``C-c C-l``). Escriba :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`k` (``C-c C-k``, ``tex-kill-job``) para matar el proceso TeX si ve que su salida ya no es útil. Use ``C-c C-b`` o ``C-c C-r`` también mata cualquier proceso TeX aún en ejecución. También puede pasar una región arbitraria a través de TeX tecleando (``C-c C-r``, ``tex-region``). Sin embargo, esto es complicado, porque la mayoría de los archivos de entrada TeX contienen comandos al principio para establecer parámetros y definir macros, sin los cuales ninguna parte posterior del archivo formateará correctamente. Para resolver este problema, ``C-c C-r`` le permite designar una parte del archivo como conteniendo comandos esenciales; se incluye antes de la región especificada como parte de la entrada a TeX. La parte designada del archivo se denomina *cabecera*. Para indicar los límites de la cabecera en modo TeX plano, inserte dos cadenas especiales en el archivo. Inserte ``%**start header`` (inicio de cabecera) antes de la cabecera y ``%**end of header`` (fin de cabecera) después. Cada cadena debe aparecer enteramente en una línea, pero puede haber otro texto en la línea anterior o posterior. Las líneas que contienen las dos cadenas se incluyen en la cabecera. Si ``%**start header`` no aparece dentro de las 100 primeras líneas del búfer, ``C-c C-r`` asume que no hay cabecera. En modo LaTeX, la cabecera comienza con ``\documentclass`` o ``\documentstyle`` y termina con ``\begin{document}``. Se trata de comandos que LaTeX obliga a usar en cualquier caso, por lo que no es necesario hacer nada especial para identificar la cabecera. Los comandos (``tex-búfer``) y (``tex-región``) hacen todo su trabajo en un directorio temporal, y no tienen disponible ninguno de los archivos auxiliares que necesita TeX para las referencias cruzadas; estos comandos no suelen ser adecuados para ejecutar la copia final en la que todas las referencias cruzadas deben ser correctas. Cuando quiera los archivos auxiliares para referencias cruzadas, use ``C-c C-f`` (``tex-file``) que ejecuta TeX en el archivo del búfer actual, en el directorio de ese archivo. Antes de ejecutar TeX, ofrece guardar cualquier búfer modificado. Generalmente, es necesario usar (``tex-file``) dos veces para que las referencias cruzadas sean correctas. El valor de la variable ``tex-start-options`` especifica opciones para la ejecución de TeX. El valor de la variable ``tex-start-commands`` especifica los comandos TeX para iniciar TeX. El valor por defecto hace que TeX se ejecute en modo sin paradas. Para ejecutar TeX de forma interactiva, ajuste la variable a ``""``. Los documentos TeX de gran tamaño suelen dividirse en varios archivos: un archivo principal, más subarchivos. Ejecutar TeX en un subarchivo normalmente no funciona; tiene que ejecutarlo en el archivo principal. Para que ``tex-file`` sea útil cuando esté editando un subarchivo, puede establecer la variable ``tex-main-file`` con el nombre del archivo principal. Entonces ``tex-file`` ejecuta TeX en ese archivo. La forma más conveniente de usar ``tex-main-file`` es especificarlo en una lista de variables locales en cada uno de los subarchivos. Véase :ref:`50.2.4`. Para archivos LaTeX, puede usar BibTeX para procesar el archivo auxiliar para el archivo del búfer actual. BibTeX busca citas bibliográficas en una base de datos y prepara las referencias citadas para la sección de bibliografía. El comando ``C-c TAB`` (``tex-bibtex-file``) ejecuta el comando del shell (``tex-bibtex-command``) para producir un archivo ``.bbl`` para el archivo del búfer actual. Generalmente, necesita hacer ``C-c C-f`` (``tex-file``) una vez para generar el archivo ``.aux``, luego hacer ``C-c TAB`` (``tex-bibtex-file``), y luego repetir ``C-c C-f`` (``tex-file``) dos veces más para obtener las referencias cruzadas correctas. Para invocar algún otro programa de compilación en el búfer actual de TeX, escriba :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`c` ``C-c C-c`` (``tex-compile``). Este comando sabe cómo pasar argumentos a muchos programas comunes, incluyendo ``pdflatex``, ``yap``, ``xdvi`` y ``dvips``. Puede seleccionar el programa de compilación que desee usando las teclas de finalización estándar (véase :ref:`9.4`). .. _26.11.4: 26.11.4. Miscelánea del Modo TeX ```````````````````````````````` Al entrar en cualquier variante del modo TeX se ejecutan los ganchos ``text-mode-hook`` y ``tex-mode-hook``. Luego ejecuta el gancho ``plsin-tex-mode-hook``, los ganchos ``doctex-mode-hook``, ``latex-mode-hook``, o ``slitex-mode-hook``, según sea apropiado. Al iniciar el intérprete de comandos TeX se ejecuta ``tex-shell-hook``. Ver :ref:`50.2.2`. Los comandos ``M-x iso-iso2tex``, ``M-x iso-tex2iso``, ``M-x iso-iso2gtex`` y ``M-x iso-gtex2iso`` pueden usarse para convertir entre archivos codificados en Latin-1 y equivalentes codificados en TeX. .. _26.12: 26.12 Modos SGML y HTML ----------------------- Los modos principales de SGML y HTML proporcionan soporte de sangría y comandos para operar con etiquetas. HTML consta de dos modos: uno, un modo básico llamado ``html-mode`` (modo html ), es una variante ligeramente personalizada del modo SGML. El otro, que se usa por defecto para los archivos HTML, se llama ``mhtml-mode``, e intenta manejar correctamente Javascript encerrado en un elemento ``