void RemoveRegisteredSchema(XmlSchemaCompletionData schema)
{
if (addedSchemas.Contains(schema) && !schema.ReadOnly)
{
addedSchemas.Remove(schema);
}
else
{
removedSchemas.Add(schema);
}
TreeIter iter;
bool valid = registeredSchemasStore.GetIterFirst(out iter);
while (valid)
{
if (GetRegisteredSchema(iter) == schema)
{
registeredSchemasStore.Remove(ref iter);
break;
}
valid = registeredSchemasStore.IterNext(ref iter);
}
//restore built-in schema
if (!schema.ReadOnly)
{
XmlSchemaCompletionData builtin = XmlSchemaManager.BuiltinSchemas[schema.NamespaceUri];
if (builtin != null)
{
AppendSchemaToStore(builtin);
}
}
}
public void SimpleFileName()
{
string fileName = @"C:\temp\foo.xml";
string expectedUri = "file:///C:/temp/foo.xml";
Assert.AreEqual(expectedUri, XmlSchemaCompletionData.GetUri(fileName));
}
/// <summary>
/// If the attribute value found references another item in the schema
/// return this instead of the attribute schema object. For example, if the
/// user can select the attribute value and the code will work out the schema object pointed to by the ref
/// or type attribute:
///
/// xs:element ref="ref-name"
/// xs:attribute type="type-name"
/// </summary>
/// <returns>
/// The <paramref name="attribute"/> if no schema object was referenced.
/// </returns>
XmlSchemaObject GetSchemaObjectReferenced(XmlSchemaCompletionData currentSchemaCompletionData, XmlSchemaElement element, XmlSchemaAttribute attribute)
{
XmlSchemaObject schemaObject = null;
if (IsXmlSchemaNamespace(element))
{
// Find attribute value.
//fixme implement
string attributeValue = ""; // XmlParser.GetAttributeValueAtIndex(xml, index);
if (attributeValue.Length == 0)
{
return(attribute);
}
if (attribute.Name == "ref")
{
schemaObject = FindSchemaObjectReference(attributeValue, currentSchemaCompletionData, element.Name);
}
else if (attribute.Name == "type")
{
schemaObject = FindSchemaObjectType(attributeValue, currentSchemaCompletionData, element.Name);
}
}
if (schemaObject != null)
{
return(schemaObject);
}
return(attribute);
}
/// <summary>
/// Attempts to locate the reference name in the specified schema.
/// </summary>
/// <param name="name">The reference to look up.</param>
/// <param name="schemaCompletionData">The schema completion data to use to
/// find the reference.</param>
/// <param name="elementName">The element to determine what sort of reference it is
/// (e.g. group, attribute, element).</param>
/// <returns><see langword="null"/> if no match can be found.</returns>
XmlSchemaObject FindSchemaObjectReference(string name, XmlSchemaCompletionData schemaCompletionData, string elementName)
{
QualifiedName qualifiedName = schemaCompletionData.CreateQualifiedName(name);
XmlSchemaCompletionData qualifiedNameSchema = FindSchema(qualifiedName.Namespace);
if (qualifiedNameSchema != null)
{
schemaCompletionData = qualifiedNameSchema;
}
switch (elementName)
{
case "element":
return(schemaCompletionData.FindElement(qualifiedName));
case "attribute":
return(schemaCompletionData.FindAttribute(qualifiedName.Name));
case "group":
return(schemaCompletionData.FindGroup(qualifiedName.Name));
case "attributeGroup":
return(schemaCompletionData.FindAttributeGroup(qualifiedName.Name));
}
return(null);
}
public void GoToSchemaDefinitionCommand()
{
try {
//try to resolve the schema
XmlSchemaCompletionData currentSchemaCompletionData = FindSchemaFromFileName(FileName);
XmlSchemaObject schemaObject = GetSchemaObjectSelected(currentSchemaCompletionData);
// Open schema if resolved
if (schemaObject != null && schemaObject.SourceUri != null && schemaObject.SourceUri.Length > 0)
{
string schemaFileName = schemaObject.SourceUri.Replace("file:/", String.Empty);
IdeApp.Workbench.OpenDocument(
schemaFileName,
DocumentContext.Project,
Math.Max(1, schemaObject.LineNumber),
Math.Max(1, schemaObject.LinePosition));
}
} catch (Exception ex) {
MonoDevelop.Core.LoggingService.LogError("Could not open document.", ex);
MessageService.ShowError("Could not open document.", ex);
}
}
public XmlCompletionDataProvider(XmlSchemaCompletionDataCollection schemaCompletionDataItems, XmlSchemaCompletionData defaultSchemaCompletionData, string defaultNamespacePrefix)
{
this.schemaCompletionDataItems = schemaCompletionDataItems;
this.defaultSchemaCompletionData = defaultSchemaCompletionData;
this.defaultNamespacePrefix = defaultNamespacePrefix;
DefaultIndex = 0;
}
/// <summary>
/// Reads an individual schema and adds it to the collection.
/// </summary>
/// <remarks>
/// If the schema namespace exists in the collection it is not added.
/// </remarks>
public void ReadSchema(string fileName, bool readOnly)
{
try
{
string baseUri = XmlSchemaCompletionData.GetUri(fileName);
XmlSchemaCompletionData data = new XmlSchemaCompletionData(baseUri, fileName);
if (data.NamespaceUri != null)
{
if (schemas[data.NamespaceUri] == null)
{
data.ReadOnly = readOnly;
schemas.Add(data);
}
else
{
// Namespace already exists.
Debug.WriteLine("Ignoring duplicate schema namespace " + data.NamespaceUri);
}
}
else
{
Debug.WriteLine("Ignoring schema with no namespace " + data.FileName);
}
}
catch (Exception ex)
{
Debug.WriteLine("Unable to read schema '" + fileName + "'. ", ex);
}
}
/// <summary>
/// Attempts to locate the type name in the specified schema.
/// </summary>
/// <param name="name">The type to look up.</param>
/// <param name="schemaCompletionData">The schema completion data to use to
/// find the type.</param>
/// <param name="elementName">The element to determine what sort of type it is
/// (e.g. group, attribute, element).</param>
/// <returns><see langword="null"/> if no match can be found.</returns>
XmlSchemaObject FindSchemaObjectType(string name, XmlSchemaCompletionData schemaCompletionData, string elementName)
{
QualifiedName qualifiedName = schemaCompletionData.CreateQualifiedName(name);
XmlSchemaCompletionData qualifiedNameSchema = FindSchema(qualifiedName.Namespace);
if (qualifiedNameSchema != null)
{
schemaCompletionData = qualifiedNameSchema;
}
switch (elementName)
{
case "element":
return(schemaCompletionData.FindComplexType(qualifiedName));
case "attribute":
return(schemaCompletionData.FindSimpleType(qualifiedName.Name));
}
return(null);
}
public void Init()
{
treeViewContainer = new XmlTreeViewContainerControl();
XmlTextReader reader = ResourceManager.GetXhtmlStrictSchema();
XmlSchemaCompletionData xhtmlSchema = new XmlSchemaCompletionData(reader);
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xhtmlSchema, String.Empty);
treeViewContainer.LoadXml("<!-- comment --><html><body class='a'><p>Text</p></body></html>", provider);
doc = treeViewContainer.Document;
treeView = treeViewContainer.TreeView;
commentTreeNode = (XmlCommentTreeNode)treeView.Nodes[0];
htmlTreeNode = (XmlElementTreeNode)treeView.Nodes[1];
htmlTreeNode.Expanding();
bodyTreeNode = (XmlElementTreeNode)htmlTreeNode.Nodes[0];
bodyTreeNode.Expanding();
paraTreeNode = (XmlElementTreeNode)bodyTreeNode.Nodes[0];
paraTreeNode.Expanding();
textTreeNode = (XmlTextTreeNode)paraTreeNode.Nodes[0];
}
public void Init()
{
treeViewContainer = new DerivedXmlTreeViewContainerControl();
treeViewContainer.DirtyChanged += TreeViewContainerDirtyChanged;
XmlTextReader reader = ResourceManager.GetXhtmlStrictSchema();
XmlSchemaCompletionData xhtmlSchema = new XmlSchemaCompletionData(reader);
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
provider = new XmlCompletionDataProvider(schemas, xhtmlSchema, String.Empty);
treeViewContainer.LoadXml("<html id='a'>text<body></body></html>", provider);
doc = treeViewContainer.Document;
treeView = treeViewContainer.TreeView;
htmlTreeNode = (XmlElementTreeNode)treeView.Nodes[0];
htmlTreeNode.Expanding();
textTreeNode = (XmlTextTreeNode)htmlTreeNode.Nodes[0];
splitContainer = (SplitContainer)treeViewContainer.Controls["splitContainer"];
textBox = (RichTextBox)splitContainer.Panel2.Controls["textBox"];
errorMessageTextBox = (RichTextBox)splitContainer.Panel2.Controls["errorMessageTextBox"];
attributesGrid = (PropertyGrid)splitContainer.Panel2.Controls["attributesGrid"];
}
/// <summary>
/// Gets the XmlSchemaObject that defines the currently selected xml element or attribute.
/// </summary>
/// <param name="currentSchemaCompletionData">This is the schema completion data for the schema currently being
/// displayed. This can be null if the document is not a schema.</param>
public XmlSchemaObject GetSchemaObjectSelected(XmlSchemaCompletionData currentSchemaCompletionData)
{
// Find element under cursor.
XmlElementPath path = GetElementPath();
//attribute name under cursor, if valid
string attributeName = null;
XAttribute xatt = Tracker.Engine.Nodes.Peek(0) as XAttribute;
if (xatt != null)
{
XName xattName = xatt.Name;
if (Tracker.Engine.CurrentState is XmlNameState)
{
xattName = GetCompleteName();
}
attributeName = xattName.FullName;
}
// Find schema definition object.
XmlSchemaCompletionData schemaCompletionData = FindSchema(path);
XmlSchemaObject schemaObject = null;
if (schemaCompletionData != null)
{
XmlSchemaElement element = schemaCompletionData.FindElement(path);
schemaObject = element;
if (element != null)
{
if (!string.IsNullOrEmpty(attributeName))
{
XmlSchemaAttribute attribute = schemaCompletionData.FindAttribute(element, attributeName);
if (attribute != null)
{
if (currentSchemaCompletionData != null)
{
schemaObject = GetSchemaObjectReferenced(currentSchemaCompletionData, element, attribute);
}
else
{
schemaObject = attribute;
}
}
}
return(schemaObject);
}
}
return(null);
}
/// <summary>
/// Loads the specified schema and adds it to an internal collection.
/// </summary>
/// <remarks>The schema file is not copied to the user's schema folder
/// until they click the OK button.</remarks>
/// <returns><see langword="true"/> if the schema namespace
/// does not already exist; otherwise <see langword="false"/>
/// </returns>
bool AddSchema(string fileName)
{
// Load the schema.
XmlSchemaCompletionData schema = new XmlSchemaCompletionData(fileName);
// Make sure the schema has a target namespace.
if (schema.NamespaceUri == null)
{
MessageService.ShowErrorFormatted("${res:ICSharpCode.XmlEditor.XmlSchemasPanel.NoTargetNamespace}", Path.GetFileName(schema.FileName));
return(false);
}
// Check that the schema does not exist.
if (SchemaNamespaceExists(schema.NamespaceUri))
{
MessageService.ShowErrorFormatted("${res:ICSharpCode.XmlEditor.XmlSchemasPanel.NamespaceExists}", schema.NamespaceUri);
return(false);
}
// Store the schema so we can add it later.
int index = schemaListBox.Items.Add(new XmlSchemaListBoxItem(schema.NamespaceUri));
schemaListBox.SelectedIndex = index;
addedSchemas.Add(schema);
if (removedSchemaNamespaces.Contains(schema.NamespaceUri))
{
removedSchemaNamespaces.Remove(schema.NamespaceUri);
}
return(true);
}
/// <summary>
/// Reads an individual schema and adds it to the collection.
/// </summary>
/// <remarks>
/// If the schema namespace exists in the collection it is not added.
/// </remarks>
static void LoadSchema(List <XmlSchemaCompletionData> list, string fileName, bool readOnly)
{
try {
string baseUri = XmlSchemaCompletionData.GetUri(fileName);
XmlSchemaCompletionData data = new XmlSchemaCompletionData(baseUri, fileName);
if (data.NamespaceUri == null)
{
LoggingService.LogWarning(
"XmlSchemaManager is ignoring schema with no namespace, from file '{0}'.",
data.FileName);
return;
}
foreach (XmlSchemaCompletionData d in list)
{
if (d.NamespaceUri == data.NamespaceUri)
{
LoggingService.LogWarning(
"XmlSchemaManager is ignoring schema with duplicate namespace '{0}'.",
data.NamespaceUri);
return;
}
}
data.ReadOnly = readOnly;
list.Add(data);
} catch (Exception ex) {
LoggingService.LogWarning(
"XmlSchemaManager is unable to read schema '{0}', because of the following error: {1}",
fileName, ex.Message);
}
}
protected virtual void addRegisteredSchema(object sender, EventArgs args)
{
string fileName = XmlEditorService.BrowseForSchemaFile();
// We need to present the window so that the keyboard focus returns to the correct parent window
((Gtk.Window)Toplevel).Present();
if (string.IsNullOrEmpty(fileName))
{
return;
}
string shortName = System.IO.Path.GetFileName(fileName);
//load the schema
XmlSchemaCompletionData schema = null;
try {
schema = new XmlSchemaCompletionData(fileName);
} catch (Exception ex) {
string msg = GettextCatalog.GetString("Schema '{0}' could not be loaded.", shortName);
MessageService.ShowError(msg, ex);
return;
}
// Make sure the schema has a target namespace.
if (schema.NamespaceUri == null)
{
MessageService.ShowError(
GettextCatalog.GetString("Schema '{0}' has no target namespace.", shortName));
return;
}
//if namaspace conflict, ask user whether they want to replace existing schema
XmlSchemaCompletionData oldSchema = GetRegisteredSchema(schema.NamespaceUri);
if (oldSchema != null)
{
bool replace = MessageService.Confirm(
GettextCatalog.GetString(
"A schema is already registered with the namespace '{0}'. Would you like to replace it?",
schema.NamespaceUri),
new AlertButton(GettextCatalog.GetString("Replace"))
);
if (!replace)
{
return;
}
//remove the old schema
RemoveRegisteredSchema(oldSchema);
}
// Store the schema so we can add it for real later, if the "ok" button's clicked
TreeIter newIter = AddRegisteredSchema(schema);
registeredSchemasView.Selection.SelectIter(newIter);
ScrollToSelection(registeredSchemasView);
}
public void SetUpFixture()
{
schemas = new XmlSchemaCompletionDataCollection();
XmlSchemaCompletionData completionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
expectedNamespace = completionData.NamespaceUri;
completionData.FileName = @"/home/Schemas/MySchema.xsd";
schemas.Add(completionData);
provider = new XmlCompletionDataProvider(schemas, completionData, String.Empty, null);
}
public void SetUpFixture()
{
schemas = new XmlSchemaCompletionDataCollection();
XmlSchemaCompletionData completionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
expectedNamespace = completionData.NamespaceUri;
completionData.FileName = @"C:\Schemas\MySchema.xsd";
schemas.Add(completionData);
provider = new XmlCompletionDataProvider(schemas, completionData, String.Empty);
}
protected virtual void removeRegisteredSchema(object sender, System.EventArgs e)
{
XmlSchemaCompletionData schema = GetSelectedSchema();
if (schema == null)
{
throw new InvalidOperationException("Should not be able to activate removeRegisteredSchema button while no row is selected.");
}
RemoveRegisteredSchema(schema);
}
public override void FixtureInit()
{
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
schemas.Add(SchemaCompletionData);
XmlSchemaCompletionData xsdSchemaCompletionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
schemas.Add(xsdSchemaCompletionData);
XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xsdSchemaCompletionData, String.Empty, null);
string xml = GetSchema();
int index = xml.IndexOf("type=\"dir\"/>");
index = xml.IndexOf("dir", index);
schemaSimpleType = (XmlSchemaSimpleType)XmlEditorView.GetSchemaObjectSelected(xml, index, provider, SchemaCompletionData);
}
private ICompletionData[] GetChildElementCompletionData(XmlElementPath path)
{
ICompletionData[] completionData = null;
XmlSchemaCompletionData schema = FindSchema(path);
if (schema != null)
{
completionData = schema.GetChildElementCompletionData(path);
}
return(completionData);
}
public void FixtureInit()
{
XmlSchemaCompletionDataCollection items = new XmlSchemaCompletionDataCollection();
StringReader reader = new StringReader(GetSchema(firstNamespace));
XmlSchemaCompletionData schema = new XmlSchemaCompletionData(reader);
items.Add(schema);
reader = new StringReader(GetSchema(secondNamespace));
schema = new XmlSchemaCompletionData(reader);
items.Add(schema);
namespaceCompletionData = items.GetNamespaceCompletionData();
}
ICompletionData[] GetAttributeCompletionData(XmlElementPath path)
{
ICompletionData[] completionData = null;
XmlSchemaCompletionData schema = FindSchema(path);
if (schema != null)
{
completionData = schema.GetAttributeCompletionData(path);
}
return(completionData);
}
public override void FixtureInit()
{
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
schemas.Add(SchemaCompletionData);
XmlSchemaCompletionData xsdSchemaCompletionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
schemas.Add(xsdSchemaCompletionData);
XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xsdSchemaCompletionData, String.Empty, null);
string xml = GetSchema();
int index = xml.IndexOf("ref=\"coreattrs\"");
index = xml.IndexOf("coreattrs", index);
schemaAttributeGroup = (XmlSchemaAttributeGroup)XmlEditorView.GetSchemaObjectSelected(xml, index, provider, SchemaCompletionData);
}
ICompletionData[] GetAttributeValueCompletionData(XmlElementPath path, string name)
{
ICompletionData[] completionData = null;
XmlSchemaCompletionData schema = defaultSchemaCompletionData;
if (schema != null)
{
completionData = schema.GetAttributeValueCompletionData(path, name);
}
return(completionData);
}
TreeIter AddRegisteredSchema(XmlSchemaCompletionData schema)
{
if (removedSchemas.Contains(schema))
{
removedSchemas.Remove(schema);
}
else
{
addedSchemas.Add(schema);
}
return(AppendSchemaToStore(schema));
}
ICompletionData[] GetChildElementCompletionData(XmlElementPath path)
{
ICompletionData[] completionData = null;
XmlSchemaCompletionData schema = defaultSchemaCompletionData;
if (schema != null)
{
completionData = schema.GetChildElementCompletionData(path);
}
return(completionData);
}
public void FixtureInit()
{
XmlSchemaCompletionDataCollection items = new XmlSchemaCompletionDataCollection();
StringReader reader = new StringReader(GetSchema(firstNamespace));
XmlSchemaCompletionData schema = new XmlSchemaCompletionData(reader);
items.Add(schema);
reader = new StringReader(GetSchema(secondNamespace));
schema = new XmlSchemaCompletionData(reader);
items.Add(schema);
namespaceCompletionData = new CompletionDataList(items.GetNamespaceCompletionData());
}
/// <summary>
/// Removes the schema with the specified namespace from the
/// user schemas folder and removes the completion data.
/// </summary>
public void RemoveUserSchema(string namespaceUri)
{
XmlSchemaCompletionData schemaData = SchemaCompletionDataItems[namespaceUri];
if (schemaData != null)
{
if (File.Exists(schemaData.FileName))
{
File.Delete(schemaData.FileName);
}
SchemaCompletionDataItems.Remove(schemaData);
OnUserSchemaRemoved();
}
}
public void FixtureInit()
{
XmlTextReader reader = ResourceManager.GetXhtmlStrictSchema();
schemaCompletionData = new XmlSchemaCompletionData(reader);
// Set up h1 element's path.
h1Path = new XmlElementPath();
h1Path.Elements.Add(new QualifiedName("html", namespaceURI));
h1Path.Elements.Add(new QualifiedName("body", namespaceURI));
h1Path.Elements.Add(new QualifiedName("h1", namespaceURI));
// Get h1 element info.
h1Attributes = schemaCompletionData.GetAttributeCompletionData(h1Path);
}
public override void FixtureInit()
{
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
schemas.Add(SchemaCompletionData);
XmlSchemaCompletionData xsdSchemaCompletionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
schemas.Add(xsdSchemaCompletionData);
XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xsdSchemaCompletionData, String.Empty, null);
string xml = GetSchema();
int index = xml.IndexOf("ref=\"xs:list");
index = xml.IndexOf("xs", index);
referencedSchemaElement = (XmlSchemaElement)XmlEditorView.GetSchemaObjectSelected(xml, index, provider, SchemaCompletionData);
}
public void FixtureInit()
{
XmlTextReader reader = ResourceManager.GetXhtmlStrictSchema();
schemaCompletionData = new XmlSchemaCompletionData(reader);
// Set up h1 element's path.
h1Path = new XmlElementPath();
h1Path.Elements.Add(new QualifiedName("html", namespaceURI));
h1Path.Elements.Add(new QualifiedName("body", namespaceURI));
h1Path.Elements.Add(new QualifiedName("h1", namespaceURI));
// Get h1 element info.
h1Attributes = schemaCompletionData.GetAttributeCompletionData(h1Path);
}
/// <summary>
/// Schedules the schema for removal.
/// </summary>
void RemoveSchema(string namespaceUri)
{
RemoveListBoxItem(namespaceUri);
XmlSchemaCompletionData addedSchema = addedSchemas[namespaceUri];
if (addedSchema != null)
{
addedSchemas.Remove(addedSchema);
}
else
{
removedSchemaNamespaces.Add(namespaceUri);
}
}
/// <summary>
/// Gets the schema completion data that is associated with the
/// specified file extension.
/// </summary>
public static XmlSchemaCompletionData GetSchemaCompletionData(string extension)
{
XmlSchemaCompletionData data = null;
XmlSchemaAssociation association = XmlEditorAddInOptions.GetSchemaAssociation(extension);
if (association != null)
{
if (association.NamespaceUri.Length > 0)
{
data = SchemaCompletionDataItems[association.NamespaceUri];
}
}
return(data);
}
XmlSchemaCompletionData GetItem(string namespaceUri)
{
XmlSchemaCompletionData matchedItem = null;
foreach (XmlSchemaCompletionData item in this)
{
if (item.NamespaceUri == namespaceUri)
{
matchedItem = item;
break;
}
}
return(matchedItem);
}
/// <summary>
/// Gets the schema completion data that is associated with the
/// specified file extension.
/// </summary>
internal XmlSchemaCompletionData GetSchemaCompletionData(string extension)
{
XmlSchemaCompletionData data = null;
XmlSchemaAssociation association = GetSchemaAssociation(extension);
if (association != null)
{
if (association.NamespaceUri.Length > 0)
{
data = SchemaCompletionDataItems[association.NamespaceUri];
}
}
return(data);
}
/// <summary>
/// Removes the schema with the specified namespace from the
/// user schemas folder and removes the completion data.
/// </summary>
public static void RemoveUserSchema(string namespaceUri)
{
XmlSchemaCompletionData schemaData = UserSchemas [namespaceUri];
if (schemaData != null)
{
if (File.Exists(schemaData.FileName))
{
File.Delete(schemaData.FileName);
}
UserSchemas.Remove(schemaData);
schemaSetTask = null;
OnUserSchemaRemoved();
}
}
public override void FixtureInit()
{
XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
schemas.Add(SchemaCompletionData);
XmlSchemaCompletionData xsdSchemaCompletionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
schemas.Add(xsdSchemaCompletionData);
XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xsdSchemaCompletionData, String.Empty);
string xml = GetSchema();
int index = xml.IndexOf("ref=\"dir\"");
index = xml.IndexOf("dir", index);
schemaAttribute = (XmlSchemaAttribute)XmlView.GetSchemaObjectSelected(xml, index, provider, SchemaCompletionData);
}
public void FixtureInit()
{
XmlTextReader reader = ResourceManager.GetXsdSchema();
schemaCompletionData = new XmlSchemaCompletionData(reader);
// Set up choice element's path.
choicePath = new XmlElementPath();
choicePath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
choicePath.Elements.Add(new QualifiedName("element", namespaceURI, prefix));
choicePath.Elements.Add(new QualifiedName("complexType", namespaceURI, prefix));
mixedAttributeValues = schemaCompletionData.GetAttributeValueCompletionData(choicePath, "mixed");
choicePath.Elements.Add(new QualifiedName("choice", namespaceURI, prefix));
// Get choice element info.
choiceAttributes = schemaCompletionData.GetAttributeCompletionData(choicePath);
maxOccursAttributeValues = schemaCompletionData.GetAttributeValueCompletionData(choicePath, "maxOccurs");
// Set up element path.
elementPath = new XmlElementPath();
elementPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
elementFormDefaultAttributeValues = schemaCompletionData.GetAttributeValueCompletionData(elementPath, "elementFormDefault");
blockDefaultAttributeValues = schemaCompletionData.GetAttributeValueCompletionData(elementPath, "blockDefault");
finalDefaultAttributeValues = schemaCompletionData.GetAttributeValueCompletionData(elementPath, "finalDefault");
elementPath.Elements.Add(new QualifiedName("element", namespaceURI, prefix));
// Get element attribute info.
elementAttributes = schemaCompletionData.GetAttributeCompletionData(elementPath);
// Set up simple enum type path.
simpleEnumPath = new XmlElementPath();
simpleEnumPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
simpleEnumPath.Elements.Add(new QualifiedName("simpleType", namespaceURI, prefix));
simpleEnumPath.Elements.Add(new QualifiedName("restriction", namespaceURI, prefix));
// Get child elements.
simpleEnumElements = schemaCompletionData.GetChildElementCompletionData(simpleEnumPath);
// Set up enum path.
enumPath = new XmlElementPath();
enumPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
enumPath.Elements.Add(new QualifiedName("simpleType", namespaceURI, prefix));
enumPath.Elements.Add(new QualifiedName("restriction", namespaceURI, prefix));
enumPath.Elements.Add(new QualifiedName("enumeration", namespaceURI, prefix));
// Get attributes.
enumAttributes = schemaCompletionData.GetAttributeCompletionData(enumPath);
// Set up xs:all path.
allElementPath = new XmlElementPath();
allElementPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
allElementPath.Elements.Add(new QualifiedName("element", namespaceURI, prefix));
allElementPath.Elements.Add(new QualifiedName("complexType", namespaceURI, prefix));
allElementPath.Elements.Add(new QualifiedName("all", namespaceURI, prefix));
// Get child elements of the xs:all element.
allElementChildElements = schemaCompletionData.GetChildElementCompletionData(allElementPath);
// Set up the path to the annotation element that is a child of xs:all.
allElementAnnotationPath = new XmlElementPath();
allElementAnnotationPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
allElementAnnotationPath.Elements.Add(new QualifiedName("element", namespaceURI, prefix));
allElementAnnotationPath.Elements.Add(new QualifiedName("complexType", namespaceURI, prefix));
allElementAnnotationPath.Elements.Add(new QualifiedName("all", namespaceURI, prefix));
allElementAnnotationPath.Elements.Add(new QualifiedName("annotation", namespaceURI, prefix));
// Get the xs:all annotation child element.
allElementAnnotationChildElements = schemaCompletionData.GetChildElementCompletionData(allElementAnnotationPath);
}
public void FixtureInitBase()
{
schemaCompletionData = CreateSchemaCompletionDataObject();
FixtureInit();
}
