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(); }