protected override Tuple<string, string> GetCollectionPathAndPropertyNameForOption(IOption key, string languageName)
        {
            if (key.Feature == EditorComponentOnOffOptions.OptionName)
            {
                return Tuple.Create(@"Roslyn\Internal\OnOff\Components", key.Name);
            }
            else if (key.Feature == InternalFeatureOnOffOptions.OptionName)
            {
                return Tuple.Create(@"Roslyn\Internal\OnOff\Features", key.Name);
            }
            else if (key.Feature == PerformanceFunctionIdOptionsProvider.Name)
            {
                return Tuple.Create(@"Roslyn\Internal\Performance\FunctionId", key.Name);
            }
            else if (key.Feature == LoggerOptions.FeatureName)
            {
                return Tuple.Create(@"Roslyn\Internal\Performance\Logger", key.Name);
            }
            else if (key.Feature == InternalDiagnosticsOptions.OptionName)
            {
                return Tuple.Create(@"Roslyn\Internal\Diagnostics", key.Name);
            }
            else if (key.Feature == InternalSolutionCrawlerOptions.OptionName)
            {
                return Tuple.Create(@"Roslyn\Internal\SolutionCrawler", key.Name);
            }
            else if (key.Feature == CacheOptions.FeatureName)
            {
                return Tuple.Create(@"Roslyn\Internal\Performance\Cache", key.Name);
            }

            throw ExceptionUtilities.Unreachable;
        }

 public override bool DisplayOptionToUser(IOption option, Interfaces.IScriptBaseObject iteratorObject)
 {
     try
     {
         if (option.DisplayToUserValue.HasValue)
         {
             return option.DisplayToUserValue.Value;
         }
         if (string.IsNullOrEmpty(option.DisplayToUserFunction))
         {
             return true;
         }
         if (iteratorObject == null)
         {
             object[] parameters = new object[0];
             return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters);
         }
         else
         {
             object[] parameters = new object[] { iteratorObject };
             return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters);
         }
     }
     catch (MissingMethodException)
     {
         object[] parameters = new object[] { iteratorObject };
         return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters);
     }
 }

 public static ITaggerEventSource OnOptionChanged(
     ITextBuffer subjectBuffer,
     IOption option,
     TaggerDelay delay)
 {
     return new OptionChangedEventSource(subjectBuffer, option, delay);
 }

		public void AddSubOption(IOption option, PolicyOptionScopeEnum policyScope)
		{
			option.PropertyChanged += OnPropertyChanged;
            if (SubOptions[(int)policyScope] != null)
                throw new InvalidOperationException("Duplicate policy scope specified for same area option");
            SubOptions[(int)policyScope] = option;
		}

        /// <summary>
        /// Returns the Greek object for a given Greek name
        /// </summary>
        /// <param name="greek">Greek name</param>
        /// <param name="option">Option object</param>
        /// <returns></returns>
        public static IGreek Create(GreekName greek, IOption option)
        {
            IGreek calculatedGreek = null;

            switch (greek)
            {
                case GreekName.Delta:
                    calculatedGreek = new Delta(option);
                    break;
                case GreekName.Gamma:
                    calculatedGreek = new Gamma(option);
                    break;
                case GreekName.Theta:
                    calculatedGreek = new Theta(option);
                    break;
                case GreekName.Vega:
                    calculatedGreek = new Vega(option);
                    break;
                case GreekName.Rho:
                    calculatedGreek = new Rho(option);
                    break;
                default:
                    break;
            }

            return calculatedGreek;
        }

 private void AddOption(StackPanel panel, IOption option)
 {
     var uiElement = CreateControl(option);
     if (uiElement != null)
     {
         panel.Children.Add(uiElement);
     }
 }

 private void AddPerLanguageOption(StackPanel panel, IOption option, string languageName)
 {
     var uiElement = CreateControl(option, languageName);
     if (uiElement != null)
     {
         panel.Children.Add(uiElement);
     }
 }

 protected void AddOption(Panel panel, IOption option, string additional = null)
 {
     var uiElement = CreateControl(option, additional: additional);
     if (uiElement != null)
     {
         panel.Children.Add(uiElement);
     }
 }

        public IEnumerable<IOption> GetSubOptions(IOption selectedOption, string term)
        {
            var fileOption = selectedOption as FileOption;
            if(fileOption == null)
                return Enumerable.Empty<IOption>();

            return new IOption[] { new OpenContainingDirectoryOption(fileOption) };
        }

        public AlreadySelectedException(IOptionGroup group, IOption option, IOption selected)
            : this("The option '" + option.Key() + "' was specified but an option from this group "
				   + "has already been selected: '" + selected.Key() + "'")
        {
            OptionGroup = group;
            Option = option;
            SelectedOption = selected;
        }

        public AbstractCheckBoxViewModel(IOption option, string description, string truePreview, string falsePreview, AbstractOptionPreviewViewModel info)
        {
            _truePreview = truePreview;
            _falsePreview = falsePreview;

            Info = info;
            Option = option;
            Description = description;
        }

 public CheckBoxOptionViewModel(IOption option, string description, string truePreview, string falsePreview, AbstractOptionPreviewViewModel info, OptionSet options)
 {
     this.Option = option;
     Description = description;
     _truePreview = truePreview;
     _falsePreview = falsePreview;
     _info = info;
     SetProperty(ref _isChecked, (bool)options.GetOption(new OptionKey(option, option.IsPerLanguage ? info.Language : null)));
 }

		public GeneralOptionView(IOption option)
		{
			if(option == null)
				throw new ArgumentNullException("option");

			_option = option;

			//初始化窗体组件
			InitializeComponent();
		}

        public IEnumerable<IOption> GetSubOptions(IOption selectedOption, string term)
        {
            var option = selectedOption as ModuleOption;
            if(option == null) return Enumerable.Empty<IOption>();

            if(option.Module == this)
                return _modules.Value.Select(m => new ModuleOption(m)).FuzzySearch(term).Fetch();

            return option.Module.GetOptions(term);
        }

 public ActionButton(string _txt, string _assetName, Rectangle _rect, Game1.Actions _actionType, Game1 _game1, IOption<Animal> _animal)
 {
     this.txt = _txt;
     this.assetName = _assetName;
     this.rect = _rect;
     this.actionType = _actionType;
     this.animal = _animal;
     _game1.buttonList.Add(this);
     this.game1 = _game1;
 }

 internal static bool MatchesSearch(IOption opt, string searchText)
 {
     if (!string.IsNullOrEmpty(opt.DisplayName))
     {
         int dispIndex = opt.DisplayName.IndexOf(searchText, 0, StringComparison.InvariantCultureIgnoreCase);
         if (dispIndex != -1)
             return true;
     }
     int index = opt.Name.IndexOf(searchText, 0, StringComparison.InvariantCultureIgnoreCase);
     return (index > -1);
 }

        public CheckBoxWithComboOptionViewModel(IOption option, string description, string truePreview, string falsePreview, AbstractOptionPreviewViewModel info, OptionSet options, IList<NotificationOptionViewModel> items)
            : base(option, description, truePreview, falsePreview, info)
        {
            NotificationOptions = items;

            var codeStyleOption = ((CodeStyleOption<bool>)options.GetOption(new OptionKey(option, option.IsPerLanguage ? info.Language : null)));
            SetProperty(ref _isChecked, codeStyleOption.Value);

            var notificationViewModel = items.Where(i => i.Notification.Value == codeStyleOption.Notification.Value).Single();
            SetProperty(ref _selectedNotificationOption, notificationViewModel);
        }

        private TreeNode CreateOptionNode(TreeNode containerNode, IOption option)
        {
            TreeNode node = new TreeNode(option.VariableName) { Tag = option };
            containerNode.Nodes.Add(node);
            UpdateTreeNodeText(option, "VariableName", node);
            // On force une mise à jour pour mettre l'interface à jour
            string a = option.VariableName;
            option.VariableName = string.Empty;
            option.VariableName = a;

            return node;
        }

        private void SetChangedOption(IOptionService optionService, IOption option, string languageName)
        {
            OptionKey key = new OptionKey(option, languageName);

            object currentValue;
            if (this.TryFetch(key, out currentValue))
            {
                OptionSet optionSet = optionService.GetOptions();
                optionSet = optionSet.WithChangedOption(key, currentValue);

                optionService.SetOptions(optionSet);
            }
        }

        private string[] ExtractOptionArgs(Queue<string> argQueue, IOption option)
        {
            string[] arguments;
            if (option != null && option.ParameterCount > 0 && argQueue.Count > 0 && !argQueue.Peek().StartsWith("/"))
            {
                if (option.IsBoolean && !IsBoolValue(argQueue.Peek()))
                    arguments = new string[] {};
                else
                    arguments = option.ParameterCount == 1 ? new[] { argQueue.Dequeue() } : argQueue.Dequeue().Split(',');
            }
            else
                arguments = new string[] {};

            return arguments;
        }