Search results for 'app:weblogs' matching tags 'WPF' and 'XAML'

WPF | Como implementar ListBoxItem com ContextMenu

Cmattos — Wed, 11 May 2011 05:00:00 GMT

(Please visit the site to view this media)

WPF - Como Aplicar DropShadowEffect num ListBoxItem

Cmattos — Mon, 09 May 2011 05:00:00 GMT

Como todos sabem, o WPF oferece diversos recursos para aprimorarmos a interface das nossas aplicações. Todos os controles do tipo Lista podem ser customizados para exibir os dados desejados. Um efeito muito comum utilizado nestes controles é o DropShadowEffect que aplica uma “sombra” sobre o item selecionado na lista. A cor e a profundidade desta sombra são definidas através dos parâmetros Color e ShadowDepth respectivamente.

Construindo o exemplo

Para ilustrar esse recurso do WPF, vamos construir uma lista de amigos. Os itens da lista exibirão os nomes e imagens. O efeito DropShadowBitmapEffect será aplicado no evento MouseOver. Veja a aplicação de exemplo em tempo de execução.

Figura 1: ListBoxItem com DropShadowEffect aplicado

Para construir a interface apresentada na Figura 1, abra o Visual Studio, crie um novo projeto baseado no Template WPF Application. Na Janela MainWindow.xaml altere o código XAML de acordo com os quadros a seguir.

O primeiro passo é criarmos a seção <Grid.Resources>onde depositaremos o DataSource que será utilizado para alimentar o ListBox e o ListItemContainerStyle que contém as definições para aplicação do efeito visual nos itens da lista.

O primeiro grupo de código XAML que adicionaremos na seção Grid.Resources utiliza o XmlDataSource para criar uma lista de amigos contendo Nome e Imagem de cada item.

Figura 2: Código XAML para criar o XmlDataSource

O segundo grupo de código XAML na seção Grid.Resources cria o ControlTemplate para o ListBoxItem. Observe que o Template é definido dentro do Tag <Style>. Este código define como os registros serão apresentados e utiliza um Trigger associado à propriedade IsMouseOver para aplicar o efeito DropShadowBitmapEffect. Confira o código na Figura 3.

Figura 3: Definindo o estilo para o controle ListBox

Finalmente, vamos ao código necessário para implementar nosso controle ListBox. Observe que a propriedade ItemSource é alimentada através do StaticResource e a propriedade ItemContainerStyle estabelece o vínculo com o estilo RedDropShadowEffect definido na seção Grid.Resources. Confira o código na Figura 4.

Figura 4: O código do controle ListBox

O mesmo estilo pode ser melhorado acrescentando outro Trigger associado à propriedade IsSelected, definindo outra cor para o efeito visual. Este é apenas um exemplo dos recursos gráficos que estão disponíveis no WPF.

Aprofunde seus conhecimentos sobre este tema visitando a comunidade WPF.

Faça download deste arquivo no formato PDF e também do código-fonte deste exemplo.

XAML: How to use a ConverterParameter which is not a string in XAML?

Matthieu MEZIL — Thu, 26 Aug 2010 05:00:00 GMT

Imagine the following case: I have a TextBox and a TextBlock and a boolean property IsEditing.

If IsEditing is true, the TextBox is visible and the TextBlock is hidden and reversely.

In this case I could use a ViewModel with two properties of type Visibility and the problem would be solved.

However in this post, I want to use with Converters.

The problem is the fact that I have only one boolean property and that Visibility controls property are both bound to it with different behaviors.

So I will use a ConverterParameter to differentiate them.

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
    return ((bool)value ^ (parameter != null && (bool)parameter)) ? Visibility.Visible : Visibility.Collapsed;
}

The problem in my binding is the fact that I can’t write this:

Visibility="{Binding IsEditing, Converter={StaticResource BooleanToVisibilityConverter}, ConverterParameter=True}"

Indeed, with it, the parameter is a string and not a boolean as expected.

Of course I can make the binding to solve this by code but it isn’t the goal of this post.

So how to do it in xaml?

Like this:

<TextBlock.Visibility>
    <Binding Path="IsEditing"
             Converter="{StaticResource BooleanToVisibilityConverter}">
        <Binding.ConverterParameter>
            <system:Boolean>True</system:Boolean>
        </Binding.ConverterParameter>
    </Binding>
</TextBlock.Visibility>

Hope that helps

Export data to Excel from Silverlight/WPF DataGrid

Outcoldman — Wed, 21 Apr 2010 05:00:00 GMT

Data export from DataGrid to Excel is very common task, and it can be solved with different ways, and chosen way depend on kind of app which you are design. If you are developing app for enterprise, and it will be installed on several computes, then you can to advance a claim (system requirements) with which your app will be work for client. Or customer will advance system requirements on which your app should work. In this case you can use COM for export (use infrastructure of Excel or OpenOffice). This approach will give you much more flexibility and give you possibility to use all features of Excel app. About this approach I’ll speak below. Other way – your app is for personal use, it can be installed on any home computer, in this case it is not good to ask user to install MS Office or OpenOffice just for using your app. In this way you can use foreign tools for export, or export to xml/html format which MS Office can read (this approach used by JIRA). But in this case will be more difficult to satisfy user tasks, like create document with landscape rotation and with defined fields for printing.

At this article I'll show you how to work with Excel object from .NET 4 and Silverlight 4 with dynamic objects and give you an approach which allow you to export data from DataGrid Silverlight and WPF controls.

VisualStateManager - how we can define user interface in WPF and Sliverlight

Sergun — Wed, 29 Apr 2009 05:00:00 GMT

It is known, that technologies WPF and Silverlight allow to change appearance of the application essentially. However, as it is found out, it is far not all know as it it is possible to do conveniently.

For definition of appearance of controls we usually use ControlTemplate, and dynamics we set via triggers. Undoubtedly, triggers in XAML - the most powerful tool. Nevertheless at construction of difficult interfaces the logic constructed on triggers happens not trivial and opaque, and at times sets restrictions.

Alternative way of construction of the task of appearance of controls is use of object VisualStateManager. I will not go deep into details, I will tell only the most necessary.

VisualStateManager is DependencyObject, with all consequences. We can set behaviour of this object for each control which we wish to operate. Idea of VSM is based on realisation of a state of an control. We can define a set of states (VisualState) in which can there is a controls and to set for each state the appearance. States are packed into groups (VisualStateGroup). Thus, it is possible to define logic groups of states and to define in them transitions.

Each state (VisualState) is Storyboard. State realisation consists that at transition in this condition works set Storyboard, i.e. animation will be starting.

It is possible to present representation of the described structure graphically.

Let's create a small example on the basis of states. Let's create new UserControl in the application WPF with simple structure.

<UserControl x:Class="WpfApplication15.UserControl1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Grid>

        <Border Name="State1Panel" Background="Red" Opacity="1"/>

        <TextBlock Text="Text of control" Foreground="White" HorizontalAlignment="Center" VerticalAlignment="Center"/>

    </Grid>

</UserControl>

It is a control with the text and a red background. Let's define two states for this control - State1 and State2. Each of states will visually differ a background. Let's describe two objects VisualState and we will set transition animations.In our case we will simply put against each other two elements Border with a different background. Animation will consist in concealment and display of the necessary element depending on a state.

<UserControl x:Class="WpfApplication15.UserControl1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Grid>

        <VisualStateManager.VisualStateGroups>

            <VisualStateGroup x:Name="Common">

                <VisualState x:Name="State1">

                    <Storyboard>

                        <DoubleAnimation To="1" Duration="0:00:00.4" Storyboard.TargetName="State1Panel" Storyboard.TargetProperty="(UIElement.Opacity)" />

                        <DoubleAnimation To="0" Duration="0:00:00.7" Storyboard.TargetName="State2Panel" Storyboard.TargetProperty="(UIElement.Opacity)" />

                    </Storyboard>

                </VisualState>

                <VisualState x:Name="State2">

                    <Storyboard>

                        <DoubleAnimation To="0" Duration="0:00:00.7" Storyboard.TargetName="State1Panel" Storyboard.TargetProperty="(UIElement.Opacity)" />

                        <DoubleAnimation To="1" Duration="0:00:00.4" Storyboard.TargetName="State2Panel" Storyboard.TargetProperty="(UIElement.Opacity)" />

                    </Storyboard>

                </VisualState>

            </VisualStateGroup>

        </VisualStateManager.VisualStateGroups>

        <Border Name="State2Panel" Background="Green" Opacity="0"/>

        <Border Name="State1Panel" Background="Red" Opacity="1"/>

        <TextBlock Text="Text of control" Foreground="White" HorizontalAlignment="Center" VerticalAlignment="Center"/>

    </Grid>

</UserControl>

Now, using VisualStateManager, it is possible to switch states of a control and thus to change appearance. For this purpose we will place a control on the form.

<Window x:Class="WpfApplication15.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:WpfApplication15="clr-namespace:WpfApplication15"

    Title="Window1" Height="300" Width="300">

    <Grid>

        <Grid.RowDefinitions>

            <RowDefinition/>

            <RowDefinition Height="40"/>

        </Grid.RowDefinitions>

        <WpfApplication15:UserControl1 x:Name="Control1" Height="118" VerticalAlignment="Top" Margin="50,12,101,0" />

        <StackPanel Orientation="Horizontal" Grid.Row="1">

            <Button Name="State1Button" Width="75" Click="State1Button_Click">State1</Button>

            <Button Name="State2Button" Width="75" Click="State2Button_Click">State2</Button>

        </StackPanel>

    </Grid>

</Window>

Also we will create handlers of pressing of buttons.

private void State1Button_Click(object sender, RoutedEventArgs e)

    VisualStateManager.GoToState(Control1, "State1", true);

private void State2Button_Click(object sender, RoutedEventArgs e)

    VisualStateManager.GoToState(Control1, "State2", true);

As a result it is had the following application.

Thus we can create some states of our control and on the basis of it to build the user interface.

Such approach becomes especially useful when we see, that for standard controls there is a set of the predefined states. For example, for the Button - Normal, MouseOver, Pressed, Disabled etc. Such states are and at other elements. Because of such possibility creation of templates for controls essentially becomes simpler. For example, we can describe the button as follows.

<Style TargetType="{x:Type Button}">

    <Setter Property="Margin" Value="5"/>

    <Setter Property="Width" Value="100"/>

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate TargetType="{x:Type Button}">

                <Grid>

                    <VisualStateManager.VisualStateGroups>

                        <VisualStateGroup x:Name="Common">

                            <VisualState x:Name="Normal"/>

                            <VisualState x:Name="MouseOver">

                                <Storyboard>

                                    <DoubleAnimation To="0" Duration="0:00:00.5" Storyboard.TargetName="NormalBorder" Storyboard.TargetProperty="(UIElement.Opacity)" />

                                    <DoubleAnimation To="1" Duration="0:00:00.3" Storyboard.TargetName="OverBorder" Storyboard.TargetProperty="(UIElement.Opacity)" />

                                    <DoubleAnimation From="0" To="10" AutoReverse="True" Duration="0:00:00.3" Storyboard.TargetName="OverBorderRotateTransform" Storyboard.TargetProperty="Angle" />

                                </Storyboard>

                            </VisualState>

                            <VisualState x:Name="Pressed">

                                <Storyboard>

                                    <DoubleAnimation To="0" Duration="0:00:00.5" Storyboard.TargetName="NormalBorder" Storyboard.TargetProperty="(UIElement.Opacity)" />

                                    <DoubleAnimation To="1" Duration="0:00:00.3" Storyboard.TargetName="OverBorder" Storyboard.TargetProperty="(UIElement.Opacity)" />

                                    <DoubleAnimation From="0" To="360" AutoReverse="True" Duration="0:00:00.4" Storyboard.TargetName="OverBorderRotateTransform" Storyboard.TargetProperty="Angle" />

                                </Storyboard>

                            </VisualState>

                        </VisualStateGroup>

                    </VisualStateManager.VisualStateGroups>

                    <Border Name="NormalBorder" CornerRadius="5" Background="Gray" Opacity="1"/>

                    <Border Name="OverBorder" CornerRadius="5" Background="Green" Opacity="0">

                        <Border.RenderTransform>

                            <RotateTransform x:Name="OverBorderRotateTransform" CenterX="50" CenterY="20" />

                        </Border.RenderTransform>

                    </Border>

                    <ContentPresenter Content="{TemplateBinding Content}" Margin="5" HorizontalAlignment="Center" VerticalAlignment="Center"/>

                </Grid>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

Now our buttons will look as follows.

Similarly it is possible to adjust appearance in Silverlight applications.

Unfortunately, this time remained without attention a Transitions, but about them next time.

WPF sample:

VSM-Silverlight-Demo.zip

Silverlight3 sample:

VSM-Silverlight-Demo.zip

Los controles contenedores en WPF

otelis — Wed, 11 Mar 2009 05:00:00 GMT

Hola ¿qué tal?

Continuando con XAML y WPF quisiera continuar en esta ocasión con el uso de los controles contenedores que se tienen disponibles para el diseño de la interfaz de usuario desde Visual Studio 2008.

Ahora vamos a ver lo que hay en el diseño de formularios con WPF que nos permitirá dibujar la interfaz de usuario de una manera ordenada. En WPF existen algunos controles que se definen como contenedores con características particulares, algunos con similitudes a los utilizados en HTML y otros utilizados típicamente de versiones anteriores y unos más que surgieron de conceptos del diseño de la interfaz de usuario de la versión anterior de Windows Forms. No iré muy a fondo en cada uno, ya que se encuentra mucho acerca de cada control en la ayuda, sin embargo, mencionar los rasgos generales nos dará una idea de su uso para ubicarnos rápidamente en la construcción de la interfaz de usuario.

Canvas

Definido por las etiquetas <Canvas></Canvas>, al utilizar este control el diseño de la interfaz de usuario se vuelve simple y permite colocar controles en el área contenedora de manera relativa a las propiedades Canvas.Left y Canvas.Top que se definen directamente en el control, cabe mencionar que la propiedad Margin se combina con dichas propiedades, esto es, Canvas.Left se suma con la distancia a la izquierda de Margin, y Canvas.Top se suma con la distancia superior de Margin. Desde el diseñador de Visual Studio se pueden mover los controles de manera libre en cualquier posición dentro del canvas.

Grid

Definido por las etiquetas <Grid></Grid>, es parecido al canvas, y se puede utilizar de igual manera, sin embargo a diferencia del anterior, en un grid se pueden definir sub regiones contenedoras establecidas por columnas (Grid.Column) y renglones (Grid.Row) similar a una tabla, creando celdas, donde los controles se posicionan relativos al área delimitada por la celda, permitiendo con esto un arreglo ordenado de la interfaz de usuario. En el diseñador de Visual Studio se puede mover el control de manera libre, sin embargo, para que se limite el control a una celda del grid se deberá especificar las propiedades Grid.Column y Grid.Row en el mismo, ya que de no hacerlo se tendrá un efecto parecido al canvas dejando al control libre en el área total del Grid.

DockPanel

Definido por las etiquetas <DockPanel></DockPanel>, que es el reemplazo de la propiedad Dock de los controles de versiones anteriores, ahora en WPF, se utilizan paneles para definir las áreas de específicas del formulario. Es rígido con los controles, al colocarlos no es simple manipularlos en su interior, por lo que se recomienda incluir un Canvas o un Grid por comodidad, la importancia de este control es para ubicar las áreas del formulario, las cuales se definen estableciendo las propiedades VerticalAlignment para definir el Top, Center, Bottom o Stretch, y la propiedad HorizontalAlignment para definir el Left, Right, Center, Stretch. Cabe mencionar que al utilizar Stretch en ambas propiedades da un resultado parecido a Fill, también es prudente mencionar que se debe utilizar la propiedad Margin para ubicar bien los paneles en sus límites con otros paneles.

StackPanel

Definido por las etiquetas <StackPanel></StackPanel>, este control es semejante al DockPanel, sin embargo se utiliza más para definir un conjunto de controles ordenados, ya sea de modo horizontal o vertical, los controles se ordenen en el mismo orden que se describen dentro del XAML, respetan los márgenes verticales (Top, Bottom) de los controles al estar orientados de manera vertical, y de la misma manera respetan los márgenes horizontales (Left y Right) de los controles al estar orientados de forma horizontal. La orientación de los controles se define con la propiedad Orientation que tiene dos valores, Vertical y Horizontal. Es útil utilizar este control para hacer composiciones de controles, digamos como agrupar un TextBlock con un TextBox como una sola pieza dentro de otros controles contenedores manteniendo su relación de aspecto.

Existen otros controles contenedores como El GroupBox y el TabItem, sin embargo estos se utilizan con los controles anteriores, ya que solo pueden contener un control, por lo que es recomendable utilizar un grid o un canvas para mostrar el contenido. El GroupBox tiene una propiedad Header que hace más visible la conceptualización de un grupo de controles. El TabControl depende de otro control, el TabItem para mostrar los tabs o pestañas, y tiene la misma limitante que el GroupBox.

Pues bien, espero que sea de utilidad esta información para ubicar rápidamente los elementos primarios del diseño de la interfaz de usuario con WPF. Más detalles del funcionamiento, eventos y propiedades de estos controles lo pueden encontrar en el MSDN Library, ya sea en línea (http://msdn.microsoft.com/library) , o bien en el que se instala con visual studio o las versiones express de visual studio.

Temas relacionados:

http://msmvps.com/blogs/otelis/archive/2009/02/25/introducci-243-n-al-uso-de-xaml-en-wpf.aspx

Saludos…

Octavio Telis

Introducción al uso de XAML en WPF

otelis — Wed, 25 Feb 2009 06:00:00 GMT

Hola ¿qué tal?

En esta ocasión voy a platicar sobre lo que es WPF, y bueno, más que decir lo qué es (que ya la gran mayoría lo ha escuchado) pues quiero dar una breve, rápida y concisa introducción a su uso con Visual Studio 2008 y WPF Forms.

Primeramente definamos WPF. Bien pues WPF es Windows Presentation Foundation, una nueva tecnología para la construcción de la interfaz de usuario en windows que se ha agregado como pilar fundamental en la liberación del .NET Framework 3.0 y que se ha mejorado y extendido en el .NET Framework 3.5. WPF dentro del desarrollo de aplicaciones utiliza un lenguaje de marcado basado en XML al que se le denomina XAML (eXtensible Application Markup Language), este lenguaje de marcado es utilizado también por WF (Workflow Foundation) y por WCF (Windows Comunication Foundation), y tiene las mismas reglas que XML, tales como el contenido único de un elemento raíz, la utilización de Etiquetas de apertura y cierre, el uso de parámetros, y también el uso de Namespaces, básicamente es XML, y la diferencia es que en XAML se tienen espacios de nombres con la definición específica de los elementos de la aplicación, en nuestro caso nos ocupa WPF, por lo que encontraremos que la definición de la ventana, y los controles de una aplicación WPF para Windows estará definida completamente en XAML con etiquetas propias para esta tarea.

Para introducirlos a WPF, siempre se comenta que si han utilizado ASP.NET pues les será muy familiar, ya que las páginas de ASP.NET están definidas con XHTML de una forma muy parecida a como se definen en XAML los controles, pero bueno, ya ustedes encontrarán la similitud.

Bien, hablando de aplicaciones WPF para Windows, veremos que el elemento raíz de la ventana es nada más y nada menos que… Window; aunque no les parezca lógico, pero es así, la definición es simple, sin embargo siempre incluye la declaración de ciertos espacios de nombres necesarios para la presentación de la interfaz de usuario, aquí les muestro un ejemplo:

<Window x:Class="Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

</Window>

Podemos ver que se utiliza la etiqueta Window y como parámetros se incluyen la declaración de dos espacios de nombres y un parámetro que indica la clase con la que se asocia la funcionalidad de la ventana. Ahora bien, las propiedades de la ventana se definen de igual manera dentro de esta etiqueta, digamos que el alto y ancho de la venta, así como su título, eventos y otras propiedades serán puestos como parámetros en esta etiqueta, como les muestro a continuación:

<Window x:Class="Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Window1" Height="100" Width="300" >

</Window>

En este bloque se puede ver que agregué el título y las propiedades Height y Width, cabe hacer notar que los valores de las propiedades están escritos entre comillas y siempre serán tomados como texto. Este código se guarda en un archivo con extensión .XAML y está ligado a un archivo .CS o .VB según sea C# o Visual Basic, en el cual se escribirá la funcionalidad de la ventana utilizando el lenguaje que ya conocemos.

Ahora, lo que falta…. Ya tengo mi ventana, pero dónde voy a dibujar mis controles, cómo los voy a ordenar y cómo se van a mostrar. Cuando se crea una ventana WPF en Visual Studio 2008 se agrega esta declaración y además se agrega dentro del elemento Window un control denominado Grid, que no debemos confundir con el DataGrid que se utilizaba anteriormente. Este control Grid será el que se encarga de mostrar los controles en el orden que nosotros definamos y puede ser utilizado análogamente como una tabla de HTML, se pueden definir columnas y renglones y confinar los controles a una celda específica. Veamos primeramente cómo se muestra la ventana al ser creada por primera vez:

<Window x:Class="Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Window1" Height="100" Width="300" >

<Grid>

</Grid>

</Window>

En este ejemplo el elemento Grid, no tiene definida ninguna propiedad por lo que el ancho y alto será limitado por la dimensión definida en la ventana, esto es 100 x 300, y no se han definido propiedades por los siguiente; el Grid se verá como el área de trabajo para el diseño de la venta, por esta razón no define ninguna propiedad. Otra de las razones importantes de utilizar un Grid es porque de no hacerlo solo podríamos declarar un control dentro de la ventana, ya que entre la etiqueta se apertura y cierre, que corresponde a la propiedad Content (contenido) de la ventana, solo puede contener un control, en cambio, el Grid, puede contener a varios controles.

Agregaré un control TextBlock, para ilustrar algunas de las propiedades básicas de los controles utilizados dentro de un Grid:

<Window x:Class="UsoWPF.Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Window1" Height="100" Width="300">

<Grid>

<TextBlock Margin="10,10,10,0" Text="Espere un momento..."

Height="25" VerticalAlignment="Top"/>

</Grid>

</Window>

Como se puede observar, el TextBlock tiene definidas algunas propiedades; Margin, Text, Height y VerticalAlignment. La propiedad Text pues no tiene mucho que decir, pues es la que se encarga de mostrar el texto. Las otras propiedades tienen sus particularidades.

En general la propiedad Height está presente en la mayoría de los controles, y es para indicar la altura del mismo, si no se define, o en algunos casos se define el valor Auto, el control tomará la altura del contenedor, en este caso del Grid, lo mismo pasa con la propiedad Width que no he definido en el ejemplo, con lo que el control se ajustará al ancho del Grid, pero… sí, hay un pero, estoy definiendo la propiedad Margin, que define el margen del control, esto es, la distancia que guarda un control con los límites de su contenedor.

La propiedad Margin, se escribe con cuatro valores separados por comas que definen la distancia entre los límites de su contenedor en el siguiente orden: margen izquierdo, margen superior, margen derecho, margen inferior.

En este caso, aunque el TextBlock no define el ancho, se ajustará al Grid manteniendo la distancia de 10 pixeles entre el extremo derecho e izquierdo, además, mantendrá una distancia de 10 pixeles con la parte superior, y podríamos suponer que tendría una distancia al inferior, sin embargo, al declararse el valor de la propiedad Height se descarta el valor inferior del margen quedando el control con la altura definida en Height.

En el ejemplo utilicé la propiedad VerticalAlignment con el valor “Top”, esta propiedad tiene cuatro valores; Bottom, Center, Stretch y Top. En sí es la alineación vertical donde se indica que el control puede estar alineado verticalmente en la base de su contenedor, en el centro, ajustarse al tamaño en relación al tamaño de su contenedor o en la parte superior. VerticalAlignment es el sustituto de la propiedad Anchor que se utilizaba para anclar un control, pero solo con respecto a su posición vertical. Si se define el valor Bottom, el control se anclará en la parte inferior, si se define Top el control se anclará en la parte superior, si se define Center el control se anclará en el centro del contenedor y si se define Stretch el control se ajustará al tamaño del contenedor de manera proporcional. Para completar el anclaje del control tendría que definirse además la propiedad HorizontalAlignment, que puede tener uno de los siguientes valores; Center, Left, Right o Stretch, que tienen un comportamiento análogo al VerticalAlignment solo que de modo horizontal.

La ubicación de los controles se da con la combinación de las propiedades Height, Widht, VerticalAlignment, HorizontalAlignment y Margin. Si se utilizan las primeras cuatro, Margin no tendrá efecto en el control en alguno de sus valores, un ejemplo es el que se muestra en el código de arriba. Otro caso es si se define VerticalAlignment = “Top” y HorizontalAlignment = “Left”, entonces los valores de margen derecho y margen inferior serán descartados. Esto debido a que el control queda anclado en la parte superior izquierda de su contenedor.

Bien, pues con esto quiero concluir esta introducción, esperando que quede claro el concepto de XAML y la manera en que se posicionan los controles en una ventana de WPF.

Espero que les sea de utilidad.

Saludos…

Octavio Telis

Expression Blend Tip: Modifying the Rows or Columns of a Grid

Anonymous — Mon, 07 Apr 2008 05:00:00 GMT

It took me a couple of minutes to realize that RowDefinitions and ColumnDefinitions of a Grid are in the Advanced Properties of the Layout category. For more information about using a Grid to layout data, you can read more on Scott Guthrie's blog at http://weblogs.asp.net/scottgu/pages/silverlight-tutorial-part-2-using-layout-management.aspx.

XAML Tip: Adding a Line Break to a TextBlock

Anonymous — Mon, 07 Apr 2008 05:00:00 GMT

I'm just starting to mess with XAML as I'm looking to see what I can do with it. As I come across some pretty basic tasks that I'm struggling with, I'll post about it in case any other newbies run into the same issue. One of my first tasks was to create some text on a canvas. However, I couldn't figure out how to do a line break. After searching Live and Google in an attempt to find something, I finally did (on page 3 of each engine). There is an object called <LineBreak/> that will perform a line break in your text. For example: