Archivo de la categoría: WPF

[WPF] Ventana sin bordes

Este no va a ser un artículo muy largo pues sólo se explicará cómo obtener una ventana sin bordes y agregar la funcionalidad de que se pueda mover, minimizar y cerrar.

Comencemos primero quitando los bordes de la ventana.

<Window x:Class="Windowless.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        WindowStyle="None"
        AllowsTransparency="True" Background="Transparent">

</Window>

La propiedad WindowStyle nos ayudará a quitar el borde donde se encuentra los botones (maximizar, minimizar y cerrar); con la propiedad AllowsTransparency creará una zona donde se permita la transparencia, esto unido al Background transparente terminará en una ventana completamente transparente.

Ahora veamos el resto de código donde se muestra la creación de la barra de título y los botones.

<Border Margin="10" BorderBrush="Red" BorderThickness="0.5">
    <Border.Effect>
        <DropShadowEffect Color="Black"
                          Direction="320"
                          BlurRadius="15"
                          ShadowDepth="3" />
    </Border.Effect>
    <DockPanel LastChildFill="True" Background="White">
        <Grid DockPanel.Dock="Top" Height="25">
            <TextBlock Text="{Binding Path=Title, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
                       HorizontalAlignment="Center" />
            <Rectangle Name="titleBar"
                       Fill="Transparent"
                       MouseLeftButtonDown="titleBar_MouseLeftButtonDown"/>
            <Button Name="closeButton"
                    Style="{StaticResource CerrarStyle}"
                    HorizontalAlignment="Right"
                    Width="15" Margin="0,0,5,0" Height="15"
                    Click="closeButton_Click"/>
            <Button Name="minButton"
                    Style="{StaticResource MinimizarStyle}"
                    HorizontalAlignment="Right"
                    Width="15" Margin="0,0,25,0" Height="9"
                    Click="minButton_Click"/>
        </Grid>
        <Grid Name:"Contenido">

        </Grid>
    </DockPanel>
</Border>

Los eventos de los botones y el rectángulo están definidos así:

private void titleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    this.DragMove();
}

private void closeButton_Click(object sender, RoutedEventArgs e)
{
    this.Close();
}

private void minButton_Click(object sender, RoutedEventArgs e)
{
    this.WindowState = System.Windows.WindowState.Minimized;
}

Y eso sería todo para crear nuestra ventana sin bordes. Como siempre les dejo el archivo en C# (Windowless.zip), esta vez no publicaré el de VB.NET pues es bastante sencillo de convertir.

Anuncios

Leer y Escribir xml usando Linq

Este va a ser un pequeño artículo donde veremos cómo leer y escribir un documento xml usando Linq. La estructura que va a tener nuestro documento al final será la siguiente:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Personas>
    <Persona>
        <Nombre> </Nombre>
        <Apellido> </Apellido>
        <Edad></Edad>
        <Correo> </Correo>
    </Persona>
</Personas>

Para leer un documento con esta estructura, debemos hacer esto usando Linq:

XDocument xdoc = XDocument.Load(archivo);

lista = (from x in xdoc.Descendants("Persona")
         select new Persona
         {
             Nombre = x.Element("Nombre").Value,
             Apellido = x.Element("Apellido").Value,
             Edad = Convert.ToInt32(x.Element("Edad").Value),
             Correo = x.Element("Correo").Value
         }).ToList();

Aclaremos ciertas cosas con respecto al código anterior: primero, la variable archivo es un string donde se guarda la ruta del archivo que deseamos leer; segundo, Persona es una clase la cual tiene como propiedades Nombre, Apellido, Edad y Correo; por último, la variable lista es una lista del tipo List<Persona> la cual contendrá todos los registros del archivo leído.

Para obtener más información puede mirar esto enlaces sobre Descendants y Element. Si desea aprender más de xml puede leer este tutorial en W3Schools.

Vayamos ahora a la parte de escribir el archivo xml:

if (dataGrid.ItemsSource != null)
{
    XDocument xdoc = new XDocument(new XDeclaration("1.0", "utf-8", "yes"),
            new XElement("Personas",
            from x in dataGrid.ItemsSource.Cast<Persona>()
            select
              new XElement("Persona",
                 new XElement("Nombre", x.Nombre),
                 new XElement("Apellido", x.Apellido),
                 new XElement("Edad", x.Edad),
                 new XElement("Correo", x.Correo)
              )
          )
    );
    xdoc.Save(archivo);
}

El proyecto está en WPF así que estoy usando un DataGrid donde cargo los datos por eso se aprecia ahí la propiedad ItemsSource, pero si usas Windows Form (WinForms) ¡espera! porque este artículo no es con respecto a la interfaz gráfica sino al lenguaje de programación. Para los que usan WinForms pueden cambiar esa parte del código por la variable lista. Como una nota para las personas que desarrollan usando WPF, si descargan el código podrán ver que he usado conceptos que expliqué en Validación en WPF y 2 Ventanas usando WPF de forma desacoplada para crear este proyecto.

Y así de fácil podemos crear y leer documentos xml utilizando Linq. Espero que a las personas que no han probado Linq, este artículo los mueva a aprender un poco más de este proyecto que ha revolucionado la forma en la que hacemos consultas. Aquí les dejo el código en C# XML2LINQ.zip y esta vez les debo el de VB.NET aunque en poco tiempo lo convertiré y aquí en VB.NET usando Windows Form XML2LINQ-VB.zip. Recuerden quitar la extensión .odt y dejar la .zip.

Asegurando nuestro código | Parte 1

En esta corta serie de artículos demostraré cómo asegurar nuestro código fuente para que este no sea copiado/robado. Supongamos que hemos creado un programa y ahora tenemos 3 opciones para difundirlo: vender licencias, como software libre o freeware.

En este caso hemos creado nuestro programa para venderlo o al menos difundirlo como freeware. El programa sirve para tomar fotos, grabar videos y aplicar filtros a las imágenes obtenidas desde una cámara web; está creado en C# y usa WPF (Windows Presentation Foundation) y además implementa el patrón MVVM (Model-View-ViewModel). Este es el aspecto visual:

Seguros de que es un buen programa hemos creado nuestra página para promocionarlo y además ponemos una descarga a una versión con limitaciones (en tiempo o funcionalidad). Observamos que nuestro programa lo han descargado muchas personas, pero al cabo de 2 o 3 meses alguien saca al mercado un programa bastante similar al de nosotros, para sorpresa nuestra, es en realidad EL MISMO PROGRAMA!!

¡Qué gran decepción, Nuestro trabajo ha sido robado!

Veamos cómo nos robaron el programa: Sigue leyendo

Estilos y Plantillas – ScrollViewer

Hola, ya tenía tiempo de no escribir así que voy a tratar de reivindicarme explicando un poco de cómo hacer estilos y plantillas para nuestros controles. Estaba haciendo un programa cuando me cansé del ScrollViewer que viene por defecto, buscando en Internet encontré algo que me gustó bastante, así que busqué cómo llegar a eso y usando este artículo de Sacha Barber y este de la librería Microsoft terminé con esto:

Para llegar a esto, vamos a tener que cortar mucha tela, así que comencemos con una imagen de lo que vamos a hacer:

Tomada de: http://sachabarber.net/?p=122

Primero que todo crearemos los RepeatButton de las esquinas:

 

 

 

 

Sigue leyendo

Validación en WPF

Como ya les había mencionado en el artículo anterior de aquí en adelante vamos a ver la maravillosa propiedad Binding de WPF (Windows Presentation Foundation). En este artículo se supone que el lector tendrá conocimiento básico de cómo hacer un Bind entre una propiedad y un control. Uno de los mayores dolores en WPF es la validación de datos. Un error frecuente en la validación es el siguiente.

Como pueden ver en la imagen, la validación de los campos se hace desde el principio de la aplicación haciendo que se vea “feo”. Qué se puede hacer para que lo visto en la imagen no ocurra. Aquí se da una propuesta para solucionar este error, pero en este artículo expondré la forma que yo he utilizado.

Manos a la obra!

Ya les he mostrado la Vista (View) del proyecto, pero, antes de entrar a ver el código xaml miremos nuestro Modelo (Model) y nuestra VistaModelo (ViewModel).

Nota: he usado el patrón MVVM para realizar este proyecto aunque no he seguido todos los reglamentos.

Modelo

public class UsuarioModel : INotifyPropertyChanged, IDataErrorInfo
{

	private string correo;
	public string Correo
	{
		get
		{
			return correo;
		}
		set
		{
			if ( correo == value ) return;

			correo = value;
			RaisePropertyChanged ( "Correo" );
		}
	}

	private string contraseña;
	public string Contraseña
	{
		get
		{
			return contraseña;
		}
		set
		{
			if ( contraseña == value ) return;

			contraseña = value;
			RaisePropertyChanged ( "Contraseña" );
		}
	}
}

Sigue leyendo

2 Ventanas usando WPF de forma Desacoplada

Tiempo atrás vimos en un artículo la forma de comunicar dos ventanas WPF usando eventos, esta vez vamos a usar una interfaz. MSDN Library define de esta manera las interfaces.

Las interfaces describen un grupo de funcionalidades relacionadas que pueden pertenecer a cualquier elemento class o struct. Define una interfaz utilizando la palabra clave de interfaz (interface).

Comencemos porque son bastantes cosas las que veremos. Primero miremos la interfaz.

public interface Enlace
{
    void agregar ( string firstName, string lastName );
}

Bastante sencilla no? Ahora miremos su implementación en la ventana Padre.

public void agregar ( string firstName, string lastName )
        {
            NameList nl = Resources["NameListData"] as NameList;
            nl.Add ( new PersonName ( firstName, lastName ) );
        }

Sigue leyendo

Exportación a Excel con C# | Parte 3

Actualizado: Exportación a Excel con C# | Parte 1Exportación a Excel con C# | Parte 2

Como ya les había comentado para terminar esta sesión de artículos voy a usar el antes mencionado ClosedXML. Vamos a usar el mismo proyecto anterior como base solo cambiaremos algunas cosas que pasaremos a ver inmediatamente. Necesitaremos ClosedXML y hacer referencia a la siguiente DLL: DocumentFormat.OpenXml.dll (parte de MS Open XML SDK 2.0)

Primero agregamos las referencias como lo hicimos en artículo anterior. Y luego pasamos a escribir esto en nuestro archivo donde vamos a exportar.
Sigue leyendo