using System;
using System.ServiceModel;
using System.ServiceModel.Activation;
using Bram.NxtSharp;
 
namespace SilverNXT.Web
{
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class MindstormsService
    {
 
        // Statisch, da es nur einen Robotor für alle gibt
        static private NxtBrick brick;
        static private NxtTankDrive tankDrive;
 
        public MindstormsService()
        {
 
            if (brick == null)
            {
                // Erzeuge Stellvertreter des NXT-Steins, der im Roboter verbaut ist
                brick = new NxtBrick();
 
                // Wichtig: Setze den Namen der Kommunikationsschnittstelle
                brick.COMPortName = "Com11";
 
                // Konfiguriere NXT-Stein mit Motoren und ggf. Sensoren
                NxtMotor motorB = new NxtMotor();
                NxtMotor motorC = new NxtMotor();
                motorB.Brick = brick;
                brick.AttachMotor(NxtMotorPort.PortB, motorB);
                motorC.Brick = brick;
                brick.AttachMotor(NxtMotorPort.PortC, motorC);
 
                // Erzeuge Hilfsobjekt zur Steuerung des Robotors ähnlich einem Panzer
                tankDrive = new NxtTankDrive();
                tankDrive.Brick = brick;
                tankDrive.Motor1 = motorB;
                tankDrive.Motor2 = motorC;
 
                // Stelle Verbindung mit dem NXT-Stein des Robotors her
                brick.Connect();
 
            }
 
        }
 
        [OperationContract]
        public void Run(SByte power, ushort distance, SByte turnRation)
        {
            tankDrive.Move(power, distance);
        }
 
        [OperationContract]
        public void Coast()
        {
            tankDrive.Coast();
        }
    }
}

using System;
using System.Windows;
using System.Windows.Controls;
using SilverNXT.MindstormsServiceReference;
 
namespace SilverNXT
{
    public partial class MainPage : UserControl
    {
        MindstormsServiceClient client = new MindstormsServiceClient();
 
        public MainPage()
        {
            InitializeComponent();
        }
 
        private void runButton_Click(object sender, RoutedEventArgs e)
        {
            client.RunCompleted += new EventHandler<system.componentmodel.asynccompletedeventargs>(client_AsyncCompleted);
            client.RunAsync(50, 0, 100);
        }
 
        private void coastButton_Click(object sender, RoutedEventArgs e)
        {
            client.CoastCompleted += new EventHandler<system.componentmodel.asynccompletedeventargs>(client_AsyncCompleted);
            client.CoastAsync();
        }
 
        void client_AsyncCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
        {
            // nothing
        }
    }
}

using System;
using System.Windows;
using WiimoteLib;
 
namespace WiiWPF
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
 
            Loaded += new RoutedEventHandler(MainWindow_Loaded);
        }
 
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            WiimoteCollection mWC = new WiimoteCollection();
 
            try
            {
                // Finde alle angeschlossenen Wii Remotes
                mWC.FindAllWiimotes();
                // Verbinde mit der ersten gefundenen Wii Remote
                Wiimote wm = mWC[0];
                wm.Connect();
                // Schalte die Vibration an der Wii Remote ein
                wm.SetRumble(false);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, &quot;Wiimote error&quot;, MessageBoxButton.OK);
            }
        }
    }
}

// Mache Klassen verfügbar
import de.davidochmann.utilities.dogesture.DoGesture;
import de.davidochmann.utilities.dogesture.events.GestureEvent;
 
// Erzeuge Geste (der ausführliche Weg)
var movedown:DoGesture = new DoGesture(stage);
 
// Lausche dem Ereignis, dass die Geste stattfand
movedown.addEventListener(GestureEvent.GESTURE_COMPLETE, movedownCompleteHandler);
// Wie lange darf das Ausführen der Geste dauern
movedown.setTimeout(1000); 
// Definiere die notwendigen Bewegungen für die Geste
movedown.add( 0, 50);
// Starte das Warten auf die Geste
movedown.start(); 
 
// Ereignismethode
function movedownCompleteHandler(e:GestureEvent):void
{
	// Was soll nun passieren...
	trace("Geste wurde durchgeführt!");
}

using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
 
namespace SilverTouch
{
    public partial class MainPage : UserControl
    {
 
        public MainPage()
        {
            // Required to initialize variables
            InitializeComponent();
 
            Loaded += new System.Windows.RoutedEventHandler(MainPage_Loaded);
        }
 
        private void MainPage_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            // Erzeuge Transformationsobjekt für Verschiebung
            CompositeTransform transform = new CompositeTransform();
            monster.RenderTransform = transform;
 
            // Lausche auf Touch-Ereignis
            Touch.FrameReported += new System.Windows.Input.TouchFrameEventHandler(Touch_FrameReported);
        }
 
        private void Touch_FrameReported(object sender, System.Windows.Input.TouchFrameEventArgs e)
        {
            // Ermittle Tranformationsobjekt 
            CompositeTransform transform = monster.RenderTransform as CompositeTransform;
            // Ermittle primären Berührungspunkt
            TouchPoint tp = e.GetPrimaryTouchPoint(monster);
            // Verschiebe Objekt zum Berührungspunkt
            transform.TranslateX += tp.Position.X - (monster.ActualWidth / 2);
            transform.TranslateY += tp.Position.Y - (monster.ActualHeight / 2);
        }
    }
}

<phoneNavigation:PhoneApplicationPage 
    x:Class="SilverPhone.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phoneNavigation="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Navigation"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="800"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}">
 
    <Grid x:Name="LayoutRoot" Background="{StaticResource PhoneBackgroundBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
 
        <!--TitleGrid is the name of the application and page title-->
        <Grid x:Name="TitleGrid" Grid.Row="0">
            <TextBlock x:Name="textBlockPageTitle" Style="{StaticResource PhoneTextPageTitle1Style}"><Run Text="MY "/><Run Text="TOUCH "/><Run Text="APPLICATION"/></TextBlock>
            <TextBlock Text="touch me" x:Name="textBlockListTitle" Style="{StaticResource PhoneTextPageTitle2Style}"/>
        </Grid>
 
        <Grid x:Name="ContentGrid" Grid.Row="1">
            <Image x:Name="monster" ManipulationDelta="Main_ManipulationDelta" Source="Assets/monster.png" HorizontalAlignment="Center" VerticalAlignment="Center" Width="240" Height="342"/>
        </Grid>
 
    </Grid>
 
</phoneNavigation:PhoneApplicationPage>

using System.Windows.Input;
using System.Windows.Media;
using Microsoft.Phone.Controls;
 
namespace SilverPhone
{
    public partial class MainPage : PhoneApplicationPage
    {
 
        public MainPage()
        {
            // Required to initialize variables
            InitializeComponent();
 
            Loaded += new System.Windows.RoutedEventHandler(MainPage_Loaded);
        }
 
        private void MainPage_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            // Erzeuge Transformationsobjekt für Verschiebung
            CompositeTransform transform = new CompositeTransform();
            monster.RenderTransform = transform;
        }
 
        // Ereignismethode
        private void Main_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            // Ermittle Tranformationsobjekt 
            CompositeTransform transform = monster.RenderTransform as CompositeTransform;
 
            // Verschiebe Objekt bzgl. der durchgeführten Manipulation
            transform.TranslateX += e.DeltaManipulation.Translation.X;
            transform.TranslateY += e.DeltaManipulation.Translation.Y;
        }
    }
}

if (!Multitouch.supportsGestureEvents) {
	Alert.show("Gesten werden nicht unterstützt", "Hinweis");
} else {
	// Stelle sicher, Gesten zu nutzen
	Multitouch.inputMode = MultitouchInputMode.GESTURE;
}

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009" 
			 xmlns:s="library://ns.adobe.com/flex/spark" 
			 xmlns:mx="library://ns.adobe.com/flex/mx"
			 creationComplete="windowedapplication_creationCompleteHandler(event)">
 
	<fx:Script>
		<![CDATA[
 
			import mx.controls.Alert;
			import mx.events.FlexEvent;
 
			protected function windowedapplication_creationCompleteHandler(event:FlexEvent):void
			{
				if (!Multitouch.supportsGestureEvents) {
					Alert.show("Gesten werden nicht unterstützt!", "Hinweis");
				} else {
					// Stelle sicher, Gesten zu nutzen
					Multitouch.inputMode = MultitouchInputMode.GESTURE;
				}
			}
 
			protected function image_gestureZoomHandler(event:TransformGestureEvent):void
			{
				// Skaliere Objekt
				(event.currentTarget as InteractiveObject).scaleX *= event.scaleX;
				(event.currentTarget as InteractiveObject).scaleY *= event.scaleY;
			}
 
			protected function image_gesturePanHandler(event:TransformGestureEvent):void
			{
				// Verschiebe Objekt
				(event.currentTarget as InteractiveObject).x += event.offsetX;
				(event.currentTarget as InteractiveObject).y += event.offsetY;
			}
 
			protected function image_gestureRotateHandler(event:TransformGestureEvent):void
			{
				// Drehe Objekt
				(event.currentTarget as InteractiveObject).rotation += event.rotation;
			}
 
		]]>
	</fx:Script>
 
	<mx:Image x="20" y="20" source="assets/monster.png" 
			  gesturePan="image_gesturePanHandler(event)"
			  gestureZoom="image_gestureZoomHandler(event)"
			  gestureRotate="image_gestureRotateHandler(event)"
			  />
 
</s:WindowedApplication>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
 
namespace SilverPen
{
	public partial class MainPage : UserControl
	{
 
		private Stroke currentStroke;
 
		public MainPage()
		{
			// Required to initialize variables
			InitializeComponent();			
		}
 
		private void inkPresenter_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
		{
            // Starte mit der Aufzeichnung
			inkPresenter.CaptureMouse();
            // Merke die Punkte
			StylusPointCollection stylusPointCollection = new StylusPointCollection();
            // Füge die ersten Punkte hinzu
            stylusPointCollection.Add(e.StylusDevice.GetStylusPoints(inkPresenter));
            // Erstelle aus den Punkten einen Strich
			currentStroke = new Stroke(stylusPointCollection);
            // Zeichne den Strich (dieser wird später weiter aktualisiert)
			inkPresenter.Strokes.Add(currentStroke);
		}
 
		private void inkPresenter_LostMouseCapture(object sender, System.Windows.Input.MouseEventArgs e)
		{
            // Beende die Aufzeichnung
			currentStroke = null;
			inkPresenter.ReleaseMouseCapture();
		}
 
		private void inkPresenter_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
		{
			// Füge dem aktuellen Strich neue Punkte hinzu
    		if (currentStroke != null) {
        		currentStroke.StylusPoints.Add(e.StylusDevice.GetStylusPoints(inkPresenter));
			}
		}
 
	}
}

currentStroke.DrawingAttributes.Height = e.StylusDevice.GetStylusPoints(inkPresenter)[0].PressureFactor * 100;

var cam:Camera;
var video:Video;
// Ermittle die Standardkamera
cam=Camera.getCamera();
// Erzwinge die Verarbeitung durch den Flash Player
video = new Video();
video.attachCamera(cam);
// Überprüfe bei jedem "Redraw" des Bildschirms...
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
 
// ...die Aktivität vor der Kamera...
function enterFrameHandler(event:Event):void {
	trace(cam.activityLevel);
	// ...und zeichne eine Linie abhängig vom Wert!
	graphics.lineStyle(0);
	graphics.lineTo(500-x,500-cam.activityLevel*4);
	x--;
}

<UserControl x:Class="SilverScanner.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" >
 
    <Grid x:Name="LayoutRoot" >
        <Button Content="Scan" Name="scanCapturingBtn" HorizontalAlignment="Left" VerticalAlignment="Top" Click="scanCapturingBtn_Click" />
    </Grid>
 
</UserControl>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
 
namespace SilverScanner
{
    public partial class MainPage : UserControl
    {
 
        CaptureSource captureSource;
        BarcodeCapture barcodeCapture;
 
        public MainPage()
        {
            InitializeComponent();
        }
 
        protected void activateCamera()
        {
            if (captureSource == null)
            {
                // Zeige Vorschau des Videobildes
                captureSource = new CaptureSource();
                captureSource.VideoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice();
                VideoBrush previewBrush = new VideoBrush();
                previewBrush.Stretch = Stretch.Uniform;
                previewBrush.SetSource(captureSource);
                LayoutRoot.Background = previewBrush;
                // Wähle möglichst gutes Videoformat für bessere Scan-Ergebnisse
                VideoFormat desiredFormat = new VideoFormat(PixelFormatType.Format32bppArgb, 640, 480, 12);
                captureSource.VideoCaptureDevice.DesiredFormat = desiredFormat;
                if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
                {
                    captureSource.Start();
                }
 
            }
        }
 
        private void scanCapturingBtn_Click(object sender, RoutedEventArgs e)
        {
            activateCamera();
 
            if (barcodeCapture == null)
            {
                // Starte das Erkennen des Barcodes
                barcodeCapture = new BarcodeCapture();
                barcodeCapture.BarcodeDetected += new EventHandler<barcodeeventargs>(onBarcodeDetected);
                barcodeCapture.CaptureSource = captureSource;
            }
        }
 
        private void onBarcodeDetected(object sender, BarcodeEventArgs e)
        {
            // Zeige gefundenen Barcode
            System.Diagnostics.Debug.WriteLine(e.Barcode);
        }
 
    }
}

var mic:Microphone;
var sound:SoundTransform;
 
// Verhindere Rückkopplung und stelle die Lautstärke auf 0
sound = new SoundTransform(0);
 
// Ermittle das Standardmikrofon
mic = Microphone.getMicrophone();
// Erzwinge die Verarbeitung durch den Flash Player
mic.setLoopBack(true);
// Verhindere Rückkopplung 
mic.soundTransform = sound;
 
// Überprüfe bei jedem "Redraw" des Bildschirms...
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
 
// ...die Aktivität des Sounds (also die Lautstärke)...
function enterFrameHandler(event:Event):void {
	trace(mic.activityLevel)	
	// ...und zeichne eine Linie abhängig vom Wert!
	graphics.lineStyle(0);
	graphics.lineTo(500-x,500-mic.activityLevel*4);
	x--;
}

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
            xmlns:s="library://ns.adobe.com/flex/spark" 
            xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600"
            creationComplete="application_creationCompleteHandler(event)"
            >
 
   <fx:Script>
      <![CDATA[
         import mx.events.FlexEvent;
 
         protected function application_creationCompleteHandler(event:FlexEvent):void
         {
            var m:Microphone = Microphone.getMicrophone();
            m.addEventListener(SampleDataEvent.SAMPLE_DATA, microphone_sampleDate);
            m.setLoopBack(true);            
         }
 
         protected function microphone_sampleDate(event:SampleDataEvent):void {
            // Verarbeite die Bytes des Samples
            trace(event.data.bytesAvailable);
         }         
      ]]>
   </fx:Script>
 
</s:Application>

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" >
 
	<fx:Script>
		<![CDATA[
			import mx.events.FlexEvent;
 
			// Führe Befehl aus
			private function executeCommand():void {
				// Wandle Befehlseingabe in Kleinbuchstaben um
				var lowercasetext:String = ti.text.toLowerCase();
				// Ermittle, ob Befehl zum Einschalten eingegeben wurde...
				if (lowercasetext.indexOf("on")>-1) {
					// ...und aktiviere Kontrollkästchen...
					cb.selected = true;
					// ... überprüfe, ob Befehl zum Ausschalten eingegeben wurde...
				} else if (lowercasetext.indexOf("off")>-1) {
					// ...und deaktiviere Kontrollkästchen...
					cb.selected = false;
				}				
			}			
 
			protected function ti_valueCommitHandler(event:FlexEvent):void {
				executeCommand();
			}
 
			protected function ti_enterHandler(event:FlexEvent):void {
				executeCommand();
			}
		]]>
	</fx:Script>
 
	<s:CheckBox x="10" y="10" label="Aktiviere mich per Kommandozeile" id="cb"/>
	<s:TextInput x="10" y="36" width="209" id="ti" 
				 enter="ti_enterHandler(event)"
				 valueCommit="ti_valueCommitHandler(event)" />
 
</s:Application>

// a shader is an algorithm that is compiled
// and loaded into the Graphics Processor Unit (GPU)
// this algorithm is run once, for every pixel in the input image
// GPUs are efficient parallel  processors and will run
// your algorithm on thousands of pixels at a time
 
/// <class>ColorChannelsEffect</class>
/// <description>An effect that turns the input into a grayscale image first and than multiplies all four channels with custom values (e.g. for anaglyph images).</description>
 
//-----------------------------------------------------------------------------------------
// Shader constant register mappings (scalars - float, double, Point, Color, Point3D, etc.)
//-----------------------------------------------------------------------------------------
 
/// <summary>Change the ratio between the Red channel</summary>
/// <minvalue>0/minValue&gt;
/// <maxvalue>1</maxvalue>
/// <defaultvalue>1</defaultvalue>
float RedRatio : register(c0);
 
/// <summary>Change the ratio between the Blue channel </summary>
/// <minvalue>0/minValue&gt;
/// <maxvalue>1</maxvalue>
/// <defaultvalue>1</defaultvalue>
float BlueRatio : register(c1);
 
/// <summary>Change the ratio between the Green channel</summary>
/// <minvalue>0/minValue&gt;
/// <maxvalue>1</maxvalue>
/// <defaultvalue>1</defaultvalue>
float GreenRatio : register(c2);
 
/// <summary>Change the ratio between the Alpha channel</summary>
/// <minvalue>0/minValue&gt;
/// <maxvalue>1</maxvalue>
/// <defaultvalue>1</defaultvalue>
float AlphaRatio : register(c3);
 
// input image
sampler2D input : register(s0);
 
// this is the entry point for the shader
// the return type is float4
// float4 contains four float values which we 
// can think of as color of a pixel
// (alpha, red, green, blue)
float4 main(float2 locationInSource : TEXCOORD) : COLOR
{
 
  // create a variable to hold our color
  float4 color;
 
  // get the color of the current pixel
  // tex2D is a HLSL function
  // 1st arg is a bitmap (called a texture in HLSL)
  // input: the incoming image, passed in from the GPU register (s0) 
  // 
  // 2nd arg is a locator for the pixel, this is normalized to range 0..1 
 
  // tex2D takes our sample input, gets a pixel at the current x,y location
  // and returns the color of the existing pixel, which means that the color is not altered
  color = tex2D( input, locationInSource.xy);
 
  // color has four value that we can change
  // color.r, color.g, color.b, color.a
 
  // get rgb values only
  float3 rgb = color.rgb;
  // create greyscale pixel via dot multiplication
  // (the effective luminance of a pixel is calculated 
  // with the following formula: 
  // 0.3 * red + 0.59 * green + 0.11 * blue);
  float3 luminance = dot(rgb, float3(0.30, 0.59, 0.11));
  // convert rgb to four channel pixel including alpha 
  color = float4(luminance, color.a);
 
  // values are normalized, so 0 is no color, 1 is full color
  color.r= color.r * RedRatio;
  color.g= color.g * GreenRatio;
  color.b= color.b * BlueRatio;
  color.a= color.a * AlphaRatio;
 
  return color;
 
}

pixelShader.UriSource = new Uri("/StereoscopeImage;component/Effects/ColorChannelsEffect.ps", UriKind.Relative);

<UserControl x:Class="StereoscopeImage.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"
    xmlns:effects="clr-namespace:Biz.Wolter.Effects"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
 
    <Grid x:Name="LayoutRoot" Background="White">
        <!-- 
            Due to legal issues I did not include the original image. 
            You can either use the URL in a trusted OOB application 
            or just download free images yourself.
        -->
        <Image x:Name="leftImage" Source="http://www.stereomaker.net/galleries/wien/lr/20090921011759_l.jpg" >
            <Image.Effect>
                <effects:ColorChannelsEffect RedRatio="1" GreenRatio="0" BlueRatio="0" AlphaRatio="1" />
            </Image.Effect>
        </Image>
        <Image x:Name="rightImage" Source="http://www.stereomaker.net/galleries/wien/lr/20090921011759_r.jpg" >
            <Image.Effect>
                <effects:ColorChannelsEffect RedRatio="0" GreenRatio="1" BlueRatio="1" AlphaRatio="0" />
            </Image.Effect>
        </Image>
    </Grid>
 
</UserControl>

<UserControl x:Class="StereoscopeVideo.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"
    xmlns:effects="clr-namespace:Biz.Wolter.Effects"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
 
    <Grid x:Name="LayoutRoot" Background="White">
 
        <Rectangle x:Name="leftImage" Stroke="Black">
            <Rectangle.Effect>
                <effects:ColorChannelsEffect RedRatio="1" GreenRatio="0" BlueRatio="0" AlphaRatio="1" />
            </Rectangle.Effect>
        </Rectangle>
        <Rectangle x:Name="rightImage" Stroke="Black">
            <Rectangle.Effect>
                <effects:ColorChannelsEffect RedRatio="0" GreenRatio="1" BlueRatio="1" AlphaRatio="0" />
            </Rectangle.Effect>
        </Rectangle>
 
        <ComboBox DisplayMemberPath="FriendlyName" Height="23" HorizontalAlignment="Left" Margin="12,12,0,0" Name="leftDeviceComboBox" VerticalAlignment="Top" Width="120" />
        <ComboBox DisplayMemberPath="FriendlyName" Height="23" HorizontalAlignment="Left" Margin="12,41,0,0" Name="rightDeviceComboBox" VerticalAlignment="Top" Width="120" />
        <Button Content="Start" Height="23" HorizontalAlignment="Left" Margin="12,70,0,0" Name="startButton" VerticalAlignment="Top" Width="75" Click="startButton_Click" />
 
    </Grid>
 
</UserControl>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Collections.ObjectModel;
 
namespace StereoscopeVideo
{
    public partial class MainPage : UserControl
    {
 
        private CaptureSource leftSource;
        private CaptureSource rightSource;
        private VideoBrush leftVideoBrush;
        private VideoBrush rightVideoBrush;
 
        public MainPage()
        {
            InitializeComponent();
 
            Loaded += new RoutedEventHandler(mainPage_Loaded);
        }
 
        private void mainPage_Loaded(object sender, RoutedEventArgs e)
        {
            ReadOnlyCollection<VideoCaptureDevice> devices = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices();
 
            // set left device collection
            leftDeviceComboBox.ItemsSource = devices;
            // create left capture source (capturing the video)
            leftSource = new CaptureSource();
            // create left video brush (displaying the video)...
            leftVideoBrush = new VideoBrush();
            leftVideoBrush.Stretch = Stretch.Uniform;
            // ...and use this brush to fill the corresponding ui-control
            leftImage.Fill = leftVideoBrush;
 
            rightDeviceComboBox.ItemsSource = devices;
            rightSource = new CaptureSource();
            rightVideoBrush = new VideoBrush();
            rightVideoBrush.Stretch = Stretch.Uniform;
            rightImage.Fill = rightVideoBrush;
        }
 
        private void startButton_Click(object sender, RoutedEventArgs e)
        {
            if (leftDeviceComboBox.SelectedIndex > -1 && rightDeviceComboBox.SelectedIndex > -1)
            {
                startButton.IsEnabled = false; // for testing purpose only one start possble so far
                startCapturing();
            }
            else
            {
                MessageBox.Show("Please choose two input devices first!", "Alert", MessageBoxButton.OK);
            }
        }
 
        private void startCapturing()
        {
 
            leftSource.VideoCaptureDevice = leftDeviceComboBox.SelectedItem as VideoCaptureDevice;
            rightSource.VideoCaptureDevice = rightDeviceComboBox.SelectedItem as VideoCaptureDevice;
 
            if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
            {
                leftSource.Start();
                leftVideoBrush.SetSource(leftSource);
 
                if (leftSource.VideoCaptureDevice != rightSource.VideoCaptureDevice)
                {
                    rightSource.Start();
                    rightVideoBrush.SetSource(rightSource);
                }
                else
                {
                    MessageBox.Show("Only one innput device does not really make sense for this 3D application!", "Alert", MessageBoxButton.OK);
                    rightVideoBrush.SetSource(leftSource);
                }
            }
 
        }
    }
}

// Die notwendigen Klassen sind in Flash CS4 und CS5 automatisch bekannt.
// Im Flex/Flash Builder müssen die Klassen importiert werden.
 
// Abonniere Ereignis, um das Drücken der Tasten zu erfahren
stage.addEventListener(KeyboardEvent.KEY_DOWN, application_keyDownHandler);
 
// Ereignismethode, um das Drücken der Tasten zu verarbeiten
function application_keyDownHandler(event:KeyboardEvent):void {
	trace("Taste gedrückt/wiederholt");
	trace("Tastencode: " + event.keyCode);
	trace("Zeichencode: " + event.charCode);
	trace("Zeichen: " + String.fromCharCode(event.charCode));
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" creationComplete="creationCopmplete_handler(event);">
 
	<mx:Script>
		<![CDATA[
			import mx.events.FlexEvent;
			private function creationCopmplete_handler(event:FlexEvent):void {
				throw new Error("Forced Error");
			}
		]]>
	</mx:Script>
 
</mx:Application>

var v:Vector.<String>;
v = new Vector.<String>();

CONFIG::FLASH_AUTHORING {
	trace("Foo");
}
trace(CONFIG::FLASH_AUTHORING);