private void элементToolStripMenuItem_Click(object sender, EventArgs e)
{
if (treeView.SelectedNode != null)
{
SeSchemaItem newssi = new SeSchemaItem();
TreeNode newTreeNode = new TreeNode();
newTreeNode.Text = newssi.ToString();
newTreeNode.Tag = newssi;
treeView.SelectedNode.Nodes.Add(newTreeNode);
if (treeView.SelectedNode.Tag is SeSchema)
{
SeSchema seSchema = (SeSchema)treeView.SelectedNode.Tag;
newssi.Parent = seSchema;
seSchema.SchemaItems.Add(newssi);
}
else if (treeView.SelectedNode.Tag is SeSchemaItem)
{
SeSchemaItem ssi = (SeSchemaItem)treeView.SelectedNode.Tag;
if (ssi.SchemaItemsChildren == null)
{
ssi.SchemaItemsChildren = new List <SeSchemaItem>();
}
newssi.Parent = ssi;
ssi.SchemaItemsChildren.Add(newssi);
}
}
else
{
MessageBox.Show("Для добавления нового элемента или схемы нажмите на ветку TreeView");//?
}
}
private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
this.Cursor = Cursors.WaitCursor;
treeView.BeginUpdate();
listView.Clear();
label_Ref.Text = "";
if (e.Node.Tag is SeSchemaItem)
{
//заполнение propertyGrid
propertyGrid.SelectedObject = e.Node.Tag;
//заполнение listView
SeSchemaItem ssi = (SeSchemaItem)e.Node.Tag;
if (ssi.Type == "")
{
var ssiOfType = ssi.FindElementOfType();
if (ssiOfType != null)
{
label_Ref.Text = "Упоминания:";
listView.Items.Add(ssiOfType.Name);
listView.Items[listView.Items.Count - 1].Tag = ssiOfType;
}
}
//изменение ComboBox при нажатии на разные схемы
TreeNode tn = e.Node;
while (tn.Parent.Tag is SeSchemaItem)
{
tn = tn.Parent;
}
if (tn.Parent.Tag is SeSchema && tn.Parent.Index < comboBox_SchemaList.Items.Count)
{
comboBox_SchemaList.SelectedIndex = tn.Parent.Index;
}
//обновление каждой дочерней ветки
if (e.Node.Nodes != null)
{
foreach (TreeNode treenode in e.Node.Nodes)
{
SeSchemaItem ssichild = (SeSchemaItem)treenode.Tag;
treenode.Text = ssichild.ToString();
}
}
}
else if (e.Node.Tag is SeSchema)
{
comboBox_SchemaList.Refresh();
propertyGrid.SelectedObject = e.Node.Tag;
if (e.Node.Index < comboBox_SchemaList.Items.Count)
{
comboBox_SchemaList.SelectedIndex = e.Node.Index;
}
}
else
{
}
treeView.EndUpdate();
this.Cursor = Cursors.Default;
}
private void Button_Add_Click(object sender, EventArgs e)
{
if (treeView.SelectedNode != null)
{
SeSchemaItem newssi = new SeSchemaItem();
TreeNode newTreeNode = new TreeNode();
newTreeNode.Text = newssi.ToString();
newTreeNode.Tag = newssi;
newTreeNode.ImageIndex = 1;
treeView.SelectedNode.Nodes.Add(newTreeNode);
if (treeView.SelectedNode.Tag is SeSchema)
{
SeSchema seSchema = (SeSchema)treeView.SelectedNode.Tag;
newssi.Parent = seSchema;
seSchema.SchemaItems.Add(newssi);
}
else if (treeView.SelectedNode.Tag is SeSchemaItem)
{
SeSchemaItem ssi = (SeSchemaItem)treeView.SelectedNode.Tag;
if (ssi.SchemaItemsChildren == null)
{
ssi.SchemaItemsChildren = new List <SeSchemaItem>();
}
newssi.Parent = ssi;
ssi.SchemaItemsChildren.Add(newssi);
}
}
else
{
MessageBox.Show("Для добавления нового элемента нажмите на ветку дерева");
}
//UpdateTreeView(treeView1.Nodes);
}
private void Button_Remove_Click(object sender, EventArgs e)
{
if (treeView.SelectedNode != null)
{
treeView.SelectedNode.Remove();
if (treeView.SelectedNode.Tag is SeSchema)
{
UpdateComboBox();
}
else if (treeView.SelectedNode.Tag is SeSchemaItem)
{
SeSchemaItem ssi = (SeSchemaItem)treeView.SelectedNode.Tag;
if (treeView.SelectedNode.Parent.Tag is SeSchemaItem)
{
SeSchemaItem ssiParent = (SeSchemaItem)treeView.SelectedNode.Parent.Tag;
ssiParent.SchemaItemsChildren.Remove(ssi);
}
else if (treeView.SelectedNode.Parent.Tag is SeSchema)
{
SeSchema ssiParent = (SeSchema)treeView.SelectedNode.Parent.Tag;
ssiParent.SchemaItems.Remove(ssi);
}
}
}
else
{
MessageBox.Show("Для удаления элемента нажмите на ветку дерева");
}
}
StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
List <string> str = new List <string>();
str.Add("");
foreach (CommonType simpletype in Enum.GetValues(typeof(CommonType)))
{
str.Add(simpletype.ToString().ToLower());
}
SeSchemaItem ssi = (SeSchemaItem)context.Instance;
while (ssi.Parent is SeSchemaItem)
{
ssi = (SeSchemaItem)ssi.Parent;
}
SeSchema ss = (SeSchema)ssi.Parent;
foreach (SeSchemaItem ssiTable in ss.SchemaItems)
{
if (ssiTable.Type == "")
{
str.Add(ssiTable.Name);
}
}
return(new StandardValuesCollection(str));
}
/// <summary>
///Чтение дочерних элементов класса SeSchemaItem и запись их в класс SeSchemaItem
/// </summary>
/// <param name="childElement">Считанный дочерний элемент считанного XSD</param>
public void ReadXSD(XmlSchemaObject childElement)
{
List <SeSchemaItem> schemaTypeInCT;
List <SeSchemaItem> schemaTypeInChoice;
XmlSchemaElement schemaElement = null;
XmlSchemaSequence seq = null;
if (childElement is XmlSchemaChoice)
{
SchemaItemsChildren.Add(new SeSchemaItem("CHOICE", "", "", this, schemaTypeInChoice = new List <SeSchemaItem>(), null));
var choice = (XmlSchemaChoice)childElement;
if (choice.Items[0] is XmlSchemaSequence)
{
seq = (XmlSchemaSequence)choice.Items[0];
foreach (XmlSchemaElement childElement2 in seq.Items)
{
ReadXSD(childElement2);
}
}
if (seq == null)
{
foreach (XmlSchemaObject childElementChild in choice.Items)
{
if (childElementChild is XmlSchemaElement)
{
schemaElement = childElementChild as XmlSchemaElement;
SeProperties seProp2 = new SeProperties(schemaElement);
schemaTypeInChoice.Add(new SeSchemaItem(schemaElement.Name, GetAnnotation(childElementChild), schemaElement.SchemaTypeName.Name, this, schemaTypeInCT = new List <SeSchemaItem>(), seProp2));
}
else
{
seq = (XmlSchemaSequence)childElementChild;
foreach (XmlSchemaElement childElementSeq in seq.Items)
{
ReadXSD(childElementSeq);
}
}
}
}
}
else if (childElement is XmlSchemaElement)
{
schemaElement = childElement as XmlSchemaElement;
SeProperties seProp = new SeProperties(schemaElement);
//<xsd:element name="..._ITEM">
SeSchemaItem schemaItem = new SeSchemaItem(schemaElement.Name, GetAnnotation(schemaElement), schemaElement.SchemaTypeName.Name, this, schemaTypeInCT = new List <SeSchemaItem>(), seProp);
if (schemaElement.ElementType is XmlSchemaSimpleType)
{
List <SeSchemaItem> schemaTypeInST = new List <SeSchemaItem>();
SeSchemaItem ssi = new SeSchemaItem(schemaElement.Name, GetAnnotation(schemaElement), GetSimpleType(schemaTypeInST, schemaElement), this, schemaTypeInST, seProp);
SchemaItemsChildren.Add(ssi);
}
else
{
SchemaItemsChildren.Add(schemaItem);
schemaItem.ReadXSDParticle(schemaElement);
}
}
}
/// <summary>
/// Получение родительского класса SeSchema
/// </summary>
/// <param name="ssi">Элемент, родительский класс SeSchema которого нужно найти</param>
/// <returns>Родительский клас SeSchema</returns>
public SeSchema GetSchema(SeSchemaItem ssi)
{
while (ssi.Parent is SeSchemaItem)
{
ssi = (SeSchemaItem)ssi.Parent;
}
return((SeSchema)ssi.Parent);
}
/// <summary>
/// Запись Annotation в новый файл XSD
/// </summary>
/// <param name="newschemaItem">Текущий экземпляр класса SeSchemaItem(список List(SeSchemaItem) класса SeSchema</param>
/// <param name="discriptionAnn">Новый элемент XmlSchemaAnnotation</param>
/// <returns>Измененный элемент XmlSchemaAnnotation</returns>
public XmlSchemaAnnotation SetAnnotation(SeSchemaItem newschemaItem)
{
XmlSchemaAnnotation discriptionAnn = new XmlSchemaAnnotation();
XmlSchemaDocumentation discriptionDoc = new XmlSchemaDocumentation();
discriptionAnn.Items.Add(discriptionDoc);
discriptionDoc.Markup = TextToNodeArray(newschemaItem.Description);
return(discriptionAnn);
}
public void UpdateNode()
{
//treeView1.BeginUpdate();
if (treeView.SelectedNode.Tag is SeSchemaItem)
{
SeSchemaItem ssi = (SeSchemaItem)treeView.SelectedNode.Tag;
treeView.SelectedNode.Text = ssi.ToString();
}
else if (treeView.SelectedNode.Tag is SeSchema)
{
SeSchema ss = (SeSchema)treeView.SelectedNode.Tag;
treeView.SelectedNode.Text = ss.ToString();
}
//treeView1.EndUpdate();
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext
context)
{
//true means show a combobox
SeSchemaItem ssi = (SeSchemaItem)context.Instance;
if (ssi.Name == "SimpleType")
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
///Чтение дочерних элементов класса SeSchema и запись их в класс SeSchema
/// </summary>
/// <param name="sChemaItem">Считанный корневой элемент считанного XSD</param>
public void ReadXSD(XmlSchemaObject sChemaItem)
{
XmlSchemaElement schemaElement = null;
XmlSchemaComplexType schemaType = null;
XmlSchemaSimpleType schemaSType = null;
SeSchemaItem seSchemaItem = null;
if (sChemaItem is XmlSchemaElement)
{
schemaElement = sChemaItem as XmlSchemaElement;
Name = schemaElement.Name;
seSchemaItem = new SeSchemaItem(schemaElement.Name, GetAnnotation(schemaElement), schemaElement.SchemaTypeName.Name, this, new List <SeSchemaItem>());
}
else if (sChemaItem is XmlSchemaComplexType)
{
List <SeSchemaItem> schemaTypeInCT;
schemaType = sChemaItem as XmlSchemaComplexType;
seSchemaItem = new SeSchemaItem(schemaType.Name, GetAnnotation(schemaType), "", this, schemaTypeInCT = new List <SeSchemaItem>());
if (schemaType.ContentTypeParticle is XmlSchemaSequence)
{
XmlSchemaSequence sequence = schemaType.ContentTypeParticle as XmlSchemaSequence;
try
{
foreach (var childElement in sequence.Items)
{
seSchemaItem.ReadXSD(childElement);
}
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
}
else if (sChemaItem is XmlSchemaSimpleType)
{
List <SeSchemaItem> schemaTypeInST = new List <SeSchemaItem>();
schemaSType = sChemaItem as XmlSchemaSimpleType;
seSchemaItem = new SeSchemaItem(schemaSType.Name, GetAnnotation(schemaSType), GetSimpleType(schemaTypeInST, schemaSType), this, schemaTypeInST);
}
if (seSchemaItem != null)
{
SchemaItems.Add(seSchemaItem);
}
}
StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
List <string> str = new List <string>();
str.Add("");
SeSchemaItem ssi = (SeSchemaItem)context.Instance;
if (ssi.Name == "SimpleType")
{
str.Add("XmlSchemaMaxLengthFacet-ЦЕЛОЕ ЧИСЛО");
str.Add("XmlSchemaTotalDigitsFacet-ЦЕЛОЕ ЧИСЛО");
str.Add("XmlSchemaFractionDigitsFacet-ЦЕЛОЕ ЧИСЛО");
}
return(new StandardValuesCollection(str));
}
private void listView_MouseClick(object sender, MouseEventArgs e)
{
if (listView.SelectedItems.Count != 0)
{
SeSchemaItem ssi = (SeSchemaItem)listView.SelectedItems[0].Tag;
propertyGrid.SelectedObject = ssi;
TreeNode[] treenodesParent = treeView.Nodes.Find(ssi.GetSchema(ssi).ToString(), false);
TreeNode[] treenodes = treenodesParent[0].Nodes.Find(ssi.ToString() + ssi.Parent.ToString(), true);
TreeNode eachTn = treenodes[0];
while (eachTn.Parent.Tag is SeSchemaItem)
{
eachTn.Parent.Expand();
eachTn = eachTn.Parent;
}
treeView.Focus();
treeView.SelectedNode = treenodes[0];
}
}
/// <summary>
/// Копирование веток от complexType к ветке, у которой этот ComplexType
/// </summary>
/// <param name="eachTnn">Текущая ветка</param>
/// <param name="nodesList">Список родительских веток</param>
private void CloneEachNode(TreeNode eachTnn)
{
foreach (TreeNode eachTnnode in eachTnn.Nodes)
{
foreach (TreeNode eachTnNode in eachTnn.Nodes)
{
SeSchemaItem newSsi = (SeSchemaItem)eachTnnode.Tag;
SeSchemaItem eachSsi = (SeSchemaItem)eachTnNode.Tag;
if (newSsi.Type == eachSsi.Name)
{
eachTnNode.ImageIndex = 2;
TreeNode clonedNode = (TreeNode)eachTnNode.Clone();
clonedNode.ImageIndex = 2;
eachTnnode.Nodes.Insert(0, clonedNode);
}
}
}
}
/// <summary>
/// Поиск элемента, ComplexType которого - текущий элемент
/// </summary>
/// <returns>Список элементов с искомым ComplexType</returns>
public SeSchemaItem FindElementOfType()
{
SeSchemaItem elementOfType = null;
SeSchema first = GetSchema(this);
foreach (SeSchemaItem ssiElement in first.SchemaItems)
{
if (ssiElement.Type == Name)
{
elementOfType = ssiElement;
}
if (ssiElement.SchemaItemsChildren.Count != 0)
{
try
{
foreach (SeSchemaItem ssiElementChild in ssiElement.SchemaItemsChildren)
{
if (ssiElementChild.Type == Name)
{
elementOfType = ssiElementChild;
}
if (ssiElementChild.SchemaItemsChildren.Count != 0)
{
foreach (SeSchemaItem ssiElementInChild in ssiElementChild.SchemaItemsChildren)
{
if (ssiElementInChild.Type == Name)
{
elementOfType = ssiElementInChild;
}
}
}
}
}
catch { }
}
}
return(elementOfType);
}
private void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
{
UpdateNode();
if (propertyGrid.SelectedObject is SeSchemaItem)
{
SeSchemaItem ssi = (SeSchemaItem)propertyGrid.SelectedObject;
if (treeView.SelectedNode != null)
{
//изменение типа у элементов с измененным ComplexType
if (ssi.Parent is SeSchema && ((ContainerControl)s).ActiveControl.AccessibleName == "Name" && ssi.Type == "")
{
ssi.ChangeNewComplexType(e.OldValue, e.ChangedItem.Value);
}
//изменение иконки для ComplexType
if (ssi.Type == "")
{
treeView.SelectedNode.ImageIndex = 2;
}
//изменение иконки для element
if (ssi.Type != "")
{
treeView.SelectedNode.ImageIndex = 1;
}
//изменение иконки для SimpleType
if (ssi.Name == "SimpleType")
{
treeView.SelectedNode.ImageIndex = 3;
}
//изменение иконки для Choice
if (ssi.Name == "CHOICE")
{
treeView.SelectedNode.ImageIndex = 4;
}
//проверка строки на содержание цифр
if (((ContainerControl)s).ActiveControl.AccessibleName == "Name")
{
bool correct = true;
string marks = ".,/':;!?-=+|/";
foreach (char symbol in ssi.Name)
{
if (symbol < '0' || symbol > '9')
{
correct = true;
}
else
{
correct = false;
}
foreach (char mark in marks)
{
if (symbol == mark)
{
correct = false;
}
}
}
if (!correct)
{
((ContainerControl)s).ActiveControl.Text = "Untitled";
MessageBox.Show("Имя элемента не может содержать цифры или знаки препинания");
}
}
}
}
}
