We just saw how to calculate the depreciation using straight line method, now we are going to calculate depreciation using another method, i.e. Decline Balance method. This is also known as double declining balance method. Here are are again going to use progress bar in the list control.

Here is a code to calculate the depreciation using declining balance method.

  1: for (int iIndex = 0; iIndex < year; iIndex++)

  2: {

  3: 	depExpense = bookValue * percentage * 2;

  4:

  5: 	if (bookValue - depExpense < scrap)

  6: 	{

  7: 		depExpense = bookValue - scrap;

  8: 		bookValue = scrap;

  9: 	}

 10: 	else

 11: 	{

 12: 		bookValue -= depExpense;

 13: 	}

 14:

 15: 	accDepreciation += depExpense;

 16:

 17: 	DepreciationInfo dpInfo = new DepreciationInfo();

 18: 	dpInfo.Year = (iIndex + 1);

 19: 	dpInfo.Depreciation = depExpense;

 20: 	dpInfo.AccDepreciation = accDepreciation;

 21: 	dpInfo.BookValue = bookValue;

 22: 	dpInfo.Percentage = (bookValue * 100) / cost; ;

 23:

 24: 	depreciation.Add(dpInfo);

 25: }

 26: 

Here is a complete XAML code of the project.

  1: <Window x:Class="Depreciation.Window1"

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

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

  4:     Title="Depreciation" Height="400" Width="600">

  5:

  6:     <Grid Background="AliceBlue">

  7:         <Grid.RowDefinitions>

  8:             <RowDefinition/>

  9:             <RowDefinition/>

 10:             <RowDefinition/>

 11:             <RowDefinition Height="4*"/>

 12:             <RowDefinition/>

 13:         </Grid.RowDefinitions>

 14:

 15:         <Grid.ColumnDefinitions>

 16:             <ColumnDefinition/>

 17:             <ColumnDefinition/>

 18:         </Grid.ColumnDefinitions>

 19:         <TextBlock Grid.Column="0" Grid.Row="0" Margin="5" VerticalAlignment="Center">Enter Cost of Fixed Asset</TextBlock>

 20:         <TextBox Grid.Column="1" Grid.Row="0" Margin="5" VerticalAlignment="Center" Name="txtCost"></TextBox>

 21:         <TextBlock Grid.Column="0" Grid.Row="1" Margin="5" VerticalAlignment="Center">Enter life Span</TextBlock>

 22:         <TextBox Grid.Column="1" Grid.Row="1" Margin="5" VerticalAlignment="Center" Name="txtYear"></TextBox>

 23:         <TextBlock Grid.Column="0" Grid.Row="2" Margin="5" VerticalAlignment="Center">Enter Scrap Value</TextBlock>

 24:         <TextBox Grid.Column="1" Grid.Row="2" Margin="5" VerticalAlignment="Center" Name="txtScrapValue"></TextBox>

 25:

 26:         <ListView Grid.Column="0" Grid.Row="3" Grid.ColumnSpan="2" Name="list" Margin="5" HorizontalContentAlignment="Stretch">

 27:             <ListView.View>

 28:                 <GridView>

 29:                     <GridView.ColumnHeaderTemplate>

 30:                         <DataTemplate>

 31:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 32:                                 <Border.Background>

 33:                                     <LinearGradientBrush>

 34:                                         <GradientStop Offset="0" Color="Wheat"/>

 35:                                         <GradientStop Offset="1" Color="LightCoral"/>

 36:                                     </LinearGradientBrush>

 37:                                 </Border.Background>

 38:                                 <TextBlock Foreground="Blue" FontSize="14" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 39:                             </Border>

 40:                         </DataTemplate>

 41:                     </GridView.ColumnHeaderTemplate>

 42:                     <GridViewColumn Width="Auto" Header="Year" DisplayMemberBinding="{Binding Path=Year}"/>

 43:                     <GridViewColumn Width="Auto" Header="Depreciation" DisplayMemberBinding="{Binding Path=Depreciation}"/>

 44:                     <GridViewColumn Width="Auto" Header="Accumulated Depreciation" DisplayMemberBinding="{Binding Path=AccDepreciation}"/>

 45:                     <GridViewColumn Width="Auto" Header="Book Value" DisplayMemberBinding="{Binding Path=BookValue}"/>

 46:                     <GridViewColumn Width="Auto" Header="Percentage">

 47:                         <GridViewColumn.CellTemplate>

 48:                             <DataTemplate>

 49:                                 <ProgressBar Width="50" Height="20" Margin="5" Minimum="0" Maximum="100" Value="{Binding Percentage}"/>

 50:                             </DataTemplate>

 51:                         </GridViewColumn.CellTemplate>

 52:                     </GridViewColumn>

 53:                 </GridView>

 54:             </ListView.View>

 55:         </ListView>

 56:         <Button Grid.Column="0" Grid.Row="4" Margin="10" Width="75" Name="btnCalculate" Click="btnCalculate_Click">Calculate</Button>

 57:         <Button Grid.Column="1" Grid.Row="4" Margin="10" Width="75" Name="btnExit" Click="btnExit_Click">Exit</Button>

 58:     </Grid>

 59: </Window>

 60: 

Here is complete C# code of the project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace Depreciation

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         List<DepreciationInfo> depreciation;

 23:         private int year;

 24:         private double cost;

 25:         private double scrap;

 26:

 27:         public Window1()

 28:         {

 29:             InitializeComponent();

 30:

 31:             depreciation = new List<DepreciationInfo>();

 32:         }

 33:

 34:         private void btnExit_Click(object sender, RoutedEventArgs e)

 35:         {

 36:             Close();

 37:         }

 38:

 39:         private void btnCalculate_Click(object sender, RoutedEventArgs e)

 40:         {

 41:             depreciation.Clear();

 42:

 43:             year = Convert.ToInt32(txtYear.Text);

 44:             cost = Convert.ToDouble(txtCost.Text);

 45:             scrap = Convert.ToDouble(txtScrapValue.Text);

 46:

 47:             if (year <= 0)

 48:             {

 49:                 MessageBox.Show("Number of years can not be zero or negative.");

 50:                 return;

 51:             }

 52:

 53:             if (cost <= 0 || scrap <= 0)

 54:             {

 55:                 MessageBox.Show("Either Cost or Scrap value is not correct.");

 56:                 return;

 57:             }

 58:

 59:             double percentage = 100 / year;

 60:             percentage /= 100;

 61:             double accDepreciation = 0;

 62:             double bookValue = cost;

 63:             double depExpense = 0;

 64:

 65:             for (int iIndex = 0; iIndex < year; iIndex++)

 66:             {

 67:                 depExpense = bookValue * percentage * 2;

 68:

 69:                 if (bookValue - depExpense < scrap)

 70:                 {

 71:                     depExpense = bookValue - scrap;

 72:                     bookValue = scrap;

 73:                 }

 74:                 else

 75:                 {

 76:                     bookValue -= depExpense;

 77:                 }

 78:

 79:                 accDepreciation += depExpense;

 80:

 81:                 DepreciationInfo dpInfo = new DepreciationInfo();

 82:                 dpInfo.Year = (iIndex + 1);

 83:                 dpInfo.Depreciation = depExpense;

 84:                 dpInfo.AccDepreciation = accDepreciation;

 85:                 dpInfo.BookValue = bookValue;

 86:                 dpInfo.Percentage = (bookValue * 100) / cost; ;

 87:

 88:                 depreciation.Add(dpInfo);

 89:             }

 90:

 91:             list.ItemsSource = depreciation;

 92:         }

 93:     }

 94:

 95:     public class DepreciationInfo

 96:     {

 97:         public int Year

 98:         { get; set; }

 99:

100:         public double Depreciation

101:         { get; set; }

102:

103:         public double AccDepreciation

104:         { get; set; }

105:

106:         public double BookValue

107:         { get; set; }

108:

109:         public double Percentage

110:         { get; set; }

111:     }

112: }

113: 

Here is the output of the program.

Not having the right mouse button available has been a hassle for both Silverlight and Adobe Flash since their inception. Flash has had the ability to customize their right-click context menu to some degree but never true right click event handling. With Silverlight 4, Silverlight will have true customizable event handling for the right mouse button. I know this might be a small step for event handling, but it’s a giant leap for rich Internet applications.

To do this in Silverlight 4, this is the code you’ll need to use:

We’re going to add an eventhandler first to out main window and then to a control through XAML.

//For a general rightclick menu for your window

this.MouseRightButtonDown += new MouseButtonEventHandler(MainPage_MouseRightButtonDown);
this.MouseRightButtonUp += new MouseButtonEventHandler(MainPage_MouseRightButtonUp);

void MainPage_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
//This is crucial. If you don’t add this, the original context menu will always show up on rightclick.
e.Handled = True;
}

void MainPage_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
{
MessageBox.Show(“Hello, Brave New World!”);
}

This can of course be used on different objects with different effects and if we want to add an event handler in XAML instead, this is the code we’ll use within an object (such as a Grid):

MouseRightButtonDown=”MainPage_MouseRightButtonDown”

MouseRightButtonUp=”MainPage_MouseRightButtonUp”

The possibilities are many and I’m glad to be using a technology that is constantly improving.

WPF 4.0 introduced lots of new feature and one of them is Data Grid control. Here we are going to study the simple usage of Data grid control. Here is a class diagram of DataGrid.

Here is a XAML code of this project.

  1: <Window x:Class="grid.MainWindow"

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

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

  4:         Title="Example of Data Grid" Height="300" Width="300">

  5:     <Grid>

  6:         <DataGrid Name="grid" AlternationCount="2" Background="AliceBlue" AlternatingRowBackground="LightGreen">

  7:         </DataGrid>

  8:     </Grid>

  9: </Window>

 10: 

We just create a list of our user define class and assign it to the grid class. Here is a complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace grid

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for MainWindow.xaml

 19:     /// </summary>

 20:     public partial class MainWindow : Window

 21:     {

 22:         private List<Student> student;

 23:

 24:         public MainWindow()

 25:         {

 26:             InitializeComponent();

 27:

 28:             student = new List<Student>();

 29:             student.Add(new Student(10, "Bob", "Smith"));

 30:             student.Add(new Student(25, "James", "Brown"));

 31:             student.Add(new Student(15, "Joe", "Martin"));

 32:             student.Add(new Student(12, "Dona", "Taylor"));

 33:             student.Add(new Student(18, "Peter", "Brian"));

 34:

 35:             grid.ItemsSource = student;

 36:         }

 37:     }

 38:

 39:     public class Student

 40:     {

 41:         public Student(int id, String firstName, String lastName)

 42:         {

 43:             ID = id;

 44:             FirstName = firstName;

 45:             LastName = lastName;

 46:         }

 47:

 48:         public int ID

 49:         { get; set; }

 50:

 51:         public String FirstName

 52:         { get; set; }

 53:

 54:         public String LastName

 55:         { get; set; }

 56:     }

 57: }

 58: 

Here is the output of this project.

We can easily insert progras bar inside the tree view just like we added check box and combo box. We are again going to use the CellTemplate property of GridViewColumn. We are going to define data template to use the progress bar.

This time we are going to do something useful rather than using some dummy sample. This time we are going to make one simple application to calculate the book value of a fixed assets cost using the straight line method.

Here is a class to store the information about the depreciation.

  1: public class DepreciationInfo

  2: {

  3: 	public int Year

  4: 	{ get; set; }

  5:

  6: 	public double Depreciation

  7: 	{ get; set; }

  8:

  9: 	public double AccDepreciation

 10: 	{ get; set; }

 11:

 12: 	public double BookValue

 13: 	{ get; set; }

 14:

 15: 	public double Percentage

 16: 	{ get; set; }

 17: }

 18: 

Calculation of book value using straight line method is very simple. Here is a simple method to calculate the book value.

  1: double depExpense = depValue / year;

  2: double accDepreciation = 0;

  3: double bookValue = cost;

  4:

  5: for (int iIndex = 0; iIndex < year; iIndex++)

  6: {

  7: 	accDepreciation += depExpense;

  8: 	bookValue -= depExpense;

  9: 	DepreciationInfo dpInfo = new DepreciationInfo();

 10: 	dpInfo.Year = (iIndex + 1);

 11: 	dpInfo.Depreciation = depExpense;

 12: 	dpInfo.AccDepreciation = accDepreciation;

 13: 	dpInfo.BookValue = bookValue;

 14: 	dpInfo.Percentage = bookValue * 100 / cost;

 15:

 16: 	depreciation.Add(dpInfo);

 17: }

 18:

 19: 

Here is a complete XAML code of this project.

  1: <Window x:Class="Depreciation.Window1"

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

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

  4:     Title="Depreciation" Height="400" Width="600">

  5:     <Grid Background="AliceBlue">

  6:         <Grid.RowDefinitions>

  7:             <RowDefinition/>

  8:             <RowDefinition/>

  9:             <RowDefinition/>

 10:             <RowDefinition Height="4*"/>

 11:             <RowDefinition/>

 12:         </Grid.RowDefinitions>

 13:

 14:         <Grid.ColumnDefinitions>

 15:             <ColumnDefinition/>

 16:             <ColumnDefinition/>

 17:         </Grid.ColumnDefinitions>

 18:         <TextBlock Grid.Column="0" Grid.Row="0" Margin="5" VerticalAlignment="Center">Enter Cost of Fixed Asset</TextBlock>

 19:         <TextBox Grid.Column="1" Grid.Row="0" Margin="5" VerticalAlignment="Center" Name="txtCost"></TextBox>

 20:         <TextBlock Grid.Column="0" Grid.Row="1" Margin="5" VerticalAlignment="Center">Enter life Span</TextBlock>

 21:         <TextBox Grid.Column="1" Grid.Row="1" Margin="5" VerticalAlignment="Center" Name="txtYear"></TextBox>

 22:         <TextBlock Grid.Column="0" Grid.Row="2" Margin="5" VerticalAlignment="Center">Enter Scrap Value</TextBlock>

 23:         <TextBox Grid.Column="1" Grid.Row="2" Margin="5" VerticalAlignment="Center" Name="txtScrapValue"></TextBox>

 24:

 25:         <ListView Grid.Column="0" Grid.Row="3" Grid.ColumnSpan="2" Name="list" Margin="5" HorizontalContentAlignment="Stretch">

 26:             <ListView.View>

 27:                 <GridView>

 28:                     <GridView.ColumnHeaderTemplate>

 29:                         <DataTemplate>

 30:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 31:                                 <Border.Background>

 32:                                     <LinearGradientBrush>

 33:                                         <GradientStop Offset="0" Color="Wheat"/>

 34:                                         <GradientStop Offset="1" Color="LightCoral"/>

 35:                                     </LinearGradientBrush>

 36:                                 </Border.Background>

 37:                                 <TextBlock Foreground="Blue" FontSize="14" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 38:                             </Border>

 39:                         </DataTemplate>

 40:                     </GridView.ColumnHeaderTemplate>

 41:                     <GridViewColumn Width="Auto" Header="Year" DisplayMemberBinding="{Binding Path=Year}"/>

 42:                     <GridViewColumn Width="Auto" Header="Depreciation" DisplayMemberBinding="{Binding Path=Depreciation}"/>

 43:                     <GridViewColumn Width="Auto" Header="Accumulated Depreciation" DisplayMemberBinding="{Binding Path=AccDepreciation}"/>

 44:                     <GridViewColumn Width="Auto" Header="Book Value" DisplayMemberBinding="{Binding Path=BookValue}"/>

 45:                     <GridViewColumn Width="Auto" Header="Percentage">

 46:                         <GridViewColumn.CellTemplate>

 47:                             <DataTemplate>

 48:                                 <ProgressBar Width="50" Height="20" Margin="5" Minimum="0" Maximum="100" Value="{Binding Percentage}"/>

 49:                             </DataTemplate>

 50:                         </GridViewColumn.CellTemplate>

 51:                     </GridViewColumn>

 52:                 </GridView>

 53:             </ListView.View>

 54:         </ListView>

 55:         <Button Grid.Column="0" Grid.Row="4" Margin="10" Width="75" Name="btnCalculate" Click="btnCalculate_Click">Calculate</Button>

 56:         <Button Grid.Column="1" Grid.Row="4" Margin="10" Width="75" Name="btnExit" Click="btnExit_Click">Exit</Button>

 57:     </Grid>

 58: </Window>

 59: 

Here is a complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace Depreciation

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         List<DepreciationInfo> depreciation;

 23:         private int year;

 24:         private double cost;

 25:         private double scrap;

 26:

 27:         public Window1()

 28:         {

 29:             InitializeComponent();

 30:

 31:             depreciation = new List<DepreciationInfo>();

 32:         }

 33:

 34:         private void btnExit_Click(object sender, RoutedEventArgs e)

 35:         {

 36:             Close();

 37:         }

 38:

 39:         private void btnCalculate_Click(object sender, RoutedEventArgs e)

 40:         {

 41:             depreciation.Clear();

 42:

 43:             year = Convert.ToInt32(txtYear.Text);

 44:             cost = Convert.ToDouble(txtCost.Text);

 45:             scrap = Convert.ToDouble(txtScrapValue.Text);

 46:

 47:             if (year <= 0)

 48:             {

 49:                 MessageBox.Show("Number of years can not be zero or negative.");

 50:                 return;

 51:             }

 52:

 53:             double depValue = cost - scrap;

 54:

 55:             if (depValue <= 0)

 56:             {

 57:                 MessageBox.Show("Either Cost or Scrap value is not correct.");

 58:                 return;

 59:             }

 60:

 61:             double depExpense = depValue / year;

 62:             double accDepreciation = 0;

 63:             double bookValue = cost;

 64:

 65:             for (int iIndex = 0; iIndex < year; iIndex++)

 66:             {

 67:                 accDepreciation += depExpense;

 68:                 bookValue -= depExpense;

 69:                 DepreciationInfo dpInfo = new DepreciationInfo();

 70:                 dpInfo.Year = (iIndex + 1);

 71:                 dpInfo.Depreciation = depExpense;

 72:                 dpInfo.AccDepreciation = accDepreciation;

 73:                 dpInfo.BookValue = bookValue;

 74:                 dpInfo.Percentage = bookValue * 100 / cost;

 75:

 76:                 depreciation.Add(dpInfo);

 77:             }

 78:

 79:             list.ItemsSource = depreciation;

 80:         }

 81:     }

 82:

 83:     public class DepreciationInfo

 84:     {

 85:         public int Year

 86:         { get; set; }

 87:

 88:         public double Depreciation

 89:         { get; set; }

 90:

 91:         public double AccDepreciation

 92:         { get; set; }

 93:

 94:         public double BookValue

 95:         { get; set; }

 96:

 97:         public double Percentage

 98:         { get; set; }

 99:     }

100: }

101: 

Here is the output of this program.

If we have a simple grid form of data then we can simply display it in list view. We can even further customize the display of our data by using data template and display in different controls such as check box, text block etc.

If we have hierarchical data, such as the state information and list of big cities in each state then we can display this in the form of nested combo box inside the list view.

First we have to change our data structure. Now our class contains not only simple data, but also list of string to store more than one big cities in each state. Here is our class look like.

  1:     public class StateInfo

  2:     {

  3:         private List<String> list;

  4:

  5:         public StateInfo()

  6:         {

  7:         }

  8:

  9:         public StateInfo(String name, String capital, String nickName, String timeZone, Boolean visited)

 10:         {

 11:             Name = name;

 12:             Capital = capital;

 13:             NickName = nickName;

 14:             TimeZone = timeZone;

 15:             Visited = visited;

 16:

 17:             list = new List<string>();

 18:         }

 19:

 20:         public String Name

 21:         { get; set; }

 22:

 23:         public String Capital

 24:         { get; set; }

 25:

 26:         public String NickName

 27:         { get; set; }

 28:

 29:         public String TimeZone

 30:         { get; set; }

 31:

 32:         public Boolean Visited

 33:         { get; set; }

 34:

 35:         public List<String> Cities

 36:         {

 37:             get { return list; }

 38:             set { list = value; }

 39:         }

 40:

 41:     }

 42: 

Now we are going to populate some data in this class. In this example we are inserting data by code, but it can be loaded by database, LINQ or any other techniques. Here is an example of inserting data in this data structure.

  1: List<StateInfo> statesList = new List<StateInfo>();

  2:

  3: StateInfo s1 = new StateInfo();

  4: s1.Name = "Maryland";

  5: s1.Capital = "Annapolis";

  6: s1.NickName = "Old Line State";

  7: s1.Visited = true;

  8: List<String> s1List = new List<string>();

  9: s1List.Add("Frederick");

 10: s1List.Add("Baltimore");

 11: s1List.Add("Rockville");

 12: s1List.Add("Hagerstown");

 13: s1.Cities = s1List;

 14: statesList.Add(s1);

 15:

 16: StateInfo s2 = new StateInfo();

 17: s2.Name = "California";

 18: s2.Capital = "Sacramento";

 19: s2.NickName = "Golden State";

 20: s2.Visited = true;

 21: List<String> s2List = new List<string>();

 22: s2List.Add("Los Angeles");

 23: s2List.Add("San Franscico");

 24: s2List.Add("San Deiago");

 25: s2List.Add("San Jose");

 26: s2List.Add("Fresno");

 27: s2List.Add("Long Beach");

 28: s2.Cities = s2List;

 29: statesList.Add(s2);

 30:

 31: StateInfo s3 = new StateInfo();

 32: s3.Name = "Taxes";

 33: s3.Capital = "Austin";

 34: s3.NickName = "Lone Star State";

 35: s3.Visited = true;

 36: List<String> s3List = new List<string>();

 37: s3List.Add("Houston");

 38: s3List.Add("Dallas");

 39: s3List.Add("San Antonio");

 40: s3List.Add("El Paso");

 41: s3.Cities = s3List;

 42: statesList.Add(s3);

 43:

 44: StateInfo s4 = new StateInfo();

 45: s4.Name = "Ohio";

 46: s4.Capital = "Columbus";

 47: s4.NickName = "Buckeye State";

 48: s4.Visited = false;

 49: List<String> s4List = new List<String>();

 50: s4List.Add("Cleveland");

 51: s4List.Add("Cincinnati");

 52: s4.Cities = s4List;

 53: statesList.Add(s4);

 54:

 55: StateInfo s5 = new StateInfo();

 56: s5.Name = "Florida";

 57: s5.Capital = "Tallahassee";

 58: s5.NickName = "Sunshine State";

 59: s5.Visited = false;

 60: List<String> s5List = new List<string>();

 61: s5List.Add("Miami");

 62: s5List.Add("Jacksonville");

 63: s5List.Add("Tampa");

 64: s5.Cities = s5List;

 65: statesList.Add(s5);

 66: 

At XAML side we define one check box to display the Boolean variable.

  1: <GridViewColumn Width="Auto" Header="Visited">

  2: 	<GridViewColumn.CellTemplate>

  3: 		<DataTemplate>

  4: 			<CheckBox IsChecked="{Binding Visited}"/>

  5: 		</DataTemplate>

  6: 	</GridViewColumn.CellTemplate>

  7: </GridViewColumn>

  8: 

Similarly we define one more data template to define the cities list in combo box.

  1: <GridViewColumn Width="100" Header="Cities">

  2: 	<GridViewColumn.CellTemplate>

  3: 		<DataTemplate>

  4: 			<ComboBox Width="75" ItemsSource="{Binding Cities}"/>

  5: 		</DataTemplate>

  6: 	</GridViewColumn.CellTemplate>

  7: </GridViewColumn>

  8: 

Rest of the code is quite straight forward. Here is complete XAML code of this project.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="525">

  6:     <Window.Resources>

  7:         <Style x:Key="myStyle" TargetType="{x:Type ListViewItem}">

  8:             <Setter Property="Background" Value="AliceBlue"/>

  9:             <Setter Property="FontSize" Value="14"/>

 10:             <Setter Property="Foreground" Value="Green"/>

 11:         </Style>

 12:     </Window.Resources>

 13:     <Grid>

 14:         <ListView ItemContainerStyle="{StaticResource myStyle}" Name="list" Margin="5" HorizontalContentAlignment="Stretch">

 15:             <ListView.View>

 16:                 <GridView>

 17:                     <GridView.ColumnHeaderTemplate>

 18:                         <DataTemplate>

 19:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 20:                                 <Border.Background>

 21:                                     <LinearGradientBrush>

 22:                                         <GradientStop Offset="0" Color="Wheat"/>

 23:                                         <GradientStop Offset="1" Color="LightCoral"/>

 24:                                     </LinearGradientBrush>

 25:                                 </Border.Background>

 26:                                 <TextBlock Foreground="Blue" FontSize="14" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 27:                             </Border>

 28:                         </DataTemplate>

 29:                     </GridView.ColumnHeaderTemplate>

 30:                     <GridViewColumn Width="Auto" Header="Visited">

 31:                         <GridViewColumn.CellTemplate>

 32:                             <DataTemplate>

 33:                                 <CheckBox IsChecked="{Binding Visited}"/>

 34:                             </DataTemplate>

 35:                         </GridViewColumn.CellTemplate>

 36:                     </GridViewColumn>

 37:                     <GridViewColumn Width="Auto" Header="State Name" DisplayMemberBinding="{Binding Path=Name}"/>

 38:                     <GridViewColumn Width="Auto" Header="State Capital" DisplayMemberBinding="{Binding Path=Capital}"/>

 39:                     <GridViewColumn Width="Auto" Header="State Nick Name">

 40:                         <GridViewColumn.CellTemplate>

 41:                             <DataTemplate>

 42:                                 <Expander ExpandDirection="Right">

 43:                                     <TextBlock Foreground="Green" FontSize="14" Text="{Binding NickName}"/>

 44:                                 </Expander>

 45:                             </DataTemplate>

 46:                         </GridViewColumn.CellTemplate>

 47:                     </GridViewColumn>

 48:                     <GridViewColumn Width="100" Header="Cities">

 49:                         <GridViewColumn.CellTemplate>

 50:                             <DataTemplate>

 51:                                 <ComboBox Width="75" ItemsSource="{Binding Cities}"/>

 52:                             </DataTemplate>

 53:                         </GridViewColumn.CellTemplate>

 54:                     </GridViewColumn>

 55:                 </GridView>

 56:             </ListView.View>

 57:         </ListView>

 58:     </Grid>

 59: </Window>

 60: 

And here is complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public Window1()

 23:         {

 24:             InitializeComponent();

 25:

 26:             List<StateInfo> statesList = new List<StateInfo>();

 27:

 28:             StateInfo s1 = new StateInfo();

 29:             s1.Name = "Maryland";

 30:             s1.Capital = "Annapolis";

 31:             s1.NickName = "Old Line State";

 32:             s1.Visited = true;

 33:             List<String> s1List = new List<string>();

 34:             s1List.Add("Frederick");

 35:             s1List.Add("Baltimore");

 36:             s1List.Add("Rockville");

 37:             s1List.Add("Hagerstown");

 38:             s1.Cities = s1List;

 39:             statesList.Add(s1);

 40:

 41:             StateInfo s2 = new StateInfo();

 42:             s2.Name = "California";

 43:             s2.Capital = "Sacramento";

 44:             s2.NickName = "Golden State";

 45:             s2.Visited = true;

 46:             List<String> s2List = new List<string>();

 47:             s2List.Add("Los Angeles");

 48:             s2List.Add("San Franscico");

 49:             s2List.Add("San Deiago");

 50:             s2List.Add("San Jose");

 51:             s2List.Add("Fresno");

 52:             s2List.Add("Long Beach");

 53:             s2.Cities = s2List;

 54:             statesList.Add(s2);

 55:

 56:             StateInfo s3 = new StateInfo();

 57:             s3.Name = "Taxes";

 58:             s3.Capital = "Austin";

 59:             s3.NickName = "Lone Star State";

 60:             s3.Visited = true;

 61:             List<String> s3List = new List<string>();

 62:             s3List.Add("Houston");

 63:             s3List.Add("Dallas");

 64:             s3List.Add("San Antonio");

 65:             s3List.Add("El Paso");

 66:             s3.Cities = s3List;

 67:             statesList.Add(s3);

 68:

 69:             StateInfo s4 = new StateInfo();

 70:             s4.Name = "Ohio";

 71:             s4.Capital = "Columbus";

 72:             s4.NickName = "Buckeye State";

 73:             s4.Visited = false;

 74:             List<String> s4List = new List<String>();

 75:             s4List.Add("Cleveland");

 76:             s4List.Add("Cincinnati");

 77:             s4.Cities = s4List;

 78:             statesList.Add(s4);

 79:

 80:             StateInfo s5 = new StateInfo();

 81:             s5.Name = "Florida";

 82:             s5.Capital = "Tallahassee";

 83:             s5.NickName = "Sunshine State";

 84:             s5.Visited = false;

 85:             List<String> s5List = new List<string>();

 86:             s5List.Add("Miami");

 87:             s5List.Add("Jacksonville");

 88:             s5List.Add("Tampa");

 89:             s5.Cities = s5List;

 90:             statesList.Add(s5);

 91:

 92:             list.ItemsSource = statesList;

 93:         }

 94:     }

 95:

 96:     public class StateInfo

 97:     {

 98:         private List<String> list;

 99:

100:         public StateInfo()

101:         {

102:         }

103:

104:         public StateInfo(String name, String capital, String nickName, String timeZone, Boolean visited)

105:         {

106:             Name = name;

107:             Capital = capital;

108:             NickName = nickName;

109:             TimeZone = timeZone;

110:             Visited = visited;

111:

112:             list = new List<string>();

113:         }

114:

115:         public String Name

116:         { get; set; }

117:

118:         public String Capital

119:         { get; set; }

120:

121:         public String NickName

122:         { get; set; }

123:

124:         public String TimeZone

125:         { get; set; }

126:

127:         public Boolean Visited

128:         { get; set; }

129:

130:         public List<String> Cities

131:         {

132:             get { return list; }

133:             set { list = value; }

134:         }

135:

136:     }

137: }

138: 

The output of this program would be something like this.

Après une très longue période sans réutiliser de technologies tel que WPF ou Silverlight, on s’aperçoit que l’on perd très vite la main. C’est donc durant un projet éclair que je me suis décidé de refaire un petit projet en utilisant le MVVM.

C’est donc confiant que je commence mon code, que je me décide à le lancer au bout d’une heure, histoire de voir ce que ça donne en dehors du Designer WPF. Mon interface ressemble donc à ce que je veux, cependant je m’aperçois que certaines de mes commandes ne marchaient pas, je passe donc 10 bonnes minutes pour trouver ce qu’il se passe et enfin corriger.

On va donc voir dans cet article un moyen de contourner la déclaration des commandes dans un DataTemplate, sans pour autant perdre en fonctionnalité.

Pour cette démonstration je vais utiliser comme base le template de MVVM qui vient de codeplex (WPF Model-View-ViewModel Toolkit 0.1) que je vais modifier de tel sorte que ViewModelBase dérive de DependencyObject, et implémente deux méthodes abstraites qui sont OnViewReady(), et OnViewDispose(). On obtient donc ceci :

/// <summary>
/// Provides common functionality for ViewModel classes
/// </summary>
public abstract class ViewModelBase : DependencyObject, INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;

        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public abstract void OnViewReady();
    public abstract void OnViewDispose();

}

Note les modifications apportées ici ne sont pas nécessaire pour la démonstration, mais grâce à cela vous pouvez utiliser les DependencyProperty dans votre ViewModel, et propager les évènements Loaded et Unloaded de vos vues, vers vos ViewModel. Voilà pour l’astuce du jour !

Voici donc  la commande que nous allons utiliser :

#region GestionCommandes
private DelegateCommand<Models.Person> editPersonCommand;

public ICommand EditPersonCommand
{
    get
    {
        if (editPersonCommand == null)
            editPersonCommand = new DelegateCommand<Models.Person>(EditPerson);
        return editPersonCommand;
    }
}

private void EditPerson(Models.Person person)
{
    MessageBox.Show("Ici on éditera la personne", "", MessageBoxButton.OK);
}
#endregion 

Bon maintenant, affichons nos données dans la vue au pas à pas. Après un binding initial on obtient quelque chose du style

<Window x:Class="WpfModelViewApplication3.Views.MainView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:c="clr-namespace:WpfModelViewApplication3.Commands"
    Title="Main Window" Height="400" Width="800">

    <Grid>
        <ListBox ItemsSource="{Binding People}" />
    </Grid>
</Window>

Avec pour interface générée :

Bon ceci, n’étant pas très lisible pour un client, on va donc créer un DataTemplate. Or pour des raisons de lecture, nous allons ajouter ce DataTemplate en ressources de la fenêtre.

Donc confiant, j’écris ceci :

<Window.Resources>
    <DataTemplate DataType="{x:Type localModel:Person}">
        <StackPanel Orientation="Horizontal">
            <Label Content="{Binding FirstName}" />
            <Button Content="Modifier" Margin="5 0" Command="{Binding EditPersonCommand}" CommandParameter="{Binding}" />
        </StackPanel>
    </DataTemplate>
</Window.Resources>

<Grid>
    <ListBox ItemsSource="{Binding People}" />
</Grid>

J’ai donc mon interface qui change en conséquence :

Le problème se situe en fait lorsque je clique sur le bouton Modifier, en effet rien ne se produit. J’ai donc regardé si lors de la construction de la fenêtre il allait bien me chercher ma commande, mais il ignora mon point d’arrêt dans Visual Studio.

Alors l’astuce facile à réaliser avec ce template est d’utiliser leur CommandReference, de tel sorte :

<Window.Resources>
    <c:CommandReference x:Key="EditPerson" Command="{Binding EditPersonCommand}" />

    <DataTemplate DataType="{x:Type localModel:Person}">
        <StackPanel Orientation="Horizontal">
            <Label Content="{Binding FirstName}" />
            <Button Content="Modifier" Margin="5 0" Command="{StaticResource EditPerson}" CommandParameter="{Binding}" />
        </StackPanel>
    </DataTemplate>
</Window.Resources>

<Grid>
    <ListBox ItemsSource="{Binding People}" />
</Grid>

Là, notre code fonctionne comme on le souhaitait, et l’on récupère bien entendu le bon membre lors du déclenchement de la commande. En fait, ce qui a changé, nous avons déclaré la command, dans l’objet CommandReference. Notre bouton peut donc appeler la commande via le nom qu’on lui a donné. En effet, il passe par une ressource statique qui existe, et non une donnée dynamique comme il était question dans le DataTemplate.

Vous pouvez retrouvez la CommandReference dans le MVVM Toolkit, ce qui nous prouve encore une fois qu’avec des Toolkit bien pensé on optimise fortement notre temps de développement.

En espérant que cet article vous aide dans de futurs développement !

Et voilà, comme je le suppose, vous avez tous du apprendre que Silverlight 4 Beta est disponible pour nous les développeurs ! Et sinon vous n’étiez pas au courant, voilà qui est fait.

Alors je ne vais pas vous lister toutes les nouveautés de Silverlight 4, vu que d’autres l’ont déjà fait !

Mais voici un ensemble de liens ou vous pourrez voir tous les avantages de cette nouvelle version.

Le blog de Tim Heueur bien entendu : http://timheuer.com/blog/archive/2009/11/18/whats-new-in-silverlight-4-complete-guide-new-features.aspx

Et la série d’article de Mike Taulty (qui soit dit en passant à réussi à faire perdre la tête à mon Netvibes)

Silverlight 4: Beta Announced at PDC

Silverlight 4 Rough Notes: Trusted Applications

Silverlight 4 Rough Notes: Camera and Microphone Support

Silverlight 4 Rough Notes: Printing

Silverlight 4 Rough Notes: HTML Hosting in the WebBrowser Control

Silverlight 4 Rough Notes: Notification Windows

Silverlight 4 Rough Notes: RichTextArea

Silverlight 4 Rough Notes: Networking

Silverlight 4 Rough Notes: FlowDirection

Silverlight 4 Rough Notes: Clipboard Access

Silverlight 4 Rough Notes: Silverlight as a Drop Target

Silverlight 4 Rough Notes: Right Mouse Button Support

Silverlight 4 Rough Notes: Binding

Silverlight 4 Rough Notes: Binding and IDataErrorInfo

Silverlight 4 Rough Notes: Binding with INotifyDataErrorInfo

Silverlight 4 Rough Notes: A Word for Visual Studio 2010

Silverlight 4 Rough Notes: Styles

Silverlight 4 Rough Notes: Commanding

Silverlight 4 Rough Notes: Customising the Window

Silverlight 4 Rough Notes: Animating Items Into/Out Of ItemsControls

Silverlight 4 Rough Notes: HTML interop & dynamic language features

Silverlight 4 Rough Notes: Data Grid Enhancements

Silverlight 4 Rough Notes: Taking Control of Navigation

Silverlight 4 Rough Notes: SelectedValue

Silverlight 4 Rough Notes: Mousewheel Support in Controls

Silverlight 4 Rough Notes: TextBlock with Trimming

Silverlight 4 Rough Notes: CompositeTransform

Silverlight 4 Rough Notes: Viewbox

Silverlight 4 Rough Notes: Managed Extensibility Framework

Et voilà de quoi occuper longuement votre weekend, et le mien aussi d’ailleurs.

Silverlight 4 Beta Information

Earlier this week at PDC09 in Los Angeles we unveiled a Beta version Silverlight 4. This latest version delivers hundreds of features and controls that, when combined with the continued innovation in Microsoft’s world-class tools for designers and developers — Microsoft Visual Studio and Microsoft Expression Blend – present the leading edge in rapid, powerful application development. With printing support, rich reporting and charting, and integration with back-end systems and server products including Microsoft SharePoint, Silverlight is ready for business.

What’s New in Silverlight 4 Beta?

Silverlight 4 delivers a full suite of powerful capabilities to business application developers, bringing the best-of-breed .NET platform to browser-based experiences. Silverlight provides an ideal platform for developing and deploying modern business applications for both customer facing and staff-facing applications.

To learn more about beta release here are some good resource:

http://silverlight.net/getstarted/silverlight-4-beta/

http://channel9.msdn.com/learn/courses/Silverlight4/Overview/Overview/

http://channel9.msdn.com/learn/courses/Silverlight4/Overview/WhatsNew/

Additionally the Day#2 keynote announcement of Silverligh4 beta release from PDC09 is available on demand at:

http://microsoftpdc.com/Sessions/KEY02

Till now are are applying template only at the list view header. This time we are going to apply template in the list view item. In this example we are going to insert the expender control inside the cell of the grid view. We are using data template for this purpose. We are going to apply on GridViewColumn and use its CellTemplate property. CellTemplate is a DataTemplate type property. Here is a piece of code to insert expender inside the list view.

  1: <GridViewColumn.CellTemplate>

  2: 	<DataTemplate>

  3: 		<Expander ExpandDirection="Right">

  4: 			<TextBlock Foreground="Green" FontSize="14" Text="{Binding NickName}"/>

  5: 		</Expander>

  6: 	</DataTemplate>

  7: </GridViewColumn.CellTemplate>

  8: 

Rest of the code is almost same as we saw earlier. Here is a complete XAML code of the project.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="400">

  6:     <Window.Resources>

  7:         <Style x:Key="myStyle" TargetType="{x:Type ListViewItem}">

  8:             <Setter Property="Background" Value="AliceBlue"/>

  9:             <Setter Property="FontSize" Value="14"/>

 10:             <Setter Property="Foreground" Value="Green"/>

 11:         </Style>

 12:     </Window.Resources>

 13:     <Grid>

 14:         <ListView ItemContainerStyle="{StaticResource myStyle}" Name="list" Margin="5" HorizontalContentAlignment="Stretch">

 15:             <ListView.View>

 16:                 <GridView>

 17:                     <GridView.ColumnHeaderTemplate>

 18:                         <DataTemplate>

 19:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 20:                                 <Border.Background>

 21:                                     <LinearGradientBrush>

 22:                                         <GradientStop Offset="0" Color="Wheat"/>

 23:                                         <GradientStop Offset="1" Color="LightCoral"/>

 24:                                     </LinearGradientBrush>

 25:                                 </Border.Background>

 26:                                 <TextBlock Foreground="Blue" FontSize="14" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 27:                             </Border>

 28:                         </DataTemplate>

 29:                     </GridView.ColumnHeaderTemplate>

 30:

 31:                     <GridViewColumn Width="Auto" Header="State Name" DisplayMemberBinding="{Binding Path=Name}"/>

 32:                     <GridViewColumn Width="Auto" Header="State Capital" DisplayMemberBinding="{Binding Path=Capital}"/>

 33:                     <GridViewColumn Width="Auto" Header="State Nick Name">

 34:                         <GridViewColumn.CellTemplate>

 35:                             <DataTemplate>

 36:                                 <Expander ExpandDirection="Right">

 37:                                     <TextBlock Foreground="Green" FontSize="14" Text="{Binding NickName}"/>

 38:                                 </Expander>

 39:                             </DataTemplate>

 40:                         </GridViewColumn.CellTemplate>

 41:                     </GridViewColumn>

 42:                 </GridView>

 43:             </ListView.View>

 44:         </ListView>

 45:     </Grid>

 46: </Window>

 47: 

C# code of this project is also same as previous project. Here is complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public Window1()

 23:         {

 24:             InitializeComponent();

 25:

 26:             List<StateInfo> statesList = new List<StateInfo>();

 27:

 28:             statesList.Add(new StateInfo("Maryland", "Annapolis", "Old Line State", "Eastern"));

 29:             statesList.Add(new StateInfo("California", "Sacramento", "Golden State", "Pacific"));

 30:             statesList.Add(new StateInfo("Washington", "Olympia", "Ever Green State", "Pacific"));

 31:             statesList.Add(new StateInfo("Taxes", "Austin", "Lone Star State", "Central"));

 32:             statesList.Add(new StateInfo("New York", "Albany", "Empire State", "Eastern"));

 33:

 34:             list.ItemsSource = statesList;

 35:         }

 36:     }

 37:

 38:     public class StateInfo

 39:     {

 40:         public StateInfo()

 41:         {

 42:         }

 43:

 44:         public StateInfo(String name, String capital, String nickName, String timeZone)

 45:         {

 46:             Name = name;

 47:             Capital = capital;

 48:             NickName = nickName;

 49:             TimeZone = timeZone;

 50:         }

 51:

 52:         public String Name

 53:         { get; set; }

 54:

 55:         public String Capital

 56:         { get; set; }

 57:

 58:         public String NickName

 59:         { get; set; }

 60:

 61:         public String TimeZone

 62:         { get; set; }

 63:     }

 64: }

 65: 

Here is the output of this program.

With the help of horizontal expender, now we can make the state nick name demand base, means user can see the nick name of his/her selected states.

We already applied the data template to the header item, but the content of the list view is still very boring. Now we are going to apply some style to the list view items. Here we are going to define style in windows resource section of the  XAML and then use the StaticResource markup extension to use that style.

  1: <Window.Resources>

  2: 	<Style x:Key="myStyle" TargetType="{x:Type ListViewItem}">

  3: 		<Setter Property="Background" Value="AliceBlue"/>

  4: 		<Setter Property="FontSize" Value="14"/>

  5: 		<Setter Property="Foreground" Value="Green"/>

  6: 	</Style>

  7: </Window.Resources>

  8: 

We select “myStyle” name of our style and apply it on all ListViewItems. In this style, we are changing three properties of ListViewItem. We are changing its font size, foreground color and its background color.

After that we apply those changes in ItemContainerStyle property of ListView which has a style type.

  1: <ListView ItemContainerStyle="{StaticResource myStyle}"

  2: 		  Name="list" Margin="5" HorizontalContentAlignment="Stretch">

  3: 

Here is a complete XAML code of this project.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="400">

  6:     <Window.Resources>

  7:         <Style x:Key="myStyle" TargetType="{x:Type ListViewItem}">

  8:             <Setter Property="Background" Value="AliceBlue"/>

  9:             <Setter Property="FontSize" Value="14"/>

 10:             <Setter Property="Foreground" Value="Green"/>

 11:         </Style>

 12:     </Window.Resources>

 13:

 14:     <Grid>

 15:         <ListView ItemContainerStyle="{StaticResource myStyle}"

 16:                   Name="list" Margin="5" HorizontalContentAlignment="Stretch">

 17:             <ListView.View>

 18:                 <GridView>

 19:                     <GridView.ColumnHeaderTemplate>

 20:                         <DataTemplate>

 21:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 22:                                 <Border.Background>

 23:                                     <LinearGradientBrush>

 24:                                         <GradientStop Offset="0" Color="Wheat"/>

 25:                                         <GradientStop Offset="1" Color="LightCoral"/>

 26:                                     </LinearGradientBrush>

 27:                                 </Border.Background>

 28:                                 <TextBlock Foreground="Blue" FontSize="14" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 29:                             </Border>

 30:                         </DataTemplate>

 31:                     </GridView.ColumnHeaderTemplate>

 32:

 33:                     <GridViewColumn Width="Auto" Header="State Name" DisplayMemberBinding="{Binding Path=Name}">

 34:                         <GridViewColumn.CellTemplate>

 35:                             <DataTemplate>

 36:                                 <Border BorderBrush="Blue" BorderThickness="2">

 37:                                     <TextBlock Foreground="Blue" Text="{Binding}"/>

 38:                                 </Border>

 39:                             </DataTemplate>

 40:                         </GridViewColumn.CellTemplate>

 41:                     </GridViewColumn>

 42:                     <GridViewColumn Width="Auto" Header="State Capital" DisplayMemberBinding="{Binding Path=Capital}"/>

 43:                     <GridViewColumn Width="Auto" Header="State Nick Name" DisplayMemberBinding="{Binding Path=NickName}"/>

 44:                 </GridView>

 45:             </ListView.View>

 46:         </ListView>

 47:     </Grid>

 48: </Window>

 49: 

Its C# code is same as previous project. Here is complete C# coding of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public Window1()

 23:         {

 24:             InitializeComponent();

 25:

 26:             List<StateInfo> statesList = new List<StateInfo>();

 27:

 28:             statesList.Add(new StateInfo("Maryland", "Annapolis", "Old Line State", "Eastern"));

 29:             statesList.Add(new StateInfo("California", "Sacramento", "Golden State", "Pacific"));

 30:             statesList.Add(new StateInfo("Washington", "Olympia", "Ever Green State", "Pacific"));

 31:             statesList.Add(new StateInfo("Taxes", "Austin", "Lone Star State", "Central"));

 32:             statesList.Add(new StateInfo("New York", "Albany", "Empire State", "Eastern"));

 33:

 34:             list.ItemsSource = statesList;

 35:         }

 36:     }

 37:

 38:     public class StateInfo

 39:     {

 40:         public StateInfo()

 41:         {

 42:         }

 43:

 44:         public StateInfo(String name, String capital, String nickName, String timeZone)

 45:         {

 46:             Name = name;

 47:             Capital = capital;

 48:             NickName = nickName;

 49:             TimeZone = timeZone;

 50:         }

 51:

 52:         public String Name

 53:         { get; set; }

 54:

 55:         public String Capital

 56:         { get; set; }

 57:

 58:         public String NickName

 59:         { get; set; }

 60:

 61:         public String TimeZone

 62:         { get; set; }

 63:     }

 64: }

 65: 

Here is the output of this program.

We just studied the basic functionality of list view and how we can display data in multiple columns in the list view. But we display our data in very simple and default format. Let’s explore it little bit more and try to customize the its display. At this stage we are going to change the header formatting and apply the data template at the header level.

To change the display of the header, we are going to set the column header template data type. Here is a piece of code to set the data template for the header of the list view.

  1: <GridView.ColumnHeaderTemplate>

  2: 	<DataTemplate>

  3: 		<Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

  4: 			<Border.Background>

  5: 				<LinearGradientBrush>

  6: 					<GradientStop Offset="0" Color="Wheat"/>

  7: 					<GradientStop Offset="1" Color="LightCoral"/>

  8: 				</LinearGradientBrush>

  9: 			</Border.Background>

 10: 			<TextBlock Foreground="Blue" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 11: 		</Border>

 12: 	</DataTemplate>

 13: </GridView.ColumnHeaderTemplate>

 14: 

ColumnHeaderTemplate is a DataTemplate type property of GridView class. Here is complete XAML code of the project.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="400">

  6:     <Grid>

  7:         <ListView Name="list" Margin="5" HorizontalContentAlignment="Stretch">

  8:             <ListView.View>

  9:                 <GridView>

 10:                     <GridView.ColumnHeaderTemplate>

 11:                         <DataTemplate>

 12:                             <Border BorderBrush="Brown" BorderThickness="2" CornerRadius="5">

 13:                                 <Border.Background>

 14:                                     <LinearGradientBrush>

 15:                                         <GradientStop Offset="0" Color="Wheat"/>

 16:                                         <GradientStop Offset="1" Color="LightCoral"/>

 17:                                     </LinearGradientBrush>

 18:                                 </Border.Background>

 19:                                 <TextBlock Foreground="Blue" FontWeight="Bold" Margin="5" Text="{Binding}" Width="Auto"/>

 20:                             </Border>

 21:                         </DataTemplate>

 22:                     </GridView.ColumnHeaderTemplate>

 23:

 24:                     <GridViewColumn Width="Auto" Header="State Name" DisplayMemberBinding="{Binding Path=Name}"/>

 25:                     <GridViewColumn Width="Auto" Header="State Capital" DisplayMemberBinding="{Binding Path=Capital}"/>

 26:                     <GridViewColumn Width="Auto" Header="State Nick Name" DisplayMemberBinding="{Binding Path=NickName}"/>

 27:                 </GridView>

 28:             </ListView.View>

 29:         </ListView>

 30:     </Grid>

 31: </Window>

 32: 

Here is a complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public Window1()

 23:         {

 24:             InitializeComponent();

 25:

 26:             List<StateInfo> statesList = new List<StateInfo>();

 27:

 28:             statesList.Add(new StateInfo("Maryland", "Annapolis", "Old Line State", "Eastern"));

 29:             statesList.Add(new StateInfo("California", "Sacramento", "Golden State", "Pacific"));

 30:             statesList.Add(new StateInfo("Washington", "Olympia", "Ever Green State", "Pacific"));

 31:             statesList.Add(new StateInfo("Taxes", "Austin", "Lone Star State", "Central"));

 32:             statesList.Add(new StateInfo("New York", "Albany", "Empire State", "Eastern"));

 33:

 34:             list.ItemsSource = statesList;

 35:         }

 36:     }

 37:

 38:     public class StateInfo

 39:     {

 40:         public StateInfo()

 41:         {

 42:         }

 43:

 44:         public StateInfo(String name, String capital, String nickName, String timeZone)

 45:         {

 46:             Name = name;

 47:             Capital = capital;

 48:             NickName = nickName;

 49:             TimeZone = timeZone;

 50:         }

 51:

 52:         public String Name

 53:         { get; set; }

 54:

 55:         public String Capital

 56:         { get; set; }

 57:

 58:         public String NickName

 59:         { get; set; }

 60:

 61:         public String TimeZone

 62:         { get; set; }

 63:     }

 64: }

 65: 

Here is the output of this program.

This feature is a really big one, and could prove the most useful feature (other than data sharing).

Basically imagine you have an application that allows you to tag people in a photo, but your photo management application
doesn’t allow this, well providing they both support Clarity and they follow the data guidelines correctly the two applications should be able to share their photos.

Now, this would normally be fine, but nobody wants to have to open another application and worry about navigating around it just to do one task, what if the application could be run when needed / hide in the background?

Well this is one way of doing it, and the application could simply make itself visible when the user wants to use it; but this also isn’t ideal.

Wouldn’t it be great if the photo manager application could “pull-in” the part of the applications interface that allows the user to tag photos, the Clarity system would then communicate all of the data and events between the two parties, and in a practically transparent manner!

This, in theory, using the Clarity system could also be done over the internet, you have some photos you took at a party and want to know who’s in them? As long as your friends have the same application they could (providing the application supports it), dive right into your photo library and tag it remotely, all using code that is running on your machine!

This technology would be initially fairly basic, and restricted to WPF for the simple fact that XAML can be so easily removed from the application logic, and the binding system provides a very quick way of doing a lot of what this system would require.

We just saw the example of list view control. In that example we saw list view just like a list box. Now let’s explore it little bit more and see the multiple columns in list view and do the data binding with the user define type. Here is a XAML code to display the multiple columns in the list view.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="400">

  6:     <Grid>

  7:         <ListView Name="list" Margin="5" HorizontalContentAlignment="Stretch">

  8:             <ListView.View>

  9:                 <GridView>

 10:                     <GridViewColumn Width="Auto" Header="State Name" DisplayMemberBinding="{Binding Path=Name}"/>

 11:                     <GridViewColumn Width="Auto" Header="State Capital" DisplayMemberBinding="{Binding Path=Capital}"/>

 12:                     <GridViewColumn Width="Auto" Header="State Nick Name" DisplayMemberBinding="{Binding Path=NickName}"/>

 13:                 </GridView>

 14:             </ListView.View>

 15:         </ListView>

 16:     </Grid>

 17: </Window>

 18: 

Let’s take a look our old example of State info class. In this C# code we are defining list of state info class and fill it with some data before doing data binding. Here is a complete C# code of this project.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public Window1()

 23:         {

 24:             InitializeComponent();

 25:

 26:             List<StateInfo> statesList = new List<StateInfo>();

 27:

 28:             statesList.Add(new StateInfo("Maryland", "Annapolis", "Old Line State"));

 29:             statesList.Add(new StateInfo("California", "Sacramento", "Golden State"));

 30:             statesList.Add(new StateInfo("Washington", "Olympia", "Ever Green State"));

 31:             statesList.Add(new StateInfo("Taxes", "Austin", "Lone Star State"));

 32:             statesList.Add(new StateInfo("New York", "Albany", "Empire State"));

 33:

 34:             list.ItemsSource = statesList;

 35:         }

 36:     }

 37:

 38:     public class StateInfo

 39:     {

 40:         public StateInfo()

 41:         {

 42:         }

 43:

 44:         public StateInfo(String name, String capital, String nickName)

 45:         {

 46:             Name = name;

 47:             Capital = capital;

 48:             NickName = nickName;

 49:         }

 50:

 51:         public String Name

 52:         { get; set; }

 53:

 54:         public String Capital

 55:         { get; set; }

 56:

 57:         public String NickName

 58:         { get; set; }

 59:     }

 60: }

 61: 

Here is the output of this program.

As I mentioned before, I’ve been working on an image extractor for a specific image board as a way to hone my .net skills. It’s almost done in the sense that “it works on my computer”.

This is the look of it at the moment. The gradient background is kind of an inside joke and those of you who get it, good for you.

The idea is for users to be able to look at multiple pages of image content without having to click through pages or read lots of useless banter. Take for instance this wallpaper-board. The user can request any number of available pages to be presented and then click on an image to see it in full resolution. Very effective.

My problem at this point is that since I developed the app using Visual Studio 2010, all references are to .net framework 4.0 and unusable to most people. A friend of mine who tested the application also complained about it stopping when trying to save the pictures. I guess the apps main thread stalls while downloading. That’s something else I’ll have to look at.

ListView control is inherited by ListBox class and it contains all the functionality of List Box class. Here is a class diagram of ListView class.

List view define a property View that define the presentation of the List view. WPF already provide one presentation for ListBox class named GridView. If we want to define our own presentation then we have to inherit our class from ViewBase class. ViewBase is an abstract class and View Property of ListView class has the ViewBase data type. Here is a class diagram to explain this.

Now lets take a look at simple usage of GridView class. Our C# code is very similar to List box example there  we define list of string. Here is C# code of this.

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Windows;

  6: using System.Windows.Controls;

  7: using System.Windows.Data;

  8: using System.Windows.Documents;

  9: using System.Windows.Input;

 10: using System.Windows.Media;

 11: using System.Windows.Media.Imaging;

 12: using System.Windows.Navigation;

 13: using System.Windows.Shapes;

 14:

 15: namespace UIElement

 16: {

 17:     /// <summary>

 18:     /// Interaction logic for Window1.xaml

 19:     /// </summary>

 20:     public partial class Window1 : Window

 21:     {

 22:         public List<String> items

 23:         { get; set; }

 24:

 25:         public Window1()

 26:         {

 27:             InitializeComponent();

 28:

 29:             items = new List<string>();

 30:             items.Add("Maryland");

 31:             items.Add("California");

 32:             items.Add("Taxes");

 33:             items.Add("Washington");

 34:             items.Add("Virginia");

 35:

 36:             list.ItemsSource = items;

 37:         }

 38:     }

 39: }

 40: 

Here is XAML code of our project.

  1: <Window x:Class="UIElement.Window1"

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

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

  4:     xmlns:local="clr-namespace:UIElement"

  5:     Title="ListView Example" Height="300" Width="400">

  6:     <Grid>

  7:         <ListView Name="list" Margin="5" HorizontalContentAlignment="Stretch">

  8:             <ListView.View>

  9:                 <GridView>

 10:                     <GridViewColumn Width="Auto" Header="States Name" DisplayMemberBinding="{Binding}"/>

 11:                 </GridView>

 12:             </ListView.View>

 13:         </ListView>

 14:     </Grid>

 15: </Window>

 16: 

Here is the output of this program.

The visual state manager is a powerful addition to WPF 4.0 that facilitates handling state visuals for WPF and Silverlight controls. For example, a button control could have the states “Pressed”, “Normal”, “Disabled”, etc., and have different looks for each of those states, with transitions between them. If you’re unfamiliar with the Visual State Manager, check out the Visual State Manager Overview, or ScottGu’s post.

The Visual State Manager is already a part of Silverlight 2, and will be in WPF 4.0. You can, however, use it already if you download the official WPF Toolkit.

Now, as nice as the VisualStateManager (VSM) is, anyone who has tried to use it with the Model-View-Viewmodel (MVVM) or Model-View-Presenter (MVP) will have run into some issues. The big showstopper is that to change states using the VSM, you have to pass the view as an argument:

VisualStateManager.GoToState(View, stateName, true);

If you’re using the MVP pattern, this is okay, since your presenter will likely be aware of the view. For example, if you’re using Caliburn (which, by the way, is an awesome framework for MVP or MVVM), you can do something like this:

private object View { get; set; }
public override void ViewLoaded(object view, object context)
{
	View = view;
	base.ViewLoaded(view, context);
}

private void ChangeStateTo(string stateName)
{
	Application.Current.Dispatcher.Invoke((System.Action) (delegate()
	{
		VisualStateManager.GoToState((Control)View, stateName, true);
	}), null);
}

This works just fine. But if you’re using MVVM this isn’t really a solution, since the viewmodel should not have to know about the view. Also, ideally you’d like to bind your visual state to a property on the presenter/viewmodel. Unit testing states will also be difficult like this.

The solution lies in WPF’s attached properties (ooh, don’t we just love those?). We’ll create a helper class with a VisualState depencency property, and in the PropertyChangedCallback method for that property we’ll pass the sender (which will be our view) and the new property value (which will be the name of the state) to the VisualStateManager:

public class StateManager : DependencyObject
{
	public static string GetVisualStateProperty(DependencyObject obj)
	{
		return (string)obj.GetValue(VisualStatePropertyProperty);
	}

	public static void SetVisualStateProperty(DependencyObject obj, string value)
	{
		obj.SetValue(VisualStatePropertyProperty, value);
	}

	public static readonly DependencyProperty VisualStatePropertyProperty =
		DependencyProperty.RegisterAttached(
		"VisualStateProperty",
		typeof(string),
		typeof(StateManager),
		new PropertyMetadata((s, e) =>
		{
		var propertyName = (string)e.NewValue;
		var ctrl = s as Control;
		if (ctrl == null)
			throw new InvalidOperationException("This attached property only supports types derived from Control.");
		System.Windows.VisualStateManager.GoToState(ctrl, (string)e.NewValue, true);
	}));
}

Now in XAML we can bind the VisualStateName string property on our viewmodel to our new helper class:

<UserControl x:Class="MyApp.SomeView"
//namespaces omitted for brevity
MyApp:StateManager.VisualStateProperty="{Binding VisualStateName}">

And that’s it! Our helper class will switch states on the view for us. The viewmodel no longer has to be aware of the view, and unit testing states becomes a lot easier.

Many thanks to Rob Eisenberg, author of Caliburn, and to whoever wrote this piece of code on Github, for putting me on the right track.

In this section we will dissect the wpf toolkit calendar control. To learn more on how Microsoft codes for wpf.

One of the challenges I had writing my own calendar control and some of the samples I looked at on the web was to display the day’s in the calendar control. At first it sounds easy, you use a uniform grid control with 7 columns and bind to a list of day’s, another solution was to use a list box and dived the days into weeks, then you have a week template and list box template. All very well. The problem was where do you store the list of day’s neatly away from the controls user yet make it easy to access for the data binding and flexible for new templates and styles to be applied.

Let see how the toolkit team did it.

WPF Toolkit Calendar Control

WPF ToolKit Calendar Control

Lets start at the Calendar style, From the main Calendar style they have a CalendarItem.  The CalendarItem is a WPF Control on its own, a nice future of the Toolkit Calendar is that it support multiple Views, this is all handled by the CalendarItem style. Having the Calendar Control Contain one CalendarItem is a clever way of Hiding the Control Code from the actual code the developer will want to see when consuming the control.

The Toolkit CalendarItem use a Grid to display the day’s with 7 columns and 7 rows fields called ‘PART_MonthView‘ the grid is contained in parent grid with 2 rows and 3 Columns. The parent grid displays the left and right arrows and the heading.

Filling the Days in the PART_MonthView

After the Control Template is set, The C# code extracts all the Template ‘PARTs’ and assign it too internal variables prefixed with underscore. the one we are interested in is ‘_monthView’ which is the grid with 7 rows and 7 columns.

_monthView is populated with ‘CalendarDayButton’ Controls using a standard loop. The CalendarItem Control Populates the grid via a function ‘PopulateGrids()’

PopulateGrids() Sets the CalendarDayButton Owner and assign the events and binds the style property.

private void SetMonthModeDayTitles() Sets the Day Titles by looping trought the 1 ste 7 cells  in the Month View Grid. Then the day’s are set using the SetMonthModeCalendarDayButtons function.

Here is a quick view of this function.

private void SetMonthModeCalendarDayButtons()
{
 DateTime firstDayOfMonth = DateTimeHelper.DiscardDayTime(DisplayDate);
 int lastMonthToDisplay = GetNumberOfDisplayedDaysFromPreviousMonth(firstDayOfMonth);
 bool isMinMonth = DateTimeHelper.CompareYearMonth(firstDayOfMonth,DateTime.MinValue) <= 0;
 bool isMaxMonth = DateTimeHelper.CompareYearMonth(firstDayOfMonth,DateTime.MaxValue) >= 0;
 int daysInMonth =_calendar.GetDaysInMonth(firstDayOfMonth.Year, firstDayOfMonth.Month);
 int count = ROWS * COLS;

 //Loop the cell's ignoring the first seven as they contain the day names for the title.
 for (int childIndex = COLS; childIndex < count; childIndex++)
 {
 CalendarDayButton childButton = _monthView.Children[childIndex] as CalendarDayButton;
 Debug.Assert(childButton !=null);
 int dayOffset = childIndex - lastMonthToDisplay- COLS;

  //Set DayButton Control with the new Content.
 if ((!isMinMonth || (dayOffset >= 0)) &&(!isMaxMonth || (dayOffset < daysInMonth)))
 {
 DateTime dateToAdd =_calendar.AddDays(firstDayOfMonth, dayOffset);
 //Sets and Calculates all the Properties for the Day
 SetMonthModeDayButtonState(childButton, dateToAdd);
 childButton.DataContext = dateToAdd;
 childButton.SetContentInternal(DateTimeHelper.ToDayString(dateToAdd));
 }
 else
 {
 SetMonthModeDayButtonState(childButton, null);
 childButton.DataContext = null;
 childButton.SetContentInternal(DateTimeHelper.ToDayString(null));
 }
 }
}

• You Hide the complexities of the month and day calculations by wrapping the actual control by anouther more userfriendly control. This they did by wrapping CalendarItem with Calendar Control. CalendarItem is in a separate name space than the Calendar control, this hide’s the control from normal developers only intrested in the Calendar, but for more advance coding you can still access the the base control by adding the primitives names space.
• They do not recreate the Day Controls but rather just update the content’s.
• There was no magic to make this work its basic clever wpf and C# coding. What was intresting to me how much they still did in code.  When starting WPF you tend to do everything in WPF, and that is not always the correct or best way of doing things.

You can find the complete WPF ToolKit and source code here.

http://wpf.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=29117

Created a simple, but nice Glass Border for a panel in my current Silverlight 3 project. I’d like to share it with you…

  <Style x:Key="GlassBorderStyle" TargetType="Border">
    <Setter Property="BorderThickness" Value="2"/>
    <Setter Property="Padding" Value="5"/>
    <Setter Property="Background">
        <Setter.Value>
            <LinearGradientBrush EndPoint="0.75,1" StartPoint="0.25,0">
                <GradientStop Color="#33FFFFFF" Offset="0"/>
                <GradientStop Color="#C0FFFFFF" Offset="0.287"/>
                <GradientStop Color="#4011322D" Offset="0.683"/>
                <GradientStop Color="#33FFFFFF" Offset="1"/>
            </LinearGradientBrush>
        </Setter.Value>
    </Setter>
    <Setter Property="BorderBrush">
        <Setter.Value>
            <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                <GradientStop Color="#5811322D" Offset="0"/>
                <GradientStop Color="#3EFFFFFF" Offset="0.25"/>
                <GradientStop Color="#FFFFFFFF" Offset="0.5"/>
                <GradientStop Color="#3EFFFFFF" Offset="0.75"/>
                <GradientStop Color="#BFFFFFFF" Offset="1"/>
            </LinearGradientBrush>
        </Setter.Value>
    </Setter>
    <Setter Property="Effect">
        <Setter.Value>
            <DropShadowEffect BlurRadius="3" ShadowDepth="3" Opacity="0.5"/>
        </Setter.Value>
    </Setter>
</Style>

To use this style:

<Border x:Name="GlassBorder" Height="100" Width="100" CornerRadius="10"
    Style="{StaticResource GlassBorderStyle}">
    <Button Content="OK"/>
</Border>

Njoy!

I’ve been trying out the Visual Studio 2010 beta for a week now and I love it. One of my favorite features is the boxmarking which VS now allows. This is nothing new but is incredibly useful when editing code.

In my sideproject, the Imageboard-Viewer, I wanted to apply a Style template to a list of ComboBoxItems. In Visual Studio 2008, I’d been forced to copy paste the text and change rows a million times (there are more items than visible here, although maybe not a million) .

What I did instead was hold down Alt while dragging a thin vertical box and pasting my code once. This resulted in the same text being pasted to each row.

I also got a chance to use boxmarking when copying multiple values. I wanted to set the content of the ComboBoxItems according to names. As is visible in the above picture, I had several different values to copy.

Boxmarking makes this an easy and quick task to complete. Imagine the time saving possibilities when handling hundreds of rows at the same time.

Now I just write the word Content and paste my names

I present you the first style (of many to come) for your projects: GraySky Button style. It is based on screenshots from Shiki-Colors GTK+ themes (no original source is used, just a lot of screenshots and color picking).

I’ve provided ResourceDictionary that you can use. Download here (rename .DOC to .RAR – wordpress limitation).

I’m currently working on a little side-project in WPF. A sort of imageviewer for imageboards. Since I want as much windowspace as possible for the images, I decided to put some of my icons on top of the image thumbnails. This proved hard to do. I therefore made a Custom Class called “MainImage”. This class will display both the original image (named here BackgroundImage) and two icons which I later added eventhandlers to to capture clicks. This worked out wonderfully well. The result is something like this:

First two normal images are put into my WrapPanel, then the third is my custom MainImage. Notice how it looks similar to the first two images but with the added icons on it. These icons are linked to two different event handlers in my codebehind. And thanks to my custom class, I can generate these custom images dynamically in my codebehind.

Tip: If you name your elements in a custom class (as I named my BackgroundImage ), you can set them and their properties in the codebehind just like any other property.

HowTo: To create a customclass, just rightclick your project in the Solution Explorer, choose “Add User Control” and choose a name for your control. You will now have a new item called YourName.xaml which in turn has a .cs file associated with it.

Here is the code I used for my MainImage control.