Создание описателя элемента управления и расширения программы Конструктор Web-разметок

<?xml version="1.0" encoding="utf-8" ?>
<Controls>
  <Control Name="RefCases" ControlGroupResourceKey="ControlGroup_Directories"  ResourceKey="Control_RefCases">
    <Properties>
    (1)
      <Property Type="Name" /> (2)
      <Property Type="PlaceHolder" /> (3)
      <Property Type="Tip" /> (4)
      <Property Type="LabelText" />
      <Property Type="ShowEmptyLabel" />
      <Property Type="Visibility" />
      <Property Type="StandardCssClass" DefaultValue="ref-cases" />
      <Property Type="CustomCssClasses" />
      <Property Type="TabStop" DefaultValue="True" />
      <Property Type="Required" />

    (5)
      <Property Type="ExtendedDataSource" /> (6)
      <Property Type="DataSource" /> (7)
      <Property Type="DataField" Editor="RefCasesFieldMetadataEditor" />
      <Property Type="Binding" BindingConverter="RefCasesConverter" /> (8)
      <Property Type="EditOperation" /> (9)

      <Property Name="RootSection" ResourceKey="Control_RefCases_Section"
                Category="BehaviorCategory" DataType="System.Guid"
                Editor="RefCasesSectionEditor" /> (10)
    </Properties>
    <Events> (11)
      <Event Name="Click" ResourceKey="ControlTypes_ClickEventProperty" />
      <Event Name="MouseOver" ResourceKey="ControlTypes_MouseOverEventProperty" /> (12)
      <Event Name="MouseOut" ResourceKey="ControlTypes_MouseOutEventProperty" /> (13)
      <Event Name="DataChanged" ResourceKey="ControlTypes_DataChangedEventProperty" /> (14)
    </Events>
  </Control>
</Controls>

using DocsVision.Platform.Tools.LayoutEditor.Extensibility;
using RefCasesDesignerExtension.Editors;
using System;
using System.Collections.Generic;
using System.Resources;

(1)
namespace RefCasesDesignerExtension.Extension
{
    class RefCasesDesignerExtension : WebLayoutsDesignerExtension
    {
        public RefCasesDesignerExtension(IServiceProvider provider)
            : base(provider)
        {
        }

        protected override Dictionary<string, Type> GetEditors()
        {
            return new Dictionary<string, Type>
            {
                { "RefCasesFieldMetadataEditor", typeof(RefCasesFieldMetadataEditor)}, (2)
                { "RefCasesSectionEditor", typeof(RefCasesSectionEditor)} (3)
            };
        }

        protected override List<ResourceManager> GetResourceManagers()
        {
            return new List<ResourceManager>
            {
                Resources.ResourceManager
            };
        }
    }
}

using DocsVision.BackOffice.WebLayoutsDesigner.Editors;
using DocsVision.Platform.Data.Metadata.CardModel;
using System;
using System.Windows;
using Xceed.Wpf.Toolkit.PropertyGrid;
using Xceed.Wpf.Toolkit.PropertyGrid.Editors;

namespace RefCasesDesignerExtension.Editors
{
    public class RefCasesFieldMetadataEditor : ITypeEditor (1)
    {
        public FrameworkElement ResolveEditor(PropertyItem propertyItem)
        {
            var refCasesID = new Guid("246197EA-846A-44DA-9EA3-0BCAE5500388");
            var sectionCasesID = new Guid("56AF8231-B918-42D4-AC15-90EC2E9A0725");

            var editor = new FieldMetadataEditor
            {
                FieldFilter = (field) => (2)
                {
                    return field.FieldType == FieldType.RefId
                    && field.LinkedCardTypeId == refCasesID
                    && field.LinkedSectionId == sectionCasesID;
                }
            };

            return editor.ResolveEditor(propertyItem);
        }

    }
}

var editor = new FieldMetadataEditor
{
    FieldFilter = (field) =>
    {
        return field.FieldType == FieldType.UniqueId; (1)
    }
};

using DocsVision.Platform.Tools.LayoutEditor;
using DocsVision.Platform.Tools.LayoutEditor.PropertiesEditor;
using DocsVision.Platform.WebClient;
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using Xceed.Wpf.Toolkit.PropertyGrid.Editors;

namespace RefCasesDesignerExtension.Editors
{
    public partial class RefCasesSectionEditor : UserControl, ITypeEditor
    {
        public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(Guid), typeof(RefCasesSectionEditor),(1)
        new FrameworkPropertyMetadata(Guid.Empty, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
        public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(RefCasesSectionEditor), new FrameworkPropertyMetadata(string.Empty));

        public Guid Value (2)
        {
            get { return (Guid)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        public string Text (3)
        {
            get { return (string)GetValue(TextProperty); }
            set {
                SetValue(TextProperty, value);
                Clear.Visibility = value != ""? Visibility.Visible: Visibility.Collapsed; (4)
            }
        }

        private IServiceProvider serviceProvider;
        private SessionContext sessionContext;

        public RefCasesSectionEditor()
        {
            InitializeComponent();
        }

        public FrameworkElement ResolveEditor(Xceed.Wpf.Toolkit.PropertyGrid.PropertyItem propertyItem) (5)
        {
            var bindingObject = (IControlPropertiesObject)propertyItem.Instance;

            this.serviceProvider = bindingObject.ServiceProvider; (6)
            var currentObjectContextProvider = ServiceUtil.GetService<ICurrentObjectContextProvider>(this.serviceProvider);
            this.sessionContext = currentObjectContextProvider.GetOrCreateCurrentSessionContext();

            Binding binding = new Binding("Value"); (7)
            binding.Source = propertyItem;
            binding.Mode = propertyItem.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay;
            BindingOperations.SetBinding(this, RefCasesSectionEditor.ValueProperty, binding);

            if (this.Value != Guid.Empty) (8)
                this.Text = new RefCasesUtils(sessionContext).GetSectionTitle(this.Value);

            return this;
        }

        private void ShowSections_Click(object sender, RoutedEventArgs e) (9)
        {
            var sectionTree = new SectionsTree(sessionContext);
            if (sectionTree.ShowDialog() == true)
            {
                this.Value = sectionTree.SelectedNodeID;
                this.Text = sectionTree.SelectedNodeText;
            }
        }

        private void Clear_Click(object sender, RoutedEventArgs e) (10)
        {
            this.Value = Guid.Empty;
            this.Text = "";
        }
    }
}

public string GetSectionTitle(Guid sectionId)
{
    SectionData sectionSesction = cardManager.GetDictionaryData(refCasesId).Sections[sectionsSectionID]; (1) (2) (3)

    if (sectionSesction.RowExists(sectionId) == false) (4)
        return "Ошибка!";

    RowData sectionRow = sectionSesction.GetRow(sectionId);
    RowData yearRow = sectionRow.SubSection.ParentRow;

    if (yearRow != null)
        return string.Format("{0}. {1}", yearRow["Year"], sectionRow["Name"].ToString());

    return "Ошибка!";
}

using Docsvision.Platform.WebClient;
using System;
using System.Windows;

namespace RefCasesDesignerExtension.Editors
{

    public partial class SectionsTree : Window
    {
        public string SelectedNodeText = "";
        public Guid SelectedNodeID = Guid.Empty;
        private RefCasesUtils refCasesUtils;

        public SectionsTree(SessionContext sessionContext)
        { (1)
            InitializeComponent();
            refCasesUtils = new RefCasesUtils(sessionContext);

            Years.ItemsSource = refCasesUtils.GetYears(); (2)
        }

        private void Years_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e) (3)
        {
            if (Years.SelectedIndex == -1 || !(Years.SelectedItem is Year))
                return;

            Year selectedYear = Years.SelectedItem as Year;

            Sections.ItemsSource = refCasesUtils.GetSections(selectedYear.ID); (4)
        }

        private void Accept_Click(object sender, RoutedEventArgs e) (5)
        {
            if (Sections.SelectedItem == null)
                return;
            var selectedNode = Sections.SelectedItem as Node;
            var selectedYear = Years.SelectedItem as Year;

            this.SelectedNodeText = string.Format("{0}. {1}", selectedYear.Value, selectedNode.Name);
            this.SelectedNodeID = selectedNode.ID;

            this.DialogResult = true;
            this.Close();
        }

        private void Cancel_Click(object sender, RoutedEventArgs e) (6)
        {
            this.Close();
        }
    }
}

public IEnumerable<Year> GetYears()
{
    refCasesData = cardManager.GetDictionaryData(refCasesId);
    SectionData yearSection = refCasesData.Sections[yearsSectionId];

    return yearSection.Rows.Select<RowData, Year>(row => new Year() { ID = row.Id, Value = row["Year"].ToString() });
}

public List<Node> GetSections(Guid yearID)
{
    var yearSection = refCasesData.Sections[yearsSectionId];

    if (yearSection.RowExists(yearID)) {
        RowDataCollection sectionRows = yearSection.GetRow(yearID).ChildSections[sectionsSectionID].Rows;

        return GetNodesFromRows(sectionRows);
    }

    return new List<Node>();
}

List<Node> GetNodesFromRows(RowDataCollection rows) (1)
{
    var nodes = new List<Node>();

    foreach (var row in rows)
    {
        var node = new Node() { ID = row.Id, Name = row["Name"].ToString() };
        if (row.HasChildRows)
            node.Nodes = GetNodesFromRows(row.ChildRows);

        nodes.Add(node);
    }
    return nodes;
}