TecProGamPho

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/

2011 the year of many many tablets - at last

2011-01-09T00:44:00.003Z

2010 was the year of iPad the current one is the year of the greater choices: Tablets at CES 2011: Honeycomb, Windows 7, and all the rest..

How to restyle WPF controls

2011-01-08T14:49:00.000Z

If you have to restyle some controls and you do not have a designer on-board there are some tools you can use or places you can check to find/gather some answers and inspirations. If you have Expression Blend you do not have to search for additional tools or help. Whatever you need to do it can be achieved with this tool. There are still some other solutions. You can use Microsoft's style examples which you can grab from Styling & Templating webpage or directly from this link ControlTemplateExamples.zip. If you are not satisfied with this approach you can go for Kaxaml which contains style snippets and can be used as a start point of your restyling process.

Expression Blend

Microsoft's examples

Kaxaml

How Poles created the new Enigma

2010-12-29T14:46:00.001Z

Interesting article to read "How Poles created the new Enigma" especially that this cryptographic system was created in my alma mater.
If you are interested in Engima please have a look at this link Enigma machine.

How to place items on a Canvas using ItemsControl and PrepareContainerForItemOverride method

2010-12-20T18:10:00.001Z

If you have to place some items on a canvas and the whole process has to be performed automatically using binding and ItemsControl, so you have to be aware that ItemsControl wraps each item with ContentPresenter before adding it to the canvas. It means that defining bindings between Canvas.Left/Top attached properties and your bound objects will not reflect their position on the canvas because your binding should be defined one level higher in ItemsControl visual tree.There are at least two ways how you can solve this problem:

harder one - to find a parent element (using VisualTreeHepler because there is no direct access to the ContentPresenter) of your visual data representation and bind it to the coordinates. The main disadvantage of this solution is that you have to modify your control because of the need to find a parent container. It makes an additional dependency and narrows the way how your control can be used in the future.
simpler one - to create a class which derives from ItemsControl class and override PrepareContainerForItemOverride method where you can create necessary bindings to pass information about coordinates.

   1:          protected override void PrepareContainerForItemOverride(DependencyObject element, object item)

   2:          {

   3:              FrameworkElement contentitem = element as FrameworkElement;

   4:              Binding leftBinding = new Binding("X");

   5:              Binding topBinding = new Binding("Y");

   6:              contentitem.SetBinding(Canvas.LeftProperty, leftBinding);

   7:              contentitem.SetBinding(Canvas.TopProperty, topBinding);

   8:              base.PrepareContainerForItemOverride(element, item);

   9:          }

If you look at input parameters of PrepareContainerForItemOverride method you will find a DependencyObject parameter which represents a wrapper (ContentPresenter) and an object parameter which represents bound data, so you have direct access to the data and you can bind whichever parameter you want (in this case coordinates).

If you would like to see this solution in action you can download it from source code section in this article: Convex Hull Algorith.

Andrew's Monotone Chain Convex Hull algorithm

2010-12-19T01:09:00.008Z

This algorithm constructs convex hull of a set of 2D points.
Algorithm:

Sorts points based on their X coordinate,
Selects two points which contain minimum and maximum of X coordinate (P1, P2) from all points,
Divides the set of points into two sub-sets (upper and lower hull) based on the line between point P1 and point P2,
Processes points on per hull basis to detect points which have to be used to create a convex polygon.

Example of usage:

Source code: ConvexHullAlgorithm.zip

Useful links: