The-Oliver.com

In der heutigen Ausgabe von msdn tv – Nachrichten für Entwickler ist Jan Schenk nach kurzem Aufenthalt unter Palmen zu Gast bei der DNUG München, der DotNET Usergroup München (http://www.munichdot.net/). Im Interview ist Hardy Erlinger, Gründer der Münchner Usergroup und Leiter der INETA Deutschland (http://ineta-germany.org), und Gregor Biswanger, Silverlight-Abhängiger und Referent auf dem Usergroup-Treffen. Ausserdem gibt es in den Fast Facts of the Week wieder viel Neues zu Dariusz Parys Tutorialserie über Visual Studio 2010, der Beta 2 der Windows Server AppFabric, einer Webcastreihe von Holger Sirtl zum Thema Windows Azure Platform und der Microsoft Roadshow "Zwanzig Zehn" zum Launch von Visual Studio 2010 am 12. April. Ausserdem ein Terminhinweis auf Tom Wendels TechTalk-Runde quer durch Deutschland zum neuen Sharepoint 2010.
Mit welcher Kopfbedeckung, welchen Versprechern und welchem Set msdn tv seine Zuschauer heute überrascht lässt sich nicht in Textform fassen. Um es mit wenigen Worten zu sagen: Die heutige Ausgabe ist die Überlänge wert. Die Gesamtspieldauer des Director’s Cut sind heute ganze 20 Minuten 38 Sekunden.

Deutsch, Developer, Info MSDN

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

Developer, English, Expression, Silverlight, Visual Studio Code

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

Developer, English, Expression, Silverlight, Visual Studio Code

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

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

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

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

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

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

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/

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ß

Developer, Expression, Info, Silverlight

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.

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

Deutsch, Developer MSDN

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

Designer, Developer, Info, Windows Phone 7 Series

Vor wenigen Minuten wurde der Weltöffentlichkeit zum ersten mal “Windows Phone 7 Series” vorgestellt: Microsofts neue mobile Plattform der nächsten Generation. Integrierte Benutzerkonzepte, aggregierte Informationen aus unterschiedlichen Quellen, einfach zusammengefasst und bedienbar für den Benutzer.

Die offizielle Homepage, inklusive eines sehr guten Simulators, heißt: http://www.windowsphone7series.com/

Den offiziellen deutschen Blog zu diesem Thema findet man ab sofort hier: http://blogs.msdn.com/windowsphone/ 

Weitere Informationen über die Entwicklerstory wird es auf der MIX’10 in Las Vegas im März und parallel hier in diesem Blog geben.

Es wird extrem spannend. Ich freu mich.

TheOliver

Developer, Info, Windows Phone 7 Series

Gleich zwei heiße Top-Themen präsentiert die aktuelle Ausgabe von msdn tv: wir gehen der Frage nach, was Windows 7 und Bob Dylan gemeinsam haben und präsentieren Mitglieder der Microsoft-Community, die erstmals vor der Kamera auspacken. Aber der Reihe nach: im Interview mit Moderator Jan Schenk informiert diesmal MSDN-Experte und Windows-Entwickler Oliver Scheer unter trickreicher Zuhilfenahme sogenannter CueCards über einige interessante Features von Windows 7 und über Ressourcen, die jeder Developer kennen sollte. Beispiel: das Windows API Code Pack.

In den Kurznachrichten gibt’s Infos zum Windows 7 Developer Center, zur neuesten Version der Microsoft-Vortragssammlung Webcast DVD Edition 2009, zur frisch gelaunchten Übersicht über die deutschsprachigen Microsoft Social Media Angebote auf dem Web-Portal „Community Guide“, zum Imagine Cup Wettbewerb 2010 und einem wichtigen Termin, den Verwender des Release Candidate von Windows 7 beachten sollten.

Schließlich bedanken sich noch drei Gewinner des Expression Studio Gewinnspiels vom Herbst letzten Jahres per Video für die übersandten Preise. Ach so – wegen Bob Dylan: Die Vorlage zum CueCard-Video stammt aus dem Jahr 1965 und ist hier anzuschauen.

Developer, Info MSDN

MSDN – das Microsoft Developer Network – unterstützt Entwickler mit einem reichhaltigen Angebot von Online- und Offline-Services und liefert mit seinem umfangreichen Know-how-Fundus effiziente Hilfe, wenn es um Fragen der Anwendungsprogrammierung auf Basis von Microsoft-Produkten und -Technologien geht. Angefangen beim .NET Framework, den verschiedenen .NET-Sprachen und der Entwicklungsumgebung Visual Studio, über Windows und Webprogrammierung, bis hin zur Entwicklung für mobile Plattformen bietet Ihnen MSDN Online genug Treibstoff, um Ihre Probleme und Fragen hinter sich zu lassen und Ihre Ziele schnell zu erreichen. Natürlich auch zu neuen Themen und Technologien wie Windows 7, Cloud Computing, Silverlight oder Multicore-Programmierung. Lesen Sie auch gerne, was die deutschsprachige Wikipedia über uns schreibt: MSDN auf Wikipedia
Mit MSDN Online möchten wir Ihnen unter der Internetadresse www.msdn-online.de grundsätzlich eine umfangreiche Grundversorgung anbieten. Dort, wo wir Ihnen einen extra Service oder die Extraportion Know-how anbieten, bemühen wir uns dies natürlich kostenfrei für Sie zu realisieren. So sind 99.5% aller unserer Online-Angebote kostenfrei nutzbar.

Mehr Infos: http://msdn-online.de/willkommen

Developer, Info MSDN

Der Release Candidate (RC) von Visual Studio 2010, die letzte Vorabversion vor der Produktveröffentlichung am 12. April 2010, steht nun allen Interessierten in den kommenden Editionen als öffentlicher Download zur Verfügung. Zum Wochenbeginn hatten bereits Inhaber einer MSDN Subscription exklusiven Zugriff auf die – gegenüber der früheren Vorabversion Beta 2 dank umfassenden Kundenfeedbacks immens beschleunigte – Entwicklungsumgebung gehabt. Die ausschließlich englischsprachig verfügbaren Vorabversionen verfügen weiterhin über eine „Go Live“-Lizenz, die den produktiven Einsatz bereits heute erlaubt. Zeitgleich zu Visual Studio 2010 hat auch das grundlegende .NET Framework 4, in den Visual Studio 2010-Installationen bereits enthalten, den RC-Status erreicht und ist von MSDN Online auch separat herunterladbar.
Download: Visual Studio 2010 (RC) und .NET Framework (RC)
Visual Studio General Manager Jason Zander bittet die geneigten Tester der Release Candidates ein weiteres Mal um ihr wertvolles Feedback und stellt in einem Channel 9-Interview die jüngste Entstehungsgeschichte der Release Candidates vor.
Tagesaktuelle Nachrichten rund um Visual Studio finden Sie auch im Visual Studio Developer Center auf MSDN. Im MSDN Forum zu Visual Studio können Sie sich mit der Community austauschen und in der MSDN Mediathek finden Sie zahlreiche weitere Multimediainhalte zu Visual Studio 2010: MSDN Mediathek

Verwandte Links:

MSDN Library zu Visual Studio 2010

Developer, Visual Studio MSDN

Microsoft Surface

Heute habe ich mir für das Video des Tages Unterstützung von unserem User Experience-Evangelisten Clemens Lutsch geholt. Er ist ein Experte auf dem Gebiet der neuartigen Benutzeroberflächen. Er befasst sich seit der ersten Stunde mit Microsoft Surface, einem Tisch, der über eine Oberfläche bzw. eine Tischplatte verfügt, mit der man sämtliche Interaktionen steuern kann. Die gesamte Interaktion wird über grafische Elemente, Bluetooth-fähige Geräte oder aber mit den Händen vorgenommen. Spannend dabei ist, dass man gleichzeitig mit nahezu beliebig vielen Händen und Fingern mit dem Tisch interagieren kann. Ein einfaches Beispiel ist die zeitgleiche Betrachtung von Bildern durch verschiedene Benutzer. Jeder kann Bilder auf dem Tisch ansehen, heranziehen, vergrößern, drehen und sortieren. Im Prinzip fast genauso, wie man es von herkömmlichen Fotoabenden mit Familie und Freunden gewohnt ist. Aber haben sie schon mal versucht ein klassisches Foto auf dem Tisch zu vergrößern, um die Details genauer zu betrachten? Ja, so etwas funktioniert nur mit dem Surface.

Ganz ehrlich, der Surface ist wegen der integrierten Hardware und der enorm wuchtigen Tischplatte, nicht ganz preiswert und derzeit nur über Microsoft direkt zu beziehen – beim Multimedia-Fachhändler um die Ecke steht er also noch nicht zur Verfügung. Allerdings kann ich jedem empfehlen, mal in den O2-Flagship-Store in Köln zu gehen, dort haben Partner von Microsoft eine Lösung für O2 erstellt, die echt „Wow“ ist.

Was hat Surface mit Windows 7 gemeinsam?

Während der Entwicklung von Windows 7 hat man sehr eng mit dem Surface-Team zusammengearbeitet und dieses Know-How in das neue Betriebssystem einfliessen lassen. Das große Geheimnis von Surface ist eigentlich, dass das darunterliegende Betriebssystem „nur“ Windows Vista Business ist, angereichert mit einigen Kameras für die Erkennung der Finger, Hände oder sonstigen Eingabegeräte. Zusätzlich gibt es noch diverse Treiber für die Eingabe sowie Software, die die Oberfläche von Surface ausmacht. Diese Software ist, etwas einfach formuliert, nur WPF (Windows Presentation Foundation) mit speziellen Steuerelementen. Für den „normalen“ Entwickler heißt das, er kann eigentlich sofort für Surface programmieren. Die Entwicklungswerkzeuge sind die gleichen, wie für Silverlight und WPF, nämlich Expression Studio und/oder Visual Studio.

In Windows 7 ist die Möglichkeit eingeflossen, den Computer über den Bildschirm mit Hilfe von Fingern zu steuern. Es gibt bereits eine Vielzahl von Computern und Notebooks, die sich mit einem Finger steuern lassen. Darüber hinaus gibt es derzeit schon eine überschaubare Anzahl von Computern, die sich schon mit zwei oder mehreren Fingern gleichzeitig steuern lassen. Wieviele gleichzeitige Eingaben unterstützt werden, ist von der Display-Hardware und damit vom Hersteller direkt abhängig.

Was hat man unter Windows 7 von Multitouch?

Eine nette Anekdote zum Thema Multitouch: Die Steuerelemente auf der Taskleiste sind wesentlich größer geworden. Der Grund dafür liegt in der natürlichen Beschaffenheit von menschlichen Fingern. Haben SIe schon einmal probiert, die kleinen Symbole der Windows Vista- oder Windows XP-Oberfläche in der Taskleiste mit dem Finger präzise zu treffen? Selbst mit einem Stift (von Tablet PCs) ist das eher ein Geschicklichkeitsspiel als ein präzises Arbeiten. Jetzt lassen sich die neuen Steuerelemente auch einfach mit dem Finger treffen und steuern.

Anwendungen, die die Basisfunktionen aus dem Betriebssystem unterstützen, wie z.B. das Vergrößern und Verkleinern, sind bereits sehr gut für Mutlitouch ausgelegt. Durch das auseinanderziehen zweier Fingern kann man beliebige Dokumente, die diese Funktion unterstützen, vergrößern oder verkleinern. Hinzu kommt die Fähigkeit der Anwendungen, natürliches Feedback zu geben, gelangt man z.B. an das Ende eines Dokumentes, so „bounced“ dieses (Bouncen heißt so viel wie „kurz über das Ziel hinausfahren und wieder zurückzukommen“). Damit erhält der Benutzer tatsächlich das Gefühl von „Ich bin am Ende des Dokumentes angekommen“. Aber auch die Docking-Funktionen von Windows sind hervoragend auf Multitouch eingestellt: bewegt man ein Fenster mit dem Finger an eine Bildschirmseite, so dockt es dort automatisch an.

Eine andere Anekdote ist, dass sich die Open Source Gemeinde um einen Browser damit rühmt, jetzt auch Multitouch unter Windows 7 zu unterstützen. Leider haben die Kollegen nicht mitbekommen, dass das ein fester Bestandteil von Windows 7 ist und sofort „ohne Code“ von jeder Anwendung automatisch verwendet werden kann.

Es gibt bereits eine Vielzahl von Anwendungen, die Multitouch direkt verwenden. Microsoft selbst liefert ein Beispielpaket aus, das Multitouch Pack, das aus einigen Spielen, Visualisierungsdemonstrationen und Surface Globe besteht. So kann man mit dem Surface Globe sehr leicht die Welt mit den eigenen Fingern erkunden.

Anwender ohne ein Multitouch-fähiges Gerät müssen aber nicht zurückstecken, die Anwendungen lassen sich zumindest starten und größtenteils auch mit der Maus steuern, wenn auch nicht ganz so komfortabel.

Wie kann man nun eigene Multitouch-fähigen Anwendungen entwickeln?

Auf MSDN-Online gibt es dazu einen sehr guten Webcast.

In diesem Webcast zeigt Ihnen Dariusz Parys, wie Sie Anwendungen für Windows 7 multi-touch-fähig machen. Unter anderem erfahren Sie, wie man einen Emulator installiert, um Multi-Touch zu simulieren, welche Gesten standardmäßig in Windows 7 unterstützt werden und wie man eine WPF-Anwendung um Multi-Touch-Funktionalität erweitert.

Link zum Webcast

Weitere technische Dokumentation zur Multitouch-API gibt es hier:

Yochay Kriaty – Multitouch-Funktionen in Windows 7

Deutsch, Developer, Windows

Heute kommen die Fans des Windows Explorer voll auf ihre Kosten. Er verfügt im Prinzip über alle wichtigen Funktionen, die man für die Navigation durch Ordner, Netze, Dateien, Bibliotheken und Suchen benötigt. Der Windows Explorer ist das Ergebnis jahrelanger Entwicklungsarbeit und spiegelt dabei die Implementierung vieler Bedürfnisse des Standardbenutzers wieder. Wer dennoch Funktionen braucht, die nicht enthalten sind, oder diese gerne auf andere Art und Weise implementieren möchte, darf dies gerne tun.

Die Funktionen des Windows Explorer stehen jedem Entwickler frei zur Verfügung. Dank des Windows API Code Packs lässt sich der Explorer in Windows Forms- oder Windows Presentation Foundation-Anwendungen integrieren.

Die Funktionen und die Visualisierung steht in Form von Steuerelementen direkt in Visual Studio zur Verfügung. Der Name der Steuerelemente ist sowohl in Windows Forms als auch in WPF ExplorerBrowser.

Die Konfiguration ist ebenfalls sehr leicht über das Eigenschaften-Fenster möglich.

Zwei Referenzimplementierungen sind direkt im Windows API Code Pack enthalten. Sie demonstrieren einfach und kompakt die volle Leistungsfähigkeit und sehen dabei sehr technisch aus. Meine Bitte an Sie, bitte bauen sie so etwas nicht, sondern machen sie es dem Benutzer leicht. J

Die WPF-Variante zum Testen der ExplorerBrowser-Funktionen.

Die Windows Forms-Variante zum Testen.

Deutsch, Developer, Windows MSDN