Pues eso… que el Google Search Console me ha avisado que tengo más de 1200 páginas en www.elguille.info que no están adaptadas a las aplicaciones móviles y similares… En realidad el aviso es: La ventana gráfica no está definida.
Así que… me he puesto a buscar los ficheros que no tienen asignado este «meta»:
Y después de buscarlos, a editarlos y añadirle esa línea en la cabecera (<head>).
Como yo sabía que las páginas ASPX que usan páginas maestras sí tienen definida la ventana gráfica, al buscar he tenido que eliminar de la búsqueda todos los ficheros aspx que tuviesen la página maestra (en realidad los ficheros que contengan <asp:Content), y como también sé que hay páginas que no deben indexarse con los buscadores, he buscado también las páginas que no tengan content=»noindex» ni content=»none», que es lo que tengo puesto en las páginas que no deben estar indexadas, en realidad el meta completo es algo así: <meta name=»robots» content=»noindex»> (o «none», que para el caso es lo mismo que «noindex»).
Para hacer la búsqueda he usado una utilidad que tengo de hace unos años (gsBuscarTexto) que he modificado entre otras cosas para poder indicar varias cadenas de búsqueda, tanto para las que estén en el fichero, por ejemplo si contiene <body es que no están usando páginas maestras, salvo la página maestra. Pero también tenía que filtra que no tuviese ciertas cadenas, las que te he indicado antes, es decir, que no tenga ninguna de estas subcadenas: <meta name=»viewport»; <asp:Content; content=»noindex»; content=»none»
Y teniendo en cuenta solo algunas directorios del sitio, han aparecido más de 600 coincidencias, pero ya me quedan menos (ver la figura 1)
Figura 1. gsBuscarTexto ayudando a buscar los ficheros que no tienen <meta name=»viewport»
Y aún me queda examinar todo el resto del sitio.
Y no solo encontrar los ficheros afectados, si no que hay que abrirlos, añadir el meta «viewport», guardarlo y después subirlos al sitio…
En fin… un buen trabajillo para que todo el que quiera ver el contenido de elGuille.info lo vea lo mejor posible… 😉
Espero que así te resulte más fácil consultar el contenido desde el dispositivo que sea…
Pues eso… En la preview 6 que la han puesto disponible esta madrugada ya funciona mejor el diseñador de WindowsForms, al menos ya puedes añadir un control, hacer doble-clic en él y se mostrará el método de evento predeterminado.
Hasta ahora no añadía ese método que en el caso de Visual Basic era añadir al final de la definición del método la cláusula Handles con el nombre del evento, y en el caso de C# añadir el evento en el diseñador de formularios.
PrivateSub Button1_Click(sender AsObject, e AsEventArgs) _
Handles Button1.Click
this.button1.Click += new System.EventHandler(this.button1_Click);
Figura 1. El diseñador de formularios (WinForms) en VS2019 v16.8.0 Preview 6 para .NET 5.0 RC2
Nota del 26-oct-2020 20:59: Esta página estaba originalmente publicada en elguille.info y la he pasado al blog para poder editarla más fácilmente ya que lo que publico en elGuille.info lo hago con un editor de texto normal y corriente… y ¡es un rollo! Por supuesto, esta misma página aparecerá en elGuille.info, así que… no se notará mucho que no está realmente ubicada allí.
NOTA del 24/Oct/2020 Revisión de esta utilidad usando la nueva versión publicada hoy de gsColorearNET en NuGet. He actualizado también la instalación de ClickOnce.
Nota del 12/Sep/2020 Estoy probando la utilidad de colorear en .NET 5.0 Preview 8 y a duras penas ya está operativa… es que el editor de Visual Studio 2019 Preview está aún muy verde para las aplicaciones de Windows Forms para Visual Basic.
El hacerlo con esa versión es para poder depurar el código de la DLL de colorear, ya que en un proyecto de .NET framework no se puede… o yo no sé cómo hacerlo… todo hay que decirlo.
Cuando tenga tiempo publicaré en el blog las cosillas que recomiendo hacer hasta que mejoren el editor/diseñador de WinForms para Visual Basic.
Nota del 11/Sep/2020: Esta nueva versión utiliza la librería de colorear código compilada para .NET Standard 2.0. Esa DLL la he instalado desde el paquete de NuGet que he creado para la DLL gsColorearNET. No he probado el instalador de ClickOnce en otro equipo, así que no sé si será totalmente operativo 😉 Al menos lo es en mi propio equipo… De todas formas, actualizaré el código fuente de la nuevas versión, que aparte de usar esa DLL de colorear, también tiene otros cambios (mejoras) con respecto a la actualización anterior del 9 de septiembre pasado.
El programa principal y la DLL de colorear están compilados con Visual Studio 2019, en el caso de la utilidad (gsColorearCodigo.exe) utilizando el .NET Framework 4.8, y la DLL (gsColorearNET.dll) está compilada para usar .NET Standard 2.0.
Entre otras cosas, esta versión (aparte de las mejoras en gsColorearNET) incluye la opción de «Colorear desde RTF» (ver la Figura 1). Así como algunos cambios en la pestaña de configuración (ver figura 2) y en la ventana de mostrar RTF, que ahora permite cambiar el código RTF y al pulsar en el botón RTF se muestran los cambios realizados.
Figura 1. Colorear desde RTF
Es la opción que en un 99.99% de las veces utilizo para colorear el código ya que me permite copiar el texto de Visual Studio (es lo que se ve detrás de la utilidad) lo pego en la aplicación y al usar esa opción de Colorear desde RTF lo que hace es colorear para HTML usando el código de RTF, es decir, no comprueba las palabras clave, etc., para generar el código HTML a usar en una página WEB.
Figura 2. Pestaña de opciones
Instalar gsColorearCodigo (y el código fuente)
Para instalar la utilidad puedes hacerlo de dos formas:
Usando el ZIP que hay más abajo, pero tendrás que compilarlo ya que el ejecutable no se incluye, solo el código fuente para Visual Basic.
Instalándolo por medio de ClickOnce (recomendado), ya que así podrás recibir notificaciones cuando haya alguna nueva versión e instalarla automáticamente.
En cualquier caso, lo instales directamente o por medio de ClickOnce, desde la ventana de Acerca de puedes comprobar si hay nuevas versiones del programa o también mirando esta página, que al fin y al cabo es la que usa el programa para saber si hay nuevas versiones (o actualizaciones).
Nota: En realidad la página que mira para ver si hay nuevas actualizaciones es la anterior (la original creada con .NET 2.0) pero he puesto allí la misma versión que en esta… y cuando actualice nuevamente la utilidad, cambiaré el enlace para que mire esta página. Esto es así porque esta página la he publicado después de compilar y crear el instalador.
Más abajo tienes los enlaces con el código completo para Visual Basic usando una solución de Visual Studio 2019 con .NET 4.8 en el que se hace referencia a la DLL gsColorearNET instalada con el package de NuGet.
Espero que te sea de utilidad
Nos vemos. Guillermo
El ZIP con el código completo
El código tanto de la aplicación gsColorearCodigo para .NET Framework 4.8 como de la DLL gsColorearNET para .NET Standard 2.0 lo puedes descargar desde GitHub
Nota del 26-oct-2020 20:45: Esta página estaba originalmente publicada en elguille.info y la he pasado al blog para poder editarla más fácilmente ya que lo que publico en elGuille.info lo hago con un editor de texto normal y corriente… y ¡es un rollo! Por supuesto, esta misma página aparecerá en elGuille.info, así que… no se notará mucho que no está realmente ubicada allí.
Esta es una biblioteca (DLL) compilada para .NET Standard 2.0 y así poder usarla en cualquier plataforma que lo acepte, incluidos los proyectos de .NET Framework 4.6.1 a 4.8 y de .NET Core 2.0 a .NET 5.0, entre otros… Si quieres ver dónde se pueden usar las DLL compiladas con .NET Standard 2.0 mira este enlace: .NET Standard
Últimas actualizaciones
Nota del 24/Oct/2020 (v1.0.0.14) He actualizado tanto el paquete de NuGet como el código en GitHub. También la utilidad de gsColorearCodigo para que use esta nueva versión.
Los cambios principales son para no eliminar las líneas en blanco que haya en el código. Esto era porque la función Split original de Visual Basic no elimina las líneas en blanco. Además de usar vbCr en lugar de vbCrLf al examinar cada línea y crear nuevas separaciones, ya que al añadir vbCrLf añadía una línea extra en blanco.
Aunque últimamente se me ha dado el problema que no todos los ficheros tienen el mismo tipo de retorno de carro. Por tanto he tenido que comprobar antes de hacer el Split qué tipo de retorno de carro tiene: vbCrLf o vbCr o vbLf.
Nota del 16/Sep/2020 (v1.0.0.7) He actualizado tanto el paquete de NuGet como el código en GitHub. También la utilidad de gsColorearCodigo para que use esta nueva versión.
Los cambios principales son para no eliminar las líneas en blanco que haya en el código. Esto era porque la función Split original de Visual Basic no elimina las líneas en blanco. Además de usar vbCr en lugar de vbCrLf al examinar cada línea y crear nuevas separaciones, ya que al añadir vbCrLf añadía una línea extra en blanco.
Nota del 13/Sep/2020 (v1.0.0.6) He actualizado tanto el paquete de NuGet como el código en GitHub. También la utilidad de gsColorearCodigo para que use esta nueva versión.
Con fecha del 12 de septiembre de 2020 he creado un repositorio en gitHub para el código de gsColorearNET.
De ahí puedes descargar el proyecto completo a excepción del fichero de nombre seguro (.snk)
Estoy probando la utilidad de colorear en .NET 5.0 Preview 8 y a duras penas ya está operativa… es que el editor de Visual Studio 2019 Preview está aún muy verde para las aplicaciones de Windows Forms para Visual Basic (y para C# tampoco está muy fino).
El hacerlo con esa versión es para poder depurar el código de la DLL de colorear, ya que en un proyecto de .NET framework no se puede… o yo no sé cómo hacerlo… todo hay que decirlo.
Cuando tenga tiempo publicaré en el blog las cosillas que recomiendo hacer hasta que mejoren el editor/diseñador de WinForms para Visual Basic.
NOTA: Aún la estoy probando desde NuGet ya que usándola como proyecto compila y funciona bien, pero al publicar el paquete en NuGet (aquí tienes el enlace: gsColorearNET en NuGet), no me encuentra los lenguajes de las palabras clave. ¡Esto último ya está solucionado con el paquete 1.0.0.1!
Por ahora no te voy a poner el código fuente, en realidad ha cambiado poco desde lo que publiqué anteayer, y como lo que quiero añadir o corregir aún lo tengo que hacer… pues… habrá que esperar unos días a que lo tenga terminado y así ya la publico de forma, que salvo que haya algunos fallos, no tenga que modificarla en algún tiempo.
Lo que sí haré es actualizar el paquete de NuGet con las correcciones que le vaya haciendo.
Sobre el uso de un proyecto DLL de .NET Standard con un proyecto de .NET Framework
Probando el código de gsColorearCodigo usando el .NET 4.8 en Visual Studio 2019 con el proyecto de gsColorearNET usando .NET Standard 2.0, al producirse un error (o sin que se produzca) y querer depurar en el código de la DLL, el VS no me dejaba… Así que… para comprobar porqué fallaba el penúltimo cambio que le hice, tuve que abrir un proyecto de .NET 5.0 (Preview 8) usando el Visual Studio Preview, y en ese entorno si pude depurar y averiguar cuál era el fallo… que después resultó ser algo trivial, pero…
Así qué… ya sabes… si mezclas… no debugues… 😉
Usar código de Visual Basic en .NET Standard
Otra de las cosillas que me he encontrado a la hora de poder compilar el código del proyecto gsColorear para .NET Framework (ya hay que ir haciendo las aclaraciones de que no todo es simplemtente .NET, porque tenemos .NET Framework, .NET Core, .NET Standard y… casi ya… también simplemente .NET refiriéndose a .NET Core) es la definición de algunas de las funciones del ensamblado Microsoft.VisualBasic en concreto de la clase Strings que no están definidas en .NET Standard 2.0, tal como: Len, Left, Mid, Right, Split, InStr y Trim.
Para no tener que cambiar todo el código que usaba esas funciones (recuerda que el código de colorear lo hice sobre el año 2001, sí, con Visual Basic 6.0, después en diciembre del 2002 lo pasé a la beta de Visual Studio .NET, la aplicación de aquél entonces era HTMLColorCode, aunque debo tener otra aplicación llamada gsEditor… el tiempo no perdona… por la memoria…) así que… me he creado una clase en la que he definido esas funciones, que (seguramente) pueden mejorarse, pero… así las he programado / codificado / como prefieras decirlo.
Y te pego aquí el código por si te puede ser de ayuda.
'------------------------------------------------------------------------------' Clase definida en la biblioteca para .NET Standard 2.0 (10/Sep/20)' Basada en gsColorear y gsColorearCore'' VBCompat (10/Sep/20)' Clase con instrucciones para compatibilidad con .NET Standard 2.0'' Declaro algunas funciones de Microsoft.VisualBasic.Strings' que no están en .NET Standard 2.0'' (c) Guillermo (elGuille) Som, 2020'------------------------------------------------------------------------------OptionStrictOnOptionInferOnImports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
'Imports System.DataPublicClassVBCompat'''<summary>''' Devuelve los caracteres desde la posición (en base 1)''' hasta el final.'''</summary>'''<param name="str"></param>'''<param name="pos"></param>PublicSharedFunction Mid(str AsString, pos AsInteger) AsStringReturn str.Substring(pos - 1)
EndFunction'''<summary>''' Devuelve la cadena desde la posición indicada con len caracteres.''' La posición del primer carácter es el 1.'''</summary>'''<param name="str"></param>'''<param name="pos"></param>'''<param name="len"></param>'''<remarks>10/Sep/20/20</remarks>PublicSharedFunction Mid(str AsString, pos AsInteger, len AsInteger) AsStringReturn str.Substring(pos - 1, len)
EndFunction'''<summary>''' Devuelve el número de caracteres.''' Si es cadena vacía o nulo devuelve 0.'''</summary>'''<param name="str"></param>'''<returns></returns>PublicSharedFunction Len(str AsString) AsIntegerIfString.IsNullOrEmpty(str) ThenReturn 0
Return str.Length
EndFunction'''<summary>''' Devuelve los primeros caracteres de la cadena.'''</summary>'''<param name="str"></param>'''<param name="len"></param>'''<returns></returns>PublicSharedFunction Left(str AsString, len AsInteger) AsStringReturn str.Substring(0, If(len > str.Length, str.Length, len))
EndFunction'''<summary>''' Devuelve los caracteres indicados desde la derecha.'''</summary>'''<param name="str"></param>'''<param name="len"></param>'''<returns></returns>PublicSharedFunction Right(str AsString, len AsInteger) AsStringDim iPos = str.Length - len
Return str.Substring(iPos, len)
EndFunction'''<summary>''' Devuelve la posición (en base 1) de la segunda cadena en la primera'''</summary>'''<param name="str1"></param>'''<param name="str2"></param>'''<returns></returns>PublicSharedFunction InStr(str1 AsString, str2 AsString) AsIntegerReturn str1.IndexOf(str2) + 1
EndFunction'''<summary>''' Devuelve la posición (en base 1) de la segunda cadena en la primera ''' empezando en la posición indicada.'''</summary>'''<param name="startPos"></param>'''<param name="str1"></param>'''<param name="str2"></param>'''<returns></returns>PublicSharedFunction InStr(startPos AsInteger, str1 AsString, str2 AsString) AsIntegerReturn str1.IndexOf(str2, startPos - 1) + 1
EndFunction'''<summary>''' Devuelve una cadena después de haber quitado ''' los espacios delante y detrás.'''</summary>'''<param name="str"></param>'''<returns></returns>PublicSharedFunction Trim(str AsString) AsStringReturn str.Trim
EndFunction'''<summary>''' Divide una cadena en elementos de un array.''' Usando el delimitador indicado.'''</summary>'''<param name="Expression"></param>'''<param name="Delimiter"></param>'''<returns></returns>PublicSharedFunction Split(Expression AsString, Optional Delimiter AsString = " ") AsString()
Return Expression.Split(Delimiter.ToCharArray, StringSplitOptions.RemoveEmptyEntries)
EndFunction'''' El código IL de Prueba1 es más corto (y parece que eficiente) que el de Prueba2'''Public Shared Function Prueba1(str As String, len As Integer) As String' Return str.Substring(0, If(len > str.Length, str.Length, len))'End Function'Public Shared Function Prueba2(str As String, len As Integer) As String' If len > str.Length Then' len = str.Length' End If' Return str.Substring(0, len)'End FunctionEndClass
Y esto es todo por ahora…
Espero que te sea de utilidad
Nos vemos. Guillermo
El código fuente completo
El código para Visual Basic con el proyecto para Visual Studio 2019 está publicado en gitHub.
Pues eso… que hace poco mandé al servicio técnico de LG la pantalla externa que conecto a mi ordenador portátil y estoy teniendo problemas cuando abro las aplicaciones que he estado usando con ese monitor, al menos las que tengo programadas para que al cambiar la posición o el tamaño se guardan en un fichero de configuración para cuando cargue de nuevo esa aplicación se muestre donde estuvo la vez anterior.
Una de las opciones por la que opté fue poner que siempre se mostrasen en el centro de la pantalla, pero con el tamaño indicado en el diseño del formulario.
La idea que se me ha ocurrido esta mañana es la de comprobar dónde está la posición Left y Top guardadas y si estarían fuera del rango de esos mismos valores de las propiedades de el WorkingArea de PrimaryScreen.
Los valores de alto y ancho (Height y Width) no los toco, ya que el usuario podrá cambiar esos tamaños a su antojo, ya que ahora sí que podrá ver la ventana de la aplicación.
Este es el código para Visual Basic con el que hago la comprobación que te he mencionado:
' Asignar el tamaño y última posición
' Comprobar que esté en la parte visible (24/Oct/20)
Dim l = cfg.GetValue("Ventana", "Left", Me.Left)
Dim t = cfg.GetValue("Ventana", "Top", Me.Top)
IfScreen.PrimaryScreen.WorkingArea.Left < l Then
Me.Left = cfg.GetValue("Ventana", "Left", Me.Left)
Else
Me.Left = 0
EndIf
IfScreen.PrimaryScreen.WorkingArea.Top < t Then
Me.Top = cfg.GetValue("Ventana", "Top", Me.Top)
Else
Me.Top = 0
EndIf
Me.Height = cfg.GetValue("Ventana", "Height", Me.Height)
Me.Width = cfg.GetValue("Ventana", "Width", Me.Width)
Los valores de la posición y tamaño del formulario los obtengo de un fichero de configuración y solo asigno el valor Left si la posición Left de WorkingArea es menor, ya que cuando está en el monitor externo (al menos en mi caso) el valor de Left suele ser negativo. Y con el valor Top hacemos lo mismo, solo asignarlo si no es menor que el valor Top del área de trabajo de la pantalla principal.
Y aquí tienes el mismo código para C#:
// Asignar el tamaño y última posición
// Comprobar que esté en la parte visible (24/Oct/20)
var l = cfg.GetValue("Ventana", "Left", this.Left);
var t = cfg.GetValue("Ventana", "Top", this.Top);
if (Screen.PrimaryScreen.WorkingArea.Left < l)
this.Left = cfg.GetValue("Ventana", "Left", this.Left);
else
this.Left = 0;
if (Screen.PrimaryScreen.WorkingArea.Top < t)
this.Top = cfg.GetValue("Ventana", "Top", this.Top);
else
this.Top = 0;
this.Height = cfg.GetValue("Ventana", "Height", this.Height);
this.Width = cfg.GetValue("Ventana", "Width", this.Width);
Y esto es todo, espero que te haya sido de utilidad.
Nota aclaratoria del 28-oct-2020: Según parece lo que la documentación indica es que no se pueden buscar textos que incluyan más de una línea, no que el texto esté en más de una línea… Este es el texto aclaratorio que me han mandado:
La traducción (automática) de ese texto en inglés: Para la documentación sobre el método FIND, significa que no puede buscar en varias líneas del texto, si desea buscar contenido de diferentes líneas, puede dividir las líneas en diferentes subcadenas.
A mí casi me deja igual… pero al ver el enlace y lo que el que pregunta quiere buscar, sí lo entiendo: Es decir, en la cadena de búsqueda no puedes usar varias líneas (con retorno de carro) de ser así devolverá -1. Pero si puedes buscar una cadena (que no tenga retornos de carro) y buscará en todas las líneas del texto del control RichTextBox. En fin…
Pues eso… En la documentación lo indica claramente, pero eso será algo nuevo y se ve que también afecta a las versiones anteriores, es decir, el control RichTextBox ya no es el mismo que era antes… al menos el método Find con búsqueda de cadenas ya no funciona igual.
Rectificación del 24-oct-2020 por la tarde: (donde dije digo digo Diego)
Aunque la documentación dice eso, en realidad si busca aunque esté más de una vez en varias líneas y no me refiero solo a .NET Framework 4.7.2, también lo hace en .NET 5.0 RC2. Ayer es que estaba yo del todo grave con lo de la boca… aparte de que veo poco incluso con las gafas… Te explico.
Estaba probando lo de Buscar texto en un programa que estoy haciendo y probé con buscar InitializeComponent, pero se ve que lo escribí mal: InitilizeComponent y al buscarlo no lo encontraba… ¡elemental querido Guille! El no comprobar si estaba o no bien escrito es porque seleccioné el texto correcto y pulsé Ctrl+F para buscar, pero se ve que en la lista de búsqueda ya estaba la palabra mal escrita y la seleccionaría sin querer…
Y claro al probar la versión que he hecho y ver que tampoco encontraba la dichosa palabra, pues… me di cuenta que le faltaba una «a«… en fin…
No lo he probado aún con el .NET Framework pero creo que el problema es el mismo.
Nota del 24-oct-2020: Acabo de probarlo en un «editor» que tengo hecho con .NET Framework 4.7.2 y va bien aunque en la documentación siga diciendo que no va.
Nota
Los Find métodos que aceptan un string como parámetro no pueden encontrar texto contenido en más de una línea de texto dentro de RichTextBox . La realización de este tipo de búsqueda devolverá un valor de uno negativo (-1).
A ver qué dicen esta gente si eso se va a quedar así o hay alguna alternativa… que debería haberla…
Lo mismo estoy equivocado, pero en una aplicación en la que estoy usándolo actualmente ya no funciona como debería funcionar… y al buscar una cadena, (sabiendo que existe en el texto) me devuelve un valor -1, que es lo que «ahora» dice la documentación que ocurrirá… pero antes no ocurría… en fin…
Esto es lo que dice la documentación:
Bueno… a ver qué ocurre con esto…
Mientras tanto voy a crear un método de extensión para añadir funcionalidad de buscar el mismo texto aunque esté en varias líneas, en principio lo llamaré FindString y será como Find(String, Int32, RichTextBoxFinds). Cuando lo tenga hecho te avisaré o pondré aquí el enlace 😉
Pues eso… seguramente habrás visto en algunas aplicaciones que en las cajas de texto (o los ComboBox) se muestra un texto en color gris para indicarte lo que puedes escribir en esa casilla.
Para tener esa funcionalidad en nuestros proyectos no es necesario usar controles especializados ni nada de eso, ya verás que es fácil, y espero que claro, hacerlo mediante unas pocas líneas de código.
Actualizado y corregido el código (24-oct-2020) Ver más abajo el comentario y el nuevo código de QuitarPredeterminado.
En la figura 1 puedes ver el aspecto de esa caja de texto.
Figura 1. La aplicación en modo ejecución
En la imagen anterior puedes ver el texto <Escribe tu nombre> en la caja de texto, cuando empieces a escribir, ese texto informativo se quita y solo estará lo que escribas, y si borras todo el texto (dejas vacía la caja de texto) se volverá a mostrar ese texto informativo.
¿Dónde controlar si se debe mostrar o no el texto predeterminado?
En mi caso, yo hago las comprobaciones en tres eventos del (en este caso) TextBox. A saber:
El evento Enter (cuando toma el foco) ahí se comprueba si debe tener el color grisáceo o el negro del texto. Se comprueba si el texto es diferente del predeterminado (el de ayuda o informativo), en ese caso se asigna el color del texto a ControlText (definido en SystemColors).
El evento Leave (cuando pierde el foco) ahí compruebo si no hay texto, en cuyo caso, asigno el texto informativo y le asigno a la propiedad ForeColor el color GrayText (también de la clase SystemColors).
El evento TextChange (cuando el texto cambia), hay lo que hay que hacer es más elaborado (menos simple que en los casos anteriores), al menos como yo lo he hecho, que puede que haya un método más fácil y simple de hacerlo. Pero es lo que le da esa vidilla al efecto ;-).
Yo suelo usar una variable a nivel de formulario llamada inicializando que me sirve para evitar la entrada en cascada del evento TextChange (y otros eventos, pero en este ejemplo es el que se produce cuando el texto cambia). Si el valor de esa variable es True, salimos del método.
La primera comprobación es si el texto del control está vacío o tiene el texto predeterminado, en cuyo caso lo ponemos en color gris y le asigno el texto informativo. Si no se da esa comprobación, el texto ya tiene algo, por ejemplo, si se ha empezado a escribir, y compruebo si el texto que había antes era el texto vacío en cuyo caso le quito el texto predeterminado con idea de que solo se quede lo que el usuario está escribiendo.
La primera idea que tuve fue quitar directamente el texto predeterminado con un Replace(textoPredeterminado, «»), pero eso solo vale si se está escribiendo al principio o al final del texto (que es lo más común), pero si el usuario se pone a escribir en medio del texto predeterminado, no funcionaría… por tanto, he creado una función en la que quito todo el texto predeterminado del texto que haya, para así dejar solo lo que se esté escribiendo, que será la primera letra que el usuario escriba.
Esa función yo la tengo como una extensión de la clase String, pero en el código que te mostraré, es simplemente una función llamada QuitarPredeterminado que recibe dos argumentos, el texto a comprobar y el texto a quitar. De esa forma nos servirá para aplicarla a cualquier control y evitar tener que repetir lo mismo en todos los evento TextChange de los controles a los que queramos dar esta funcionalidad.
Aquí (y en la comprobación anterior) entra en juego la variable inicializando, que es la que evitará que se entre nuevamente mientras modificamos el texto.
Finalmente asignamos a la variable que contiene el texto anterior, el texto actual para que no se quite nada cuando ya no sea el texto predeterminado, ya que es posible que el usuario escriba en el texto ese mismo texto que damos por predeterminado, el problema es que el usuario solo escriba el texto predeterminado, pero… bueno, se supone que no lo escribirá… 😉
Y esto es todo lo que hay que hacer… viendo ahora el código para Visual Basic y C# lo entenderás mejor.
Rectificación del código (24-oct-2020)
Pues resulta que hay que hacer una comprobación extra antes de quitar los caracteres del texto predeterminado, si no, puede pasar lo que me pasó anoche, que al asignar la palabra InitializeComponent a la caja de textos donde está la palabra predeterminada Buscar… pues… se encontró con la a (de Buscar) y la quitó… Así que… ahora compruebo primero si están todas las letras del texto predeterminado y de ser así, entonces hago el reemplazo, si no están todas las letras, simplemente se devuelve el texto original y como si nada.
El código de QuitarPredeterminado que te muestro más abajo ya tiene las modificaciones indicadas.
Empezaré mostrándote las variables que necesitaremos a nivel de formulario. Es decir, la que controla si ya estamos dentro del evento, la que contiene el texto predeterminado y la que contiene el texto anterior de la caja de texto.
Estas dos últimas serán diferentes para cada control a los que queramos aplicar el efecto. Al menos la del texto anterior, ya que el texto predeterminado puede ser el mismo para varios controles.
El código del evento TextChanged en el que uso la función para quitar el texto predeterminado esté en la posición que esté. Después te muestro el código de esa función QuitarPredeterminado.
Visual Basic .NET
PrivateSub txtTexto_TextChanged(sender AsObject,
e AsEventArgs) Handles txtTexto.TextChanged
If inicializando ThenReturn
If txtTexto.Text = ""OrElse txtTexto.Text = textVacio Then
txtTexto.ForeColor = SystemColors.GrayText
inicializando = True
txtTexto.Text = textVacio
inicializando = False
Else
If textAnterior = textVacio Then
inicializando = True
txtTexto.Text = QuitarPredeterminado(txtTexto.Text, textVacio)
inicializando = False
txtTexto.SelectionStart = txtTexto.Text.Length
EndIf
txtTexto.ForeColor = SystemColors.ControlText
EndIf
textAnterior = txtTexto.Text
EndSub
Fíjate que antes de asignar un texto al TextBox asigno el valor true a inicializando, de esa forma, cuando se cambie el texto (al asignarlo se cambiará), no entrará nuevamente en el evento.
Y como te comentaba antes, cuando el texto que había anterior es el predeterminado (textVacio), quitamos dicho texto de la propiedad Text de la caja de textos mediante una llamada al método QuitarPredeterminado, al que le pasamos el texto que queremos comprobar (el del control TextBox) y el que queremos quitar.
Veamos el código de ese método… y verás lo casi retorcido que es… 🙂 En serio, lo que hago es recorrer cada carácter del texto a quitar (el predeterminado) y quitarlo del texto, de esa forma, esté donde esté ese carácter que queremos quitar lo hará correctamente.
Aquí tienes el código de la función QuitarPredeterminado.
Visual Basic .NET
'''<summary>
''' Quitar de una cadena un texto indicado (que será el predeterminado cuando está vacío).
''' Por ejemplo si el texto grisáceo es Buscar... y
''' se empezó a escribir en medio del texto (o en cualquier parte)
''' BuscarL... se quitará Buscar... y se dejará L.
''' Antes de hacer cambios se comprueba si el texto predeterminado está al completo
''' en el texto en el que se hará el cambio.
'''</summary>
'''<param name="texto">El texto en el que se hará la sustitución.</param>
'''<param name="predeterminado">El texto a quitar.</param>
'''<returns>Una cadena con el texto predeterminado quitado.</returns>
'''<remarks>18/Oct/2020 actualizado 24/Oct/2020</remarks>
PublicFunction QuitarPredeterminado(texto AsString, predeterminado AsString) AsString
Dim cuantos = predeterminado.Length
Dim k = 0
For i = 0 To predeterminado.Length - 1
Dim j = texto.IndexOf(predeterminado(i))
If j = -1 ThenContinueFor
k += 1
Next
' si k es distinto de cuantos es que no están todos lo caracteres a quitar
If k <> cuantos Then
Return texto
EndIf
For i = 0 To predeterminado.Length - 1
Dim j = texto.IndexOf(predeterminado(i))
If j = -1 ThenContinueFor
If j = 0 Then
texto = texto.Substring(j + 1)
Else
texto = texto.Substring(0, j) & texto.Substring(j + 1)
EndIf
Next
Return texto
EndFunction
C#
///<summary>
/// Quitar de una cadena un texto indicado (que será el predeterminado cuando está vacío).
/// Por ejemplo si el texto grisáceo es Buscar... y
/// se empezó a escribir en medio del texto (o en cualquier parte)
/// BuscarL... se quitará Buscar... y se dejará L.
/// Antes de hacer cambios se comprueba si el texto predeterminado está al completo
/// en el texto en el que se hará el cambio.
///</summary>
///<param name="texto">El texto en el que se hará la sustitución.</param>
///<param name="predeterminado">El texto a quitar.</param>
///<returns>Una cadena con el texto predeterminado quitado.</returns>
///<remarks>18/Oct/2020 actualizado 24/Oct/2020</remarks>
privatestring QuitarPredeterminado(string texto, string predeterminado)
{
var cuantos = predeterminado.Length;
var k = 0;
for (var i = 0; i < predeterminado.Length; i++)
{
var j = texto.IndexOf(predeterminado[i]);
if (j == -1)
continue;
k += 1;
}
// si k es distinto de cuantos es que no están todos lo caracteres a quitar
if (k != cuantos)
return texto;
for (var i = 0; i < predeterminado.Length; i++)
{
var j = texto.IndexOf(predeterminado[i]);
if (j == -1)
continue;
if (j == 0)
texto = texto.Substring(j + 1);
else
texto = texto.Substring(0, j) + texto.Substring(j + 1);
}
return texto;
}
Y esto es todo… yo lo estoy usando de varias formas, por ejemplo en los TextBox (en realidad un ComboBox del tipo ToolStripComboBox) para Buscar y otro para Reemplazar, en el primero muestro de forma predeterminada el texto Buscar… y el de reemplazar el texto Reemplazar….
La idea la tomé prestada, con estas mejoras que te he mostrado aquí, del proyecto CSharp2VB de Paul1956.
Publicaré Ya está el código completo de ejemplo tanto para Visual Basic como para C# (proyectos para .NET Framework 4.8, aunque sirven igualmente con proyectos para .NET 5.0 RC2) publicado en GitHub: Mostrar-texto-grisaceo.
Pues eso… necesitaba saber cómo detectar varias pulsaciones de teclas al estilo de Ctrl+K, Ctrl+C y similares, es decir, se pulsa la tecla Control seguida de la K y se pulsa la tecla Control seguida de la C (como la combinación de Visual Studio para poner comentarios en la selección que haya en el código). Así que… busqué en internet, pero… había ejemplos muy enrevesados… con temporizadores y demás monadas… así que… basándome en algunos ejemplos (seguramente del mismo autor o copiados unos de otros) he hecho algo que puede servir… al menos a mí me sirve, aunque se puede mejorar, como todo.
De la forma que lo he hecho da igual si se pulsa primero Ctrl+K que Ctrl+C, ya que lo que he intentado es que se sepa cuando se han hecho esas pulsaciones, y si entre cualquiera de las dos pulsaciones se ha pulsado otra tecla, no se tiene en cuenta esa combinación. Es decir si quieres detectar Ctrl+K seguida de Ctrl+C (que para el caso del código que te mostraré es lo mismo que si pulsas Ctrl+C seguida de Ctrl+K) pulsas otra tecla o combinación de teclas, no se dará como detectada esa doble pulsación.
Nota: Precisamente con esas teclas: Ctrl+C y otras automatizadas de edición: Ctrl+V, Ctrl+X, Ctrl+P, etc., habría que tener cuidado o hacerle un seguimiento distinto al que ahora hago para que no la detecte y, por ejemplo pegue el texto si es Ctrl+P).
¿Dónde se hará la comprobación de la tecla pulsada?
Las comprobaciones de qué tecla se está pulsando (o se ha pulsado) la hago en el evento KeyDown del formulario. Y como de forma predeterminada el formulario no intercepta las pulsaciones de las teclas, habrá que hacer una asignación de un valor verdadero (true) a la propiedad KeyPreview del formulario. Eso lo he puesto en el evento Load, con idea de que esté activado si por casualidad cambio el valor en el diseñador (esas cosas suelen ocurrir, y es complicado de saber porqué antes funcionaba y después no).
En la figura 1 tienes una captura del código de ejemplo en funcionamiento (en ese caso la aplicación de C# creada con .NET Framework 4.8).
Figura 1. La aplicación de ejemplo en funcionamiento.
¿Cómo saber si hay varias combinaciones de teclas?
Lo que yo he hecho es crear unas variables para asignarles un valor si la combinación que se quiere detectar se cumple. Esas variables (o campos) definidas a nivel de la clase, las he declarado de tipo entero, (en los ejemplos que vi en la web eran de tipo Boolean, bool en C#), ya que lo que me interesa es saber si algunas de las combinaciones se ha hecho más de una vez, ese es el caso de Ctrl+K, Ctrl+K, es decir: pulsar dos veces la tecla Control y la tecla K.
Si no quieres comprobar si hay una combinación que se haga más de una vez, lo mismo puedes usar variables de tipo Bolean (bool en C#), eso ya a tu discreción (o preferencia).
Aquí te muestro el código con la definición de esas variables (tanto para VB como para C#):
' Para doble pulsación de teclasPrivate CtrlK AsIntegerPrivate CtrlC AsIntegerPrivate CtrlU AsIntegerPrivate CtrlL AsIntegerPrivate ShiftAltL AsIntegerPrivate ShiftAltS AsInteger
// Para doble pulsación de teclasprivateint CtrlK;
privateint CtrlC;
privateint CtrlU;
privateint CtrlL;
privateint ShiftAltL;
privateint ShiftAltS;
Esas variables las usaremos en el evento KeyDown del formulario, incrementando el valor cuando se cumpla que se han pulsado las teclas indicadas, por ejemplo si queremos detectar la pulsación de Ctrl+K, tendremos que incrementar el valor de la variable CtrlK, ídem con el resto.
Como en el ejemplo hay varias combinaciones de teclas que detectar, puede ser un poco largo de ver, pero prefiero que lo veas completo para que no te líes demasiado. Ahí se comprueban las tres posibles teclas de «control«, es decir, Control, Shift y Alt. También hago comprobaciones para que, por ejemplo, si queremos detectar Ctrl+Shift se haga en un bloque de código diferente para cuando se detecta, por ejemplo Ctrl+Alt o Shift+Alt. Creo que el código está bastante claro y no tendrás complicaciones de ver el proceso que se hace.
Aquí tienes el código de VB y C#.
PrivateSubForm1_KeyDown(senderAsObject, e AsKeyEventArgs) HandlesMe.KeyDown' Comprobaciones para Ctrl+Shift' esta de forma simpleIf e.ControlAndAlso e.ShiftThenIf e.KeyCode = Keys.V Then
e.Handled = True'MostrarRecortes();txtPulsadas.Text = "Capturada: Ctrl+Shift+V" & vbCrLf & txtPulsadas.TextEndIf' Estas son con varias combinaciones' Comprobaciones para Shift+AltElseIf e.ShiftAndAlso e.AltThen' si se ha pulsado Shift+Alt+LIf e.KeyCode = Keys.L Then
e.Handled = True
ShiftAltL += 1
' si se ha pulsado Shift+Alt+SElseIf e.KeyCode = Keys.S Then
e.Handled = True
ShiftAltS += 1
EndIf' Si se ha pulsado Shitf+Alt+S, Shift+Alt+L' (en cualquier orden)If ShiftAltL = 1 AndAlso ShiftAltS = 1 Then
e.Handled = True'ClasificarSeleccion();txtPulsadas.Text = "Capturada: Shift+Alt+L, Shift+Alt+S" & vbCrLf & txtPulsadas.TextEndIf' Comprobaciones para solo la tecla Ctrl (sin Shift ni Alt)ElseIf e.ControlAndAlsoNot e.ShiftAndAlsoNot e.AltThen' Solo se ha pulsado la tecla Ctrl' comprobar el resto de combinaciones' Forma simple si se ha pulsado Ctrl+BIf e.KeyCode = Keys.B Then
e.Handled = True' Esta solo es para detectar' la combinación 'simple' de Ctrl+B' No es necesario llevar la cuenta de las pulsacionestxtPulsadas.Text = "Capturada: Ctrl+B" & vbCrLf & txtPulsadas.TextElseIf e.KeyCode = Keys.K Then
e.Handled = True
CtrlK += 1
txtPulsadas.Text = "Ctrl+K - " & txtPulsadas.TextElseIf e.KeyCode = Keys.C Then
e.Handled = True
CtrlC += 1
txtPulsadas.Text = "Ctrl+C - " & txtPulsadas.TextElseIf e.KeyCode = Keys.U Then
e.Handled = True
CtrlU += 1
txtPulsadas.Text = "Ctrl+U - " & txtPulsadas.TextElseIf e.KeyCode = Keys.L Then
e.Handled = True
CtrlL += 1
txtPulsadas.Text = "Ctrl+L - " & txtPulsadas.TextEndIf' Si se ha pulsado Ctrl+K, CtrlCIf CtrlK = 1 AndAlso CtrlC = 1 Then
e.Handled = True' Ctrl+K, Ctrl+C
CtrlK = 0
CtrlC = 0
'PonerComentarios(richTextBoxCodigo);txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+C" & vbCrLf & txtPulsadas.Text' Si se ha pulsado Ctrl+K, Ctrl+UElseIf CtrlK = 1 AndAlso CtrlU = 1 Then
e.Handled = True' Ctrl+K, Ctrl+U
CtrlK = 0
CtrlU = 0
'QuitarComentarios(richTextBoxCodigo);txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+U" & vbCrLf & txtPulsadas.Text' Si se ha pulsado Ctrl+K, Ctrl+LElseIf CtrlK = 1 AndAlso CtrlL = 1 Then
e.Handled = True' Ctrl+K, Ctrl+L
CtrlK = 0
CtrlL = 0
' preguntar'buttonEditorMarcadorQuitarTodos.PerformClick();txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+L" & vbCrLf & txtPulsadas.Text' Si se ha pulsado Ctrl+K, Ctrl+KElseIf CtrlK = 2 Then
e.Handled = True' Ctrl+K, Ctrl+K
CtrlK = 0
'MarcadorPonerQuitar();txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+K" & vbCrLf & txtPulsadas.TextEndIfElsetxtPulsadas.Text = $"{vbCrLf}No es una de las teclas comprobadas: {e.KeyCode} +{vbCrLf}" &
$" Ctrl: {e.Control}, Shift: {e.Shift}, Alt: {e.Alt}{vbCrLf}" & txtPulsadas.Text
CtrlK = 0
CtrlC = 0
CtrlU = 0
ShiftAltL = 0
ShiftAltS = 0
' Otras pulsaciones' No están detectadas explícitamenteEndIfEndSub
privatevoidForm1_KeyDown(objectsender, KeyEventArgs e)
{
// Comprobaciones para Ctrl+Shift// esta de forma simpleif (e.Control && e.Shift)
{
if (e.KeyCode == Keys.V)
{
e.Handled = true;
//MostrarRecortes();txtPulsadas.Text = "Capturada: Ctrl+Shift+V\r\n" + txtPulsadas.Text;
}
}
// Estas son con varias combinaciones// Comprobaciones para Shift+Altelseif (e.Shift && e.Alt)
{
// si se ha pulsado Shift+Alt+Lif (e.KeyCode == Keys.L)
{
e.Handled = true;
ShiftAltL += 1;
}
// si se ha pulsado Shift+Alt+Selseif (e.KeyCode == Keys.S)
{
e.Handled = true;
ShiftAltS += 1;
}
// Si se ha pulsado Shitf+Alt+S, Shift+Alt+L// (en cualquier orden)if (ShiftAltL == 1 && ShiftAltS == 1)
{
e.Handled = true;
//ClasificarSeleccion();txtPulsadas.Text = "Capturada: Shift+Alt+L, Shift+Alt+S\r\n" + txtPulsadas.Text;
}
}
// Comprobaciones para solo la tecla Ctrl (sin Shift ni Alt)elseif (e.Control && !e.Shift && !e.Alt)
{
// Solo se ha pulsado la tecla Ctrl// comprobar el resto de combinaciones// Forma simple si se ha pulsado Ctrl+Bif (e.KeyCode == Keys.B)
{
e.Handled = true;
// Esta solo es para detectar// la combinación 'simple' de Ctrl+B// No es necesario llevar la cuenta de las pulsacionestxtPulsadas.Text = "Capturada: Ctrl+B\r\n" + txtPulsadas.Text;
}
elseif (e.KeyCode == Keys.K)
{
e.Handled = true;
CtrlK += 1;
txtPulsadas.Text = "Ctrl+K - " + txtPulsadas.Text;
}
elseif (e.KeyCode == Keys.C)
{
e.Handled = true;
CtrlC += 1;
txtPulsadas.Text = "Ctrl+C - " + txtPulsadas.Text;
}
elseif (e.KeyCode == Keys.U)
{
e.Handled = true;
CtrlU += 1;
txtPulsadas.Text = "Ctrl+U - " + txtPulsadas.Text;
}
elseif (e.KeyCode == Keys.L)
{
e.Handled = true;
CtrlL += 1;
txtPulsadas.Text = "Ctrl+L - " + txtPulsadas.Text;
}
// Si se ha pulsado Ctrl+K, CtrlCif (CtrlK == 1 && CtrlC == 1)
{
e.Handled = true;
// Ctrl+K, Ctrl+C
CtrlK = 0;
CtrlC = 0;
//PonerComentarios(richTextBoxCodigo);txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+C\r\n" + txtPulsadas.Text;
}
// Si se ha pulsado Ctrl+K, Ctrl+Uelseif (CtrlK == 1 && CtrlU == 1)
{
e.Handled = true;
// Ctrl+K, Ctrl+U
CtrlK = 0;
CtrlU = 0;
//QuitarComentarios(richTextBoxCodigo);txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+U\r\n" + txtPulsadas.Text;
}
// Si se ha pulsado Ctrl+K, Ctrl+Lelseif (CtrlK == 1 && CtrlL == 1)
{
e.Handled = true;
// Ctrl+K, Ctrl+L
CtrlK = 0;
CtrlL = 0;
// preguntar//buttonEditorMarcadorQuitarTodos.PerformClick();txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+L\r\n" + txtPulsadas.Text;
}
// Si se ha pulsado Ctrl+K, Ctrl+Kelseif (CtrlK == 2)
{
e.Handled = true;
// Ctrl+K, Ctrl+K
CtrlK = 0;
//MarcadorPonerQuitar();txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+K\r\n" + txtPulsadas.Text;
}
}
else
{
txtPulsadas.Text = $"\r\nNo es una de las teclas comprobadas: {e.KeyCode} +\r\n"+
$" Ctrl: {e.Control}, Shift: {e.Shift}, Alt: {e.Alt}\r\n" + txtPulsadas.Text;
CtrlK = 0;
CtrlC = 0;
CtrlU = 0;
ShiftAltL = 0;
ShiftAltS = 0;
// Otras pulsaciones// No están detectadas explícitamente
}
}
Nota: En el código están comentadas las funciones / métodos a los que en el programa que uso esta forma de controlar las pulsaciones (múltiples) de teclas llama cuando se produce una. Así sabrás cuándo tienes que actuar cuando se produzca la pulsación esperada.
Una aclaración sobre la diferencia entre KeyCode y KeyValue
Hay gente que no se aclara entre los valores de esas dos propiedades del argumento KeyEventArgs del evento KeyDown (o KeyUp).
KeyCode contiene el código de la tecla pulsada y el del tipo Keys (enumeración). KeyValue contiene el código de la tecla pulsada y el de tipo Integer (int en C#).
En Visual Basic se puede usar indistintamente sin hacer nada especial, es decir, par saber si se ha pulsado la tecla B puedes hacerlo de estas dos formas: If e.KeyCode = Keys.B Then o If e.KeyValue = Keys.B
Pero en C# no te permite hacer la comparación del valor int con un valor de la enumeración Keys. Si así lo quieres hacer, tendrías que hacer un cast al tipo entero: if (e.KeyValue == (int)Keys.B)
Por tanto, es mejor usar e.KeyCode si la intención es compararla con un valor de Keys.
Ya solo me queda ponerte el código completo de esta aplicación de prueba, pero como últimamente estoy haciendo (creo que solo lo he hecho una vez) ese código (tanto el de Visual Basic como el de C#) está en mis repositorios en GitHub, concretamente en varias-pulsaciones-de-teclas.
Dicho código está creado en un proyecto para Visual Studio 2019 usando .NET Framework 4.8, pero también es válido para aplicaciones (de WinForms) creadas para .NET Core, al menos yo lo estoy usando en .NET 5.0 RC1.
Si continuas usando este sitio, aceptas el uso de cookies. más información
The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.