public XmlSchemaCompletionData GetSchemaFromFileName(string fileName)
{
XmlSchemaCompletionData data = user.GetSchemaFromFileName(fileName);
if (data == null)
{
data = builtin.GetSchemaFromFileName(fileName);
}
return(data);
}
public XmlSchemaCompletionData this [string namespaceUri] {
get {
XmlSchemaCompletionData val = user[namespaceUri];
if (val == null)
{
val = builtin[namespaceUri];
}
return(val);
}
}
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());
}
public static void Initialise ()
{
if (schemas != null)
return;
schemas = new Dictionary<string, HtmlSchema> ();
//load all the schemas from addin points
//NOTE: the first ([0]) schema must be the default schema
foreach (DocTypeExtensionNode node in Mono.Addins.AddinManager.GetExtensionNodes ("/MonoDevelop/Html/DocTypes")) {
if (schemas.ContainsKey (node.Name))
LoggingService.LogWarning (
"HtmlSchemaService cannot register duplicate doctype with the name '{0}'", node.Name);
if (!string.IsNullOrEmpty (node.XsdFile)) {
string path = node.Addin.GetFilePath (node.XsdFile);
try {
IXmlCompletionProvider provider = new XmlSchemaCompletionData (path);
schemas.Add (node.Name, new HtmlSchema (node.Name, node.FullName, provider));
} catch (Exception ex) {
LoggingService.LogWarning (
"HtmlSchemaService encountered an error registering the schema '" + path + "'", ex);
}
} else {
schemas.Add (node.Name, new HtmlSchema (node.Name, node.FullName, node.CompletionDocTypeName));
}
}
//initialise the default backup schema if it doesn't exist already
if (!schemas.ContainsKey (DefaultDocTypeName)) {
HtmlSchema defaultSubstProvider = schemas["XHTML 1.0 Transitional"];
IXmlCompletionProvider provider;
if (defaultSubstProvider != null) {
//start the threaded schema loading
LoadSchema (defaultSubstProvider, true);
provider = defaultSubstProvider.CompletionProvider;
} else {
LoggingService.LogWarning ("Completion schema for default HTML doctype not found.");
provider = new EmptyXmlCompletionProvider ();
}
schemas[DefaultDocTypeName] = new HtmlSchema ("HTML 4.01 Transitional",
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n"
+ "\"http://www.w3.org/TR/html4/loose.dtd\">",
provider);
}
MonoDevelop.Core.LoggingService.LogDebug ("HtmlSchemaService initialised");
}
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);
}
async Task Init ()
{
if (schemaCompletionData != null)
return;
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 = await schemaCompletionData.GetAttributeCompletionData(h1Path, CancellationToken.None);
}
protected virtual void addRegisteredSchema (object sender, EventArgs args)
{
string fileName = XmlEditorService.BrowseForSchemaFile ();
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);
}
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);
}
}
TreeIter AddRegisteredSchema (XmlSchemaCompletionData schema)
{
if (removedSchemas.Contains (schema))
removedSchemas.Remove (schema);
else
addedSchemas.Add (schema);
return AppendSchemaToStore (schema);
}
TreeIter AppendSchemaToStore (XmlSchemaCompletionData schema)
{
return registeredSchemasStore.AppendValues (schema);
}
/// <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;
}
/// <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>
/// 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>
/// 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);
}
}
/// <summary>
/// Adds the schema to the user schemas folder and makes the
/// schema available to the xml editor.
/// </summary>
public static void AddUserSchema (XmlSchemaCompletionData schemaData)
{
if (UserSchemas [schemaData.NamespaceUri] == null) {
if (!Directory.Exists(UserSchemaFolder)) {
Directory.CreateDirectory (UserSchemaFolder);
}
string fileName = Path.GetFileName (schemaData.FileName);
string destinationFileName = Path.Combine (UserSchemaFolder, fileName);
File.Copy (schemaData.FileName, destinationFileName);
schemaData.FileName = destinationFileName;
UserSchemas.Add (schemaData);
OnUserSchemaAdded ();
} else {
LoggingService.LogWarning ("XmlSchemaManager cannot register two schemas with the same namespace '{0}'.", schemaData.NamespaceUri);
}
}
/// <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;
}
void SetDefaultSchema ()
{
var filename = DocumentContext.Name;
if (filename == null)
return;
defaultSchemaCompletionData = XmlSchemaManager.GetSchemaCompletionDataForFileName (filename);
if (defaultSchemaCompletionData != null)
inferredCompletionData = null;
else
QueueInference ();
defaultNamespacePrefix = XmlSchemaManager.GetNamespacePrefixForFileName (filename);
}
async Task Init ()
{
if (schemaCompletionData != null)
return;
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 = await schemaCompletionData.GetAttributeValueCompletionData(choicePath, "mixed", CancellationToken.None);
choicePath.Elements.Add(new QualifiedName("choice", namespaceURI, prefix));
// Get choice element info.
choiceAttributes = await schemaCompletionData.GetAttributeCompletionData(choicePath, CancellationToken.None);
maxOccursAttributeValues = await schemaCompletionData.GetAttributeValueCompletionData(choicePath, "maxOccurs", CancellationToken.None);
// Set up element path.
elementPath = new XmlElementPath();
elementPath.Elements.Add(new QualifiedName("schema", namespaceURI, prefix));
elementFormDefaultAttributeValues = await schemaCompletionData.GetAttributeValueCompletionData (elementPath, "elementFormDefault", CancellationToken.None);
blockDefaultAttributeValues = await schemaCompletionData.GetAttributeValueCompletionData(elementPath, "blockDefault", CancellationToken.None);
finalDefaultAttributeValues = await schemaCompletionData.GetAttributeValueCompletionData(elementPath, "finalDefault", CancellationToken.None);
elementPath.Elements.Add(new QualifiedName("element", namespaceURI, prefix));
// Get element attribute info.
elementAttributes = await schemaCompletionData.GetAttributeCompletionData(elementPath, CancellationToken.None);
// 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 = await schemaCompletionData.GetChildElementCompletionData(simpleEnumPath, CancellationToken.None);
// 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 = await schemaCompletionData.GetAttributeCompletionData(enumPath, CancellationToken.None);
// 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 = await schemaCompletionData.GetChildElementCompletionData(allElementPath, CancellationToken.None);
// 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 = await schemaCompletionData.GetChildElementCompletionData(allElementAnnotationPath, CancellationToken.None);
}
public void FixtureInitBase()
{
schemaCompletionData = CreateSchemaCompletionDataObject();
FixtureInit();
}
