Nuevos atajos en ZinjaI (parte 2/2)

En el post anterior les comentaba que la última release de ZinjaI traía algunas funcionalidades nuevas que no están tan a la vista pero que pueden ser muy útiles para acelerar nuestra codificación. Y les conté de lo nuevo en el menú "Generación de código" (si no lo leyeron, empiecen por ahí antes de seguir con este). Lo que quedó para la segunda parte son los cambios en los autocódigos y una nueva forma de edición múltiple.

Si no sabe qué son los autocódigos, les recomiendo primero pasar por este otro post y luego seguir leyendo por aquí. Básicamente eran pequeñas plantillas que podemos escribir de forma abreviada en nuestro código y hacer que ZinjaI las extienda con una tecla. El primer ejemplo es siempre el del for, pueden escribir "fori(n)" y apretar la tecla Tab a continuación para ver cómo se reemplaza por "for(int i=0; i<n; i++) { }" y el cursor queda entre las llaves para que escriban el contenido. Y vale para cualquier cosa que pongan en lugar de n.

Estas plantillas se configuran desde un archivito de texto. Si van al menú "Archivo", eligen "Preferencias...", y seleccionan la pestaña "Asistencias" verán un campo que dice "Archivo de definiciones de plantillas de auto-código". Ahí eligen de dónde ZinjaI lee las plantillas. Pueden usar el botón de los tres puntos que está a la derecha para cambiar de archivo o editar ese mismo. El formato es muy similar al de las funciones de preprocesador. Está explicado en los comentarios del mismo archivo. Por ejemplo, la del fori se define así:
    #autocode fori(N)
    for(int i=0;i<N;i++) { #here# }
El "#here#" dice donde debe quedar el cursor después de la expansión.

Este cuatrimestre estoy temporalmente dando clases en una materia más en la cual tenemos usamos y requete-usamos los contenedores y algoritmos de la STL en la práctica. El diseño de la STL es brillante, pero el precio de ser tan genéricas es a veces tener que escribir lo mismo una y otra vez. Por ejemplo, si declaro una lista de string, cada vez que quiero un iterador auxiliar tengo que poner el tipo "std::list<std::string>::iterator" que resulta algo largo y molesto. C++11 tiene la solución para esto con "auto", pero si uno está explicando cómo funciona la STL, mejor hacerlo explícito para que sea más claro, aunque tedioso. En fin, si quiero evitar eso, tengo que hacer un autocódigo como este:
    #autocode it
    list<int>::iterator #here#
Pero, ¿que tal si no es una list, sino un vector? ¿o si los elementos son float en lugar de int? ¿o si en realidad es un "std::map<std::string,std::list<double>::iterator>::iterator"? Muy molesto, ¿verdad? Por algo agregaron el "auto"... Pero volvamos a ZinjaI. Ahora puedo definir mi autocódigo así:
    #autocode it(c)
    #typeof(c)#::iterator #here#
Lo nuevo es el "#typeof(algo)#". ZinjaI cuando ve esto trata de deducir el tipo de ese "algo", y reemplazarlo. Entonces, si en mi código declaré un "std::map<std::string,std::list<double>::iterator> m", al expandir "it(m)" obtengo toda la porquería que mencioné antes en la tercer pregunta. O sea que lo que antes me requería presionar 65 teclas, ahora solo 7 teclas por un shift (escribir "it(l)" y presionar tab). De igual forma puedo definir cosas como:
    #autocode forit(v)
    for( #typeof(v)#::iterator it=v.begin(); it!=v.end(); ++it ) { #here# }
que de todos modos se pueden abreviar en C++11 con los "range-based for loops", pero igual que antes, si es parte de la explicación, quiero la forma larga.

Y por último, una nueva forma de edición múltiple. Llamo edición múltiple a lo que pasa cuando en tiempo real se modifican varias lineas de código a la vez. Hasta ahora, la única forma de hacer eso era con la selección rectangular. Esto es, selecciones con el ratón pero teniendo la tecla Alt presionada, o seleccionen normalmente y luego presionando Alt+Enter. Si no lo habían probado, los invito a hacerlo, verán que queda seleccionado solo en la primer linea, pero cualquier edición que hagan dentro de esa selección se aplica también en las demás en tiempo real (la equivalencia es por columnas). Bueno, el sistema ahora es un poquito más flexible y permite editar también varias posiciones al mismo tiempo, pero pueden no estar en diferentes lineas, o no estar en lineas contiguas, o no estar las mismas columnas, o cualquier cosa.

El problema es la interfaz, ¿cómo decirle a ZinjaI dónde editar? Por ahora agregué un primer mecanismo adicional, supongo que en futuras versiones vendrán otros. El que ya está funciona así: Supongamos que tenemos un identificador resaltado (se resalta con doble click, verán que le aparece un fondo verde), si seleccionamos unas cuantas líneas de código y presionamos Alt+Shift+Enter, el cursor irá a posicionarse sobre la primera vez que aparezca el identificador dentro de ese bloque. Si editan el identificador, la edición se replica en todas las demás (dentro de la selección original). Esto sirve, por ejemplo, para cambiar el nombre a una variable: primero resalten la variable haciéndole doble click, después seleccionen el scope de la variable (aquí el atajo Ctrl+M puede ayudar), y finalmente Alt+Shift+Enter para empezar a editar todas las menciones a esa variable en simultáneo.

Si no les gustan los atajos de teclado, después del doble click, busquen el comando para empezar esta edición en el menú contextual (click derecho sobre las lineas seleccionadas). Pero si no les gusta sacar las manos del teclado, Alt+Shift+Enter (el mismo atajo) cuando no hay nada seleccionado lo que hace es resaltar el identificador en el que estemos parado (reemplazando al doble-click). Así que hay combinaciones para todos los gustos.

Y con esto cierro la ronda de trucos y novedades en cuando a la edición en ZinjaI 20150823. Como siempre, espero que les resulte útil y les facilite el trabajo, y cualquier comentario al respecto será bienvenido.