protected virtual FrameworkElement CreateComboBox(PropertyItem pi, PropertyControlFactoryOptions options)
 {
     var cbox = new ComboBox() { IsEditable = true };
     cbox.SetBinding(Selector.SelectedItemProperty, new Binding(pi.Descriptor.Name + ".Text"));
     cbox.SetBinding(ItemsControl.ItemsSourceProperty, new Binding(pi.Descriptor.Name + ".Values"));
     return cbox;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="label"></param>
        /// <param name="property"></param>
        public DateTimeEditor(PropertyLabel label, PropertyItem property)
            : base(property)
        {
            currentValue = property.Value;
              property.PropertyChanged += property_PropertyChanged;
              property.ValueError += property_ValueError;

              contentPanel = new StackPanel();
              this.Content = contentPanel;

              datePicker = new DatePicker
              {
            Visibility = Visibility.Visible,
            Margin = new Thickness(0),
            VerticalAlignment = VerticalAlignment.Center,
            HorizontalAlignment = HorizontalAlignment.Stretch
              };

              datePicker.CalendarOpened += dtp_CalendarOpened;
              datePicker.CalendarClosed += dtp_CalendarClosed;
              datePicker.LostFocus += dtp_LostFocus;
              contentPanel.Children.Add(datePicker);
              datePicker.Focus();

              this.ShowTextBox();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PropertyItemValue"/> class.
        /// </summary>
        /// <param name="property">The property.</param>
        public PropertyItemValue(PropertyItem property)
        {
            if (property == null) throw new ArgumentNullException("property");
              this._property = property;

              _hasSubProperties = property.Converter.GetPropertiesSupported();

              if (_hasSubProperties)
              {
            object value = property.GetValue();

            PropertyDescriptorCollection descriptors = property.Converter.GetProperties(value);
            foreach (PropertyDescriptor d in descriptors)
            {
              _subProperties.Add(new PropertyItem(property.Owner, value, d));
              // TODO: Move to PropertyData as a public property
              NotifyParentPropertyAttribute notifyParent = d.Attributes[KnownTypes.Attributes.NotifyParentPropertyAttribute] as NotifyParentPropertyAttribute;
              if (notifyParent != null && notifyParent.NotifyParent)
              {
            d.AddValueChanged(value, NotifySubPropertyChanged);
              }
            }
              }

              this._property.PropertyChanged += new PropertyChangedEventHandler(ParentPropertyChanged);
        }

		/// <summary>
		///     Initializes a new instance of the <see cref="PropertyItemValue" /> class.
		/// </summary>
		/// <param name="property">The property.</param>
		public PropertyItemValue(PropertyItem property)
		{
			if (property == null) throw new ArgumentNullException("property");
			_property = property;

			_hasSubProperties = property.Converter.GetPropertiesSupported();

			if (_hasSubProperties)
			{
				var value = property.GetValue();

				var descriptors = property.Converter.GetProperties(value);
				foreach (PropertyDescriptor d in descriptors)
				{
					_subProperties.Add(new PropertyItem(property.Owner, value, d));
					// TODO: Move to PropertyData as a public property
					var notifyParent =
						d.Attributes[KnownTypes.Attributes.NotifyParentPropertyAttribute] as NotifyParentPropertyAttribute;
					if (notifyParent != null && notifyParent.NotifyParent)
					{
						d.AddValueChanged(value, NotifySubPropertyChanged);
					}
				}
			}

			if (property.IsCollection)
			{
				LoadCollectionValues();
			}

			_property.PropertyChanged += ParentPropertyChanged;
		}

        public StringEditor(PropertyLabel label, PropertyItem property)
            : base(property)
        {
            if (property.PropertyType == typeof(Char))
              {
            if ((char)property.Value == '\0')
              property.Value = "";
              }

              property.PropertyChanged += property_PropertyChanged;
              property.ValueError += property_ValueError;

              textBox = new TextBox
              {
            Height = 20,
            Foreground = Property.CanWrite ? Brushes.Black : Brushes.Gray,
            BorderThickness = new Thickness(0),
            Margin = new Thickness(0),
            IsReadOnly = !Property.CanWrite
              };

              if (null != property.Value)
            textBox.Text = property.Value.ToString();

              if (Property.CanWrite)
            textBox.TextChanged += Control_TextChanged;

              Content = textBox;
              GotFocus += StringValueEditor_GotFocus;
        }

        public PersonAdapter(PersonViewModel viewModel)
        {
            items = new List<Item> ();

            foreach (var pg in viewModel.PropertyGroups) {
                items.Add (new MainHeaderItem (pg.Title));
                foreach (var p in pg.Properties) {

                    PropertyItem item;

                    switch (p.Type) {
                    case PersonViewModel.PropertyType.Phone:
                        item = new PhonePropertyItem (p);
                        break;
                    case PersonViewModel.PropertyType.Email:
                        item = new EmailPropertyItem (p);
                        break;
                    case PersonViewModel.PropertyType.Url:
                        item = new UrlPropertyItem (p);
                        break;
                    case PersonViewModel.PropertyType.Twitter:
                        item = new TwitterPropertyItem (p);
                        break;
                    default:
                        item = new PropertyItem (p);
                        break;
                    }

                    items.Add (item);
                }
            }
        }

 public ButtonEditor(PropertyLabel label, PropertyItem property)
     : base(property)
 {
     var button = new Button { Content = "..." };
       button.Click += (sender, e) => MessageBox.Show("Custom dialog comes here...");
       this.Content = button;
 }

        public StringValueEditor(PropertyGridLabel label, PropertyItem property)
            : base(label, property)
        {
            if (property.PropertyType == typeof(Char))
            {
                if ((char)property.Value == '\0')
                    property.Value = "";
            }

            property.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(property_PropertyChanged);
            property.ValueError += new EventHandler<ExceptionEventArgs>(property_ValueError);

            txt = new TextBox();
            txt.Height = 20;
            if (null != property.Value)
                txt.Text = property.Value.ToString();
            //txt.IsReadOnly = !this.Property.CanWrite;
            txt.Foreground = this.Property.CanWrite ? new SolidColorBrush(Colors.Black) : new SolidColorBrush(Colors.Gray);
            txt.BorderThickness = new Thickness(0);
            txt.Margin = new Thickness(0);

            if (this.Property.CanWrite)
                txt.TextChanged += new TextChangedEventHandler(Control_TextChanged);

            this.Content = txt;
            this.GotFocus += new RoutedEventHandler(StringValueEditor_GotFocus);
        }

        public PersonAdapter (PersonViewModel viewModel)
        {
            items = new List<Item> ();

            foreach (var pg in viewModel.PropertyGroups) {
                items.Add (new MainHeaderItem (pg.Title));
                foreach (var p in pg.Properties) {

                    PropertyItem item;

                    if (p.Type == PersonViewModel.PropertyType.Phone) {
                        item = new PhonePropertyItem (p);
                    } else if (p.Type == PersonViewModel.PropertyType.Email) {
                        item = new EmailPropertyItem (p);
                    } else if (p.Type == PersonViewModel.PropertyType.Url) {
                        item = new UrlPropertyItem (p);
                    } else if (p.Type == PersonViewModel.PropertyType.Twitter) {
                        item = new TwitterPropertyItem (p);
                    } else {
                        item = new PropertyItem (p);
                    }

                    items.Add (item);
                }
            }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="label"></param>
        /// <param name="property"></param>
        public ComboBoxEditorBase(PropertyLabel label, PropertyItem property)
            : base(property)
        {
            currentValue = property.Value;
              property.PropertyChanged += property_PropertyChanged;
              property.ValueError += property_ValueError;

              cbo = new ComboBox
              {
            Visibility = Visibility.Collapsed,
            Margin = new Thickness(0),
            VerticalAlignment = VerticalAlignment.Center,
            HorizontalAlignment = HorizontalAlignment.Stretch
              };

              cbo.DropDownOpened += cbo_DropDownOpened;
              cbo.LostFocus += cbo_LostFocus;

              this.InitializeCombo();

              pnl = new StackPanel();
              pnl.Children.Add(cbo);

              this.ShowTextBox();

              this.Content = pnl;
        }

        //=====================================================================
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="project">The project file reference</param>
        public UserDefinedPropertyEditorDlg(SandcastleProject project)
        {
            PropertyItem propItem;

            InitializeComponent();

            this.Project = project;
            this.UserDefinedProperties = new Collection<PropertyItem>();

            lbProperties.Sorted = true;

            try
            {
                foreach(BuildProperty prop in this.Project.GetUserDefinedProperties())
                {
                    propItem = new PropertyItem(this, prop);
                    this.UserDefinedProperties.Add(propItem);
                    lbProperties.Items.Add(propItem);
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("Unable to load user-defined properties.  " +
                    "Error " + ex.Message, Constants.AppName,
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            lbProperties.Sorted = false;

            if(lbProperties.Items.Count == 0)
                pgProps.Enabled = false;
            else
                lbProperties.SelectedIndex = 0;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyValueChangedEventArgs"/> class.
 /// </summary>
 /// <param name="routedEvent">The routed event.</param>
 /// <param name="property">The property.</param>
 /// <param name="oldValue">The old value.</param>
 public PropertyValueChangedEventArgs(RoutedEvent routedEvent, PropertyItem property, object oldValue)
     : base(routedEvent, property)
 {
     Property = property;
     NewValue = property.PropertyValue;
     OldValue = oldValue;
 }

        public ImageVaueEditor(PropertyGridLabel label, PropertyItem property)
            : base(label, property)
        {
            property.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(property_PropertyChanged);
            property.ValueError += new EventHandler<ExceptionEventArgs>(property_ValueError);

            _attribute = property.GetAttribute<ImageAttribute>();

            if(null == _attribute)
            {
                _attribute = new ImageAttribute();
                _attribute.OnlyImage = false;
            }
            _grid.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1d, GridUnitType.Auto) });
            _grid.ColumnDefinitions.Add(new ColumnDefinition());
            _grid.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1d, GridUnitType.Auto) });
            _grid.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1d, GridUnitType.Auto) });
            _grid.Children.Add(_image);
            _grid.Children.Add(_text);
            _grid.Children.Add(_removeButton);
            _grid.Children.Add(_broswerButton);
            _image.SetValue(Grid.ColumnProperty, 0);
            _text.SetValue(Grid.ColumnProperty, 1);
            _removeButton.SetValue(Grid.ColumnProperty, 2);
            _broswerButton.SetValue(Grid.ColumnProperty, 3);
            this.Content = _grid;
            _broswerButton.Click += BroswerButton_Click;
            _removeButton.Click += RemoveButton_Click;
            UpdateLabel(property.Value);
            _text.GotFocus += Text_GotFocus;
            _text.Background = null;
            _text.BorderBrush = null;
            _text.BorderThickness = new Thickness();
        }

 public override FrameworkElement CreateControl(PropertyItem pi, PropertyControlFactoryOptions options)
 {
     if (pi.Is(typeof(IValueWithSource)))
     {
         return CreateComboBox(pi, options);
     }
     return base.CreateControl(pi, options);
 }

        public void ShouldApplyPropertyReadonlyState()
        {
            PropertyItem property = new PropertyItem(
            new PropertyGrid(),
            new BusinessObject(),
            TypeDescriptor.GetProperties(typeof(BusinessObject))["ReadOnlyProperty"]);

              Assert.IsTrue(property.IsReadOnly);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExtendedPropertyEditorTab"/> class.
        /// </summary>
        /// <param name="property">The property to display extended editor for.</param>
        public ExtendedPropertyEditorTab(PropertyItem property)
            : this()
        {
            if (property == null) throw new ArgumentNullException("property");

              Property = property;
              Header = property.Name;
              Content = CreateContent(property);
        }

    //private SelectValueEditorAttribute _attrs = null;

    /// <summary>
    /// Данный конструктор используется в динамических PropertyGrid, на событии OnCustomEditor
    /// </summary>
    /// <param name="label"></param>
    /// <param name="property"></param>
    /// <param name="attrs"></param>
    public SelectValueEditor(PropertyGridLabel label, PropertyItem property, SelectValueEditorAttribute attrs)
      : base(label, property) {
      var v_attrs = attrs ?? this.Property.GetAttribute<SelectValueEditorAttribute>();
      this.SelectorPlugin = v_attrs.SelectorPluginName;
      this.DisplayField = v_attrs.DisplayFieldName;
      this.ValueField = v_attrs.ValueFieldName;
      this.IsMultiselector = v_attrs.isMultiselector;
      
    }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="label">The associated label for this Editor control</param>
 /// <param name="property">The associated PropertyItem for this control</param>
 public EditorBase(PropertyItem property)
 {
     this.Name = "textBox" + property.Name;
       this.Property = property;
       this.BorderThickness = new Thickness(0);
       this.Margin = new Thickness(0);
       this.HorizontalAlignment = HorizontalAlignment.Stretch;
       this.HorizontalContentAlignment = HorizontalAlignment.Stretch;
 }

 public BrushEditor(PropertyLabel label, PropertyItem property)
     : base(property)
 {
     currentValue = property.Value;
       property.PropertyChanged += property_PropertyChanged;
       property.ValueError += property_ValueError;
       contentPanel = new StackPanel();
       this.Content = contentPanel;
       ShowTextBox();
 }

        public void ShouldClearValue()
        {
            BusinessObject component = new BusinessObject() { Name = "TestName" };
              PropertyItem property = new PropertyItem(new PropertyGrid(), component, BusinessObject.ExtractProperty("Name"));

              Assert.AreEqual<string>("TestName", property.GetValue().ToString());

              property.ClearValue();

              Assert.AreEqual<string>("DefaultName", property.GetValue().ToString());
        }