PaVZaV's blog

Is it really our future?

2013-02-27T22:23:00.001Z

Microsoft Technologies

2013-01-13T00:06:00.000Z

Microsoft Technologies - An infographic by the team from Next at Microsoft

Interception and ServiceLocator in Unity

2012-05-07T22:42:00.000+01:00

This time I would like to familiarize you with two interesting concepts of Unity (IoC Container) which you can find very useful.

Interceptors allow programmers to run some functionality before or after a selected piece of code. This approach is called Aspect-Oriented Programming (AOP) and its main goal is to increase modularity through separation of cross-cutting concerns e.g. logging messages before and after a code execution. The following example shows how easy you can apply logging in a method using a [MethodHandler()] attribute.

ServiceLocator is an excellent concept of the Unity but I do not like the fact that it can be easily abused and overdosed. An example below shows two different approaches for creating an instance of a Logger class. First one is using constructor injection and the second one is using ServiceLocator (have a look at the constructors). The only one case scenario when ServiceLocator seems to be very useful is a situation when we have a class created outside of the Unity and this class needs access to the other types registered in a container. An example below shows how to make ServiceLocator aware of the Unity.

   1:          class Program

   2:          {

   3:              static void Main(string[] args)

   4:              {

   5:                  IUnityContainer unity = new UnityContainer();

   6:                  UnityServiceLocator locator = new UnityServiceLocator(unity);

   7:                  ServiceLocator.SetLocatorProvider(() => locator);

8:

   9:                  unity.AddNewExtension<Interception>();

  10:                  unity.RegisterType<ILogger, Logger>();

  11:                  unity.RegisterType<ITest, Test>().Configure<Interception>().SetDefaultInterceptorFor<ITest>(new InterfaceInterceptor());

12:

  13:                  unity.Resolve<ITest>().Execute();

  14:                  Console.ReadKey();

  15:              }

  16:          }

17:

  18:          public class Test : ITest

  19:          {

  20:              public void Execute()

  21:              {

  22:                  Console.WriteLine("Execute Method Body");

  23:              }

  24:          }

25:

  26:          public interface ITest

  27:          {

  28:              [MethodHandler()]

  29:              void Execute();

  30:          }

31:

  32:          public class CallHandler : ICallHandler

  33:          {

  34:              private IUnityContainer _container;

  35:              private ILogger _logger;

36:

  37:              public CallHandler(IUnityContainer container, ILogger logger)

  38:              {

  39:                  _logger = logger;

  40:              }

41:

  42:              public CallHandler()

  43:              {

  44:                  _logger = ServiceLocator.Current.GetInstance<ILogger>();

  45:              }

46:

  47:              public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)

  48:              {

  49:                  _logger.LogPreMessage(input.MethodBase.Name);

  50:                  IMethodReturn methodReturn = getNext()(input, getNext);

  51:                  _logger.LogPostMessage(input.MethodBase.Name);

  52:                  return methodReturn;

  53:              }

54:

  55:              public int Order

  56:              {

  57:                  get;

  58:                  set;

  59:              }

  60:          }

61:

  62:          public class MethodHandlerAttribute : HandlerAttribute

  63:          {

  64:              public MethodHandlerAttribute()

  65:              {

  66:              }

67:

  68:              public override ICallHandler CreateHandler(IUnityContainer container)

  69:              {

  70:                  return new CallHandler(container);

  71:              }

  72:          }

73:

  74:          interface ILogger

  75:          {

  76:              void LogPreMessage(string msg);

  77:              void LogPostMessage(string msg);

  78:          }

79:

  80:          class Logger : ILogger

  81:          {

  82:              public void LogPreMessage(string msg)

  83:              {

  84:                  Console.WriteLine("Pre -> " + msg);

  85:              }

86:

  87:              public void LogPostMessage(string msg)

  88:              {

  89:                  Console.WriteLine("Post -> " + msg);

  90:              }

  91:          }

  92:      }

Useful links:

Live Tiles

2012-04-29T23:30:00.000+01:00

One of the most expected features of Mango release were live tiles allowing developers to present data on the Home screen. I was quite exited about this feature especially that I wanted to give users opportunity to learn new words or whole sentences. You can see it in action on Multi-Translator Webpage or you can install it from Marketplace.There are actually few ways to present data in live tiles.

FindAndDeleteTile method

   1:          private void FindAndDeleteTile(string tileName)

   2:          {

   3:              ShellTile tile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("DefaultTitle="+tileName));

   4:              if (tile != null)

   5:                  tile.Delete();

   6:          }

TileHelper class

   1:   public static class TileHelper

   2:      {

   3:          public static void CreateTile(string content, string fileName, string originalFileName)

   4:          {

   5:              TextBlock text = new TextBlock()

   6:              {

   7:                  Width = 173,

   8:                  Height = 173,

   9:                  TextWrapping = TextWrapping.Wrap,

  10:                  Foreground = new SolidColorBrush(Colors.White),

  11:                  Padding = new Thickness(5, 5, 5, 60),

  12:                  FontSize = 18,

  13:                  Clip = new RectangleGeometry { Rect = new Rect(0, 0, 173, 135) }

  14:              };

  15:              text.Text = content;

  16:              Canvas canvas = new Canvas() { Width = 173, Height = 173, Background = new SolidColorBrush(Colors.Blue) };

  17:              canvas.Children.Add(text);

18:

  19:              StreamResourceInfo sri = Application.GetResourceStream(new Uri(originalFileName, UriKind.Relative));

  20:              BitmapImage src = new BitmapImage();

  21:              src.SetSource(sri.Stream);

  22:              WriteableBitmap background = new WriteableBitmap(src);

  23:              WriteableBitmap bmp = new WriteableBitmap((int)canvas.Width, (int)canvas.Height);

  24:              bmp.Render(canvas, null);

  25:              bmp.Invalidate();

26:

  27:              for (int x = 0; x < canvas.Width; x++)

  28:                  for (int y = 0; y < canvas.Height; y++)

  29:                      //Detect the colour different from your canvas background (in this case Blue)

  30:                      //and replace the background.jpg pixel with the one from your canvas

  31:                      if (bmp.Pixels[y * (int)canvas.Width + x] != BitConverter.ToInt32(new byte[] { 255, 0, 0, 255 }, 0))

  32:                          background.Pixels[y * (int)canvas.Width + x] = bmp.Pixels[y * (int)canvas.Width + x];

33:

  34:              var iss = IsolatedStorageFile.GetUserStoreForApplication();

  35:              using (var stm = iss.CreateFile(fileName))

  36:                  background.SaveJpeg(stm, 173, 173, 0, 100);

  37:          }

38:

  39:          public static void CreateRenderedTile(FrameworkElement frameworkElement, string fileName)

  40:          {

  41:              WriteableBitmap bmp = new WriteableBitmap((int)frameworkElement.Width, (int)frameworkElement.Height);

  42:              bmp.Render(frameworkElement, null);

  43:              bmp.Invalidate();

44:

  45:              var iss = IsolatedStorageFile.GetUserStoreForApplication();

  46:              using (var stm = iss.CreateFile(fileName))

  47:                  bmp.SaveJpeg(stm, 173, 173, 0, 100);

  48:          }

  49:      }

Default approach - using API

   1:          var filename = "/Shared/ShellContent/renderedF.jpg";

   2:          var filenameBack = "/Shared/ShellContent/renderedB.jpg";

   3:          TileHelper.CreateRenderedTile(frontBorder, filename);

   4:          TileHelper.CreateRenderedTile(backBorder, filenameBack);

5:

   6:          FindAndDeleteTile("Rendered");

   7:          StandardTileData NewTileData = new StandardTileData

   8:          {

   9:              BackgroundImage = new Uri("isostore:" + filename, UriKind.Absolute),

  10:              Title = "rendered - front",

  11:              BackTitle = "rendered - back",

  12:              BackBackgroundImage = new Uri("isostore:" + filenameBack, UriKind.Absolute)

  13:          };

  14:          ShellTile.Create(new Uri("/MainPage.xaml?DefaultTitle=Rendered", UriKind.Relative), NewTileData);

Custom approaches:

Rendered - Saving the content of controls visible on the screen into a file and using it as a tile background

   1:          var filename = "/Shared/ShellContent/renderedF.jpg";

   2:          var filenameBack = "/Shared/ShellContent/renderedB.jpg";

   3:          TileHelper.CreateRenderedTile(frontBorder, filename);

   4:          TileHelper.CreateRenderedTile(backBorder, filenameBack);

5:

   6:          FindAndDeleteTile("Rendered");

   7:          StandardTileData NewTileData = new StandardTileData

   8:          {

   9:              BackgroundImage = new Uri("isostore:" + filename, UriKind.Absolute),

  10:              Title = "rendered - front",

  11:              BackTitle = "rendered - back",

  12:              BackBackgroundImage = new Uri("isostore:" + filenameBack, UriKind.Absolute)

  13:          };

  14:          ShellTile.Create(new Uri("/MainPage.xaml?DefaultTitle=Rendered", UriKind.Relative), NewTileData);

In memory - Saving a content of controls generated in memory into a file and using it as a tile background

   1:          var filename = "/Shared/ShellContent/inMemoryF.jpg";

   2:          var filenameBack = "/Shared/ShellContent/inMemoryB.jpg";

   3:          TileHelper.CreateTile(front.Text, filename, "Images/background.jpg");

   4:          TileHelper.CreateTile(back.Text, filenameBack, "Images/backgroundBack.jpg");

5:

   6:          FindAndDeleteTile("InMemory");

   7:          StandardTileData NewTileData = new StandardTileData

   8:          {

   9:              BackgroundImage = new Uri("isostore:" + filename, UriKind.Absolute),

  10:              Title = "in memory - front",

  11:              BackTitle = "in memory - back",

  12:              BackBackgroundImage = new Uri("isostore:" + filenameBack, UriKind.Absolute)

  13:          };

  14:          ShellTile.Create(new Uri("/MainPage.xaml?DefaultTitle=InMemory", UriKind.Relative), NewTileData);

Useful links:

Source code: LiveTiles.rar

Multi-Translator

2012-03-22T21:53:00.001Z

Multi-Translator version 2.1 has been released http://www.windowsphone.com/en-GB/apps/386c92a9-ec33-4f92-9499-172bd6e4131b

What are the most profitable apps?

2012-01-12T08:48:00.000Z

If you ask yourself what type of app you should create from the profitability point of view, just have a look below.

Merry Christmas and Happy New Year

2011-12-24T08:11:00.001Z

Multi-Translator ver. 2.0

2011-12-19T08:58:00.001Z

Multi-Translator 2.0 [Mango] has been released.

How to scroll ListBox (ScrollViewer) to show an element without using BringIntoView method

2011-11-30T16:43:00.001Z

This is a problem you can encounter in WPF and Silverlight. The usual solution presented in the Internet is to use BringIntoView() method. This approach works but does not guarantee that the whole element will be showed. The solution I want to show you is similar in both technologies and is more precise than BringIntoView() method.

Let's assume that our UI contains a ListBox with a content

   1:  <ListBox x:Name="SomeItems">

   2:  <!--...-->

   3:  </ListBox>

4:

If we want to show a particular item contained in SomeItems ListBox we have to discover ScrollViewer which is a part of a ListBox visual tree and run ScrollToVerticalOffset method pointing to an index of an item we want to show. The following class can be used to find any DepenendecyObject in a visual tree.

   1:      public static class VisualHelper

   2:      {

   3:          public static T FindDependencyObject<T>(DependencyObject dependencyObject)

   4:      where T : DependencyObject

   5:          {

   6:              DependencyObject d = dependencyObject;

   7:              while (!(d is T) && VisualTreeHelper.GetChildrenCount(d) > 0)

   8:                  d = VisualTreeHelper.GetChild(d, 0);

   9:              return d as T;

  10:          }

  11:      }

12:

This is how you can use the code presented above

   1:  var scrollViewer = VisualHelper.FindDependencyObject<ScrollViewer>(SomeItems);

   2:  scrollViewer.ScrollToVerticalOffset([index of an item]);

Multi-Translator

2011-11-04T08:13:00.000Z

My first application has been released and is available on Windows Phone Marketplace

Windows 8

2011-09-14T00:03:00.000+01:00

Microsoft finally unveiled some additional details regarding new Windows 8. If you would like to watch the keynote session please have a look at http://www.buildwindows.com/.

Some key conclusions (for developers) from the keynote:

JavaScript is becoming a first-class language (you can find few proofs below)
Developers will receive VS2011 and Expression Blend 5 with arrival of Windows 8

I really like new Microsoft 'no compromises' approach which means that developers will be able to use new Windows 8 tablets for everything - the most important for coding.

Key concepts in Silverlight in comparison with WPF

2011-09-07T22:51:00.000+01:00

In this article I would like to show you how to use some of the key Silverlight features:

Dependency Properties,
Data Bindings,
Commands,
Implicit styles,
Explicit styles,
Visual State Manager,
Animations,
Value Converters,
CollectionViewSource,
Custom Controls.

1. Dependency Properties

If you want to understand the reason and the way how DP works please visit this link. I would like to mention differences between WPF and SL DPs. When you create DP in SL you can specify PropertyMetadata but as a result you will lack coercion and validation support which can be handled in FrameworkPropertyMetadata (WPF). These two can be useful especially if you want to create advanced controls. If you cannot imagine how coercion can be useful for you I can give an example - range IP address control.

   1:  public static readonly DependencyProperty RadiusProperty = DependencyProperty.Register("Radius", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

2:

   3:          public double Radius

   4:          {

   5:              get { return (double)GetValue(RadiusProperty); }

   6:              set { SetValue(RadiusProperty, value); }

   7:          }

2. Data Bindings
I describe data bindings as maximum functionality and minimum code, very useful for displaying and interacting with data. Bindings are even more useful when you use Model-View-ViewModel (MVVM) pattern because in case like that data bindings create these pipelines/streams of data between presentation layer (V) and logic behind it (VM) and no additional code is needed.

Example below shows how to use data bindings directly in your view (V)

   1:  <local:CelestialBodyControl BodyName="{Binding Name}" Radius="{Binding Radius}" AverageDistanceFromSun="{Binding AverageDistanceFromSun}"

   2:                                                  RotationPeriod="{Binding RotationPeriod}" OrbitalPeriod="{Binding OrbitalPeriod}"/>

This example shows how to use a data binding inside a style

   1:  <TextBlock Text="{Binding Radius, RelativeSource={RelativeSource TemplatedParent}}" Foreground="White"/>

3. Commands
Commands are a way to handle user interface actions but the problem is that they are not widely supported in SL. They are a loosely coupled way to bind the UI to the logic that performs the action. This is the way how you can perform interactions between your View and a ViewModel.

   1:  <ToggleButton Content="Start" Command="{Binding StartCommand}" Width="100" Height="30" />

   1:          public ViewModel()

   2:          {

   3:              //...

   4:              StartCommand = new DelegateCommand<object>(HandleStartCommand);

   5:              //...

   6:          }

7:

   8:          public DelegateCommand<object> StartCommand

   9:          {

  10:              get { return _startCommand; }

  11:              set

  12:              {

  13:                  _startCommand = value;

  14:                  OnPropertyChanged("StartCommand");

  15:              }

  16:          }

17:

  18:          private void HandleStartCommand(object payload)

  19:          {

  20:              //...

  21:          }

4. Styles
Styles allows users/designers to apply consistent look & feel across multiple controls, some times very different controls. Styles can be defined globally or just locally if you define them inside resources of a control. Key elements of each style are:

Setter element - specifies key (property name) value (property value) pair,
TargetType attribute - specifies a type of a control,
x:Key or x:Name attributes - specify the name of a style for implicit styling. This is another difference between WPF and SL because only in SL you are able to use them interchangeably.

TraditionalListBox and CanvasListBox are the best examples of different approaches in styling because the blue ListBox uses an implicit style and the green one uses an explicit style.

   1:   <!--Implicit style-->

   2:          <Style TargetType="local:CelestialBodyControl">

   3:              <Setter Property="Template">

   4:                  <Setter.Value>

   5:                      <ControlTemplate TargetType="local:CelestialBodyControl">

   6:                          <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch">

   7:                              <Grid.ColumnDefinitions>

   8:                                  <ColumnDefinition Width="*"/>

   9:                                  <ColumnDefinition Width="*"/>

  10:                              </Grid.ColumnDefinitions>

  11:                              <StackPanel Orientation="Vertical" Grid.Column="0">

  12:                                  <TextBlock x:Name="PART_Name" Text="{TemplateBinding BodyName}" Foreground="White"/>

  13:                                  <TextBlock Text="{Binding Radius, RelativeSource={RelativeSource TemplatedParent}}" Foreground="White"/>

  14:                                  <TextBlock Text="{Binding AverageDistanceFromSun, RelativeSource={RelativeSource TemplatedParent}}" Foreground="White"/>

  15:                                  <TextBlock Text="{Binding RotationPeriod, RelativeSource={RelativeSource TemplatedParent}}" Foreground="White"/>

  16:                                  <TextBlock Text="{Binding OrbitalPeriod, RelativeSource={RelativeSource TemplatedParent}}" Foreground="White"/>

  17:                              </StackPanel>

  18:                              <Border BorderThickness="0" Width="70" Height="70" RenderTransformOrigin="0.5,0.5" Grid.Column="1">

  19:                                  <Border.Resources>

  20:                                      <local:ImageConverter x:Key="ImageConverter"/>

  21:                                  </Border.Resources>

  22:                                  <Border.Background>

  23:                                      <ImageBrush ImageSource="{Binding BodyName, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ImageConverter}}"/>

  24:                                  </Border.Background>

  25:                              </Border>

  26:                          </Grid>

27:

  28:                      </ControlTemplate>

  29:                  </Setter.Value>

  30:              </Setter>

  31:          </Style>

32:

  33:          <!--Explicit style-->

  34:          <Style TargetType="local:CelestialBodyControl" x:Key="CanvasStyle">

  35:              <Setter Property="Template">

  36:                  <Setter.Value>

  37:                      <ControlTemplate TargetType="local:CelestialBodyControl">

  38:                          <Border BorderThickness="2" Width="100" Height="100" RenderTransformOrigin="0.5,0.5" x:Name="border">

39:

  40:                              <VisualStateManager.VisualStateGroups>

  41:                                  <VisualStateGroup x:Name="SelectionStates">

  42:                                      <VisualState x:Name="Unselected"/>

  43:                                      <VisualState x:Name="Selected">

  44:                                          <Storyboard>

  45:                                              <DoubleAnimation Duration="0" To="0.5" Storyboard.TargetProperty="Opacity" Storyboard.TargetName="border"/>

  46:                                          </Storyboard>

  47:                                      </VisualState>

  48:                                  </VisualStateGroup>

  49:                              </VisualStateManager.VisualStateGroups>

  50:                              <Border.Background>

  51:                                  <ImageBrush ImageSource="{Binding BodyName, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ImageConverter}}"/>

  52:                              </Border.Background>

  53:                              <Border.RenderTransform>

  54:                                  <TransformGroup>

  55:                                      <ScaleTransform ScaleX="{Binding Radius, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ValueConverter}, ConverterParameter=0.00003}" ScaleY="{Binding Radius, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ValueConverter}, ConverterParameter=0.00003}"  CenterX="0.5" CenterY="0.5"/>

  56:                                      <RotateTransform CenterX="0.5" CenterY="0.5" Angle="{Binding RotationAngle, RelativeSource={RelativeSource TemplatedParent}}"/>

  57:                                      <TranslateTransform X="{Binding AverageDistanceFromSun, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ValueConverter}, ConverterParameter=100}" Y="{Binding AverageDistanceFromSun, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource ValueConverter}, ConverterParameter=100}"/>

  58:                                      <RotateTransform  Angle="{Binding OrbitalAngle, RelativeSource={RelativeSource TemplatedParent}}"/>

  59:                                      <TranslateTransform X="800" Y="0"/>

  60:                                  </TransformGroup>

  61:                              </Border.RenderTransform>

  62:                          </Border>

63:

  64:                      </ControlTemplate>

  65:                  </Setter.Value>

  66:              </Setter>

  67:          </Style>

5. Visual State Manager
VSM manages states and the logic for transitioning between states for controls. Interesting fact is that VSM has been added to WPF 4.0 but SL was actually the first one where VSM has been implemented.

   1:   <VisualStateManager.VisualStateGroups>

   2:                                  <VisualStateGroup x:Name="CommonStates">

   3:                                      <VisualState x:Name="Normal"/>

   4:                                      <VisualState x:Name="MouseOver">

   5:                                      </VisualState>

   6:                                      <VisualState x:Name="Disabled">

   7:                                          <Storyboard>

   8:                                              <DoubleAnimation Duration="0" To=".55" Storyboard.TargetProperty="Opacity" Storyboard.TargetName="contentPresenter"/>

   9:                                          </Storyboard>

  10:                                      </VisualState>

  11:                                  </VisualStateGroup>

  12:                                  <VisualStateGroup x:Name="SelectionStates">

  13:                                      <VisualState x:Name="Unselected"/>

  14:                                      <VisualState x:Name="Selected">

  15:                                          <Storyboard>

  16:                                              <DoubleAnimation Duration="0:0:0.3" To=".3" AutoReverse="True" RepeatBehavior="Forever" Storyboard.TargetProperty="Opacity" Storyboard.TargetName="contentPresenter"/>

  17:                                              <!--<ColorAnimation Duration="0" To="#FF0096FF" Storyboard.TargetProperty="(BorderBrush).(SolidColorBrush.Color)" Storyboard.TargetName="..." />-->

  18:                                          </Storyboard>

  19:                                      </VisualState>

  20:                                  </VisualStateGroup>

  21:                                  <VisualStateGroup x:Name="FocusStates">

  22:                                      <VisualState x:Name="Focused">

  23:                                      </VisualState>

  24:                                      <VisualState x:Name="Unfocused"/>

  25:                                  </VisualStateGroup>

  26:                              </VisualStateManager.VisualStateGroups>

6. Animations
Only DPs can be animated. Types of animations:

DoubleAnimation,
ColorAnimation,
PointAnimation.

7. Value Converters (IValueConverter interface)
Allow modifying data as it passes through the binding engine. The difference between WPF and SL is that SL does not support multi-value converters (IMultiValueConverter interface).

   1:  public class ValueConverter : IValueConverter

   2:      {

   3:          public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

   4:          {

   5:              double multiplier = 1;

   6:              double position = value != null ? (double)value : 0;

   7:              if (parameter != null)

   8:                  double.TryParse((string)parameter, out multiplier);

   9:              return position * multiplier;

  10:          }

11:

  12:          public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

  13:          {

  14:              throw new NotImplementedException();

  15:          }

  16:      }

8. CollectionViewSource

CollectionViewSource is a proxy of a collection view class, can be used for sorting, grouping and filtering data. If you would like to know how to implement filtering in MVVM architecture please visit the following link: http://pavzav.blogspot.com/2011/07/filtering-in-mvvm-architecture.html.

   1:          <CollectionViewSource x:Name="SortedCelestialBodies" Source="{Binding CelestialBodies}">

   2:              <CollectionViewSource.SortDescriptions>

   3:                  <compMod:SortDescription PropertyName="Name"/>

   4:              </CollectionViewSource.SortDescriptions>

   5:          </CollectionViewSource>

6:

7:

   8:          <!--Usage of CollectionViewSource-->

   9:          <ListBox ItemsSource="{Binding Source={StaticResource SortedCelestialBodies}}" HorizontalAlignment="Right" VerticalAlignment="Bottom" Background="Black" Width="150" SelectedItem="{Binding SelectedItem, Mode=TwoWay}">

  10:              <ListBox.ItemTemplate>

  11:                  <DataTemplate>

  12:                      <local:CelestialBodyControl BodyName="{Binding Name}" Radius="{Binding Radius}" AverageDistanceFromSun="{Binding AverageDistanceFromSun}"

  13:                                                  RotationPeriod="{Binding RotationPeriod}" OrbitalPeriod="{Binding OrbitalPeriod}"/>

  14:                  </DataTemplate>

  15:              </ListBox.ItemTemplate>

  16:          </ListBox>

9. Custom Controls (Skinnable/Faceless Controls)

The most important feature of Custom Controls is a fact that their UI representation can be easily replaced and this it the reason why developers call them faceless controls.

   1:   public class CelestialBodyControl : Control

   2:      {

   3:          public static readonly DependencyProperty BodyNameProperty = DependencyProperty.Register("BodyName", typeof(string), typeof(CelestialBodyControl), new PropertyMetadata(string.Empty));

   4:          public static readonly DependencyProperty RadiusProperty = DependencyProperty.Register("Radius", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

   5:          public static readonly DependencyProperty AverageDistanceFromSunProperty = DependencyProperty.Register("AverageDistanceFromSun", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

   6:          public static readonly DependencyProperty RotationPeriodProperty = DependencyProperty.Register("RotationPeriod", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

   7:          public static readonly DependencyProperty OrbitalPeriodProperty = DependencyProperty.Register("OrbitalPeriod", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

   8:          public static readonly DependencyProperty OrbitalAngleProperty = DependencyProperty.Register("OrbitalAngle", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

   9:          public static readonly DependencyProperty RotationAngleProperty = DependencyProperty.Register("RotationAngle", typeof(double), typeof(CelestialBodyControl), new PropertyMetadata(double.NaN));

10:

  11:          public CelestialBodyControl()

  12:          {

  13:              this.DefaultStyleKey = typeof(CelestialBodyControl);

  14:          }

15:

  16:          //...

  17:       }

Source code: KeyConceptsInSilverlight.rar

How to list and activate services from command-line console

2011-09-06T16:01:00.002+01:00

My colleague had this unusual problem with his computer (actually it was a virus) and he had no access to the Services console in Administrative Tools but at the same time he had to run a service. As a solution we decided to use a command-line console. Please have a look below to find out how you can do it.

To list all up and running services type: net start
To list all inactive services type: sc query type= service state= inactive
With the second command you can check the name of your inactive service and to make it running type: sc start [service name]

AddressAccessDeniedException HTTP could not register URL http://+:...

2011-08-18T13:36:00.006+01:00

System.ServiceModel.AddressAccessDeniedException was unhandled

Message=HTTP could not register URL http://+:xxxx/. Your process does not have access rights to this namespace (see http://go.microsoft.com/fwlink/?LinkId=70353 for details).

This is a typical problem which you can encounter when you migrate/create a service on Vista or Windows 7 machine. The reason why you can see it is because your user/group does not have rights to create a service that listen on the portion of the namespace. To perform reservation on Windows Vista or Windows 7 you have to use netsh.exe application which is available directly from your command line:

netsh http add urlacl http://+:[port]/ user=[Domain\Username or Everyone]

Before you even start, remember to run your command line application as an administrator otherwise you will not be able to accomplish the procedure. If your case scenario is more specific/unusual go to Microsoft webpage where you can find more detailed information. If you want to list existing reservations use the following expression: netsh http show urlacl

Battlefield 3

2011-08-06T12:18:00.002+01:00

Excellent, detailed presentation of BF3.

Geek Definition/Evolution - Whose of them are you?

2011-07-28T17:49:00.000+01:00

Flowtown - Social Media Marketing Application

Filtering in MVVM architecture - Silverlight & WPF

2011-07-26T16:14:00.004+01:00

Before you start implementing functionality for filtering data in MVVM architecture you have to find out which technologies you are going to use. There are two different ways how you can implement filtering in WPF but only one solution can be ported to Silverlight. The reason behind it is that Silverlight version of CollectionViewSource class does not support GetDefaultView method. The following example shows how you can filter data in MVVM architecture by changing the content of FilteringMethod predicate.

   1:  class MainWindowPresentationModel : INotifyPropertyChanged

   2:      {

   3:          ObservableCollection<string> _observableCollection = new ObservableCollection<string>() { "a", "bb", "ccc", "dddd", "eeeee", "ffffff", "eeeeeeee", "fffffffffffffff", "gggggggggggggggggg" };

   4:          private int _threshold = 100;

   5:          private ICollectionView _Items;

   6:          private CollectionViewSource _CollectionViewSourceItems;

   7:          public event PropertyChangedEventHandler PropertyChanged;

8:

   9:          public MainWindowPresentationModel(Window window)

  10:          {

  11:              FilterCommand = new RoutedCommand();

  12:              CommandBinding customCommandBinding = new CommandBinding(FilterCommand, HandleFilterCommand);

  13:              window.CommandBindings.Add(customCommandBinding);

14:

  15:              window.DataContext = this;

  16:              window.Show();

17:

  18:              Items = CollectionViewSource.GetDefaultView(_observableCollection);

  19:              Items.Filter = FilteringMethod;

  20:              Items.Refresh();

21:

  22:              CollectionViewSourceItems = new CollectionViewSource();

  23:              CollectionViewSourceItems.Source = _observableCollection;

  24:              CollectionViewSourceItems.View.Filter = FilteringMethod;

  25:              CollectionViewSourceItems.View.Refresh();

  26:          }

27:

  28:          public ICommand FilterCommand

  29:          {

  30:              get;

  31:              set;

  32:          }

33:

  34:          public ICollectionView Items

  35:          {

  36:              get { return _Items; }

  37:              set {

  38:                  _Items = value;

  39:                  OnPropertyChanged("Items");

  40:              }

  41:          }

42:

  43:          public CollectionViewSource CollectionViewSourceItems

  44:          {

  45:              get { return _CollectionViewSourceItems; }

  46:              set

  47:              {

  48:                  _CollectionViewSourceItems = value;

  49:                  OnPropertyChanged("CollectionViewSourceItems");

  50:              }

  51:          }

52:

  53:          private void HandleFilterCommand(object sender, ExecutedRoutedEventArgs e)

  54:          {

  55:              int result = 0;

  56:              if (int.TryParse(e.Parameter.ToString(), out result))

  57:              {

  58:                  _threshold = result;

  59:              }

  60:              Items.Refresh();

  61:              CollectionViewSourceItems.View.Refresh();

  62:          }

63:

  64:          public bool FilteringMethod(object input)

  65:          {

  66:              return _threshold == 0 ? true : ((string)input).Length < _threshold;

  67:          }

68:

  69:          private void OnPropertyChanged(string propertyName)

  70:          {

  71:              if (PropertyChanged != null)

  72:              {

  73:                  var localPropertyChanged = PropertyChanged;

  74:                  localPropertyChanged(this, new PropertyChangedEventArgs(propertyName));

  75:              }

  76:          }

  77:      }

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

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

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

   4:          Title="MainWindow" Height="350" Width="525">

   5:      <Grid>

   6:          <Grid.RowDefinitions>

   7:              <RowDefinition Height="Auto"/>

   8:              <RowDefinition Height="Auto"/>

   9:              <RowDefinition Height="*"/>

  10:              <RowDefinition Height="*"/>

  11:          </Grid.RowDefinitions>

12:

  13:          <Button Grid.Row="0" Content="Show items shorter than 5 characters" Command="{Binding FilterCommand}" CommandParameter="5" Height="30"/>

  14:          <Button Grid.Row="1" Content="Show all items" Command="{Binding FilterCommand}" CommandParameter="0"  Height="30"/>

  15:          <ListBox Grid.Row="2" ItemsSource="{Binding Items}"/>

  16:          <ListBox Grid.Row="3" ItemsSource="{Binding CollectionViewSourceItems.View}"/>

  17:      </Grid>

  18:  </Window>

   1:      public partial class App : Application

   2:      {

   3:          protected override void OnStartup(StartupEventArgs e)

   4:          {

   5:              base.OnStartup(e);

6:

   7:              MainWindow view = new MainWindow();

   8:              MainWindowPresentationModel model = new MainWindowPresentationModel(view);

   9:          }

  10:      }

   1:  <Application x:Class="WpfApplication1.App"

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

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

   4:               >

   5:      <Application.Resources>

6:

   7:      </Application.Resources>

   8:  </Application>

How to make dynamically generated tiles in Windows Mobile 7?

2011-06-23T21:07:00.003+01:00

This project was inspired by the way how menu in Portal 2 game works. Portal 2 is a first-person puzzle-platform video game developed by Valve Corporation. Really interesting and very well executed. Going back to the subject when I saw Portal 2 menu in action I decided to do something similar in WM7. The whole idea is quite simple:

define your area of interest e.g. a whole screen or a part
make a screenshot
populate WrapPanel with rectangles which contain appropriate parts of the previously created screenshot.
hide your area of interest (yourUIElement)
start animations
perform a transition if needed

Points 1 and 2

   1:              WriteableBitmap bmp = new WriteableBitmap((int)LayoutRoot.ActualWidth, (int)LayoutRoot.ActualHeight);

   2:              bmp.Render(yourUIElement, null);

   3:              bmp.Invalidate();

   4:              image.Source = bmp;

Point 3 and 5

   1:              for (int j = 0; j < y; j++)

   2:                  for (int i = 0; i < x; i++)

   3:                  {

   4:                      Rectangle rect = new Rectangle();

   5:                      rect.Width = (image.Source as WriteableBitmap).PixelWidth / x;

   6:                      rect.Height = (image.Source as WriteableBitmap).PixelHeight / y;

   7:                      ImageBrush brush = new ImageBrush();

   8:                      brush.AlignmentX = AlignmentX.Left;

   9:                      brush.AlignmentY = AlignmentY.Top;

  10:                      brush.Transform = new TranslateTransform() { X = i * -(image.Source as WriteableBitmap).PixelWidth / x, Y = j * -(image.Source as WriteableBitmap).PixelHeight / y };

  11:                      brush.Stretch = Stretch.None;

  12:                      brush.ImageSource = image.Source;

  13:                      rect.Fill = brush;

  14:                      wrapPanel.Children.Add(rect);

15:

  16:                      rect.Projection = new PlaneProjection() { RotationX = 0, RotationY = Forward ? 0 : -90, RotationZ = 0 };

17:

  18:                      DoubleAnimation animation = new DoubleAnimation();

  19:                      animation.From = Forward ? 0 : -90;

  20:                      animation.To = Forward ? -90 : 0;

  21:                      animation.Duration = TimeSpan.FromMilliseconds(100);

22:

  23:                      Storyboard story = new Storyboard();

  24:                      story.BeginTime = TimeSpan.FromMilliseconds(((i + j)) * 100);

  25:                      Storyboard.SetTarget(animation, rect.Projection);

  26:                      Storyboard.SetTargetProperty(animation, new PropertyPath(PlaneProjection.RotationYProperty));

27:

  28:                      story.Begin();

  29:                  }

Point 6

   1:       <toolkit:TransitionService.NavigationInTransition>

   2:          <toolkit:NavigationInTransition>

   3:              <toolkit:NavigationInTransition.Backward>

   4:                  <local:TilesTransition Forward="False"/>

   5:              </toolkit:NavigationInTransition.Backward>

   6:          </toolkit:NavigationInTransition>

   7:      </toolkit:TransitionService.NavigationInTransition>

8:

   9:      <toolkit:TransitionService.NavigationOutTransition>

  10:          <toolkit:NavigationOutTransition>

  11:              <toolkit:NavigationOutTransition.Forward>

  12:                  <local:TilesTransition Forward="True"/>

  13:              </toolkit:NavigationOutTransition.Forward>

  14:          </toolkit:NavigationOutTransition>

  15:      </toolkit:TransitionService.NavigationOutTransition>

Useful links:

Kinect for Windows SDK is getting closer and closer - MIX11

2011-04-13T22:32:00.002+01:00

Kinect for Windows will be available this Spring - version for enthusiasts and academic researchers

2011-02-22T12:28:00.003Z

I am really glad that Microsoft is going to release Windows version of Kinect this Spring. I cannot wait to put my hands on this amazing piece of hardware.

Another pretty amazing Kinect hack

Useful links:

http://research.microsoft.com/en-us/news/features/kinectforwindowssdk-022111.aspx

How to make a fully animated ListBox in Windows Mobile 7

2011-02-13T15:27:00.003Z

If you want to animate all ListBox items in a way similar to the WM7 embedded functionality please have a look at the following article.

Requirements:

only items visible on the screen take part in an animation,
an animation kicks off when one of the the ListBox items is selected,
all items are animated apart from the one which is selected,
items are animated one by one from the bottom to the top of the screen,
when the animation is finished the application navigates to the another page.

Solutions:

If we want to detect visible ListBox items you need to get access to the ScrollViewer which is a part of a ListBox visual tree. To iterate through the visual tree we will be using the following method:

   1:          private T FindDependencyObject<T>(DependencyObject dependencyObject)

   2:              where T : DependencyObject

   3:          {

   4:              DependencyObject d = dependencyObject;

   5:              while (!(d is T) && VisualTreeHelper.GetChildrenCount(d) > 0)

   6:                  d = VisualTreeHelper.GetChild(d, 0);

   7:              return d as T;

   8:          }

ScrollViewer VerticalOffset and ViewportHeight properties tell us the index of the first visible item and how many items are visible altogether.

Animations will be started when a ListBox triggers SelectionChanged event.

All functionality responsible for running animations on per ListBox item basis will be nested in SelectionChanged event handler.

Items will be animated one by one using Storyboards nested in DataTemplate resources. An animation of each item will be delayed with Storyboard BeginTime property which has to be populated in code based on an item position.

The last animated item Completed event handler will be used to trigger NavigationService.Navigate(...) method.

Found problems:

When you run animations/storyboards in code you have to be aware of few pitfalls. It is not allowed to start an animations which has been started it means that you have to be aware of the animation state and stop it if necessary. In this particular case a user is able to change a selected item in the middle of the running animation and this is the moment when we have to clean it up and start the whole process again.

Results:

Useful links:

https://www.silverlight.net/learn/quickstarts/animations/#advanced_animations

Source code: ListBoxAnimation.zip

Microsoft's Surface V.2 0 - It's amazing

2011-02-03T11:53:00.002Z

Dependency Property

2011-01-30T20:23:00.005Z

Definition:

Dependency property is a new type of property which can be used with dependency objects, to enable styling, data binding or animation. To define your own dependency property you have to register your new property using DependencyProperty.Register(...) method and optionally you can create FrameworkPropertyMetadata object where you can specify property characteristics.

Example:

   1:   public partial class MinMaxControl : Control

   2:      {

   3:          public static readonly DependencyProperty MinProperty =

   4:              DependencyProperty.Register("Min", typeof(int), typeof(MinMaxControl),

   5:              new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,

   6:                  HandleMinValueChanged, CoerceMinValue), ValidateMinValue);

   7:          public static readonly DependencyProperty MaxProperty =

   8:              DependencyProperty.Register("Max", typeof(int), typeof(MinMaxControl),

   9:              new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,

  10:                  HandleMaxValueChanged, CoerceMaxValue), ValidateMaxValue);

11:

  12:          static MinMaxControl()

  13:          {

  14:              DefaultStyleKeyProperty.OverrideMetadata(typeof(MinMaxControl), new FrameworkPropertyMetadata(typeof(MinMaxControl)));

  15:          }

16:

  17:          public int Min

  18:          {

  19:              get { return (int)GetValue(MinMaxControl.MinProperty); }

  20:              set { SetValue(MinMaxControl.MinProperty, value); }

  21:          }

22:

  23:          public int Max

  24:          {

  25:              get { return (int)GetValue(MinMaxControl.MaxProperty); }

  26:              set { SetValue(MinMaxControl.MaxProperty, value); }

  27:          }

28:

  29:          private static void HandleMinValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

  30:          {

31:

  32:          }

33:

  34:          private static void HandleMaxValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

  35:          {

36:

  37:          }

38:

  39:          private static object CoerceMinValue(DependencyObject d, object value)

  40:          {

  41:              var control = d as MinMaxControl;

  42:              if (control != null)

  43:              {

  44:                  if ((int)value > control.Max)

  45:                      return control.Max;

  46:              }

  47:              return value;

  48:          }

49:

  50:          private static object CoerceMaxValue(DependencyObject d, object value)

  51:          {

  52:              var control = d as MinMaxControl;

  53:              if (control != null)

  54:              {

  55:                  if ((int)value < control.Min)

  56:                      return control.Min;

  57:              }

  58:              return value;

  59:          }

60:

  61:          private static bool ValidateMinValue(object value)

  62:          {

  63:              if ((int)value < 0)

  64:                  return false;

  65:              return true;

  66:          }

67:

  68:          private static bool ValidateMaxValue(object value)

  69:          {

  70:              if ((int)value < 0)

  71:                  return false;

  72:              return true;

  73:          }

  74:      }

When you specify a Dependency Property you have to include:

property name,
property type,
property owner type,
optionally, a FrameworkPropertyMetadata object,
optionally, a validation callback

When you specify a property you have to be aware that it may be set incorrectly. Dependency property has set of tools which you can use to protect yourself against incorrect values: ValidateValueCallback and CoerceValueCallback. Previously mentioned callbacks are executed in a particular order as follows:

ValidateValueCallback - does not have any knowledge about other dependency properties so the input value can be validated against some predefined conditions only,
CoerceValueCallback - has access to a control so the value can be modified based on other properties,
PropertyValueChangedCallback - the last step of the whole process, can force coercion on other dependency properties if necessary.

If you want/have to change a dependency property metadata and you do not have a direct access to the property you can achieve it using OverrideMetadata method:

   1:   MinProperty.OverrideMetadata(typeof(ModifiedMinMaxControl), new FrameworkPropertyMetadata(123, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

Useful links:

Source code: DependencyProperyCoercionValidation.zip

How to calculate coordinates of a control in WPF

2011-01-30T02:06:00.001Z

If you have a control nested in another control and you have to calculate their coordinates, you can achieve it using TranslatePoint(..,..) method e.g. [your control].TranslatePoint(new Point(0, 0), [parent control]); If you need to retrieve a control coordinates to make it visible on the screen you can consider BringIntoView() method. The only problem with previously mentioned method is lack of consistency but on the other hand you do not have to perform any additional calculations.

Please have a look at the following example if you want to see TranslatePoint and BringIntoView methods in action: Coordinates.zip

Uno - merge between motorcycle and segway

2011-01-10T20:33:00.003Z

Link to the company: http://bpg-motors.com/