The-Oliver.com

Behaviors are great new feature in Silverlight 3 (or better in Blend 3) for adding “features” to a control without coding. My favorite sample is a hover effect, that applies when a mouse enters a control.

Live-Preview

XAML-Code:

<UserControl
    x:Class="Hover3DBehavior.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
    xmlns:TheOliver_Controls="clr-namespace:TheOliver.Controls"
    d:DesignHeight="300"
    d:DesignWidth="400"
    xmlns:dataInput="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.Input">

    <Grid
        x:Name="LayoutRoot"
        Background="White">
        <Button
            Content="Button"
            Height="23"
            HorizontalAlignment="Left"
            Margin="89,78,0,0"
            Name="button1"
            VerticalAlignment="Top"
            Width="75">
            <i:Interaction.Behaviors>
                <TheOliver_Controls:Hover3DBehavior />
            </i:Interaction.Behaviors>
        </Button>

        <dataInput:Label
            Height="50"
            HorizontalAlignment="Left"
            Margin="274,64,0,0"
            Name="label1"
            VerticalAlignment="Top"
            Width="100"
            Content="Hello World">
            <i:Interaction.Behaviors>
                <TheOliver_Controls:Hover3DBehavior />
            </i:Interaction.Behaviors>
        </dataInput:Label>

        <RadioButton
            Content="RadioButton"
            Height="16"
            HorizontalAlignment="Left"
            Margin="12,133,0,0"
            Name="radioButton1"
            VerticalAlignment="Top">
            <i:Interaction.Behaviors>
                <TheOliver_Controls:Hover3DBehavior />
            </i:Interaction.Behaviors>
        </RadioButton>

    </Grid>
</UserControl>

Source-Code:

// Copyright © Microsoft Corporation.  All Rights Reserved.
// This code released under the terms of the
// Microsoft Public License (MS-PL, http://opensource.org/licenses/ms-pl.html.)

using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interactivity;
using System.Windows.Media;
using System.Windows.Media.Animation;

namespace TheOliver.Controls
{
    public class Hover3DBehavior : Behavior<UIElement>
    {
        PlaneProjection _planeProjection;

        public Hover3DBehavior()
            : base()
        {

        }

        Storyboard _hoverMe;
        Storyboard _unhoverMe;

        public double ZHoverValue
        {
            get { return (double)GetValue(ZHoverValueProperty); }
            set { SetValue(ZHoverValueProperty, value); }
        }

        public static readonly DependencyProperty ZHoverValueProperty =
            DependencyProperty.Register("ZHoverValue", typeof(double), typeof(Hover3DBehavior),
            new PropertyMetadata(500.0, null));

        public int HoverDurationMilliseconds
        {
            get { return (int)GetValue(HoverDurationMillisecondsProperty); }
            set { SetValue(HoverDurationMillisecondsProperty, value); }
        }

        public static readonly DependencyProperty HoverDurationMillisecondsProperty =
            DependencyProperty.Register("HoverDurationMilliseconds"
            , typeof(int)
                , typeof(Hover3DBehavior),
                new PropertyMetadata(200, null));

        #region Overrides 

        protected override void OnAttached()
        {
            base.OnAttached();

            _planeProjection = new PlaneProjection();
            this.AssociatedObject.Projection = _planeProjection;

            if (!DesignerProperties.GetIsInDesignMode(this))
            {
                _hoverMe = new Storyboard();

                DoubleAnimation da1 = new DoubleAnimation();

                _hoverMe.Children.Add(da1);
                da1.Duration = new Duration(new System.TimeSpan(0, 0, 0, 0, HoverDurationMilliseconds));
                da1.To = this.ZHoverValue;
                Storyboard.SetTarget(da1, this.AssociatedObject);
                Storyboard.SetTargetProperty(da1, new PropertyPath("(UIElement.Projection).(PlaneProjection.LocalOffsetZ)"));

                DoubleAnimation da2 = new DoubleAnimation();
                BounceEase be2 = new BounceEase();
                be2.EasingMode = EasingMode.EaseOut;
                be2.Bounces = 3;
                da2.EasingFunction = be2;

                _unhoverMe = new Storyboard();
                _unhoverMe.Children.Add(da2);
                da2.Duration = new Duration(new System.TimeSpan(0, 0, 0, 0, 1000));
                da2.To = 0.0;
                Storyboard.SetTarget(da2, this.AssociatedObject);
                Storyboard.SetTargetProperty(da2, new PropertyPath("(UIElement.Projection).(PlaneProjection.LocalOffsetZ)"));

                if ((this.AssociatedObject as FrameworkElement).Resources.Contains("hoverme"))
                {
                    (this.AssociatedObject as FrameworkElement).Resources.Remove("hoverme");
                }
                (this.AssociatedObject as FrameworkElement).Resources.Add("hoverme", _hoverMe);

                if ((this.AssociatedObject as FrameworkElement).Resources.Contains("unhoverme"))
                {
                    (this.AssociatedObject as FrameworkElement).Resources.Remove("unhoverme");
                }
                (this.AssociatedObject as FrameworkElement).Resources.Add("unhoverme", _unhoverMe);
            }

            this.AssociatedObject.MouseEnter += AssociatedObject_MouseEnter;
            this.AssociatedObject.MouseLeave += AssociatedObject_MouseLeave;

        }

        protected override void OnDetaching()
        {
            base.OnDetaching();

            this.AssociatedObject.Projection = null;
            _planeProjection = null;

            this.AssociatedObject.MouseEnter -= AssociatedObject_MouseEnter;
            this.AssociatedObject.MouseLeave -= AssociatedObject_MouseLeave;
        }

        #endregion

        #region Events

        void AssociatedObject_MouseLeave(object sender, MouseEventArgs e)
        {
            _unhoverMe.Begin();
        }

        void AssociatedObject_MouseEnter(object sender, MouseEventArgs e)
        {
            //FrameworkElement e1 = this.AssociatedObject as FrameworkElement;
            //if (e1.Parent is Panel)
            //{
            //    Panel p = e1.Parent as Panel;
            //    if (p != null)
            //    {
            //        UIElement element = this.AssociatedObject;
            //        element.SetValue(UIElement.
            //        p.Children.Remove(element);
            //        p.Children.Add(element);
            //    }
            //}
            _hoverMe.Begin();
        }

        #endregion

    }
}

Download-SampleCode

The-Oliver Developer, English, Expression, Silverlight, Visual Studio Code

Auf www.paris-26-gigapixels.com befindet sich das derzeit angeblich größte Digitalfoto. Aus 2346 Bilden wurde die Skyline von Paris zusammengesetzt.

Schon sehr beeindruckend. Allerdings frage ich mich warum man sich so einen riesigen Aufwand mit dem Zusammensetzen der Bilder macht, aber null Aufwand für einen gescheiten Player, der das Bild ordentlich darstellt.

Die Navigation ist sehr gewöhnungsbedürftig, übliche Verfahren wie Doppelklicks oder Mausrad funktionieren nicht. Entgegen allen üblichen Navigationen wandert man nach rechts in dem man die Maus nach links bewegt. Darüber hinaus explodiert quasi Speicherverbrauch der Webseite.

Wer so etwas auf einfache Art und Weise selber machen möchte, ohne wirklich selber viel Aufwand zu haben, kriegt dazu von Microsoft kostenlose Werkzeuge an die Hand gelegt.

Mit der Windows Live Fotogallerie gibt es eine sehr gute Bilderverarbeitung die für jeden Hobby- und semiprofessionellen Fotografen ausreicht. Die Fotogallerie hat eine tolle Funktion zum automatischen Zusammensetzen von vielen Bildern, die allerdings gewisse Überschneidungen haben müssen.

Hat man dann ein sehr großes Bild, dann kann man dieses mit dem Deep Zoom Composer so vorbereiten, das es sehr schnell von jedem Browser geladen werden kann. Diese Technik basiert auf Silverlight.

Die Tools sind kostenlos und gibt es hier:

Windows Live Fotogallerie

Deep Zoom Composer

Ein weiteres Tool das etwas technischer ist: Microsoft Research Image Composite Editor

The-Oliver Deep Zoom, Designer, Deutsch, Web Foto

An interesting control is a Image Stack, where Images are stacked on top of each other. Normally you remove the image on top and put it to the back. So I did. If you double-click the stack an animation move the image to the back.

Live-Demo here

XAML-Code:

<UserControl x:Class="ImageStack.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="321" d:DesignWidth="416" xmlns:my="clr-namespace:TheOliver.Controls">

    <Grid x:Name="LayoutRoot" Background="White">
        <my:ImageStack Margin="12" x:Name="imageStack1" Background="Gray" >
            <Image Source="/ImageStack;Component/Assets/1.jpg" />
            <Image Source="/ImageStack;Component/Assets/2.jpg" />
            <Image Source="/ImageStack;Component/Assets/3.jpg" />
            <Image Source="/ImageStack;Component/Assets/4.jpg" />
            <Image Source="/ImageStack;Component/Assets/5.jpg" />

        </my:ImageStack>
    </Grid>
</UserControl>

Source-Code:

// Copyright © Microsoft Corporation.  All Rights Reserved.
// This code released under the terms of the
// Microsoft Public License (MS-PL, http://opensource.org/licenses/ms-pl.html.)

using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Effects;
using System.Windows.Threading;

namespace TheOliver.Controls
{
    public class ImageStack : Panel
    {
        public ImageStack()
        {
            _doubleClickTimer = new DispatcherTimer();
            _doubleClickTimer.Interval = new TimeSpan(0, 0, 0, 0, DoubleClickSpeedInMS);
            _doubleClickTimer.Tick += (s, e) =>
                {
                    _clickCount = 0;
                    _doubleClickTimer.Stop();
                };

            this.MouseLeftButtonUp += (s, e) =>
                {
                    if (_clickCount == 1)
                    {
                        // Doubleclick detected
                        HideCurrentImage();
                    }
                    else
                    {
                        _clickCount++;
                        _doubleClickTimer.Start();
                    }
                };

            _hideStoryboard.Completed += (s, e) =>
                {
                    this.Children.Remove(_removedImage);
                    this.Children.Insert(0, _removedImage);
                    ShowNextImage();
                };

            _showStoryboard.Completed += (s, e) =>
                {
                    _storyboardIsActive = false;
                };
        }

        Random _random = new Random();
        int _clickCount;
        DispatcherTimer _doubleClickTimer;
        Storyboard _hideStoryboard = new Storyboard();
        Storyboard _showStoryboard = new Storyboard();
        Image _removedImage;
        bool _storyboardIsActive = false;
        double _newX;
        double _newY;
        Size _finalSize;

        private void ShowNextImage()
        {
            TimeSpan duration = new TimeSpan(0, 0, 0, 0, AnimationInMS);

            // Part 2
            DoubleAnimation xa2 = new DoubleAnimation();
            xa2.Duration = duration;
            xa2.To = -_newX;

            DoubleAnimation ya2 = new DoubleAnimation();
            ya2.Duration = duration;
            ya2.To = -_newY;

            _showStoryboard.Stop();
            _showStoryboard.Children.Clear();
            _showStoryboard.Duration = duration;
            _showStoryboard.Children.Add(xa2);
            _showStoryboard.Children.Add(ya2);

            TransformGroup tg = _removedImage.RenderTransform as TransformGroup;
            TranslateTransform tt2 = new TranslateTransform();
            tg.Children.Add(tt2);
            _removedImage.RenderTransform = tg;

            Storyboard.SetTarget(xa2, tt2);   //set Animation Target
            Storyboard.SetTargetProperty(xa2, new PropertyPath("X"));   // set Animation TargetProperty
            Storyboard.SetTarget(ya2, tt2);
            Storyboard.SetTargetProperty(ya2, new PropertyPath("Y"));

            if (this.Resources.Contains("showme"))
            {
                this.Resources.Remove("showme");
            }
            this.Resources.Add("showme", _showStoryboard);

            _showStoryboard.Begin();
        }

        bool _layouted = false;

        protected override Size ArrangeOverride(Size finalSize)
        {
            _finalSize = finalSize;

            if (!_layouted)
            {
                LayoutImages(_finalSize);
                _layouted = true;
            }
            return base.ArrangeOverride(finalSize);
        }

        private void HideCurrentImage()
        {
            if (_storyboardIsActive)
            {
                return;
            }

            _storyboardIsActive = true;
            _removedImage = this.Children[this.Children.Count - 1] as Image;
            if (_removedImage != null)
            {
                TimeSpan duration = new TimeSpan(0, 0, 0, 0, AnimationInMS);

                double angle = _random.Next(360);
                _newX = Math.Sin(angle) * this.RenderSize.Width;
                _newY = Math.Cos(angle) * this.RenderSize.Height;

                _hideStoryboard.Stop();
                _hideStoryboard.Children.Clear();

                // Part 1
                DoubleAnimation xa1 = new DoubleAnimation();
                xa1.Duration = duration;
                xa1.To = _newX;      

                DoubleAnimation ya1 = new DoubleAnimation();
                ya1.Duration = duration;
                ya1.To = _newY;

                _hideStoryboard.Duration = duration;
                _hideStoryboard.Children.Add(xa1);
                _hideStoryboard.Children.Add(ya1);

                TransformGroup tg = _removedImage.RenderTransform as TransformGroup;

                TranslateTransform tt = new TranslateTransform();
                tg.Children.Add(tt);
                _removedImage.RenderTransform = tg;

                Storyboard.SetTarget(xa1, tt);
                Storyboard.SetTargetProperty(xa1, new PropertyPath("X"));
                Storyboard.SetTarget(ya1, tt);
                Storyboard.SetTargetProperty(ya1, new PropertyPath("Y"));

                if (this.Resources.Contains("hideme"))
                {
                    this.Resources.Remove("hideme");
                }
                this.Resources.Add("hideme", _hideStoryboard);

                _hideStoryboard.Begin();
            }
        }

        private Size LayoutImages(Size finalSize)
        {
            var images = this.Children.OfType<Image>();
            Random rnd = new Random();

            foreach (var image in images)
            {
                // Drop Shadow Effect
                if (ShowDropShadowEffect)
                {
                    DropShadowEffect dse = new DropShadowEffect();
                    dse.ShadowDepth = 0.3;
                    image.Effect = dse;
                }

                // Center image
                image.VerticalAlignment = System.Windows.VerticalAlignment.Center;
                image.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;

                TransformGroup tg = new TransformGroup();

                // Scale to fit the finalsize * 90%
                image.Stretch = Stretch.Uniform;
                image.Width = finalSize.Width * ResizeFactor;
                image.Height = finalSize.Height * ResizeFactor;

                image.Margin = new Thickness(
                    (finalSize.Width - image.Width) / 2, (finalSize.Height - image.Height) / 2,
                    (finalSize.Width - image.Width) / 2, (finalSize.Height - image.Height) / 2);

                // Rotate image
                RotateTransform rt = new RotateTransform();
                rt.Angle = 90 - rnd.Next(180);
                rt.CenterX = image.Width / 2;
                rt.CenterY = image.Height / 2;
                tg.Children.Add(rt);

                image.RenderTransform = tg;
            }
            return finalSize;
        }

        #region Properties

        public double ResizeFactor
        {
            get { return (double)GetValue(ResizeFactorProperty); }
            set { SetValue(ResizeFactorProperty, value); }
        }

        public static readonly DependencyProperty ResizeFactorProperty =
            DependencyProperty.Register(
                "ResizeFactor",
                typeof(double),
                typeof(ImageStack),
                new PropertyMetadata(0.5, OnValueChanged));

        private static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ImageStack stack = sender as ImageStack;
            stack.InvalidateArrange();
        }

        public bool ShowDropShadowEffect
        {
            get { return (bool)GetValue(ShowDropShadowEffectProperty); }
            set { SetValue(ShowDropShadowEffectProperty, value); }
        }

        public static readonly DependencyProperty ShowDropShadowEffectProperty =
            DependencyProperty.Register(
                "ShowDropShadowEffect",
                typeof(bool),
                typeof(ImageStack),
                new PropertyMetadata(true, OnValueChanged));

        public int DoubleClickSpeedInMS
        {
            get { return (int)GetValue(DoubleClickSpeedInMSProperty); }
            set { SetValue(DoubleClickSpeedInMSProperty, value); }
        }

        public static readonly DependencyProperty DoubleClickSpeedInMSProperty =
            DependencyProperty.Register(
                "DoubleClickSpeedInMS",
                typeof(int),
                typeof(ImageStack),
                new PropertyMetadata(500, OnDoubleClickSpeedChanged));

        private static void OnDoubleClickSpeedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ImageStack stack = sender as ImageStack;
            stack._doubleClickTimer.Stop();
            stack._doubleClickTimer.Interval = new TimeSpan(0, 0, 0, 0, (int)e.NewValue);
        }

        public bool EnableDragging
        {
            get { return (bool)GetValue(EnableDraggingProperty); }
            set { SetValue(EnableDraggingProperty, value); }
        }

        public static readonly DependencyProperty EnableDraggingProperty =
            DependencyProperty.Register(
                "EnableDragging",
                typeof(bool),
                typeof(ImageStack),
                new PropertyMetadata(false));

        public int AnimationInMS
        {
            get { return (int)GetValue(AnimationInMSProperty); }
            set { SetValue(AnimationInMSProperty, value); }
        }

        public static readonly DependencyProperty AnimationInMSProperty =
            DependencyProperty.Register(
                "AnimationInMS",
                typeof(int),
                typeof(ImageStack),
                new PropertyMetadata(125));

        #endregion

    }
}

Download Sourcecode

The-Oliver Developer, English, Expression, Silverlight, Visual Studio Code

Microsoft hat heute auf der MIX10 in Las Vegas das Internet Explorer 9 Platform Preview Programm vorgestellt. Im Rahmen dieser Vorschau zeigt Microsoft seinen Entwicklungen rund um die nächste Version des Internet Explorer.

Einige Highlights:

• Hardwarebeschleunigung
• Eine neue JavaScript-Engine
• Standards: HTML5, CSS3, DOM, SVG

Microsoft liefert auf der Webseite diverse Testszenarien für diese Standards mit. DIese sollte man definitiv mit den “anderen” Browsern auch mal testen. Unglaublich.

Download und Testplattform: http://ietestdrive.com

The-Oliver Internet Explorer

Für Expression Blend 4 wird es bald eine spezielle kostenfrei Version für Windows Phone geben. Diese Version hat es nicht mehr in den Developer Toolkit CTP für Windows Phone geschafft, wird aber in der finalen Version bald verfügbar sein.

Um dennoch mit Blend Windows Phone Anwendungen entwickeln zu können, wird dieses Add-in benötigt.

Download

The-Oliver Windows Phone 7 Series MIX

There are a lot of carousel controls out there, but I didn’t find any control which can be customized easy without re-coding or “hacking” hard-coded links to images. What I want is a control that can be customized from the design-interface or in XAML, but not in code.

So I created based on a sample on the web a really reusable carousel with mouse control to move it to the left or right.

And … very important you can insert as much pictures as you want, and change different other parameters like radius

A spindle with five images ….

A spindle with ten images … and no code change.

Live-Preview here

Xaml-Code:

<UserControl x:Class="ImageSpindle.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" xmlns:my="clr-namespace:TheOliver.Controls">

    <Grid x:Name="LayoutRoot" Background="White">
        <my:ImageSpindle Margin="12" x:Name="imageSpindle1">
            <Image Source="Assets/1.jpg" />
            <Image Source="Assets/2.jpg" />
            <Image Source="Assets/3.jpg" />
            <Image Source="Assets/4.jpg" />
            <Image Source="Assets/5.jpg" />
        </my:ImageSpindle>
    </Grid>
</UserControl>

Control-Sourcecode:

using System;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace TheOliver.Controls
{
    public class ImageSpindle : Panel
    {
        Point _mousePoint;
        double _height;
        double _width;
        bool _isMouseOver;

        public ImageSpindle()
        {
            this.Loaded += (s, e) =>
                {
                    if (DesignerProperties.GetIsInDesignMode(this))
                    {
                        return;
                    }

                    this.MouseMove += (s1, e1) =>
                        {
                            _mousePoint = e1.GetPosition(this);
                        }; 

                    CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
                };

            this.MouseEnter += (s, e) =>
                {
                    _isMouseOver = true;
                };

            this.MouseLeave += (s, e) =>
                {
                    _isMouseOver = false;
                };
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            _height = availableSize.Height;
            _width = availableSize.Width;

            var images = this.Children.OfType<Image>();
            int imageCount = images.Count();
            if (imageCount > 0)
            {
                double step = 360.0 / imageCount;
                double currentStep = 0;
                foreach (var image in images)
                {
                    UpdateImage(image, currentStep);
                    currentStep += step;
                }
            }
            return base.MeasureOverride(availableSize);
        }

        private Image UpdateImage(Image image, double step)
        {
            image.Height = ImageHeight;
            image.Width = ImageWidth;
            image.Margin = new Thickness(
                (_width - ImageWidth) / 2, (_height - ImageHeight) / 2,
                (_width - ImageWidth) / 2, (_height - ImageHeight) / 2);
            image.RenderTransformOrigin = new Point(0.5, 0.5);
            image.Stretch = ImageStretch;

            PlaneProjection pp = new PlaneProjection();
            pp.CenterOfRotationZ = SpindleCenterOfRotation;
            pp.RotationY = step;
            image.Projection = pp;

            return image;
        }

        void CompositionTarget_Rendering(object sender, EventArgs e)
        {
            if (StopWhenMouseLeft)
            {
                if (!_isMouseOver)
                {
                    return;
                }
            }

            if (double.IsNaN(_width) || _width == 0)
            {
                return;
            }

            foreach (var image in this.Children.OfType<Image>())
            {
                PlaneProjection pp = image.Projection as PlaneProjection;
                if (pp != null)
                {
                    pp.RotationY += ((_mousePoint.X - (_width / 2)) / _width) * 10;
                }
                image.Opacity = (_mousePoint.Y / _height) * 0.5 + 0.5;
            }
        }

        #region Properties

        public Stretch ImageStretch
        {
            get { return (Stretch)GetValue(ImageStretchProperty); }
            set { SetValue(ImageStretchProperty, value); }
        }

        public static readonly DependencyProperty ImageStretchProperty =
            DependencyProperty.Register(
                "ImageStretch",
                typeof(Stretch),
                typeof(ImageSpindle),
                new PropertyMetadata(Stretch.Uniform, OnValueChanged));

        public double ImageWidth
        {
            get { return (double)GetValue(ImageWidthProperty); }
            set { SetValue(ImageWidthProperty, value); }
        }

        public static readonly DependencyProperty ImageWidthProperty =
            DependencyProperty.Register(
                "ImageWidth",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(160.0, OnValueChanged));

        public double ImageHeight
        {
            get { return (double)GetValue(ImageHeightProperty); }
            set { SetValue(ImageHeightProperty, value); }
        }

        public static readonly DependencyProperty ImageHeightProperty =
            DependencyProperty.Register(
                "ImageHeight",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(120.0, OnValueChanged));

        public double SpindleCenterOfRotation
        {
            get { return (double)GetValue(SpindleCenterOfRotationProperty); }
            set { SetValue(SpindleCenterOfRotationProperty, value); }
        }

        public static readonly DependencyProperty SpindleCenterOfRotationProperty =
            DependencyProperty.Register(
                "SpindleCenterOfRotation",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(-160.0, OnValueChanged));

        private static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ImageSpindle spindle = sender as ImageSpindle;
            spindle.InvalidateMeasure();
        }

        public bool StopWhenMouseLeft
        {
            get { return (bool)GetValue(StopWhenMouseLeftProperty); }
            set { SetValue(StopWhenMouseLeftProperty, value); }
        }

        public static readonly DependencyProperty StopWhenMouseLeftProperty =
            DependencyProperty.Register(
                "StopWhenMouseLeft",
                typeof(bool),
                typeof(ImageSpindle),
                new PropertyMetadata(true));

        #endregion

    }
}

Download-Source

The-Oliver Developer, English, Silverlight, Visual Studio Code

Heute auf der Mix10 in Las Vegas habe wir die Entwicklungsumgebung für Windows Phone 7 Series veröffentlicht.

Alles was der Entwickler benötigt gibt es zum kostenfreien Download.

Zum einen gibt es die Entwicklungswerkzeuge in einem einzigen Download. Hat man noch kein Visual Studio 2010 RC installiert, so erhält man auch automatisch Visual Studio 2010 Express for Windows Phone. Hat man bereits Visual Studio 2010 RC, dann wird nur eine Projektvorlage für Windows Phone Anwendungen hinzugefügt.

Der Download enthält zusätzlich auch das XNA Game Studio 4.0.

Zusätzlich bieten wir auch direkt den Download auch Trainingsunterlagen für Windows Phone zum Download an.

Dann kann es ja losgehen.

Download Windows Phone 7 Developer Tools CTP

Download Windows Phone 7 Developer Training

The-Oliver Deutsch, Developer, Windows Phone 7 Series MIX

Das erste Mal vergisst man nie. Besonders heute. Live auf der MIX10 habe ich mir zum ersten Mal Visual Studio 2010 Express for Windows Phone installiert. Auf meinen 1,5 Jahre alten Samsung NC 10 im Batteriesparmodus. Inklusive Download aus einem völlig überlasteten freien WLAN, inklusive Installation … eine Stunde … Ta Da

The-Oliver Designer, Deutsch, Developer, Silverlight, Windows Phone 7 Series MIX

Sitze gerade in der Keynote der MIX10 in Las Vegas.

09:07 Video von Bing Maps Future Video mit Streetside, Argumented Reality. www.discoverbingmaps.com

09:10 Es geht los. Scott Guthrie betritt die Stage.

09:11 Silverlight. Silverlight hat heute 60 % Verbreitung weltweit. Und ist damit das sich am schnellsten verbreitende Browserplugin.

12 Millionen Stunden Live Übertragung bei den Olympischen Spielen in Vancouver 2010. IIS Smooth Streaming + Silverlight.

Der Player ist jetzt Open Source unter http://smf.codeplex.com

Silverlight erlaubt es jetzt in Umgebungen mit mehreren Monitoren auf einem Monitor Fullscreen HD darzustellen, während auf anderen Monitoren andere Anwendungen aktiv sind.

09:18 Live Labs Pivot wird präsentiert. Deep Zoom zum Pivotieren von extrem großen Bilddaten (www.kiva.org, AP, Football-League). www.getpivot.com

9:21 Expression Blend 4 wird angekündigt. Jeder Besitzer von Expression Blend 3 bekommt ein kostenloses Update.

Ebay und Cynergy präsentieren ihre Silverlight Lösung zum Einstellen neuer Artikel zum Verkaufen. Integration von Out-Of-Browser-Experience, Webcamsupport zum Scannen von Barcodes auf Produkten. Coole UI. Auf Open Ebay kann jetzt jeder Entwickler spezialisierte Ebay-Anwendungen in Silverlight 4 entwickeln.

Demonstration wie diese Lösung mit SketchFlow zusammen mit Ebay und Cynergy designt und entwickelt wurde.

9:33 Scott Guthrie: Silverlight 4 RC ist ab sofort verfügbar

9:34 Windows Phone

Joe Belfiore, Corporate Vice President Wndows Phone. Die erste Thirdparty Lösung wird präsentiert: Associated Press.

Cool. Windows Phone kann die Darstellung auf dem Bildschirm auch nach außern liefern, so das man prima Demos auf den Beamer bringen kann.

Start, Search, Back – Die einzigen Buttons auf einem Windows Phone.

Sehr coole Demos, die zeigen, die sehr genial miteinander kombinierbar sind. Facebook, Windows Live, Photos. Sehr cool. Alles in Silverlight gebaut.

Jetzt kommt ein 3D Game in XNA entwickelt: Harvest. Genial. Ein echtes XBOX-Live Game. Echtes 3D.

10:01 Scott Guthrie ist wieder auf der Bühne.

Silverlight auf Windows Phone. Same Programming Model. Same Silverlight. Same Tools.

Scott macht selber eine Live Demo. Ist halt immer noch ein Entwickler Visual Studio ist die Entwicklungsumgebung für Windows Phone. Alle Features die man kennt, funktionieren auch für Windows Phone Entwicklung. Design Preview, Intellisense, Debugging, Emulator (Virtual PC). “It just works”. Orientation Testing.

Scott baut live der ersten Windows Phone Twitter Client. Mit WebClient-Klasse einfach auf den Feed zugreifen … Fertig.

10:12 Jon Harris zeigt Photo Apps auf dem Windows Phone und wie diese mit Expression Blend for Windows Phone erstellt werden können.

10:22 Scott is back.

Die Tools für die Entwicklung von Windows Phone:

• Expression Blend for Windows Phone
• Visual Studio 2010 Express for Windows Phone

KOSTENLOS

Download: http://developer.windowsphone.com

Noch Fragen???

Jetzt ein paar Beispiele von Partnern:

• Netflix – Playready DRM
  Videos ausleihen aufs Handy. Genial.
• Graphic.Ly – Mike Swanson
  Comic Viewer, inklusive Hardware Accelerated Deep Zoom.
• FourSquare – Laura Foy

10:36 Scott introducing Shazam – Jeff Sandquist

Lieder erkennen mit dem Windows Phone. Shazam erkennt Lieder. Integration mit dem Zune Marketplace.

Major League Soccer – Charlie Kindel stellt vor, wie man mit dem Windows Phone Daten über Fussball (nicht American Football) visualieren kann.

Marionette – Einen Avatar Tool. Scott läßt Steve Ballmer “Phone Developers” singen …

10:45 Seesmic – Loic Le Meur´

Eine coole Silverlight Anwendung für den Desktop (Windows und Mac). Und jetzt auch auf Windows Phone. Sehr cool. http://platform.seesmic.com

10:51 Coding4Fun mit dem Windows Phone – Cannon.

Eine Remote Kanonensteuerung jetzt wird auf das Publikum geschossen. Schnell weg hier Rote Polo Shirts werden ins Publikum geschossen.

10:57 XNA Gaming auf dem Windows Phone und in der Cloud – Battle Punks und Harvest

Die 3-Screen-Experience = Ein Spiel auf drei Plattformen = Windows Phone 7 + XBOX 360 + PC. Live Demo … sehr cool. Alles mit dem XNA Studio 4.0. Genial.

11:02 Marketplace – Wie können Entwickler Geld verdienen? Ganz einfach über den Marketplace für Windows Phone.

Sehr cool, das Try & Buy Feature. Anwendungen erst mal testen bevor man die Katze im Sack kauft. Für den Consumer super, für den Entwickler eine Zeile Code.

Okay … das wars.

Windows Phone 7 = Silveright + XNA + Kostenloses Blend for Windows Phone + Kostenloses Visual Studio for Windows Phone

The-Oliver Deep Zoom, Designer, Deutsch, Developer, Expression, Silverlight, Visual Studio

Based on a true story, I built a small control for Silverlight to tip text, like an old fashioned typewriter.

Liveversion: here.

Code for the Control:

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;

namespace TheOliver.Controls
{
    public class TippingText : UserControl
    {
        TextBox _textblock;
        DispatcherTimer _timer;

        public TippingText()
        {
            _textblock = new TextBox();

            this.Content = _textblock;

            _timer = new DispatcherTimer();

            _timer.Interval = new TimeSpan(0, 0, 0, 0, TippingSpeedInMilliseconds);
            _timer.Tick += (s, e) =>
                {
                    ShowNextCharacter();
                    _currentCharacter++;
                    if (_currentCharacter >= Text.Length)
                    {
                        _timer.Stop();
                        if (Repeat)
                        {
                            _currentCharacter = 0;
                            _timer.Start();
                        }
                    }
                };

            this.Loaded += (s, e) =>
                {
                    if (Text.Length > 0)
                    {
                        _timer.Start();
                    }
                };
        }

        private void ShowNextCharacter()
        {
            if (Text.Length > _currentCharacter + 1)
            {
                _textblock.Text = Text.Substring(0, _currentCharacter + 1);
            }
        }

        private int _currentCharacter;

        public string Text
        {
            get { return (string)GetValue(TextProperty); }
            set { SetValue(TextProperty, value); }
        }

        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register(
                "Text",
                typeof(string),
                typeof(TippingText),
                new PropertyMetadata("No Text", OnValueChanged));

        private static void OnValueChanged(object sender, DependencyPropertyChangedEventArgs args)
        {
            TippingText tt = sender as TippingText;
            tt._timer.Stop();
            tt._timer.Interval = new TimeSpan(0, 0, 0, 0, tt.TippingSpeedInMilliseconds);
            tt._currentCharacter = 0;
            tt._textblock.TextWrapping = tt.TextWrapping;
            tt._textblock.TextAlignment = tt.TextAlignment;
            tt._textblock.Text = tt.Text;
            if (tt.Text.Length > 0)
            {
                tt._timer.Start();
            }
        }

        public int TippingSpeedInMilliseconds
        {
            get { return (int)GetValue(TippingSpeedInMillisecondsProperty); }
            set { SetValue(TippingSpeedInMillisecondsProperty, value); }
        }

        public static readonly DependencyProperty TippingSpeedInMillisecondsProperty =
            DependencyProperty.Register(
                "TippingSpeedInMilliseconds",
                typeof(int),
                typeof(TippingText),
                new PropertyMetadata(200, OnValueChanged));

        public bool Repeat
        {
            get { return (bool)GetValue(RepeatProperty); }
            set { SetValue(RepeatProperty, value); }
        }

        public static readonly DependencyProperty RepeatProperty =
            DependencyProperty.Register(
                "Repeat",
                typeof(bool),
                typeof(TippingText),
                new PropertyMetadata(true, OnValueChanged));

        public TextWrapping TextWrapping
        {
            get { return (TextWrapping)GetValue(TextWrappingProperty); }
            set { SetValue(TextWrappingProperty, value); }
        }

        public static readonly DependencyProperty TextWrappingProperty =
            DependencyProperty.Register(
                "TextWrapping",
                typeof(TextWrapping),
                typeof(TippingText),
                new PropertyMetadata(TextWrapping.Wrap, OnValueChanged));

        public TextAlignment TextAlignment
        {
            get { return (TextAlignment)GetValue(TextAlignmentProperty); }
            set { SetValue(TextAlignmentProperty, value); }
        }

        public static readonly DependencyProperty TextAlignmentProperty =
            DependencyProperty.Register(
                "TextAlignment",
                typeof(TextAlignment),
                typeof(TippingText),
                new PropertyMetadata(TextAlignment.Center, OnValueChanged));

    }
}

Download Sourcecode

The-Oliver Developer, English, Silverlight Code

Silverlight 4 comes with a lot of new features. A common request was the support of different types of window styles for the out-of-browser-functionality.

And … Microsoft listen … The support is there. This feature enables a developer to create their on style of window styles for their browser. This is requires, the agreement of the user, to change this.

When you customize your application for deployment, you have now several options in the configuration.

The button “Out-of-Browser-Settings” enables the developer to customize the behavior of the Application, when it runs out of browser. If you request elevated trust from the user, you can choose different styles of a window.

When the user tries to install the application he got the following standard installation Prompt.

After that, he can enjoy one of the following window styles:

• Default Style
• No Border
• Single Border
• Borderless round corners

Have fun,
The-Oliver

The-Oliver Designer, Developer, English, Expression, Silverlight, Visual Studio

Microsoft hat gerade eine neue Plattform für kostenfreie Online-Trainings zu Silverlight und Expression Studio gelauchnt. Zielgruppe sind alle Designer und Design-affine Entwickler.

Link: http://www.microsoft.com/design/toolbox/

The-Oliver Designer, Deutsch, Developer, Expression, Silverlight

Ein großes Hobby von mir sind Steuerelemente für Silverlight. Es gibt extrem viele tolle Beispiele an Tricks und Effekten in Silverlight. Doch leider sind diese sehr oft nur schwer übertragbar, da es sich dabei um Spaghetti-Code handelt oder hart-verdrahtete Konstanten verwendet werden.

Im heutige Beispiel erstelle ich ein Bilderkaroussel das man dynamisch anpassen kann, so wie man es von “echten” Steuerelementen gewohnt ist.

In Blend hat kann man nun beliebige Bilder einfügen, anpassen und sortieren.

Der Objektbaum wird dabei im Objects&Timeline-Bereich ordentlich dargestellt.

Der gesamte Sourcecode:

using System;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace TheOliver.Controls
{
    public class ImageSpindle : Panel
    {
        Point _mousePoint;
        double _height;
        double _width;
        bool _isMouseOver;

        public ImageSpindle()
        {
            this.Loaded += (s, e) =>
                {
                    if (DesignerProperties.GetIsInDesignMode(this))
                    {
                        return;
                    }

                    this.MouseMove += (s1, e1) =>
                        {
                            _mousePoint = e1.GetPosition(this);
                        }; 

                    CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
                };

            this.MouseEnter += (s, e) =>
                {
                    _isMouseOver = true;
                };

            this.MouseLeave += (s, e) =>
                {
                    _isMouseOver = false;
                };
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            _height = availableSize.Height;
            _width = availableSize.Width;

            var images = this.Children.OfType<Image>();
            int imageCount = images.Count();
            if (imageCount > 0)
            {
                double step = 360.0 / imageCount;
                double currentStep = 0;
                foreach (var image in images)
                {
                    UpdateImage(image, currentStep);
                    currentStep += step;
                }
            }
            return base.MeasureOverride(availableSize);
        }

        private Image UpdateImage(Image image, double step)
        {
            image.Height = ImageHeight;
            image.Width = ImageWidth;
            image.Margin = new Thickness(
                (_width - ImageWidth) / 2, (_height - ImageHeight) / 2,
                (_width - ImageWidth) / 2, (_height - ImageHeight) / 2);
            image.RenderTransformOrigin = new Point(0.5, 0.5);
            image.Stretch = ImageStretch;

            PlaneProjection pp = new PlaneProjection();
            pp.CenterOfRotationZ = SpindleCenterOfRotation;
            pp.RotationY = step;
            image.Projection = pp;

            return image;
        }

        void CompositionTarget_Rendering(object sender, EventArgs e)
        {
            if (StopWhenMouseLeft)
            {
                if (!_isMouseOver)
                {
                    return;
                }
            }

            if (double.IsNaN(_width) || _width == 0)
            {
                return;
            }

            foreach (var image in this.Children.OfType<Image>())
            {
                PlaneProjection pp = image.Projection as PlaneProjection;
                if (pp != null)
                {
                    pp.RotationY += ((_mousePoint.X - (_width / 2)) / _width) * 10;
                }
                image.Opacity = (_mousePoint.Y / _height) * 0.5 + 0.5;
            }
        }

        #region Properties

        public Stretch ImageStretch
        {
            get { return (Stretch)GetValue(ImageStretchProperty); }
            set { SetValue(ImageStretchProperty, value); }
        }

        public static readonly DependencyProperty ImageStretchProperty =
            DependencyProperty.Register(
                "ImageStretch",
                typeof(Stretch),
                typeof(ImageSpindle),
                new PropertyMetadata(Stretch.Uniform, OnValueChanged));

        public double ImageWidth
        {
            get { return (double)GetValue(ImageWidthProperty); }
            set { SetValue(ImageWidthProperty, value); }
        }

        public static readonly DependencyProperty ImageWidthProperty =
            DependencyProperty.Register(
                "ImageWidth",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(160.0, OnValueChanged));

        public double ImageHeight
        {
            get { return (double)GetValue(ImageHeightProperty); }
            set { SetValue(ImageHeightProperty, value); }
        }

        public static readonly DependencyProperty ImageHeightProperty =
            DependencyProperty.Register(
                "ImageHeight",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(120.0, OnValueChanged));

        public double SpindleCenterOfRotation
        {
            get { return (double)GetValue(SpindleCenterOfRotationProperty); }
            set { SetValue(SpindleCenterOfRotationProperty, value); }
        }

        public static readonly DependencyProperty SpindleCenterOfRotationProperty =
            DependencyProperty.Register(
                "SpindleCenterOfRotation",
                typeof(double),
                typeof(ImageSpindle),
                new PropertyMetadata(-160.0, OnValueChanged));

        private static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ImageSpindle spindle = sender as ImageSpindle;
            spindle.InvalidateMeasure();
        }

        public bool StopWhenMouseLeft
        {
            get { return (bool)GetValue(StopWhenMouseLeftProperty); }
            set { SetValue(StopWhenMouseLeftProperty, value); }
        }

        public static readonly DependencyProperty StopWhenMouseLeftProperty =
            DependencyProperty.Register(
                "StopWhenMouseLeft",
                typeof(bool),
                typeof(ImageSpindle),
                new PropertyMetadata(true));

        #endregion

    }
}

Dieses und weitere Controls befinden sich in meiner Control-Bibliothek unter http://theolivercontrols.codeplex.com/ Viel Spaß

The-Oliver Developer, Expression, Info, Silverlight

Aus dem offiziellen Deutschen Windows Phone 7 Series Blog –>

Es sind nur noch wenige Tage bis zur MIX10, der Konferenz, auf der wir über die offizielle Entwicklerstory zu WP7S sprechen werden. Doch die Spekulationen kochen inzwischen immer höher, und ich erlebe das hier z.Zt. täglich auf der CeBIT – ca. 50% der Fragen drehen sich darum, wie & womit für die neuen Phones entwickelt werden kann (und das Interesse, das zu tun, ist riesig, was mich sehr freut).

Das Produktteam hat deshalb, um die Sache etwas zu beruhigen und die Erwartungen für Las Vegas richtig zu setzen, eine Art offizielle Aussage über Charlie Kindels Blog veröffentlicht. Hier ist die Essenz daraus: Softwareentwicklung für Windows Phone 7 Series beruht auf

• .NET
• Silverlight (!)
• XNA (!)
• maßgeschneiderten Tools dafür von Microsoft
• Web-2.0-Mechanismen

Die Katze ist damit aus dem Sack: Silverlight als neue Oberflächentechnologie wird es auf einfache Art und Weise möglich machen, Apps zu bauen, die in Sachen User Experience dem restlichen WP7S-UI in nichts nachstehen. XNA wird für fantastische, auf einem Windows Phone bisher nicht dagewesene Games sorgen. Ich denke, das ist eine großartige Botschaft für alle, die von uns einen mutigen Neuanfang erwartet haben – wir haben ihn gemacht, in Entwicklerdingen genauso wie bei der Konzeption der Phones generell.

Mehr Details auf der MIX – und ab dann online und auf diversen Veranstaltungen auch hierzulande.

P.S.: Und übrigens – heute existierende Anwendungen werden auf WP7S nicht lauffähig sein, das lassen die fundamentalen Neuerungen einfach nicht zu. Es heißt also Ärmel hochkrempeln und portieren oder ganz neu starten – die neuen Möglichkeiten legen es nahe, und die Tools werden es einfach machen!

The-Oliver Deutsch, Windows Phone 7 Series

Die CeBIT läuft gerade und wir sind mit dabei. Auf dem Microsoft Stand bildet das MSDN/TechNet-Kino quasi das Herz von Microsoft Deutschland

Im Entwicklerkino herscht unglaublich viel Betrieb. Frau Merkel war auch schon da. Wirklich.

Wer es nicht glauben will, guckt bitte selbst … und zwar hier.

The-Oliver Deutsch, Developer CeBIT

Nicht erst mit seiner neuesten Version hat sich der Office SharePoint Server im Webbereich als äußerst flexibles Allround-Werkzeug etabliert und ist entsprechend weit verbreitet. Trotzdem pflegen nicht wenige Entwickler ihre Vorurteile gegenüber der Anwendung, etwa: SharePoint ist eh nur ein System zum Verwalten von Listen!

Dass die Realität weit von dem entfernt ist, zeigt Ihnen MSDN im Rahmen der kostenlosen TechTalk-Roadshow,  die im März wieder in fünf Städten Station macht. MSDN-Experte Tom Wendel gibt dabei  einen umfassenden Einblick in den Funktionsumfang des neuen SharePoint 2010 und zeigt aus Entwicklersicht, wo überall Sie bei der Anwendung selbst  Hand anlegen können, um dem SharePoint zu vollem Potential zu verhelfen.

Daten/Locations:

• 22. März 2010, Köln
• 23. März 2010, Hamburg
• 24. März 2010, Karlsruhe
• 29. März 2010, Berlin
• 30. März 2010, München

Details und Anmeldung unter: http://www.microsoft.com/germany/msdn/techtalk/aktuell2/default.mspx

The-Oliver Deutsch, Developer MSDN

Liebe Twitter-Spammer,

wer 2422 Tweets schreibt und 1751 Leuten folgt, mir “followed” und glaubt, das ich ihm auch folge, der hat sich doch nicht mehr alle in seinem Apothekerkästchen, oder?

2422 Tweets

Nehmen wir mal an, man benötigt pro Tweet mit Tippen und Senden 1 Minute. Dann hat man ungefähr 40 Stunden seinen Lebens mit Nachrichten wie “Optimisten haben seltener Schnupfen” vergeudet. Macht knapp zwei Tage (4 Stunden schlaf pro Tag mal abgezogen) Lebenszeit.

1479 Followers

Jetzt frag ich mich nur, welche 1479 Leute sich für so jemanden interessieren? Jemand der sie mit wichtigen Informationen überschüttet wie: “Bauchfett ist ungesund – aber warum?”. Okay wahrscheinlich haben es 1479 Leute noch nicht mitgekriegt, aber ja “Fett ist ungesund”. Warum sollte ich sonst ständig auf der Trettmühle rumrennen oder versuche auf einem Brett den Berg runter zu rutschen (oft sogar erfolgreich)? Ja Fett ist ein guter Grund dies zu tun-

Following 1751 People

Wer 1751 Leuten folgt, also wirklich folgt, der muss doch im Schnitt mindestens 10 Sekunden pro Follower pro Tag und dessen Nachrichten aufbringen, oder? Nur mal ganz grob geschätzt. Macht also 1751* 10 Sekunden = ungefähr 292 Minuten pro Tag. Sorry, wer so lange vor dem Computer sitzt, nur um zu Twittern, der kann doch gar nichts zu sagen haben und verdient folgendes:

Warum folgst du mir 1apo?

Habe ich ausversehen einmal Apotheke getwittert und du hast danach gesucht? Interessierst Du dich für Oliver, den Evangelisten, der gerne und viel über Technologien spricht? Interessierst Du dich für Oliver den Menschen, der versucht auf einem Brett den Berg runterzurutschen? Wenn ja, lass uns mal ein Bier trinken gehen und nicht über Twitter kommunizieren.

Meine Meinung
TheOliver

The-Oliver Smalltalk Twitter

Wunschzettel für Weihnachten kann man nicht früh genug schreiben.

The-Oliver Info

Wunschzettel für Weihnachten kann man nicht früh genug schreiben.

The-Oliver Windows Phone 7 Series

Jetzt wird es richtig spannend.

“Conferences just don’t get any better than this-announcing Windows Phone 7

Join us at MIX10 and be among the first to learn how to build applications and games for Windows Phone 7. We’ll introduce you to the development platform, show you how to work with the Windows Phone 7 development tools, and give you a tour of the Windows Phone Marketplace. All MIX10 attendees will receive access to the Windows Phone 7 development tools and have access to a dedicated track on the Windows Phone 7 platform that runs throughout the event.

MIX10 attendees will get exclusive free developer support for the Windows Phone 7 development tools. Don’t miss this unique opportunity to be among the first to learn about Windows Phone 7.

REGISTER NOW FOR MIX10

The ONLY way to learn about Windows Phone 7 is to register now for MIX10-we’ve even extended the special discount on registration through February 21st-you have less than a week to take advantage of this $200 discount.

Don’t wait! This is absolutely your last chance to receive this discount. “

Ich bin dort, wer noch?

TheOliver

The-Oliver Designer, Developer, Info, Windows Phone 7 Series