SpellCheck.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / System / Windows / Controls / SpellCheck.cs / 1305600 / SpellCheck.cs
                        
                        
                            //---------------------------------------------------------------------------- 
//
// File: SpellCheck.cs
//
// Copyright (C) Microsoft Corporation.  All rights reserved. 
//
// Description: Speller properties for TextBoxBase. 
// 
//---------------------------------------------------------------------------
 
namespace System.Windows.Controls
{
    using System.Threading;
    using System.Windows.Documents; 
    using System.Windows.Controls.Primitives;
    using System.ComponentModel; 
    using System.Collections.Generic; 
    using System.Collections;
    using System.Windows.Markup; 

    /// 
    /// Speller properties for TextBoxBase.
    ///  
    public sealed class SpellCheck
    { 
        //----------------------------------------------------- 
        //
        //  Constructors 
        //
        //-----------------------------------------------------

        #region Constructors 

        // Ctor. 
        internal SpellCheck(TextBoxBase owner) 
        {
            _owner = owner; 
        }

        #endregion Constructors
 
        //------------------------------------------------------
        // 
        //  Public Properties 
        //
        //----------------------------------------------------- 

        #region Public Properties

        ///  
        /// Enables and disables spell checking within the associated TextBoxBase.
        ///  
        ///  
        /// Defaults to false.
        ///  
        public bool IsEnabled
        {
            get
            { 
                return (bool)_owner.GetValue(IsEnabledProperty);
            } 
 
            set
            { 
                _owner.SetValue(IsEnabledProperty, value);
            }
        }
 
        /// 
        /// Enables and disables spell checking within a TextBoxBase. 
        ///  
        public static void SetIsEnabled(TextBoxBase textBoxBase, bool value)
        { 
            if (textBoxBase == null)
            {
                throw new ArgumentNullException("textBoxBase");
            } 

            textBoxBase.SetValue(IsEnabledProperty, value); 
        } 

        ///  
        /// Gets if spell checking is enabled within a TextBoxBase.
        /// 
        public static bool GetIsEnabled(TextBoxBase textBoxBase)
        { 
            if (textBoxBase == null)
            { 
                throw new ArgumentNullException("textBoxBase"); 
            }
 
            return (bool)textBoxBase.GetValue(IsEnabledProperty);
        }

        ///  
        /// Enables and disables spell checking within the associated TextBoxBase.
        ///  
        ///  
        /// Defaults to false.
        ///  
        public static readonly DependencyProperty IsEnabledProperty =
                DependencyProperty.RegisterAttached(
                        "IsEnabled",
                        typeof(bool), 
                        typeof(SpellCheck),
                        new FrameworkPropertyMetadata(new PropertyChangedCallback(OnIsEnabledChanged))); 
 
        /// 
        /// The spelling reform mode for the associated TextBoxBase. 
        /// 
        /// 
        /// In languages with reformed spelling rules (such as German or French),
        /// this property specifies whether to apply old (prereform) or new 
        /// (postreform) spelling rules to examined text.
        ///  
        public SpellingReform SpellingReform 
        {
            get 
            {
                return (SpellingReform)_owner.GetValue(SpellingReformProperty);
            }
 
            set
            { 
                _owner.SetValue(SpellingReformProperty, value); 
            }
        } 


        /// 
        /// Sets the spelling reform mode for a TextBoxBase. 
        /// 
        public static void SetSpellingReform(TextBoxBase textBoxBase, SpellingReform value) 
        { 
            if (textBoxBase == null)
            { 
                throw new ArgumentNullException("textBoxBase");
            }

            textBoxBase.SetValue(SpellingReformProperty, value); 
        }
 
        ///  
        /// The spelling reform mode for the associated TextBoxBase.
        ///  
        /// 
        /// In languages with reformed spelling rules (such as German or French),
        /// this property specifies whether to apply old (prereform) or new
        /// (postreform) spelling rules to examined text. 
        /// 
        public static readonly DependencyProperty SpellingReformProperty = 
                DependencyProperty.RegisterAttached( 
                        "SpellingReform",
                        typeof(SpellingReform), 
                        typeof(SpellCheck),
                        new FrameworkPropertyMetadata(Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName == "de" ? SpellingReform.Postreform : SpellingReform.PreAndPostreform,
                                                      new PropertyChangedCallback(OnSpellingReformChanged)));
 
        /// 
        /// Custom dictionary locations 
        ///  
        public IList CustomDictionaries
        { 
            get
            {
                return (IList)_owner.GetValue(CustomDictionariesProperty);
            } 
        }
 
        ///  
        /// Gets the collection of custom dictionaries used for spell checking of custom words.
        ///  
        /// 
        /// 
        public static IList GetCustomDictionaries(TextBoxBase textBoxBase)
        { 
            if (textBoxBase == null)
            { 
                throw new ArgumentNullException("textBoxBase"); 
            }
            return (IList)textBoxBase.GetValue(CustomDictionariesProperty); 
        }

        private static readonly DependencyPropertyKey CustomDictionariesPropertyKey =
                DependencyProperty.RegisterAttachedReadOnly( 
                        "CustomDictionaries",
                        typeof(IList), 
                        typeof(SpellCheck), 
                        new FrameworkPropertyMetadata(new DictionaryCollectionFactory()));
 
        /// 
        /// Attached property representing location of custom dicitonaries for given 
        /// 
        public static readonly DependencyProperty CustomDictionariesProperty = CustomDictionariesPropertyKey.DependencyProperty; 

        #endregion Public Properties 
 
        //------------------------------------------------------
        // 
        //  Private Methods
        //
        //------------------------------------------------------
 
        #region Private Methods
 
        // Callback for changes to the IsEnabled property. 
        private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            TextBoxBase textBoxBase = d as TextBoxBase;

            if (textBoxBase != null)
            { 
                TextEditor textEditor = TextEditor._GetTextEditor(textBoxBase);
 
                if (textEditor != null) 
                {
                    textEditor.SetSpellCheckEnabled((bool)e.NewValue); 
                    if ((bool)e.NewValue != (bool)e.OldValue)
                    {
                        textEditor.SetCustomDictionaries((bool)e.NewValue);
                    } 
                }
            } 
        } 

        // SpellingReformProperty change callback. 
        private static void OnSpellingReformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            TextBoxBase textBoxBase = d as TextBoxBase;
 
            if (textBoxBase != null)
            { 
                TextEditor textEditor = TextEditor._GetTextEditor(textBoxBase); 

                if (textEditor != null) 
                {
                    textEditor.SetSpellingReform((SpellingReform)e.NewValue);
                }
            } 
        }
 
        #endregion Private Methods 

        //----------------------------------------------------- 
        //
        //  Internal Types
        //
        //------------------------------------------------------ 
        internal class DictionaryCollectionFactory : MS.Internal.DefaultValueFactory
        { 
            internal DictionaryCollectionFactory() 
            { }
            internal override object DefaultValue 
            {
                get
                {
                    return null; 
                }
            } 
            internal override object CreateDefaultValue(DependencyObject owner, DependencyProperty property) 
            {
                return new CustomDictionarySources(owner as TextBoxBase); 
            }
        }

        //----------------------------------------------------- 
        //
        //  Private Fields 
        // 
        //-----------------------------------------------------
 
        #region Private Fields


        // TextBoxBase mapped to this object. 
        private readonly TextBoxBase _owner;
 
        #endregion Private Fields 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
SpellCheck.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
