Ary Boretc.

<TextBox x:Name="uiText" Width="100" Height="30"
    manas:Autocomplete.Suggest="DoSuggest" />

// The texts we want to suggest
private string[] options = new string[]
{
    "Al", "Amiko", "Angla", "Anglujo", "Ankaux", "Antaux", "Atomo", "Auxto",
    "Bebo", "Bela", "Birdo",
}

// The method we have to implement to offer suggestions
public void DoSuggest(string text, SuggestCallback callback)
{
    // Don't suggest if there's no text
    if (text.Length == 0)
    {
        callback(null);
        return;
    }

    var result = new List();

    // See which options have as a prefix the text entered by the user
    foreach (var option in options)
    {
        if (option.StartsWith(text, StringComparison.InvariantCultureIgnoreCase))
        {
            result.Add(new Suggestion() { DisplayString = option,
                                                      ReplaceString = option });
        }
    }

    callback(result.ToArray());
}

using System;
using System.Net;
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;
using System.Diagnostics;

namespace Manas.Silverlight
{

    /// <summary>
    /// Allows reporting suggestions asynchronously.
    /// </summary>
    public delegate void SuggestCallback(Suggestion[] suggestions);

    /// <summary>
    /// Invoked when suggestions are needed.
    /// </summary>
    /// <param name="text">the text to autocomplete</param>
    /// <param name="callback">where to report the suggestions</param>
    public delegate void SuggestHandler(string text, SuggestCallback callback);

    /// <summary>
    /// Each suggestion to report for the autocompletion.
    /// </summary>
    public class Suggestion
    {

        /// <summary>
        /// What to show in the autocomplete popup.
        /// </summary>
        public string DisplayString { get; set; }

        /// <summary>
        /// What to insert as a replacement if this suggestion is selected.
        /// </summary>
        public string ReplaceString { get; set; }

        public override string ToString()
        {
            return DisplayString;
        }

    }

    /// <summary>
    /// Allows adding autocomplete capabilities to a TextBox.
    /// </summary>
    public class Autocomplete
    {

        #region XAML support
        public static readonly DependencyProperty Suggest = DependencyProperty.RegisterAttached("Suggest", typeof(string), typeof(Autocomplete), null);

        public static void SetSuggest(DependencyObject obj, string handler)
        {
            obj.SetValue(Suggest, handler);

            EventSupport.AttachEvent(obj, handler,
                new Type[] { typeof(string), typeof(SuggestCallback) },
                (sender, target, info) =>
                {
                    Autocomplete autocomplete = new Autocomplete(sender as TextBox);
                    autocomplete.SuggestHandler = (text, callback) =>
                    {
                        info.Invoke(target, new object[] { text, callback });
                    };
                });
        }

        public static string GetSuggest(DependencyObject obj)
        {
            return (string)obj.GetValue(Suggest);
        }
        #endregion

        private TextBox textBox;
        private ListBox listBox;

        internal Autocomplete(TextBox textBox)
        {
            this.textBox = textBox;

            textBox.LostFocus += textBox_LostFocus;
            textBox.GotFocus += (s, e) =>
            {
                OfferSuggestions();
            };
            textBox.KeyDown += textBox_KeyDown;
            textBox.KeyUp += textBlock_KeyUp;
        }

        /// <summary>
        /// Adds autocomplete support to the given TextBox.
        /// </summary>
        public Autocomplete(TextBox textBox, SuggestHandler handler)
            : this(textBox)
        {
            this.SuggestHandler = handler;
        }

        internal SuggestHandler SuggestHandler { get; set; }

        void textBox_LostFocus(object sender, RoutedEventArgs e)
        {
            object elem = FocusManager.GetFocusedElement();
            if (elem == listBox)
            {
                return;
            }

            ListBoxItem item = elem as ListBoxItem;
            if (item != null)
            {
                object parent = item.Parent;
                while (!(parent is ListBox) && parent is FrameworkElement)
                {
                    parent = (parent as FrameworkElement).Parent;
                }

                if (parent == listBox)
                {
                    InsertSuggestion();
                }
            }

            HideListBox();
        }

        void textBox_KeyDown(object sender, KeyEventArgs e)
        {
            if (listBox == null) return;

            if (e.Key == Key.Down)
            {
                listBox.SelectedIndex = (listBox.SelectedIndex + 1) % listBox.Items.Count;
            }
            else if (e.Key == Key.Up)
            {
                if (listBox.SelectedIndex == 0)
                {
                    listBox.SelectedIndex = listBox.Items.Count - 1;
                }
                else
                {
                    listBox.SelectedIndex--;
                }
            }
            else if (e.Key == Key.Enter)
            {
                InsertSuggestion();
            }
        }

        void textBlock_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Down || e.Key == Key.Up) return;

            OfferSuggestions();
        }

        void OfferSuggestions()
        {
            SuggestHandler(textBox.Text, Callback);
        }

        void Callback(Suggestion[] suggestions)
        {
            // If there are no suggestions, do nothing
            //                    or
            // If there is only one suggestion but it's the text that we have in the
            // text box, do nothing
            if (suggestions == null ||
                suggestions.Length == 0 ||
                (suggestions.Length == 1 && suggestions[0].ReplaceString == textBox.Text))
            {
                HideListBox();
                return;
            }

            ShowListBox(suggestions.Length);

            listBox.Items.Clear();
            foreach (var suggestion in suggestions)
            {
                listBox.Items.Add(suggestion);
            }

            this.listBox.Dispatcher.BeginInvoke(() =>
            {
                listBox.SelectedIndex = 0;
            });
        }

        void ShowListBox(int count)
        {
            if (listBox == null)
            {
                listBox = new ListBox();
                ScrollViewer.SetVerticalScrollBarVisibility(listBox, ScrollBarVisibility.Visible);
                listBox.SelectionChanged += (s, e) =>
                {
                    if (listBox.SelectedItem != null && listBox.Items.Contains(listBox.SelectedItem))
                    {
                        try
                        {
                            listBox.ScrollIntoView(listBox.SelectedItem);
                        }
                        catch { }
                    }
                };
                listBox.MinWidth = textBox.RenderSize.Width;

                var canvas = (Canvas)System.Windows.Application.Current.RootVisual;
                var transform = textBox.TransformToVisual(canvas);
                var topLeft = transform.Transform(new Point(0, 0));

                Canvas.SetLeft(listBox, topLeft.X);
                Canvas.SetTop(listBox, topLeft.Y + textBox.RenderSize.Height);
                canvas.Children.Add(listBox);
            }

            if (count >= 5)
            {
                count = 5;
            }
            listBox.MaxHeight = count * 21;
        }

        private void InsertSuggestion()
        {
            Suggestion suggestion = listBox.SelectedItem as Suggestion;
            if (suggestion != null)
            {
                textBox.Text = suggestion.ReplaceString;
                textBox.Select(textBox.Text.Length, 0);
            }
        }

        void HideListBox()
        {
            if (listBox != null)
            {
                var canvas = (Canvas)System.Windows.Application.Current.RootVisual;
                canvas.Children.Remove(listBox);
                listBox = null;
            }
        }

    }

}

using System;
using System.Net;
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;
using System.Windows.Browser;

namespace Manas.Silverlight
{
    /// <summary>
    /// Allows embedding a YouTube player inside a Silveright application.
    ///
    /// Invoking the Embed() method of an instance of this class simply creates
    /// a floating div which contains an embedded YouTube flash player. For this
    /// reason, the Top and Left properties are absolute, and not relative to
    /// some particular Silverlight control.
    ///
    /// The Dispose() method removes the div from the page.
    ///
    /// Changing any dimension property of a player when it has already been embeded
    /// updates the div properties to reflect the changes.
    /// </summary>
    public class YouTubePlayer : IDisposable
    {

        /// <summary>
        /// The default with of a player, if none is specified.
        /// </summary>
        public const int DefaultWidth = 425;

        /// <summary>
        /// The default height of a player, if none is specified.
        /// </summary>
        public const int DefaultHeight = 344;

        #region Private properties
        private string uniqueId = Guid.NewGuid().ToString();

        private double top;
        private double left;
        private double height = DefaultHeight;
        private double width = DefaultWidth;

        private string videoId;
        private bool isEmbeded;
        private HtmlElement div;
        #endregion

        /// <summary>
        /// Creates a player for the given video id. You must invoke Embed()
        /// later, to actually insert the video into the page.
        /// </summary>
        /// <param name="videoId"></param>
        public YouTubePlayer(string videoId)
        {
            this.videoId = videoId;
        }

        /// <summary>
        /// The absolute y position of this player.
        /// </summary>
        public double Top
        {
            get { return top; }
            set
            {
                top = value;

                if (isEmbeded)
                {
                    SetStyleProperty(DivId, "top", "\"" + (int)top + "px\"");
                }
            }
        }

        /// <summary>
        /// The absolute x position of this player.
        /// </summary>
        public double Left
        {
            get { return left; }
            set
            {
                left = value;

                if (isEmbeded)
                {
                    SetStyleProperty(DivId, "left", "\"" + (int)left + "px\"");
                }
            }
        }

        /// <summary>
        /// The height of this player.
        /// </summary>
        public double Height
        {
            get { return height; }
            set
            {
                height = value;

                if (isEmbeded)
                {
                    SetAllDivsProperty("height", "\"" + (int)height + "px\"");
                }
            }
        }

        /// <summary>
        /// The width of this player.
        /// </summary>
        public double Width
        {
            get { return width; }
            set
            {
                width = value;

                if (isEmbeded)
                {
                    SetAllDivsProperty("width", "\"" + (int)width + "px\"");
                }
            }
        }

        /// <summary>
        /// Allow fullscreen to be activated?
        /// </summary>
        public bool AllowFullScreen { get; set; }

        /// <summary>
        /// Embeds this player into the HTML page. Invoking this method many
        /// times has no effect. You must invoke Dipose() to remove the player
        /// form the HTML page.
        /// </summary>
        public void Embed()
        {
            if (isEmbeded) return;
            isEmbeded = true;

            div = HtmlPage.Document.CreateElement("div");
            div.SetAttribute("id", DivId);
            div.SetAttribute("style", "position: absolute; width:" + (int)Width + "px; height:" + (int)Height + "px; top: " + (int)Top + "px; left: " + (int)Left + "px; z-index:10");
            div.SetProperty("innerHTML",
                "<object width=\"" + (int)Width + "\" height=\"" + (int)Height + "\" id=\"" + ObjectId + "\">" +
                    "<param name=\"movie\" value=\"http://www.youtube.com/v/" + videoId + "&hl=en&fs=1\"></param>" +
                    "<param name=\"allowFullScreen\" value=\"" + AllowFullScreen + "\"></param>" +
                    "<embed id=\"" + EmbedId + "\" src=\"http://www.youtube.com/v/" + videoId + "&hl=en&fs=1\" type=\"application/x-shockwave-flash\" allowfullscreen=\"" + AllowFullScreen + "\" width=\"" + (int)Width + "\" height=\"" + (int)Height + "\"></embed>" +
                "</object>"
                );

            HtmlPage.Document.Body.AppendChild(div);
        }

        /// <summary>
        /// Removes this embedded player from the HTML page. Has no effect if this
        /// player was not embedded, or is already disposed.
        /// </summary>
        public void Dispose()
        {
            if (!isEmbeded) return;
            isEmbeded = false;

            HtmlPage.Document.Body.RemoveChild(div);
        }

        #region Implementation

        private string DivId { get { return "YouTubePlayer" + uniqueId; } }

        private string ObjectId { get { return "YouTubePlayer_Object_" + uniqueId; } }

        private string EmbedId { get { return "YouTubePlayer_Embed_" + uniqueId; } }

        private void SetAllDivsProperty(string property, object value)
        {
            SetProperty(DivId, property, value);
            SetProperty(ObjectId, property, value);
            SetProperty(EmbedId, property, value);
        }

        private void SetProperty(string divId, string property, object value)
        {
            HtmlPage.Window.Eval("document.getElementById(\"" + divId + "\")." + property + " = " + value + ";");
        }

        private void SetStyleProperty(string divId, string property, object value)
        {
            HtmlPage.Window.Eval("document.getElementById(\"" + divId + "\").style." + property + " = " + value + ";");
        }

        #endregion
    }
}

using System;
using System.Reflection;
using System.Threading;
using System.Windows;
using System.Windows.Input;

namespace Manas.Silverlight {

    /// <summary>
    /// Allows attaching onself to multiple click events in a component, instead 
    /// of sticking with Silverlight single click support only.
    /// 
    /// Usage:
    /// ^^^^^^
    /// MultipleClicks clicks = new MultipleClicks(someUiElmenet);
    /// clicks.MouseLeftButtonDown += (sender, e) => {
    ///   Console.WriteLine("Number of clicks: " + e.Clicks);
    /// };
    /// 
    /// You can limit the number of clicks allowed over an element:
    /// 
    /// MultipleClicks clicks = new MultipleClicks(someUiElmenet, 2);
    /// clicks.MouseLeftButtonDown += (sender, e) => {
    ///   Console.WriteLine("Number of clicks: " + e.Clicks); // allways 1 or 2, no more
    /// };
    /// 
    /// If you are only planning on supporting double click, this is faster 
    /// since if you don't specify a limit, a little time will be wait to see 
    /// if there's a third click before firing the event. If you do specify a 
    /// limit, as soon as the limit is reached, the event will be fired.
    /// 
    /// XAML
    /// ^^^^
    /// You can attach event handlers to a XAML by using the attached 
    /// property Clicks:
    /// 
    /// manas:Mouse.Click="SomeMethod"
    /// 
    /// or
    /// 
    /// manas:Mouse.Click="SomeMethod, limit" 
    /// 
    /// where limit must be an integer, and, of course, SomeMethod must have 
    /// the following signature:
    /// 
    /// public void SomeMethod(object sender, MouseButtonExtendedEventArgs e)
    /// </summary>
    public class Mouse
    {

        #region XAML support
        public static readonly DependencyProperty Click = DependencyProperty.RegisterAttached("Click", typeof(string), typeof(Mouse), null);

        public static void SetClick(DependencyObject obj,
            string handler)
        {
            obj.SetValue(Click, handler);

            // Check if a limit was specified
            int limit = -1;
            int indexOfComma = handler.IndexOf(',');
            if (indexOfComma != -1)
            {
                if (!int.TryParse(handler.Substring(indexOfComma + 1)
                    .Trim(), out limit))
                {
                    throw new ArgumentException("Syntax for Clicks is 'handler[, limit]', but the specified limit isn't a number. It was: '" + limit + "'");
                }

                handler = handler.Substring(0, indexOfComma).Trim();
            }

            EventSupport.AttachEvent(obj, handler, new Type[] { typeof(object), typeof(MouseButtonExtendedEventArgs) }, (sender, target, info) =>
                {
                    Mouse clicks =
                        new Mouse(sender as UIElement, limit);
                    clicks.MouseLeftButtonDown += (sender2, e2) =>
                    {
                        info.Invoke(target,
                            new object[] { sender2, e2 });
                    };
                });
        }

        public static string GetClick(DependencyObject obj)
        {
            return (string)obj.GetValue(Click);
        }
        #endregion

        // How much time to wait before firing the event
        private const int Threshold = 400;

        public event EventHandler<MouseButtonExtendedEventArgs> MouseLeftButtonDown;

        private Timer timer;
        private int clickCount;
        private int limit;

        /// Allows attaching event fired on multiple clicks over the given 
        /// element without limiting the maximum number of clicks.
        /// </summary>
        public Mouse(UIElement elem) : this(elem, -1)
        {
        }

        /// <summary>
        /// Allows attaching event fired on multiple clicks over the 
        /// given element limiting the maximum number of clicks.
        /// </summary>
        public Mouse(UIElement elem, int limit)
        {
            this.limit = limit;
            elem.MouseLeftButtonDown += new MouseButtonEventHandler(elem_MouseLeftButtonDown);
        }

        private void elem_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            clickCount++;

            if (clickCount == limit)
            {
                Fire(sender, e, clickCount);
                return;
            }

            if (timer == null)
            {
                timer = new Timer((state) =>
                {
                    // If there's a limit set and it was reached, then this 
                    // method will be invoked anyway, so only fire it if there's
                    // no limit or the limit was not yet reached
                    if (limit == -1 || clickCount < limit)
                    {
                        Fire(sender, e, clickCount);
                    }

                    // Reset everything for the next click group
                    clickCount = 0;
                    timer.Dispose();
                    timer = null;
                }, null, Threshold, Timeout.Infinite);
            }
            else
            {
                timer.Change(Threshold, Timeout.Infinite);
            }
        }

        // Fires the MouseLeftButtonDown event, *without* setting the 
        // timer to null
        private void Fire(object sender, MouseButtonEventArgs e, int clicks)
        {
            if (MouseLeftButtonDown != null)
            {
                (sender as UIElement).Dispatcher.BeginInvoke(() =>
                {
                    MouseLeftButtonDown(sender, new MouseButtonExtendedEventArgs()
                    {
                        MouseButtonEventArgs = e,
                        Clicks = clicks
                    });
                });
            }
        }
    }

    public class MouseButtonExtendedEventArgs : EventArgs
    {

        /// <summary>
        /// The original MouseButtonEventArgs.
        /// </summary>
        public MouseButtonEventArgs MouseButtonEventArgs { get; set; }

        /// <summary>
        /// The number of clicks. This is allways >= 1.
        /// </summary>
        public int Clicks { get; set; }

    }

    /// <summary>
    /// Indicates how to attach an event to the given target.
    /// </summary>
    /// <param name="sender">the object that fired the event</param>
    /// <param name="target">the object to which an event must be attached</param>
    /// <param name="method">the method to invoke in the event handler</param>
    public delegate void EventAttacher(object sender,
        DependencyObject target, MethodInfo method);

    /// <summary>
    /// Support for attaching to an event based on the name of a method.
    /// </summary>
    public static class EventSupport
    {

        /// <summary>
        /// Attaches an event to the first Parent of obj (which must be a 
        /// FrameworkElement) which declares a public method with the name 
        /// "handler" and arguments of types "types".
        /// 
        /// When that method is found, attacher is invoked with:
        /// - sender is "obj"
        /// - target is the Parent that declares the method
        /// - method is the method of Parent
        /// </summary>
        /// <param name="obj">the object to which to attach an event</param>
        /// <param name="handler">the name of the method to be found in some Parent of obj</param>
        /// <param name="attacher">indicates how to attach an event to the target</param>
        public static void AttachEvent(DependencyObject obj, string handler, Type[] types, EventAttacher attacher)
        {
            FrameworkElement fe = obj as FrameworkElement;
            if (fe == null)
            {
                throw new ArgumentException("Can only attach events to FrameworkElement instances, not to '" + obj.GetType() + "'");
            }

            fe.Loaded += (sender, e) =>
            {
                DependencyObject parent = sender as DependencyObject;

                MethodInfo info = null;
                while (info == null)
                {
                    info = parent.GetType().GetMethod(handler, types);
                    if (info != null)
                    {
                        attacher(sender, parent, info);
                        return;
                    }

                    if (parent is FrameworkElement)
                    {
                        parent = (parent as FrameworkElement).Parent;
                    }
                    else
                    {
                        parent = null;
                    }

                    if (parent == null)
                    {
                        throw new ArgumentException("Can't find handler '" + handler + "' (maybe it's not public?)");
                    }
                }
            };
        }

    }

}