← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/DisplayBindings/XmlEditor/Project/Src/RegisteredXmlSchemas.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/DisplayBindings/XmlEditor/Project/Src/RegisteredXmlSchemas.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using System.IO;
 
7
using System.Runtime.InteropServices;
 
8
 
 
9
using ICSharpCode.Core;
 
10
 
 
11
namespace ICSharpCode.XmlEditor
 
12
{
 
13
        /// <summary>
 
14
        /// Keeps track of all the schemas that the XML Editor is aware of.
 
15
        /// </summary>
 
16
        public class RegisteredXmlSchemas : IXmlSchemaCompletionDataFactory
 
17
        {
 
18
                List<string> readOnlySchemaFolders = new List<string>();
 
19
                string userDefinedSchemaFolder;
 
20
                XmlSchemaCompletionCollection schemas = new XmlSchemaCompletionCollection();
 
21
                IFileSystem fileSystem;
 
22
                IXmlSchemaCompletionDataFactory factory;
 
23
                List<RegisteredXmlSchemaError> schemaErrors = new List<RegisteredXmlSchemaError>();
 
24
                
 
25
                public event EventHandler UserDefinedSchemaAdded;
 
26
                public event EventHandler UserDefinedSchemaRemoved;
 
27
                        
 
28
                public RegisteredXmlSchemas(string[] readOnlySchemaFolders, 
 
29
                        string userDefinedSchemaFolder, 
 
30
                        IFileSystem fileSystem, 
 
31
                        IXmlSchemaCompletionDataFactory factory)
 
32
                {
 
33
                        this.readOnlySchemaFolders.AddRange(readOnlySchemaFolders);
 
34
                        this.userDefinedSchemaFolder = userDefinedSchemaFolder;
 
35
                        this.fileSystem = fileSystem;
 
36
                        this.factory = factory;
 
37
                }
 
38
                
 
39
                public RegisteredXmlSchemas(string[] readOnlySchemaFolders, string userDefinedSchemaFolder, IFileSystem fileSystem)
 
40
                        : this(readOnlySchemaFolders, userDefinedSchemaFolder, fileSystem, null)
 
41
                {
 
42
                        this.factory = this;
 
43
                }
 
44
                
 
45
                public XmlSchemaCompletionCollection Schemas {
 
46
                        get { return schemas; }
 
47
                }
 
48
                
 
49
                public bool SchemaExists(string namespaceUri)
 
50
                {
 
51
                        return schemas.Contains(namespaceUri);
 
52
                }
 
53
                
 
54
                public void RemoveUserDefinedSchema(string namespaceUri)
 
55
                {
 
56
                        XmlSchemaCompletion schema = schemas[namespaceUri];
 
57
                        if (schema != null) {
 
58
                                if (fileSystem.FileExists(schema.FileName)) {
 
59
                                        fileSystem.DeleteFile(schema.FileName);
 
60
                                }
 
61
                                schemas.Remove(schema);
 
62
                                OnUserDefinedSchemaRemoved();
 
63
                        }
 
64
                }
 
65
                
 
66
                void OnUserDefinedSchemaRemoved()
 
67
                {
 
68
                        if (UserDefinedSchemaRemoved != null) {
 
69
                                UserDefinedSchemaRemoved(this, new EventArgs());
 
70
                        }
 
71
                }
 
72
                                
 
73
                public void AddUserSchema(XmlSchemaCompletion schema)
 
74
                {
 
75
                        if (!fileSystem.DirectoryExists(userDefinedSchemaFolder)) {
 
76
                                fileSystem.CreateDirectory(userDefinedSchemaFolder);
 
77
                        }
 
78
                        
 
79
                        string newSchemaDestinationFileName = GetUserDefinedSchemaDestination(schema);
 
80
                        fileSystem.CopyFile(schema.FileName, newSchemaDestinationFileName);                     
 
81
                        
 
82
                        schema.FileName = newSchemaDestinationFileName;
 
83
                        schemas.Add(schema);
 
84
                        
 
85
                        OnUserDefinedSchemaAdded();
 
86
                }               
 
87
 
 
88
                string GetUserDefinedSchemaDestination(XmlSchemaCompletion schema)
 
89
                {
 
90
                        string fileName = Path.GetFileName(schema.FileName);
 
91
                        return Path.Combine(userDefinedSchemaFolder, fileName);
 
92
                }
 
93
                                
 
94
                void OnUserDefinedSchemaAdded()
 
95
                {
 
96
                        if (UserDefinedSchemaAdded != null) {
 
97
                                UserDefinedSchemaAdded(this, new EventArgs());
 
98
                        }
 
99
                }
 
100
                
 
101
                public RegisteredXmlSchemaError[] GetSchemaErrors()
 
102
                {
 
103
                        return schemaErrors.ToArray();
 
104
                }
 
105
                
 
106
                public void ReadSchemas()
 
107
                {
 
108
                        foreach (string folder in readOnlySchemaFolders) {
 
109
                                ReadSchemas(folder, "*.xsd", true);
 
110
                        }
 
111
                        ReadSchemas(userDefinedSchemaFolder, "*.*", false);
 
112
                }
 
113
                
 
114
                void ReadSchemas(string directory, string searchPattern, bool readOnly)
 
115
                {
 
116
                        if (fileSystem.DirectoryExists(directory)) {
 
117
                                foreach (string fileName in fileSystem.GetFilesInDirectory(directory, searchPattern)) {
 
118
                                        XmlSchemaCompletion schema = ReadSchema(fileName, readOnly);
 
119
                                        if (schema != null) {
 
120
                                                AddSchema(schema);
 
121
                                        }
 
122
                                }
 
123
                        }
 
124
                }               
 
125
                
 
126
                XmlSchemaCompletion ReadSchema(string fileName, bool readOnly)
 
127
                {
 
128
                        try {
 
129
                                string baseUri = XmlSchemaCompletion.GetUri(fileName);
 
130
                                XmlSchemaCompletion schema = factory.CreateXmlSchemaCompletionData(baseUri, fileName);
 
131
                                schema.FileName = fileName;
 
132
                                schema.IsReadOnly = readOnly;
 
133
                                return schema;
 
134
                        } catch (Exception ex) {
 
135
                                schemaErrors.Add(new RegisteredXmlSchemaError("Unable to read schema '" + fileName + "'.", ex));
 
136
                        }
 
137
                        return null;
 
138
                }
 
139
                
 
140
                XmlSchemaCompletion IXmlSchemaCompletionDataFactory.CreateXmlSchemaCompletionData(string baseUri, string fileName)
 
141
                {
 
142
                        return new XmlSchemaCompletion(baseUri, fileName);
 
143
                }
 
144
                
 
145
                void AddSchema(XmlSchemaCompletion schema)
 
146
                {
 
147
                        if (schema.HasNamespaceUri) {
 
148
                                schemas.Add(schema);
 
149
                        } else {
 
150
                                schemaErrors.Add(new RegisteredXmlSchemaError("Ignoring schema with no namespace '" + schema.FileName + "'."));
 
151
                        }               
 
152
                }
 
153
        }
 
154
}