En este artículo, continuación del anterior sobre las comillas, analizaremos el código AutoHotkey empleado para poder escribir las comillas que te apetezca en cualquier aplicación.
Como viste en el anterior artículo, la macro de AutoHotkey tiene una pequeña ventana de configuración:
Ya sabes que te puedes descargar la macro de AutoHotkey completa aquí:
https://www.gonduana.com/wp-content/uploads/2015/06/comillas-con-AutoHotkey.txt
Descárgate la macro con la opción Guardar enlace como del menú contextual dentro de tu navegador web, y cambia la extensión TXT a AHK para que puedas ejecutar la macro AutoHotkey
Análisis del código de la macro AutoHotkey
A continuación, vamos a analizar poco a poco lo que hace esta macro, así, si quieres, podrás cambiarla a tu gusto.
¿Preparado?
Código inicial
;===================================== ; macro AutoHotkey de www.gonduana.com/comillas-con-autohotkey ; www.gonduana.com/analisis-de-la-macro-autohotkey-para-comillas ;===================================== #NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases. ; #Warn ; Enable warnings to assist with detecting common errors. SendMode Input ; Recommended for new scripts due to its superior speed and reliability. #SingleInstance ignore
Las primeras cuatro líneas, son comentarios, ya que el primer carácter de cada línea es un punto y coma.
La líneas 5 a 7 las crea AutoHotkey automáticamente al crear una nueva macro en alguna carpeta del Explorador de Windows.
La línea 8 ya es mía y tiene una razón técnica: impedir que haya más de una instancia de la macro ejecutándose en el ordenador.
La configuración inicial de las comillas dobles
¡Entramos ya en materia!
Al código anterior le sigue este otro:
;===================================== ; Configuración inicial de las comillas ;===================================== ; CONFIGURACIÓN DE COMILLAS DOBLES ; tipo: elegir solo un 1 Comillas2Rectas := 0 Comillas2Inglesas := 0 Comillas2Latinas := 1 Comillas2Francesas := 0 Comillas2Alemanas := 0 ; individuales o en pares Comillas2Individuales := 1 Comillas2Cursor := 1 Comillas2Pares := !Comillas2Individuales if (Comillas2Rectas + Comillas2Inglesas + Comillas2Latinas + Comillas2Francesas + Comillas2Alemanas) > 1 MsgBox, Solo debería haber una comilla doble seleccionada en código.
Las líneas 16 a 20 se encargan de establecer la configuración inicial de las comillas dobles. Por ejemplo, la línea 18 es Comillas2Latinas := 1 porque mi preferencia es empezar escribiendo con comillas latinas.
Si tienes otra preferencia, puedes poner a 1 la línea que quieras, dejando el resto a cero.
Las líneas 24 a 24 se encargan de establecer otros parámetros de las comillas dobles.
Por ejemplo, si estas líneas fueran así:
Comillas2Individuales := 0 Comillas1Pares := !Comillas1Individuales Comillas2Cursor := 1
lo que haría sería configurar que quiero que al escribir unas comillas dobles de apertura, se escriban automáticamente las de cierre.
Además, quiero que el cursor se sitúe entre las dos comillas, para escribir directamente el entrecomillado.
Ten en cuenta que en la línea 24, el operador ! significa «lo contrario» de la variable que sigue. Es decir, si Comillas2Individuales tiene el valor 1, Comillas2Pares tendrá el valor 0. Si Comillas2Individuales tiene el valor 0, Comillas2Pares tendrá el valor 1.
Igualmente, puedes cambiarlo si te apetece…
Como ves, las líneas 16 a 24 deciden la configuración inicial de la parte izquierda de la ventana anterior:
Si cambias esta configuración inicial, por ejemplo, prefieres poner las comillas rectas, deberás editar el código con algún editor. En este momento, ten cuidado y no pongas a 1 más de un tipo de comillas. Si no eres cuidadoso y tienes más de un 1, la línea 26 detectará que hay más de unas comillas dobles seleccionadas y con la función MsgBox de la línea 27 te mostrará un mensaje informativo, para que cambies esta configuración inicial:
Nota 1: sé que es un sistema bastante burdo de cambiar la configuración predeterminada, pero de momento no tengo tiempo de programar la macro para que guarde la última configuración en el Registro del sistema, por ejemplo. Si te ves con fuerzas, puedes intentarlo… ¿Te doy una pista? Creo que habría que emplear las funciones RegRead y RegWrite. De momento, no lo veo importante, pero si alguna vez lo programo, lo publicaré en el blog.
Nota 2: por razones técnicas que no puedo controlar, en la línea 26 hay un error: aparece insertado un punto y como (;) después de cada signo mayor que (>) o del signo &. Ese punto y coma no debería estar ahí, pero el plugin que empleo para colorear automáticamente partes del código lo inserta muy a pesar mío. 🙁
La configuración inicial de las comillas simples
La macro continúa con estas líneas para la configuración inicial de las comillas simples:
; CONFIGURACIÓN DE COMILLAS SIMPLES: elegir solo un 1 Comillas1Rectas := 1 Comillas1Inglesas := 0 Comillas1Alemanas := 0 ; Comillas simples individuales o en pares Comillas1Individuales := 1 Comillas1Cursor := 1 Comillas1Pares := !Comillas1Individuales if (Comillas1Rectas + Comillas1Inglesas + Comillas1Alemanas) > 1 MsgBox, Solo debería haber una comilla simple seleccionada en código.
Como ves, estas líneas 30 a 36 deciden la configuración inicial de la parte derecha de la ventana de configuración de comillas:
Es un código muy similar al de las comillas dobles, así que puedes consultar lo dicho para las comillas dobles.
Únicamente quiero resaltar que no selecciones más de un tipo de comillas, ya que se hace una comprobación rápida en la línea 38 y si hay un error, te mostrará un cuadro de diálogo (línea 39).
Diseño de la ventana de configuración de las comillas
Ya tenemos la configuración inicial de las comillas.
Ahora veremos el código que crea los elementos gráficos del cuadro de diálogo anterior es:
;===================================== ; Ventana de selección de comillas ;===================================== ; PANEL IZQUIERDO: COMILLAS DOBLES Gui, Add, GroupBox, xm ym+10 Section w220 h200, Comillas dobles Gui, Add, Radio , xs+10 ys+20 checked%Comillas2Rectas% vRadioComillas2Rectas gComillas2, &Rectas ( " " ) Gui, Add, Radio , xs+10 ys+40 checked%Comillas2Inglesas% vRadioComillas2Inglesas gComillas2, &Inglesas ( “ ” ) Gui, Add, Radio , xs+10 ys+60 checked%Comillas2Latinas% vRadioComillas2Latinas gComillas2, &Latinas ( « » ) Gui, Add, Radio , xs+10 ys+80 checked%Comillas2Francesas% vRadioComillas2Francesas gComillas2, &Francesas ( «· ·» ) Gui, Add, Radio , xs+10 ys+100 checked%Comillas2Alemanas% vRadioComillas2Alemanas gComillas2, &Alemanas ( „ “ ) Gui, Add, Radio, xs+10 ys+140 checked%Comillas2Individuales% Group vRadioComillas2Individuales gComillas2, &Individuales ( « → » → « ···) Gui, Add, Radio, xs+10 ys+160 checked%Comillas2Pares% vRadioComillas2Pares gComillas2, &Pares ( 2x" ) Gui, Add, CheckBox, xs+30 ys+180 checked%Comillas2Cursor% vCheckComillas2Cursor gComillas2, &Cursor dentro de las comillas ( « | » )
Como ves, se emplea función Gui, Add para añadir cada elemento del cuadro de diálogo.
En una línea típica de cada elemento, se empieza con Gui, Add y luego se declara qué tipo de elemento es:
- GroupBox es una caja donde habrá botones de opción.
- Radio es un botón de opción. Si se marca uno de los botones de opción dentro de un mismo GroupBox, el resto se desmarcará.
- CheckBox es una casilla de verificación.
Después se declaran las coordenadas horizontal y vertical del elemento, el valor inicial del elemento (marcado, por ejemplo), el nombre de la variable con el valor del estado del elemento (checked%Comillas2Latinas%, por ejemplo), el procedimiento que se ejecutará cuando el elemento cambie de estado (Comillas2, por ejemplo), el título del elemento (&Rectas, por ejemplo, donde el carácter que sigue al signo & funciona como método abreviado en esa ventana de configuración, en este caso la erre.).
La sección del panel derecho de comillas simples es similar:
; PANEL DERECHO: COMILLAS SIMPLES Gui, Add, GroupBox, xm+230 ym10 Section w220 h200, Comillas simples Gui, Add, Radio , xs+10 ys+20 checked%Comillas1Rectas% vRadioComillas1Rectas gComillas1, &Rectas ( ' ' ) Gui, Add, Radio , xs+10 ys+40 checked%Comillas1Inglesas% vRadioComillas1Inglesas gComillas1, &Inglesas ( ‘ ’ ) Gui, Add, Radio , xs+10 ys+100 checked%Comillas1Alemanas% vRadioComillas1Alemanas gComillas1, &Alemanas ( ‚ ‘ ) Gui, Add, Radio, xs+10 ys+140 checked%Comillas1Individuales% Group vRadioComillas1Individuales gComillas1, &Individuales ( ‚ → ‘ → ‚ ···) Gui, Add, Radio, xs+10 ys+160 checked%Comillas1Pares% vRadioComillas1Pares gComillas1, &Pares ( 2x' ) Gui, Add, CheckBox, xs+30 ys+180 checked%Comillas1Cursor% vCheckComillas1Cursor gComillas1, &Cursor dentro de las comillas ( ‚ | ‘ ) nbsp;
Código que se ejecuta al cambiar la configuración de comillas
Cuando cambias algún botón de opción o alguna casilla de la sección de comillas dobles se ejecutará el procedimiento Comillas2:
;===================================== ; Código que se ejecuta al inicio ; o cuando se cambian de comillas ;===================================== ; Inicializando gosub, Comillas2 gosub, Comillas1 ; GOSUB de Comillas dobles Comillas2: GuiControlGet, RadioComillas2Rectas GuiControlGet, RadioComillas2Inglesas GuiControlGet, RadioComillas2Latinas GuiControlGet, RadioComillas2Francesas GuiControlGet, RadioComillas2Alemanas GuiControlGet, RadioComillas2Individuales GuiControlGet, RadioComillas2Pares GuiControlGet, CheckComillas2Cursor if RadioComillas2Pares = 0 GuiControl, Disable, CheckComillas2Cursor else GuiControl, Enable, CheckComillas2Cursor ComillasFinalesBoolean2:=true return
Como ves, se emplea la función GuiControlGet para guardar en unas variables el valor de la casilla de verificación o botón de opción. Tanto si cambias algún botón de opción como alguna casilla de verificación de la sección de comillas dobles: se ejecutará el procedimiento Comillas2.
En la línea 84 se comprueba si quieres escribir automáticamente las comillas de cierre. Si es así, en la línea 88, la función Enable habilita por programa la casilla de verificación Cursor dentro de las comillas, que se llama CheckComillas2Cursor, porque la lógica dice que solo puedes querer el cursor entre las comillas de apertura y de cierre cuando quieres escribir automáticamente la de cierre después de la de apertura.
Si seleccionas el botón de opción Individuales, entonces la función Disable de línea 85 deshabilita por programación la casilla de verificación Cursor dentro de las comillas.
La línea 90 hace que cuando se cambie algo de las comillas dobles, se asigne el valor true a una variable booleana que usaremos más tarde llamada ComillasFinalesBoolean2. La idea que hay detrás de esta asignación, es que si se tiene marcado el botón de opción Individual, para ir alternando las comillas, se desactivará la casilla de verificación que permite colocar el cursor en el entrecomillado. Esto es así porque situar el cursor dentro de las comillas solo tiene sentido si se cierran automáticamente las comillas.
Cuando cambias algún botón de opción o alguna casilla de la sección de comillas simples se ejecutará el procedimiento Comillas1:
; GOSUB de Comillas simples Comillas1: GuiControlGet, RadioComillas1Rectas GuiControlGet, RadioComillas1Inglesas GuiControlGet, RadioComillas1Alemanas GuiControlGet, RadioComillas1Individuales GuiControlGet, RadioComillas1Pares GuiControlGet, CheckComillas1Cursor if RadioComillas1Pares = 0 GuiControl, Disable, CheckComillas1Cursor else GuiControl, Enable, CheckComillas1Cursor ComillasFinalesBoolean1:=true return
Ambos procedimientos Comillas2 y Comillas1 son similares: actualizan todas las variables relativas a los controles (botones de opción y casillas de verificación). Así se podrán usar sus valores en cualquier momento.
Fíjate que al lanzar la macro de AutoHotkey, también se ejecutan estos procedimientos Comillas2 y Comillas1. Esto se hace así para que puedas empezar a escribir las comillas que tienes configuradas, sin necesidad de abrir la ventana de configuración. Para ello, se emplean las funciones Gosub de las líneas 70 y 71.
Puedes mirar con tranquilidad lo que hacen estas líneas, si tienes alguna duda, me preguntas, ¿vale?
Más código
Le sigue el siguiente código:
; Oculta la ventana, ; aunque puede hacerse visible de nuevo con WIN+Q GuiEscape: GuiClose: Gui, hide Return
Lo que hacen estas líneas es capturar el intento de cerrar la ventana con las líneas 113 y 114 y, en realidad, ocultarla en la línea 115 con la función Gui, Hide. Este es el comportamiento que quiero para mí, pero es posible que tú quieras otro…
Le siguen estas líneas:
;======================================== ; Tecla WIN+Q para mostrar la ventana ;======================================== #q:: ; se muestra la ventana de selección de comillas Gui, Show Return
Lo que hace es capturar la secuencia WIN+Q para mostrar la ventana de configuración, la primera que aparece en el artículo.
La línea 123 emplea la función Gui, Show para mostrar esa ventana, nada más…
Puedes ver que sin nada más que hacer doble clic en el documento AHK, esta macro de AutoHotkey escribiría las comillas de la forma que tienes configurada como te acabo de comentar.
También puedes ver que no se mostrará la ventana de configuración hasta que pulsas WIN+Q, así que si quieres cambiar de comillas, deberás cambiar la configuración pulsando WIN+Q, por ejemplo, si estás escribiendo con comillas latinas, pero quieres poner unas comillas rectas.
Al pulsar WIN+Q para cambiar algún parámetro de las comillas, se mostrará la ventana de configuración con los elementos (casillas de verificación, botones de opción, etc.) que tienes programados entre las líneas 46 y 63.
¿Ves estos dos elementos en la captura de arriba, verdad?
Con la ventana de configuración visible, ahora puedes cambiar algún parámetro de las comillas. Al cambiar algo de las comillas dobles, se lanza el procedimiento Comillas2 (líneas 74 a 91). Por otra parte, si cambias algo de las comillas simples se lanza el procedimiento Comillas1 (líneas 94 a 109).
Las líneas con Return finalizan cada procedimiento Comillas2 o Comillas1.
Por cierto, cuando hayas terminado de hacer tus cambios en la ventana de configuración, puedes cerrarla o minimizarla con toda tranquilidad, que se escribirán las comillas que tengas seleccionadas.
Código que se ejecuta al teclear comillas dobles
El código que se procesa cada vez que pulsas la tecla de comillas dobles de tu teclado es el siguiente:
;=====================================
;Si se pulsa la tecla de comillas dobles
;=====================================
:*?:"::
if RadioComillas2Rectas = 1
{
comilla2Inicial= "
comilla2Final= "
}
if RadioComillas2Inglesas = 1
{
comilla2Inicial= “
comilla2Final= ”
}
if RadioComillas2latinas = 1
{
comilla2Inicial= «
comilla2Final= »
}
if RadioComillas2Francesas = 1
{
comilla2Inicial= «
comilla2Final= »
}
if RadioComillas2Alemanas = 1
{
comilla2Inicial= „
comilla2Final= “
}
;Si se CIERRRA (NO se alterna)
if RadioComillas2Pares = 1
{
Send %comilla2Inicial%
Send %comilla2Final%
if CheckComillas2Cursor = 1
{
Send {Left}
if RadioComillas2Francesas = 1
Send {Left}
}
}
;Si se alterna
else if (ComillasFinalesBoolean2=false)
{
Send %comilla2Final%
ComillasFinalesBoolean2:=true
}
else
{
Send %comilla2Inicial%
ComillasFinalesBoolean2:=false
}
Return
La línea 129 es la abreviatura para capturar la pulsación de la tecla de comillas dobles. Fíjate que esta línea incluye los parámetros asterisco (*) e interrogación (?) para que se dispare la abreviatura con solo pulsar la tecla de comillas dobles, es decir, sin pulsar ningún punto, coma, etc. Además, se disparará incluso si estamos escribiendo una palabra. Si lo piensas bien, este es el comportamiento que mejor te viene. O eso creo…
Después se mira si tienes configurado que quieres comillas rectas (línea 130) para escribir ", o unas comillas inglesas (línea 136) para escribir “ o ”, o unas comillas latinas (línea 142) para escribir « o », o unas comillas francesas (línea 148) para escribir « o » (con espacios duros incluidos), o finalmente unas comillas alemanas (línea 154) para escribir „ o “.
Cualquiera de las posibilidades, hace que se guarden las comillas que se quieren usar en las variables comilla2Inicial y comilla2Final. Por ejemplo si quieres comillas latinas, se ejecutarán las líneas 143 a 146.
Después, en la línea 161 se comprueba si quieres escribir automáticamente las comillas dobles a pares, es decir, escribir las comillas de cierre inmediatamente después de las comillas de apertura. Si es así, se emplea la función Send para escribir por programación las comillas de apertura y de cierre (líneas 163 y 164).
Fíjate que a la función Send le sigue un nombre de variable que tiene guardado las comillas dobles que hemos elegido. Como es una variable y no una cadena de texto literal, hay que escribirla entre signos de porcentaje %.
A continuación, en la línea 165 se comprueba si quieres posicionar automáticamente el cursor entre las dos comillas de apertura y la de cierre. Si es así, emplea la función Send para mover el cursor una posición a la izquierda (línea 167). En el caso especial de las comillas francesas (se comprueba en la línea 168), habría que desplazar el cursor una posición más, ya que hay un espacio duro antes de las comillas de cierre (línea 169).
Hasta aquí claro, ¿verdad?
Bien pues seguimos…
En la línea 173 se comprueba si tienes seleccionado el botón de opción Pares porque quieres que se vayan escribiendo las comillas dobles de una en una, pero de forma inteligente; es decir, que si por ejemplo tienes configuradas las comillas latinas, después de « venga ». Si es así, hay una variable booleana llamada ComillasFinalesBoolean2 que lleva la cuenta de si estás escribiendo las comillas de apertura o de cierre. Las variables booleanas solo pueden tener dos valores, verdadero o falso, o true o false en AutoHotkey.
En la línea 175 o 180 se emplea la función Send para escribir las comillas dobles correspondientes.
En la línea 176 o 181 se cambia el valor de la variable ComillasFinalesBoolean2: de verdadero a falso, o de falso a verdadero.
El Return de la línea 183 hace terminar el código iniciado al pulsar la tecla de comillas dobles de tu teclado.
Es algo de lío, lo admito… Sobre todo es lioso, que no complicado, entender la lógica subyacente, pero si quieres cambiar algo el código de AutoHotkey que te muestro, necesitarás saber dónde tocar.
Míratelo con detenimiento, y si tienes alguna duda, me la puedes preguntar.
Código que se ejecuta al teclear comillas simples
Para terminar, el código que se procesa cada vez que pulsas la tecla de comillas simples de tu teclado es el siguiente:
;========================================
;Si se pulsa la tecla de comillas simples
;========================================
:*?:'::
; Si son comillas rectas
if RadioComillas1Rectas = 1
{
comilla1Inicial= '
comilla1Final= '
}
if RadioComillas1Inglesas = 1
{
comilla1Inicial= ‘
comilla1Final= ’
}
if RadioComillas1Alemanas = 1
{
comilla1Inicial= ‚
comilla1Final= ‘
}
;Si se CIERRA (NO se alterna)
if RadioComillas1Pares = 1
{
Send %comilla1Inicial%
Send %comilla1Final%
if CheckComillas1Cursor = 1
{
Send {Left}
if RadioComillas1Francesas = 1
Send {Left}
}
}
;Si se alterna
else if (ComillasFinalesBoolean1=false)
{
Send %comilla1Final%
ComillasFinalesBoolean1:=true
}
else
{
Send %comilla1Inicial%
ComillasFinalesBoolean1:=false
}
return
Es un código algo simplificado del de las comillas dobles, orque no hay comillas simples latinas ni francesas, así que no voy a repetir aquí lo que hace cada línea.
Conclusiones de las comillas con AutoHotkey
Tienes una macro de AutoHotkey para elegir fácilmente las comillas, dobles o simples, que quieres en cualquier aplicación. Puedes cambiar rápidamente y en cualquier momento las comillas.
Con el análisis de este artículo puedes editar la macro de AutoHotkey para personalizarla a tu gusto.
Por cierto, aunque he comprobado la macro a conciencia durante dos meses para estar seguro de que funciona como se espera, soy sincero si digo que la he programado un poco rápido…
Por ello, es muy posible que encuentres cosas mejorables en el código. Si es así, te rogaría que lo compartieses con todos, ¿vale?
Ejemplo de edición: comillas danesas
Como he comentado, he tratado de que esta macro fuera lo más completa para mí, pero aun así, puedes llegar a tener necesidades que no he previsto.
Este blog está dirigido a traductores de habla hispana y sé que hay lectores de muchos países y puede que tus combinaciones de idiomas no se cubran con mi macro.
En este caso, es muy posible que necesites añadir algunas comillas más que no he incluido.
Por ejemplo, según tengo entendido, en danés usan » y « como comillas de apertura y de cierre, respectivamente (¡al contrario que nuestras latinas!).
Como he tratado de hacer una macro flexible, te propongo que edites el archivo AHK para incluir estas comillas danesas…
Añade un botón de opción debajo de la línea 51. Tendrás que escribir un rótulo a Danés que aparecerá en la ventana de configuración, así como las variables que van a guardar el estado del nuevo botón de opción. No olvides modificar todo lo necesario a tus comillas danesas, incluidos la configuración inicial, el procedimiento Comillas2 y un nuevo bloque if debajo de la línea 159. Si se te olvida algo, verás que la macro no te funciona bien, lo normal en los primeros intentos, pero no te preocupes: lo bueno es que siempre podrás ir mejorando tu macro.
Haz las pruebas que necesites para confirmar que no te has equivocado al agregar tus comillas danesas, ¡y ya lo tienes!
