elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Sigue las noticias más importantes de elhacker.net en ttwitter!


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 1002
121  Programación / Scripting / Re: La tarea no me ejecuta mi .exe!!! en: 27 Junio 2017, 20:19
Supongo que por "tarea" te refieres a una tarea programada del sistema.

Sinceramente, ¿qué esperas que te podamos decir con la información que da?, si tan solo dices que no funciona, y no muestras cómo estás creando la tarea, ni nada en absoluto...

Abre el programador de tareas, localiza la tarea programada que creaste, expórtala a Xml y muéstranos el contenido del archivo generado para que podamos analizar los parámetros de la tarea programada...

Saludos
122  Programación / .NET / Re: Colorear marco de textbox o combobox en: 27 Junio 2017, 20:05
Ya sería la repera si en el icono que muestra el ErrorProvider pudiese ponerse un atributo para que al pasar el ratón por encima te mostrase una frase, así como hace el atributo title en php...  

Jeje, pues si, te refieres a mostrar un Tooltip, y eso es precisamente una de sus funcionalidades... :-)

Sencillamente debes utilizar el método ErrorProvider.SetError(), a este método le pasas como argumento el control que falló en la validación, y el mensaje de error...

Ejemplo:
Código
  1. if (string.IsNullOrWhiteSpace(this.TextBox1.Text)) {
  2. this.ErrorProvider1.SetError(this.TextBox1, "Invalid username.");
  3. }



Saludos
123  Programación / Scripting / Re: Añadir codigo de Barra de Progreso a un BAT en: 27 Junio 2017, 09:24
El utilizar el programa InnoSetup, sólo me serviría para crear 1 sólo instalador y NO múltiples y de forma normal o desatendida.

No. Con InnoSetup (o cualquier otro install builder) puedes empaquetar los 14 executables que quieres instalar, en un solo executable/instalador, con barra de progreso. La instalación de esos 14 executables será desatendida/silenciosa/automatizada, como quieras. De hecho si lo prefieres ni siquiera tienes que empaquetar esos executables, pueden estar ubicados en cualquier directorio (de la misma manera que lo están cuando los quieres ejecutar con un batch-script). Como ya dije, sirviría para llevar a cabo la misma tarea que pretendes realizar en Batch, y no solo me refiero al procedimeinto de instalación de cada executable/instalador por individual de forma automatizada, sino también a la creación de una interfáz de usuario o menú donde elegir el tipo de instalación, y etc.

Simplemente me gustaría saber si me pueden colaborar en el foro a poder añadir o una barra de progreso o algún tipo de porcentaje que me indique cuanto falta para que termine dicho proceso.

Batch es un "lenguaje de programación" muy limitado el cual no ha sido pensado para ese tipo de tareas, cualquier cosa se vuelve compleja de realizar precisamente por su escasez, ya que no provee miembros built-in para ciertas tareas ni mucho menos componentes de interfaces gráficas. Si realmente quieres optar por la programación, entonces deberías considerar la idea de deshechar Batch y empezar a utilizar un lenguaje capacitado para esa tarea, un lenguaje de verdad, preferiblemente un lenguaje que posea un framework con un componente de progressbar/barra de progreso que te permita desarrollar de forma sencilla una GUI; unos ejemplos serían: C#, Java o VB.NET.

Pero es que de todas formas a la pregunta que formulaste ya se te explicó la solución, se te explicó cual es el valor que modificar y como podrías implementar la funcionalidad que deseas, ¿qué más dudas tienes con respecto a eso?... ¿lo has intentando hacer por ti mismo?.

PD: Aunque no te lo parezca, la opción de utilizar un install builder es la más apropiada en estas circunstancias, precisamente por que es un software ideado específicamente para cumplir esa funcionalidad, la de proveer un procedimiento sofisticado (y personalizable) de instalación.

Saludos
124  Programación / .NET / Re: Ayuda en C# Con el DeleteObject en: 26 Junio 2017, 23:23
no me aparece y no se porque

Lee aquí:

Saludos.
125  Programación / Programación General / MOVIDO: Ayuda en C# Con el DeleteObject en: 26 Junio 2017, 23:10
El tema ha sido movido a .NET.

http://foro.elhacker.net/index.php?topic=471561.0
126  Programación / .NET / Re: Error de Visual Basic en: 26 Junio 2017, 21:59
Sabéis a qué se puede deber este error?

¿Quizás podría estar relacionado con este error de número de compilaciones que provocan un reinicio inesperado de la aplicación WEB?:


( Abajo en la sección 'Resolution' te indican una posible solucion. )

Ante un problema tan extraño y sin mensaje de error ni nada por el estilo, creo que sería aconsejable que pruebes a utilizar una versión más reciente de Visual Studio.

Saludos!
127  Programación / Programación Visual Basic / MOVIDO: Error de Visual Basic en: 26 Junio 2017, 21:52
El tema ha sido movido a .NET.

http://foro.elhacker.net/index.php?topic=471564.0
128  Foros Generales / Foro Libre / Re: ¿Es La Tierra una mente y la razón de nuestra Consciencia Colectiva? en: 26 Junio 2017, 20:40
Esa creencia de que nuestro planeta "está hecho a nuestra media" es una idea bonita, pero falsa.

Si ponemos las cosas en perspectiva, somos mas pequeños respecto a nuestro planeta, que los "bichitos" y bacterias varias que viven en nuestra piel

De hecho eso sería otra teoría a barajar... que simplemente seamos "bacterias", jeje, la de veces que lo he pensado... y por supuesto eso ya no sería soberbio, pero a lo mejor si que resultaría ser el extremo opuesto, es decir, infravalorarse hasta el límite... no lo sé, no tengo las respuestas a los enigmas de la vida.

Saludos!
129  Programación / Scripting / Re: Añadir codigo de Barra de Progreso a un BAT en: 26 Junio 2017, 06:15
Esa barra de progreso es demostrativa más que rehutilizable y funcional, está muy hardcodeada (no podría ser de otra forma siendo Batch).

En esta linea se determina que la operación de "progreso" ha terminado cuando el valor de la variable counter es igual o mayor que 50.
Citar
Código
  1. if %counter% GEQ 50 set msg=complete& set counterb=10000& goto exit

El valor de porcentage (si es que se le puede llamar así) se define en la variable counterb, no juega ningún papel real en el algoritmo, tan solo es un dato visual y hardcodeado para que llegue a 100% (o mejor dicho a 10.000) al mismo tiempo que se escriben esos 50 "Û" es decir que el valor de la variable counter llegue a 50.

Sabiendo eso, y que tienes 14 executables que quieres instalar, o dicho de ora forma 14 operaciones a realizar, pues simplemente debes calcular y adaptar el código a tus necesidades. Debes aumentar el límite de 50 a 56, y por cada una de las 14 operaciones debes sumarle un "4" al valor de la variable counter (14*4=56), de esta forma conseguirar que el "progreso" finalice en 14 ciclos.

Pero ya te digo que eso resulta muy tedioso de hacer, si quieres evitar tener que copiar 14 veces el mismo bloque de código entonces tienes que idear la forma de adaptar la ejecución de tus 14 operaciones en un For ...por ejemplo leyendo la primera linea de un archivo de texto que contenga la ruta hacia cada instalador (y posteriormente eliminar esa linea, para luego leer la siguiente linea en la siguiente iteración) ¿y que pasará cuando en vez de 14 executables tengas 13, 10 o 21?, a volver a modificar todos los valores y empezar desde cero con la adaptación...

Sinceramente, esas "barras de progreso" en Batch no vale la pena ni tan siquiera fijarse en su decoración, no veo ninguna razón lo suficientemente sostenible ni inteligente para invertir tiempo y esfuerzo en adaptar el código, amigo, tú lo que realmente necesitas es un software de creación de instaladores (o install builder) como por ejemplo InnoSetup, en el que puedes llevar a cabo la misma tarea que quieres hacer en Batch, solo que de forma eficiente, sofisticada, dinámica, segura y con un estilo visual mucho más bonito. Si lo llegas a utilizar y aceptar este consejo que te doy, me lo agradecerás, te lo aseguro. :P

Saludos!
130  Programación / .NET / Re: Colorear marco de textbox o combobox en: 26 Junio 2017, 05:11
utilizando expresiones regulares para dni, correo, etc...

La forma más segura de validar una dirección de email, es mediante un proveedor de validación de dominios (ya sea online, o mediante una bd offline), pero a falta de esto, mejor que una expresión regular es más recomendable utilizar los miembros de la clase System.Uri para validar la estructura/sintaxis de la dirección de e-mail ( puedes combinar esta metodología con una evaluación RegEx para cubrir otros aspectos de validación sobre el string, pero en mi opinión eso sería perder el tiempo, puesto que nada es 100% efectivo, y esto ya cubre varios aspectos importantes de validación de direcciones e-mail ):

Código
  1. /// ----------------------------------------------------------------------------------------------------
  2. /// <summary>
  3. /// Validates a mail address.
  4. /// </summary>
  5. /// ----------------------------------------------------------------------------------------------------
  6. /// <example> This is a code example.
  7. /// <code>
  8. /// Dim isValid As Boolean = ValidateMail("Address@Gmail.com")
  9. /// Dim isValid As Boolean = ValidateMail("mailto:Address@Gmail.com")
  10. /// </code>
  11. /// </example>
  12. /// ----------------------------------------------------------------------------------------------------
  13. /// <param name="address">
  14. /// The mail address.
  15. /// </param>
  16. /// ----------------------------------------------------------------------------------------------------
  17. /// <returns>
  18. /// <see langword="true"/> if the mail address is valid, <see langword="false"/> otherwise.
  19. /// </returns>
  20. /// ----------------------------------------------------------------------------------------------------
  21. [DebuggerStepThrough()]
  22. public static bool ValidateMail(string address) {
  23.  
  24. if (!address.StartsWith("mailto:", StringComparison.OrdinalIgnoreCase)) {
  25. address = address.Insert(0, "mailto:");
  26. }
  27.  
  28. if (!Uri.IsWellFormedUriString(address, UriKind.Absolute)) {
  29. return false;
  30. }
  31.  
  32. Uri result = null;
  33. if (Uri.TryCreate(address, UriKind.Absolute, result)) {
  34. return (result.Scheme == Uri.UriSchemeMailto);
  35.  
  36. } else {
  37. return false;
  38.  
  39. }
  40.  
  41. }
  42.  
  43. /// ----------------------------------------------------------------------------------------------------
  44. /// <summary>
  45. /// Validates a mail address.
  46. /// </summary>
  47. /// ----------------------------------------------------------------------------------------------------
  48. /// <example> This is a code example.
  49. /// <code>
  50. /// Dim isValid As Boolean = ValidateMail(New MailAddress("Address@Gmail.com"))
  51. /// Dim isValid As Boolean = ValidateMail(New MailAddress("mailto:Address@Gmail.com"))
  52. /// </code>
  53. /// </example>
  54. /// ----------------------------------------------------------------------------------------------------
  55. /// <param name="address">
  56. /// The mail address.
  57. /// </param>
  58. /// ----------------------------------------------------------------------------------------------------
  59. /// <returns>
  60. /// <see langword="true"/> if the mail address is valid, <see langword="false"/> otherwise.
  61. /// </returns>
  62. /// ----------------------------------------------------------------------------------------------------
  63. [DebuggerStepThrough()]
  64. public static bool ValidateMail(MailAddress address) {
  65. return MailUtil.ValidateMail(address.Address);
  66. }

El código original, este de aquí abajo, lo he extraido de mi framework comercial Elektrokit para programadores de .NET (el cual lo puedes encontrar en mi firma, por si te interesa)...



Código
  1.    Graphics g = //....aqui me he quedado porque en la funcion original se usaba
  2. //un PaintEventArgs e como argumento y la línea de instrucción seguia ...e.Graphics.
  3.  

Esto que voy a explicar no te conviene hacerlo, tan solo me estoy limitando a responder a tu pregunta para aclararte la duda que tienes:

El objeto "e" es del tipo Graphics, por ende, la función equivalente que estás buscando es Control.CreateGraphics(), o bien Graphics.FromHwnd() (ambas tienen el mismo efecto)


Te muestro un ejemplo de uso genérico que he elaborado con extensiones de método:
Código
  1. public static class ControlExtensions {
  2.  
  3. /// <summary>
  4. /// Draws a solid border of the specified color with 1 pixel width around the bounds of the source <see cref="Control"/>.
  5. /// </summary>
  6. public static void DrawBorder(this Control sender, Color color) {
  7. ControlExtensions.DrawBorder(sender, color, 1, ButtonBorderStyle.Solid, sender.ClientRectangle);
  8. }
  9.  
  10. /// <summary>
  11. /// Draws a solid border of the specified color and with around the bounds of the source <see cref="Control"/>.
  12. /// </summary>
  13. public static void DrawBorder(this Control sender, Color color, int width) {
  14. ControlExtensions.DrawBorder(sender, color, width, ButtonBorderStyle.Solid, sender.ClientRectangle);
  15. }
  16.  
  17. /// <summary>
  18. /// Draws a border of the specified color, with and style around the bounds of the source <see cref="Control"/>.
  19. /// </summary>
  20. public static void DrawBorder(this Control sender, Color color, int width, ButtonBorderStyle style) {
  21. ControlExtensions.DrawBorder(sender, color, width, style, sender.ClientRectangle);
  22. }
  23.  
  24. /// <summary>
  25. /// Draws a border of the specified color, with and style around the specified bounds of the source <see cref="Control"/>.
  26. /// </summary>
  27. public static void DrawBorder(this Control sender, Color color, int width, ButtonBorderStyle style, Rectangle bounds) {
  28.  
  29. switch (sender.GetType()) {
  30.  
  31. // You can implement here a custom case for selective painting...
  32.        // case typeof(TextBox):
  33.        // case typeof(RichTextBox):
  34.        // etc.
  35.  
  36. default:
  37. using (Graphics g = sender.CreateGraphics()) { // or also: Graphics.FromHwnd(sender.Handle)
  38.  
  39. ControlPaint.DrawBorder(g, bounds,
  40.                    color, width, style,  // left
  41.                    color, width, style,  // top
  42.                    color, width, style,  // right
  43.                    color, width, style); // bottom
  44. }
  45. break;
  46. }
  47.  
  48. }
  49.  
  50. }

Modo de empleo:
Código
  1. myControl.DrawBorder(Color.Red, 1, ButtonBorderStyle.Solid);

Código original, escrito en VB.NET:



me gustaría que si un campo no pasa la validación, dicho campo(siendo textbox o combobox, o label para radiobutton o checkbox) cambiase de color(la letra en los labels y el borde de los textbox o combobox).

Para el tratamiento de validación de entrada en controles de edición (o Edit-controls) te conviene utilizar el componente ErrorProvider, sin más, una vez lo hayas configurado de forma correcta (controlando las validaciones de cada campo/control) si un control no pasa la validación entonces el componente mostrará un icono (personalizable) que indicará un fallo de validación en "X" campo(s), y de esta manera evitarás tener que reinventar la rueda para ir intentando modificar el color de los bordes de todos los controles del Form en caso de fallo de validación...






lo único de lo que realmente me entero es de que le he pasado el control y que creo que no debe ser tan difícil...

Alguien me puede decir si voy por buen camino y qué es lo que me falta??

No, no vas por buen camino, por varios motivos...

La solución que considero más óptima ya te la expliqué más arriba, el componente ErrorProvider, y todo lo que voy a decir desde este momento hasta el final del post no contribuye a la solución recomendada, por que la solución más óptima para tus necesidades ya se te explicó cual es (insisto), ahora, con la intención de intentar enseñarte y que aprendas algo básico que te podría servir de ayuda, déjame explicarte que los controles por defecto de Microsoft/.NET Framework se renderizan a partir de los estilos de ventana (también conocidos como Window Styles, y los estilos de ventana extendidos o Extended Window Styles) y de los estilos visuales definidos para el tipo de control (a su vez, los estilos visuales del control están definidos por el tema visual/windows theme que esté actualmente activo en el sistema operativo), quienes controlan el aspecto resultante del control. Puedes aplicar un estilo de ventana y también un estilo visual de control específico, por ejemplo puedes asignarle el estilo visual de un button a un picturebox (todo esto de forma administrada), lo que literálmente convertirá el aspecto del control sin realizar mayor esfuerzo, e incluso puedes desactivar los estilos visuales en toda la aplicación, pero eso es otra historia...

Por si te interesa para el futuro:

Sigamos con las explicaciones...

Dependiendo del control en cuestión, éste puede requerir un tratamiento específico y "especial" para poder aplicarle personalizaciones de diseño como por ejemplo añadir un borde de un color específico, pues los controles se encargan de controlar por si mismos sus eventos de dibujado y con ello se encargan de administrar el cómo, el cuando, y el qué deben dibujar ( en general todos los controles exponen el evento Control.Paint, pero otros controles disponen de varios eventos adicionales de dibujado, los que internámente administran los mensajes de ventana: WM_PAINT, WM_PRINTCLIENT, etc ), y en muchos controles la complejidad de "dibujado manual" aumenta considerablemente, por ejemplo en un ListView, si queremos personalizar su diseño entonces deberemos encargarnos de administrar el dibujado del fondo o background, y de la rejilla o grid, las columnas, el texto de cada campo de cada fila y su posicionamiento/alineación, etc; son muchos factores a tener en cuenta.

Personalizar el diseño de un control no es un tema sencillo, se requiere entendimiento, pues de hecho es MUY denso (hay muchos conceptos que no he tratado para no alargar más las explicaciones, y otros tantos conceptos que ni conoceré), y sobre todo se necesita PRÁCTICA para comprender, por que tarde o tempranos las pasaremos canutas puesto que algunos controles no permiten una administración guiada o sencilla por parte del usuario para este tipo de personalizaciones... y tendremos que activar una propiedad conocida como OwnerDraw y/o activar el UserPaint para "obligar" a que el control deje de administrar el dibujado para darnos el relevo y encarganos nosotros, pero en algunos controles esto será ignorado internamente, y entonces deberemos recurrir a la API de Windows para administrar el dibujado del control, todo esto se debe a que la tecnología de WindowsForms (a diferencia de WPF) no está pensada para satisfacer las necesidades exquisitas de este tipo de personalizaciones avanzadas de diseño de controles... el soporte es muy limitado en este aspecto.

Por último, y quizás lo más importante que debes saber despues de todo este rollo...

La forma en la que estás intentando dibujar un borde sobre un control, es incorrecta (a parte de estar usando el método DrawRectangle que es bastante expensivo y esto puede generar flickering), por que como ya hemos aclarado previamente, los controles se encargan de administrar el cómo, el cuando, y el qué deben dibujar, esto quiere decir que si tú en un momento determinado "X" le modificas el borde al control, ese cambio no persistirá demasiado... ya que la próxima vez que el control vuelva a controlar su dibujado, éste desechará el cambio que le aplicaste (o mejor dicho, el borde que tu dibujaste se "limpiará"), esto puedes comprobarlo sin ir más lejos con un Button, cuando pasas el puntero del mouse por encima del button se disparan varios eventos del mouse y del foco, y con ello el botón se redibujará... y perderás el borde que hayas aplicado de la manera en la que lo estás intentando aplicar.

Para solucionar ese problema, tienes dos opciones, la primera y la más deficiente es seguir con el código que estabas escribiendo (o con el código que yo te mostré con las extensiones de método) y controlar desde tu Form todos y cada uno de los eventos de "X" control que impliquen un redibujado de ese control, para llamar al método encargado de dibujar el borde en cada redibujado (esto es muy ineficiente y no siempre dará el resultado esperado).

La segunda opción, la más óptima, sería heredar la clase del control para controlar el dibujado. Según el control que sea, podrá ser tan sencillo como ampliar la implementación de invalidación (u overriding) del método heredado Control.OnPaint(), en otros casos hará falta hacer lo mismo en otros métodos heredados relacionados con el dibujado, y en los casos más tediosos o quizás "complejos" deberemos procesar manualmente los mensajes de dibujado de ventana mediante el método de procedimiento de ventana (WndProc), y según la sofisticación que queramos obtener, adicionálmente recurrir a la API de Windows a las funciones BeginPaint y EndPaint para reducir el efecto de flickering... entre otras técnicas que también podemos combinar para el mismo propósito.

En fin, para acabar te muestro un ejemplo sencillo y básico de como se podría implementar la funcionalidad de modificar el color del borde de un control de tipo Button:

Código
  1. [DisplayName("MyExtendedButton")]
  2. [Description("A extended Button control.")]
  3. [DesignTimeVisible(true)]
  4. [DesignerCategory("UserControl")]
  5. [ToolboxBitmap(typeof(Button), "Button.bmp")]
  6. [ToolboxItemFilter("System.Windows.Forms", ToolboxItemFilterType.Require)]
  7. [ClassInterface(ClassInterfaceType.AutoDispatch)]
  8. [ComVisible(true)]
  9. [DefaultProperty("Text")]
  10. [DefaultEvent("Click")]
  11. public sealed class MyExtendedButton : Button {
  12.  
  13. [Browsable(true)]
  14. [EditorBrowsable(EditorBrowsableState.Always)]
  15. [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  16. [Localizable(false)]
  17.        [Category("(Extended) Appearance")]
  18. [Description("The border color of the control.")]
  19. [DefaultValue(typeof(Color), "ControlLight")]
  20. public Color BorderColor { get; set; }
  21.  
  22. [DebuggerNonUserCode()]
  23. public MyExtendedButton() {
  24. base.SuspendLayout();
  25.  
  26. base.SetStyle(ControlStyles.DoubleBuffer, true);
  27. // base.SetStyle(ControlStyles.AllPaintingInWmPaint, ... );
  28. // base.SetStyle(ControlStyles.ResizeRedraw, ... );
  29. // base.SetStyle(ControlStyles.UserPaint, ... );
  30. // base.SetStyle(ControlStyles.SupportsTransparentBackColor, ... );
  31.  
  32. base.ResumeLayout(performLayout: false);
  33. }
  34.  
  35. [DebuggerStepThrough()]
  36. protected override void OnPaint(PaintEventArgs e) {
  37. base.OnPaint(e);
  38. }
  39.  
  40. [DebuggerStepThrough()]
  41. protected override void OnPaintBackground(PaintEventArgs e) {
  42. base.OnPaintBackground(e);
  43. }
  44.  
  45. [DebuggerStepperBoundary()]
  46. protected override void WndProc(ref Message m) {
  47. base.WndProc(m);
  48.  
  49. switch (m.Msg) {
  50. case 15: // WM_Paint
  51. this.DrawBorder();
  52. break;
  53. }
  54. }
  55.  
  56. [DebuggerStepperBoundary()]
  57. private void DrawBorder() {
  58. using (Graphics g = base.CreateGraphics()) {
  59. ControlPaint.DrawBorder(g, base.ClientRectangle,
  60.                                    this.BorderColor, 1, ButtonBorderStyle.Solid,  // left
  61.                                    this.BorderColor, 1, ButtonBorderStyle.Solid,  // top
  62.                                    this.BorderColor, 1, ButtonBorderStyle.Solid,  // right
  63.                                    this.BorderColor, 1, ButtonBorderStyle.Solid); // bottom
  64.  
  65. }
  66. }
  67.  
  68. }

Código original, escrito en VB.NET:

PD: Logicamente ese código es un ejemplo, carente de muchas funcionalidades básicas, por ejemplo se podría adaptar para aplicar un color distitno en el caso de que el botón tenga foco o no lo tenga, o cuando está pulsado o no lo está.

Saludos.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 1002
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines